Segmentation & Concatenation in LTE 4G

Introduction

RLC — the Radio Link Control protocol, TS 36.322 — is the layer-2 entity that sits between PDCP above and MAC below in the LTE user- and control-plane stack. Its defining task is rate matching in the size domain: turning a stream of arbitrarily-sized RLC SDUs into RLC PDUs that exactly fill whatever byte budget the MAC scheduler grants each transmission-time interval (TTI, 1 ms in LTE).

Every radio bearer runs one RLC entity in one of three modes — Transparent (TM), Unacknowledged (UM) or Acknowledged (AM) — chosen by RRC in the rlc-Config IE. Segmentation and concatenation are performed by UM and AM entities; TM does neither and carries the SDU untouched. This page is about how UM/AM reshape data and, crucially, how they record what they did so the peer can reverse it exactly.

It matters because the air interface is rigidly framed: a grant is a fixed number of bytes and the transport block must be filled to the byte. If RLC returns a PDU even one byte off, MAC's multiplexing breaks. Understanding this reshaping is also the cleanest way to see why NR RLC (TS 38.322) dropped concatenation entirely — a change driven by latency, examined at the end.

Why RLC Reshapes Data at All

RLC sits between PDCP above and MAC below. From PDCP it receives RLC SDUs — one per PDCP PDU, whatever size they happen to be, from a 40-byte VoIP frame to a 1500-byte TCP segment. Below it, MAC never asks "how big is your data?" Instead, each TTI the scheduler decides a grant for the logical channel and tells RLC exactly how many bytes it may hand down. RLC must then produce an RLC PDU whose total size — header plus payload — equals that number precisely, no more and no less.

The size RLC is told to hit is not a suggestion. If RLC returns a PDU even one byte off, MAC cannot fit its multiplexing and the transport block is malformed. So the reshaping is not a nicety — it is the mechanism that lets a packet-switched stream of arbitrary SDUs ride a rigidly-sized physical channel. Everything else on this page is detail about how RLC records what it did so the peer can undo it.

Concatenation — LTE's Distinctive Trick

This is the feature that most sharply separates LTE RLC from NR RLC, so it earns the spotlight. When the grant is larger than a single small SDU, LTE RLC packs multiple SDUs into one PDU rather than waste the room. Picture several short SDUs waiting in the transmission buffer and a grant big enough for all of them: RLC lines them up back-to-back inside one RLC PDU, then records the internal boundaries in the header.

The receiver needs those boundaries because the payload is just an undifferentiated run of bytes — there is no delimiter byte, no length prefix inside the data field itself. That is precisely what Length Indicators (LI) are for: one per boundary between concatenated units. If a PDU carries the tail of SDU A, all of SDU B, and the head of SDU C, the header lists the byte lengths of A's tail and of B, and the receiver slices the byte stream back into the original SDUs, passing complete ones up to PDCP and holding partial ones for later.

Concatenation and segmentation are not separate operations that happen in different PDUs — in the general case they happen together. A single PDU very often starts with the continuation of a previously-segmented SDU (segmentation) and ends with the head of an SDU that will be segmented into the next PDU (segmentation again), with several whole SDUs concatenated in between. One PDU can therefore embody segmentation at both ends and concatenation in the middle simultaneously.

The AMD / UMD PDU Header Fields

A data PDU — an AMD PDU in Acknowledged Mode, a UMD PDU in Unacknowledged Mode — carries a header that tells the receiver how to reassemble the payload. Transparent Mode (TM) has no header at all and does neither segmentation nor concatenation, so it is out of scope here. The key AMD/UMD header fields defined in TS 36.322 are:

The 11-bit width of LI is worth noting: it can express lengths up to 2047 bytes, comfortably larger than any LTE SDU that would need one, so a single LI always suffices per boundary. And because the final unit's length is implicit, a PDU concatenating k data units needs only k−1 length indicators — the header never wastes a field on the tail.

The E-bit chain, precisely

The header is variable-length, and the E bit is what makes it self-describing. Immediately after the fixed part (D/C, SN, FI) comes a first E bit. If E = 0, the header ends and the payload is a single data unit (no concatenation). If E = 1, an LI+E pair follows: an 11-bit length and another E bit that again says whether yet another pair follows. The receiver walks this chain until it reads E = 0, at which point it knows the header is complete and the remaining bytes are the payload.

The takeaway: the header grows by roughly 11–12 bits for every additional SDU concatenated (an LI plus its E bit, byte-aligned in pairs), which is the overhead price LTE pays for filling grants tightly.

Framing Info: Reading the Four FI Values

The FI field is how the receiver distinguishes concatenation from segmentation, so it deserves its own look. It is two bits. The first bit describes the first byte of the payload; the second bit describes the last byte. A bit value of 0 means "this end aligns with an SDU boundary" (a whole start or a whole end); a bit value of 1 means "this end is a segment" (the byte is in the middle of an SDU that continues in a neighbouring PDU).

