Why is code block segmentation necessary?

LDPC decoders have a maximum block size determined by the parity-check matrix dimensions. In 5G NR, the largest LDPC lifting size is Z = 384, giving maximum information block sizes of 8,448 bits (BG1: 22 information columns times 384) and 3,840 bits (BG2: 10 columns times 384). A 5G NR transport block can be much larger, up to approximately 1.3 million bits for a single slot with maximum bandwidth (273 PRBs, 256-QAM, 14 OFDM symbols, code rate 948/1024). Without segmentation, this entire block would need to be encoded at once, requiring an impossibly large LDPC matrix. Segmentation divides it into approximately 150 code blocks (1.3M / 8,448), each encoded independently. This also enables parallel decoding: modern 5G base station hardware uses arrays of LDPC decoder cores that process code blocks simultaneously, reducing decoding latency from milliseconds to microseconds. Additionally, each code block has its own CRC, enabling early termination when a block passes its CRC check and identifying which specific blocks need HARQ retransmission.

How does segmentation affect decoding latency?

Without segmentation, the decoder must wait for the entire transport block to be received before decoding can begin (since it would be a single codeword). With segmentation into C code blocks, decoding of the first code block can begin as soon as its bits have been received, while later code blocks are still being demodulated and deinterleaved. For a transport block spanning 14 OFDM symbols in a 1 ms slot, the first code block's bits arrive within the first 1 to 2 symbols (approximately 71 to 143 microseconds), enabling the decoder to start working immediately. Modern 5G base station implementations use pipelined architectures where demodulation, deinterleaving, and LDPC decoding of different code blocks operate simultaneously on different hardware units. The total decoding time is approximately max(demod_time, C * single_block_decode_time / N_decoders), where N_decoders is the number of parallel LDPC cores. Typical single-block decode time is 1 to 5 microseconds with 10 to 20 iterations, and with 8 to 16 parallel cores, 150 code blocks complete in approximately 10 to 100 microseconds.

Digital Communications

Code Block Segmentation

Q: How does segmentation interact with HARQ?

In 5G NR, code block group (CBG) based HARQ retransmission allows the receiver to request retransmission of only the code blocks that failed their CRC, rather than the entire transport block. The C code blocks from segmentation are grouped into 2, 4, 6, or 8 code block groups (configured by RRC parameter maxCodeBlockGroupsPerTransportBlock). Each CBG has its own HARQ feedback bit. When a CBG fails (one or more of its code blocks has a CRC error), only that CBG is retransmitted, not the entire transport block. For a 1 Mbps transport block segmented into 150 code blocks grouped into 8 CBGs of approximately 19 blocks each, a single-block error triggers retransmission of only 1/8 of the data instead of the full block. This reduces retransmission overhead by 75 to 87% compared to transport-block-level HARQ, directly improving throughput and reducing latency for retransmissions. CBG-based HARQ is particularly beneficial at high SNR where errors are rare and isolated.

/kohd blok seg-men-tay-shun/

Code block segmentation divides large 5G NR transport blocks into smaller code blocks for independent LDPC encoding per 3GPP TS 38.212. Max code block sizes: 8,448 bits (BG1, high rate) and 3,840 bits (BG2, low rate). Each code block gets its own 24-bit CRC (CRC24B), enabling parallel decoding, reduced latency, and code block group (CBG) HARQ retransmission that reduces overhead 75 to 87% vs full transport block retransmission.

Category: Digital Communications

Max CB (BG1): 8,448 bits

Standard: 3GPP TS 38.212

Understanding Code Block Segmentation

5G NR achieves peak data rates exceeding 20 Gbps by transmitting very large transport blocks that can contain over 1 million information bits in a single slot. However, the LDPC channel coder has a fixed maximum block size determined by the parity-check matrix dimensions (8,448 bits for base graph 1). Code block segmentation bridges this gap: it splits the transport block into smaller pieces, each small enough for the LDPC encoder, adds per-block error detection (CRC24B), and enables the decoder to process blocks in parallel for low latency.

The segmentation procedure is straightforward. First, a 24-bit CRC (CRC24A) is appended to the transport block for whole-block error detection. If the resulting size B+24 exceeds the maximum code block size K_cb, the block is divided into C = ceil((B+24)/(K_cb-24)) code blocks. The 24 bits subtracted from K_cb in the denominator account for the per-block CRC24B that will be added to each code block. Filler bits (zero padding) are prepended to the first code block if needed to equalize block sizes. Each code block then proceeds through LDPC encoding, rate matching, and code block concatenation before modulation and mapping to OFDM resource elements.

Segmentation Formulas

Number of Code Blocks:
C = ⌈(B + 24) / (K_cb - 24)⌉

Code Block Size (including CRC):
K = ⌈(B + 24 + C×24) / C⌉ rounded to valid LDPC lifting size

CBG HARQ Overhead Savings:
Savings = 1 - (1/N_CBG) per single-CBG failure

Where B = transport block size (bits), K_cb = max code block size (8,448 for BG1, 3,840 for BG2). Example: B = 100,000 bits. C = ceil(100,024/8,424) = 12 code blocks. With 8 CBGs: retransmit 1/8 instead of full block (87.5% saving).

Segmentation Examples

Transport Block	Base Graph	K_cb	Code Blocks (C)	CB Size (K)
5,000 bits	BG1	8,448	1	5,024 bits
50,000 bits	BG1	8,448	6	~8,400 bits
500,000 bits	BG1	8,448	60	~8,400 bits
1,300,000 bits	BG1	8,448	155	~8,400 bits
2,000 bits	BG2	3,840	1	2,024 bits

Common Questions

Frequently Asked Questions

Why is segmentation necessary?

LDPC max info block: 8,448 bits (BG1) or 3,840 bits (BG2). 5G transport blocks up to ~1.3 Mbit. Without segmentation, encoder matrix would be impossibly large. Segmentation enables parallel decoding (arrays of LDPC cores), per-block CRC for early termination, and CBG-level HARQ for efficient retransmission.

How does segmentation interact with HARQ?

Code blocks grouped into 2/4/6/8 CBGs (RRC-configured). Each CBG gets own HARQ feedback bit. Failed CBG retransmitted, not entire TB. 150 code blocks in 8 CBGs: single-block error retransmits 1/8 of data (87.5% overhead reduction). Critical for high-SNR scenarios with rare, isolated errors.

How does it affect decoding latency?

First code block decoded while later blocks still demodulating. Pipelined architecture: demod + deinterleave + LDPC decode on different blocks simultaneously. Single-block decode: 1 to 5 μs (10 to 20 iterations). 150 blocks on 8 to 16 parallel cores: ~10 to 100 μs total vs ms without parallelism.

Related Terms

← Cochlear Implant Code Block Size →