Segmentation & Reassembly in 5G NR

Introduction

Segmentation is a transmit-side function of the RLC sublayer, defined in TS 38.322. RLC sits between PDCP above and MAC below: it takes each RLC SDU (one PDCP PDU handed down) and produces RLC PDUs sized to whatever uplink or downlink grant the MAC scheduler has issued for this slot. Whenever an SDU is larger than the space in the current grant, RLC segments it — and that happens constantly on any bearer carrying real traffic.

It runs on every bearer configured in UM (Unacknowledged Mode) or AM (Acknowledged Mode) — effectively all user-plane DRBs and all signalling SRBs. Only TM (Transparent Mode, used for BCCH/PCCH/CCCH broadcast-style transport) never segments, because it adds no RLC header at all. So from the moment a bearer is set up and data starts flowing, segmentation is in the path for nearly everything that crosses the air interface.

It matters because the transport-block size is not RLC's to choose: it is decided slot-by-slot by the scheduler and swings with the channel, the buffer occupancy and the cell load. Segmentation is what lets RLC honour whatever grant arrives immediately rather than stalling for a bigger one — which is exactly what NR's latency targets require.

Why RLC segments — and why it no longer concatenates

The size of a transport block is decided by the scheduler in the gNB and changes slot to slot with the channel, the buffer status, and how many UEs share the cell. RLC has no vote in it — it simply receives a grant and must produce a PDU that fits. An RLC SDU (one PDCP PDU handed down) might be 1500 bytes while this slot's grant is only 200 bytes. RLC cannot stall waiting for a bigger grant without inflating latency, so the only lever it has to reconcile a large SDU with a small grant is segmentation: cut the SDU into contiguous byte-ranges and send one range per PDU.

In LTE, RLC had a second lever — concatenation — where several small SDUs (plus framing information, the FI and E fields and per-SDU LI length indicators) were packed into one PDU to fill a large grant. NR deliberately removed this. Concatenation is now a MAC responsibility: MAC multiplexes multiple RLC PDUs into one transport block using MAC subheaders that already carry each PDU's length. Pushing the "combine small pieces" job up to MAC lets RLC pre-build most of its PDU header the moment an SDU arrives, before the grant size is even known, which shortens the processing pipeline and helps NR hit its low-latency targets. RLC keeps only the "split a big piece" job, which genuinely needs the live grant size.

The SI and SO fields — how a segment is labelled

Two header fields carry all of the segmentation bookkeeping. The SI (Segmentation Info) field is 2 bits and tells the receiver which part of the SDU this PDU is. The SO (Segmentation Offset) field is 16 bits and tells it where that part starts, counted in bytes from the beginning of the original SDU (byte 0 is the first byte). Together with the SN, they are everything a receiver needs to rebuild an SDU that was scattered across several PDUs.

The SI encoding is fixed by TS 38.322 and worth memorising exactly, because the two data-segment codes are easy to swap in your head:

The logic behind "when is SO present" is pure economy. A complete SDU (00) and a first segment (01) both start at byte 0, so their offset is known implicitly and the 16-bit SO is omitted — saving two bytes on the common case. Only a middle (11) or last (10) segment starts partway into the SDU, so only those two carry an explicit SO. Because SO is 16 bits, the largest offset it can express is 65 535 (0–65535), which comfortably covers any RLC SDU size the system will produce.

UMD and AMD PDU header formats

The exact header a segment carries depends on two things: the RLC mode (UM produces UMD PDUs, AM produces AMD PDUs) and which SI case applies. The rule of thumb is simple — the header grows as the segment needs more identity. A complete SDU needs the least; a middle or last segment needs the most because it must also carry SO.

UMD PDU (Unacknowledged Mode). UM has no ARQ, so its header carries no delivery control — no D/C bit (there are no UM control PDUs) and no P (poll) bit. The headline NR feature lives here: a complete SDU in UM carries no header at all — just the Data field, zero overhead. The SN only appears once an SDU is actually segmented, because only then does the receiver need to correlate fragments. First segments carry SI+SN; middle and last segments add the 16-bit SO.

AMD PDU (Acknowledged Mode). AM always carries a fixed header because ARQ needs it on every PDU: a D/C bit (Data vs Control, since AM also sends STATUS PDUs), a P (polling) bit that asks the peer for a status report, the 2-bit SI, and the SN. So even a complete SDU in AM has a real header. As in UM, middle and last segments append the 16-bit SO.

Every one of these headers is byte-aligned — each ends on an octet boundary so the Data field always begins at a whole byte, which keeps parsing cheap and lets hardware copy payload without bit-shifting. Alignment is not free with these field widths, so the spec inserts reserved (R) bits as padding where the fields do not naturally fill an octet. Two examples: the UM 12-bit-SN header packs SI (2 bits) + SN (12 bits) = 14 bits, so 2 reserved bits pad it to a clean 2 octets; the AM 18-bit-SN header packs D/C+P+SI+SN = 22 bits, so 2 reserved bits pad it to 3 octets. By contrast the UM 6-bit-SN first-segment header (SI+SN = 8 bits) and the AM 12-bit-SN header (4+12 = 16 bits) fall on octet boundaries naturally and need no padding.