Those two bits are what let segmentation and concatenation coexist in one PDU. Take a PDU with FI = 11 that also carries three LI chain entries: the receiver reads FI and learns the first and last payload units are partial; it reads the LI chain and learns where the internal boundaries fall; between them it knows the first unit is a continuation to be joined to a held fragment, the middle units are whole SDUs to deliver immediately, and the last unit is a head to hold for the next PDU. No other field is needed to describe the shape of the PDU.

Building One PDU to Fill the Grant

Putting it together: given a grant of N bytes, RLC reserves room for the header it is about to build, then walks its transmission buffer filling the payload. It may lead with the leftover tail of a partially-sent SDU (segmentation), follow with as many whole SDUs as fit (concatenation), and finish by taking just the head of the next SDU so that not one byte of the grant is wasted (segmentation again). Each internal boundary earns an LI; the E bits chain those indicators; the FI field marks whether the first and last SDUs are segmented. The header length is not known until RLC decides how many SDUs it is packing, so building the header and choosing the fill are one interleaved step.

Two points fall out of the figure. First, PDU n needs exactly three LI fields for its four data units, because the fourth (D's head) is the last unit and its length is implicit. Second, PDU n+1 carries only the remainder of D — FI = 10, a single data unit, and therefore E = 0 with no LI at all: the header shrinks to its minimum whenever a PDU carries one non-concatenated unit.

Re-segmentation for AM Retransmissions

Acknowledged Mode adds one more wrinkle. Suppose a PDU is transmitted, the peer's STATUS PDU reports it was not received, and RLC must retransmit — but the grant available now is smaller than the original PDU. RLC cannot simply re-run concatenation on an already-numbered PDU, because its SN and its SDU boundaries are fixed and the peer's ARQ state is keyed to them. Instead it re-segments the original PDU into a smaller piece called an AMD PDU segment.

An AMD PDU segment reuses the original PDU's SN unchanged and sets the RF bit to 1, then adds fields so the receiver knows which slice of the original this is:

Crucially, re-segmentation operates on the PDU's data field as a flat byte range, not on the SDUs inside it. The SO counts bytes from the start of the original data field; the internal FI/LI structure is only interpreted once the full PDU has been reassembled. That is why re-segmentation can chop anywhere — it does not care where SDU boundaries sit.

The same original PDU can be re-segmented again and again into ever-smaller AMD PDU segments as successive grants allow, each carrying the identical SN plus its own SO and its own LSF. A segment covering the middle of the PDU has SO > 0 and LSF = 0; the segment carrying the very end has LSF = 1. There is no upper limit imposed by re-segmentation itself — grants govern how small the pieces get.

Reassembly at the Receiver

Everything the transmitter records exists so the receiver can run the process in reverse. Reassembly happens in two nested loops: first rebuild each PDU from any segments, then rebuild each SDU from the PDUs' data units.

At the PDU level (AM only), when segments arrive the receiver groups them by SN, orders them by SO, and stitches the byte ranges together. Once it holds a contiguous range from offset 0 through the segment marked LSF = 1, that SN's full AMD PDU is reconstructed and can be processed like any received PDU. Missing byte ranges simply leave a hole that a later retransmitted segment fills.

At the SDU level, the receiver walks each in-order PDU's data field using the header: the LI chain gives the length of every data unit except the last, and FI says whether the first and last units are partial. A unit marked as a continuation is joined to the fragment held from the previous PDU's tail; a unit marked as a head is held to be joined with the next PDU; every whole unit between is delivered straight to PDCP. Because delivery must be in order and complete, a segmented SDU is only delivered once the PDUs on both sides of it have arrived.

The LTE-vs-NR Contrast, Sharpened

Everything above is why LTE RLC is heavier than NR RLC. LTE RLC assembles PDUs reactively, at grant time, doing concatenation, segmentation and (in AM) re-segmentation on the fly — which means LI chains, E-bit lists and re-segmentation offsets all live in the RLC header and all cost per-PDU processing on the critical path between grant and transmission.

NR's motivation was latency. By dropping concatenation and letting RLC build most of a PDU before the exact grant is known — leaving MAC to multiplex ready-made RLC PDUs into the transport block — NR shortens the critical path from grant to transmission. Understanding LTE's concatenation is therefore the cleanest way to understand why NR removed it: the LI chain that makes LTE grants fit so tightly is exactly the per-grant work NR wanted off the fast path.

Summary

LTE RLC exists to make arbitrarily-sized SDUs fit the fixed byte grant MAC hands it every TTI. It does that with two operations — segmentation (split one SDU across PDUs) and concatenation (pack several SDUs into one PDU) — often both in the same AMD/UMD PDU. The header makes the operation reversible: SN orders and (in AM) tracks PDUs, FI marks whether the outer units are whole or partial, and an E-bit-chained list of 11-bit LI fields delimits the internal boundaries (one per boundary, none for the last unit). For AM retransmissions into a smaller grant, RLC re-segments the PDU's flat byte range using RF, a 15-bit SO and LSF. The receiver reverses everything: recombine segments by SN+SO, order by SN, split by the LI chain, classify outer units by FI, deliver whole SDUs to PDCP in order. The one fact that captures the LTE→NR jump: NR removed concatenation to shorten the grant-to-air latency path, which is why NR RLC PDUs carry no LI fields at all.