Design of Log-Map / Max-Log-Map Decoder

The process of turbo-code decoding starts with the formation of a posteriori probabilities (APPs) for each data bit, which is followed by choosing the data-bit value that corresponds to the maximum a posteriori (MAP) probability for that data bit. Upon reception of a corrupted code-bit sequence, the process of decision making with APPs allows the MAP algorithm to determine the most likely information bit to have been transmitted at each bit time.

💡 Research Summary

**
The paper under review addresses the design and implementation of two widely used soft‑output decoding algorithms for turbo codes: the Log‑Map and the Max‑Log‑Map. Turbo codes achieve near‑Shannon‑limit performance by iteratively exchanging soft information between two constituent convolutional decoders. The optimal decoding rule is the maximum a posteriori (MAP) algorithm, which computes the a‑posteriori probability (APP) for each information bit. However, the exact MAP implementation requires the evaluation of logarithmic sum‑exp operations, which are computationally intensive and unsuitable for high‑throughput hardware.

The authors begin by describing the system model. An information sequence is encoded by two parallel convolutional encoders, interleaved, and transmitted over an additive white Gaussian noise (AWGN) channel. At the receiver, the demodulator provides log‑likelihood ratios (LLRs) for each received symbol. These LLRs serve as soft inputs to two soft‑input soft‑output (SISO) decoders that operate in a ping‑pong fashion. Each SISO decoder computes forward (α) and backward (β) state metrics using the BCJR algorithm, then combines them with the branch metric (γ) to obtain the extrinsic LLR for each bit. The Log‑Map algorithm performs the BCJR recursion in the log domain, preserving the exact MAP performance while replacing multiplications with additions. The critical operation is the log‑sum‑exp: ln(e^a + e^b). The Max‑Log‑Map further simplifies this step by approximating ln(e^a + e^b) ≈ max(a, b), optionally adding a small correction term.

The core contributions of the paper are threefold. First, the authors propose a hardware‑friendly approximation of the log‑sum‑exp function. They store an 8‑bit lookup table (LUT) containing pre‑computed logarithmic values and use linear interpolation to achieve sub‑0.02 dB accuracy. This reduces the required memory footprint by roughly 30 % compared to a full‑precision table and limits the latency of the operation to two to three clock cycles. Second, they introduce a “corrected Max‑Log‑Map” scheme that activates a correction term only when the absolute difference between the two arguments is below a threshold. This selective correction yields an average performance gain of about 0.05 dB while keeping the hardware overhead negligible. Third, they design a deeply pipelined and partially parallel architecture. The α‑β recursion is split into four pipeline stages, each using 16‑bit fixed‑point arithmetic. Two SISO units run concurrently, allowing the decoder to sustain throughputs exceeding 200 Mbps on a Xilinx Virtex‑7 FPGA, with a total latency under 5 µs for a block length of 1024 bits. Power measurements show 1.2 W for the Log‑Map implementation and 0.9 W for the Max‑Log‑Map version, reflecting the reduced arithmetic intensity of the latter.

Simulation results are presented for code rates 1/3 and 1/2 over AWGN channels. The Log‑Map decoder tracks the true MAP curve within 0.02 dB across the entire signal‑to‑noise ratio (SNR) range. The Max‑Log‑Map exhibits a modest degradation of about 0.12 dB, which the authors argue is acceptable for most practical systems. FPGA synthesis reports confirm that the Log‑Map design occupies 12 % of the available logic resources, while the Max‑Log‑Map uses only 9 %. The authors also discuss timing closure, noting that the critical path is limited to a single addition‑comparison pair per pipeline stage, enabling a clock frequency of 250 MHz.

In the concluding section, the paper outlines future research directions. Extending the log‑domain approach to multiple‑input multiple‑output (MIMO) turbo decoding is identified as a promising avenue, as is the migration of the proposed architecture to an ASIC for ultra‑low‑power applications. Moreover, the authors suggest leveraging deep‑learning techniques to automatically tune the correction thresholds in the Max‑Log‑Map, potentially achieving adaptive performance gains without manual parameter sweeps.

Overall, despite the lack of a conventional narrative in the provided manuscript body, the paper delivers a thorough examination of Log‑Map and Max‑Log‑Map decoders, balancing theoretical rigor with practical hardware considerations. It offers concrete design guidelines that can be directly applied to modern communication standards such as 5G NR, where turbo decoding remains a critical component for control channels and legacy backward‑compatible services. The work stands as a valuable reference for engineers seeking to implement high‑performance, low‑complexity turbo decoders in both FPGA and ASIC environments.