One SDU across several MAC PDUs

Here is a single 1400-byte RLC SDU (with SN = 42) being carried over three successive grants of different sizes. Every RLC PDU shares the same SN; the SI and SO fields let the receiver drop each fragment into the correct place. Notice that the first fragment omits SO (its offset is implicitly 0) while the middle and last fragments carry an explicit SO, and that each RLC PDU rides inside its own MAC subheader + MAC SDU slot within a transport block.

Sequence Number sizes and the reassembly window

The SN is what lets the receiver tell SDUs apart, detect loss, and place fragments, so its width sets how many PDUs can be outstanding before the numbering wraps. NR gives two choices per mode, configured by RRC in the RLC-Config IE (inside RLC-BearerConfig). The field is sn-FieldLength: size6/size12 under ul-UM-RLC/dl-UM-RLC, and size12/size18 under ul-AM-RLC/dl-AM-RLC. The choice is a direct trade between header overhead and how much data can be in flight.

The reason the window matters is wrap-around. The transmit and reassembly/reordering windows each span half the SN space (AM_Window_Size = UM_Window_Size = 2^[SN−1]), so a 12-bit AM SN allows up to 2048 PDUs in flight and an 18-bit AM SN allows up to 131072. If the SN is too short for the volume of data outstanding, the window edge catches up with un-acknowledged PDUs: the transmitter stalls, and after a wrap the receiver can misinterpret an old SN as a new one. This is precisely why high-throughput AM bearers — large file transfers, high-order carrier aggregation — are configured with the 18-bit SN, while a small signalling or voice-like bearer is happy with the shortest option.

Re-segmentation of retransmissions (AM only)

In AM, a PDU that was already sent can be flagged for retransmission when the peer's STATUS PDU NACKs it. But the grant available for that retransmission may be smaller than the original PDU — the channel has changed since the first attempt. Rather than wait for a matching grant and stall ARQ, AM can re-segment: take the PDU (or PDU segment) it needs to resend and cut it into still-smaller segments, each fitting the new, smaller grant.

Two properties make this cheap. First, re-segmentation invents no new mechanism — it reuses the very same SN + SO + SI fields. A re-segmented piece is just another labelled fragment of the same SDU, so the receiver's reassembly logic handles it identically to an original segment; it never needs to know whether a fragment came from a first transmission or a re-cut retransmission. Second, only AM ever does this. UM has no ARQ, never retransmits, and therefore never re-segments — a UM segment is built once and either arrives or is lost.

Reassembly at the receiver — SN + SO + t-Reassembly

The receiving RLC entity holds incoming fragments in a buffer keyed by SN, and within each SN it orders fragments by SO. When it has a contiguous byte run from a first (or complete) fragment through to the matching last fragment with no gaps, the SDU is whole and is delivered upward to PDCP. Because segments and whole PDUs can arrive out of order, or a middle piece can simply go missing, the receiver arms the t-Reassembly timer to bound how long it waits. t-Reassembly is set by RRC in RLC-Config and takes an enumerated value in milliseconds (a discrete ladder from single-digit values up to 200 ms), chosen against the bearer's latency budget.

What happens on expiry is where the two modes fork. In UM, the receiver discards the incomplete SDU, advances the reassembly window past it, and moves on — UM is for delay-sensitive traffic that would rather drop a packet than wait for a retransmission that arrives too late to be useful. In AM, expiry (and gap detection generally) drives a STATUS PDU: the missing SN ranges are reported as NACKs (with per-segment SOstart/SOend where only part of an SDU is missing), and the sender retransmits them — possibly re-segmenting as described above. Same timer, same "something is missing" detection, opposite reliability contract: UM abandons the gap, AM repairs it.

Summary

NR RLC segments because it has to: the scheduler fixes the transport-block size every slot, and RLC must fit its PDU to that grant with no ability to concatenate (that job moved to MAC). Segmentation cuts one RLC SDU into contiguous byte-ranges, all sharing the SDU's SN, each labelled by a 2-bit SI (complete/first/middle/last) and, for pieces that do not start at byte 0, a 16-bit SO.

Header size grows with segment identity: a complete UM SDU has no header at all, while AM always carries the fixed D/C+P+SI+SN, and middle/last segments add SO in both modes; reserved bits keep every header byte-aligned. The SN width (UM 6/12, AM 12/18) sets a window of half the SN space, which must cover the bearer's in-flight data. At the receiver, fragments are grouped by SN, ordered by SO, and bounded by t-Reassembly — on expiry, UM drops the gap while AM turns it into a NACK and repairs it, re-segmenting the retransmission if the new grant is smaller.

Quick Q&A