Properties of LDPC codes used in the WiMAX IEEE 802.16e standard.
1. Introduction
The WiMAX is a wireless communications standard (IEEE 802.16e) used in small to medium distances in urban areas, that uses LowDensity ParityCheck (LDPC) codes, which are powerful error correcting codes very demanding from a computational perspective [Gallager, 1962, Mackay & Neal, 1996]. The throughput requirements imposed by the WiMAX standard define a maximum of 75 Mbps [IEEE P802.16e/D12, 2005], which typically demands a high number of arithmetic operations and memory accesses per second. In order to accommodate such requirements hardwarededicated solutions were investigated and developed to deliver such computational power.
With the number of transistors on a die approximately doubling every 18 months, we have seen in last years processors scaling up to hundreds of millions of gates. To overcome power and memory wall constraints, the industry of processors has introduced a new trend: increasing the number of cores per processor rather than using higher clock speeds. Associated to this new paradigm, new kinds of different homogeneous and heterogeneous multicore architectures have been proposed. Initially developed essentially for rendering purposes in the industry of games, recently we have seen multicores start offering new possibilities to support general purpose computing. Nowadays largely disseminated worldwide and supported by appropriate tools, they can be exploited by convenient parallel programming models delivering unmatched performances. This reality introduced the massive generalization of general purpose processing in these parallel architectures.
So far, dedicated VLSI was the only solution capable of decoding LDPC codes at acceptable rates [Brack et al., 2006, Liu et al., 2008]. In this chapter we present a novel, programmable/flexible and scalable parallel LDPC decoding approach for the WiMAX standard based on multicore accelerators such as the Cell/B.E. architecture from SonyToshibaIBM (STI) [Hofstee, 2005, International Business Machines Corporation, 2007, Falcão et al., 2008]. Moreover, we exploit parallel programming models and present parallel algorithms for this architecture [Falcão et al., 2009a]. We also report experimental results and compare them with stateoftheart LDPC hardware decoding solutions, based on Application Specific Integrated Circuits (ASIC).
Besides the introductory and closure sections, we propose to organize this chapter around five other main sections. The second and third sections introduce, respectively, WiMAX LDPC codes and the algorithms used to perform LDPC decoding. The main characteristics of the Cell/B.E. multicore architecture are presented in section four. The fifth section describes the parallel programming models and the parallel algorithms developed to efficiently implement LDPC decoding. Finally, the experimental results section shows that the obtained throughputs compare fairly against stateoftheart ASIC LDPC decoders.
2. WiMAX LDPC codes
The WiMAX standard (IEEE 802.16e) works in distances typically below the 10 Km range [Falcão et al., 2008], and uses LDPC codes, whose decoders can be very demanding from a computational perspective. For this reason, they are still implemented using dedicated hardware based on ASIC solutions. LDPCs are linear (
The Forward Error Correcting (FEC) system of the WiMAX standard is based on a special class of LDPC codes [IEEE P802.16e/D12, 2005] characterized by a sparse binary block paritycheck matrix H of the form:
where H1 is sparse and adopted special periodicity constraints introduced in the pseudo random design of the matrix [IEEE P802.16e/D12, 2005; Brack et al., 2006] and H2 is a sparse lower triangular block matrix with a staircase profile. The periodic nature of these codes defines H1 based on permutation submatrices
Therefore, the LDPC codes adopted by the WiMAX standard (IEEE 802.16e) support 19 different codeword sizes with 4 distinct code rates (
Code  Codeword bits ( n ) 

Information bits ( k )  
(rate)  ( rate )  ( rate )  ( rate )  





1  576 

288  384  432  480 
2  672 

336  448  504  560 
3  768 

384  512  576  640 
4  864 

432  576  648  720 
5  960 

480  640  720  800 
6  1056 

528  704  792  880 
7  1152 

576  768  864  960 
8  1248 

624  832  936  1040 
9  1344 

672  896  1008  1120 
10  1440 

720  960  1080  1200 
11  1536 

768  1024  1152  1280 
12  1632 

816  1088  1224  1360 
13  1728 

864  1152  1296  1440 
14  1824 

912  1216  1368  1520 
15  1920 

960  1280  1440  1600 
16  2016 

1008  1344  1512  1680 
17  2112 

1056  1408  1584  1760 
18  2208 

1104  1472  1656  1840 
19  2304 

1152  1536  1728  1920 
To illustrate the periodic nature introduced in the design of the H matrix, the generic structure of a sample paritycheck matrix used in WiMAX, with
3. Algorithms for LDPC decoding (SPA and MSA)
Computationally intensive messagepassing algorithms can be used for LDPC decoding, varying from the well known belief propagation, or SumProduct algorithm (SPA) [Falcão et al., 2009a] to the more efficient but yet still intensive MinSum algorithm (MSA) [Falcão et al., 2008]. The intensive message passing procedure is illustrated in figure 2. We will discuss the parallelization of the SPA and MSA, and show how data dependencies can be manipulated in order to allow the implementation of parallel decoders.
3.1. The SumProduct Algorithm (SPA)
The SPA is a very efficient algorithm [Lin & Costello, 2004] used for LDPC decoding and it is based on the belief propagation between adjacent nodes connected as indicated by the Tanner graph edges (figure 2). As proposed by Gallager, the SPA operates on probabilities [Gallager, 1962, Mackay & Neal, 1996, Lin & Costello, 2004]. Given a (n, k) LDPC code, we assume BinaryPhase Shift Keying (BPSK) modulation which maps a codeword c = (c_{1}, c_{2},..., c_{n}) into the sequence x = (x_{1}, x_{2},..., x_{n}), according to x_{i} = (1)^{c} _{i}. Then, x is transmitted through an additive white Gaussian noise (AWGN) channel originating the received sequence y = (y_{1}, y_{2},..., y_{n}) on the decoder side, with y_{i} = x_{i} + n_{i}, where n_{i} is a random variable with zero mean and variance σ^{2}.
The SPA is depicted from (2) to (8) [Lin & Costello, 2004]. It is mainly described by two horizontal and vertical intensive processing blocks, respectively defined by equations (3), (4) and (5), (6). The first two calculate messages moving from each CN_{m} to BN_{n}, considering accesses to H on a row basis. It indicates the probability of BN_{n} being 0 or 1. Figure 2 exemplifies, for a particular 4 x 8 H matrix, BN_{0}, BN_{1} and BN_{2} being updated by CN_{0}, then BN_{3}, BN_{4} and BN_{5} updated by CN_{1} and finally BN_{0}, BN_{3}, BN_{6} by CN_{2}. Similarly, the vertical processing block computes messages sent from BN_{n} to CN_{m}, assuming accesses on a column basis. The iterative procedure is stopped if the decoded word ĉ verifies all paritycheck equations of the code
{For each node pair (BN_{n}, CN_{m}), corresponding to
{1. Horizontal Processing (kernel 1) – Compute messages sent from CN_{m} to BN_{n}, that indicate the probability of BN_{n} being 0 or 1:}
{where N(m)\n represents BNs connected to CN_{m} excluding BN_{n}.
{2. Vertical Processing (kernel 2) – Compute messages sent from BN_{n} to CN_{m}:}
{where
{3. Compute
{where
{Perform hard decoding}
3.2. The MinSum Algorithm (MSA)
The MSA [Guilloud et al., 2003] is a simplification of the wellknown SPA in the logarithmic domain. It is also based on the intensive belief propagation between nodes connected as indicated by the Tanner graph edges, but that uses only comparison and addition operations. Being one of the most efficient algorithms used for LDPC decoding [Liu et al., 2008, Seo et al., 2007], even so, the MSA still requires intensive processing.
Let us denote the loglikelihood ratio LLR of a random variable as
{1. Horizontal Processing (kernel 1) – Compute messages sent from CN_{m} to BN_{n}:}
{2. Vertical Processing (kernel 2) – Compute messages sent from BN_{n} to CN_{m}:}
{3. Finally, we calculate the
4. The Cell/B.E. multicore architecture
The required computational power and the irregular memory access patterns for LDPC decoding define hard challenges that we propose to tackle for the heterogeneous Cell/B.E. multicore [Hofstee, 2005] shown in figure 3. The Cell/B.E. processor provides a set of cores that include one main 64bit PowerPC Processor Element (PPE) and eight Synergistic Processor Elements (SPEs) under a vectorized 128bit wide Single Instruction Multiple Data (SIMD) oriented architecture [Sony Computer Entertainment Incorporated, 2005]. Data transfers between the main memory and each SPE’s local memory (256KByte) are performed by using efficient Direct Memory Access (DMA) mechanisms that offload the processors from the expensive task of moving data. Each SPE, by its turn, exploits quite efficiently a dual pipeline mechanism executing independently: one supports arithmetic operations; while the other performs load and store memory operations.
The memory in the CELL/B.E. is organized as a distributed memory system. Data is loaded from the main memory into the SPE’s local storage and viceversa, allowing each processor to exploit data locality individually. As in opposition to architectures based on shared memory models, here the programmer is free from having to deal with strategies to avoid memory access conflicts.
5. The parallel programming model and parallel algorithms for LDPC decoding on multicores
The Single Program Multiple Data (SPMD) and the SIMD programming models are adopted to exploit data parallelism and to develop the parallel methods and algorithms for LDPC decoding on the Cell/B.E. A vectorized SIMDbased multicore approach that exploits data locality and fast datablock transfers associated to a powerful dual pipeline mechanism, allowed us to efficiently implement the concept of simultaneous multicodeword LDPC decoding on the Cell/B.E. Each SPE decodes several complete codewords and a total of 24 to 96 codewords, depending if we use 32 or 8bit data precision, are decoded in parallel and at the same time in all the 6 SPEs available on the PlayStation 3 platform used in this work.
The parallel LDPC decoder exploits SIMD dataparallelism by applying the same algorithm to different codewords on each SPE. As the Tanner graph is common to all codewords under decoding, these data structures can be shared allowing multicodeword decoding simultaneously in all SPEs. These features are illustrated in figure 4.
The irregular memory access patterns common in LDPC decoding represent a challenge to the efficiency of the algorithm as illustrated in figure 5 for the example shown in figure 2. The access to different nodes in the Tanner graph is defined by the H matrix and should favor randomization in order to allow good coding gains. For that reason, the data structures developed and represented in figure 6 try to minimize that effect, by grouping contiguously in memory associated data computed in the same kernel. A global irregular access pattern is translated into several partial regular access patterns. Moreover, only nonnull elements of the H matrix are stored which represents savings in terms of memory usage.
5.1. The parallel algorithm on the Cell/B.E.
The parallelization approach proposed for developing an LDPC decoder is explained in the context of the Cell/B.E. architecture. The data structures that define the Tanner graph and the program as well are loaded into the local storage on the SPEs where the processing is performed. The LDPC decoder processes on an iterative basis. The PPE reads information y_{n} from the input channel and produces the probabilities p_{n} as indicated in (2). The PPE controls the main tasks, offloading the intensive processing to the SPEs, where the processing is then distributed over several threads. Each SPE runs independently of the other SPEs. After receiving the p_{n} values associated to the corresponding codewords, each SPE performs two steps:
The parallel LDPC decoder explores dataparallelism by applying the same algorithm to several codewords simultaneously on each SPE (as shown in figure 4). Data is represented as 32bit precision floatingpoint or 8bit integer elements, depending on the algorithm used – SPA or MSA. The proposed LDPC decoder suits scalability and for that reason it can be easily adopted by future generations of the architecture with a higher number of SPEs. In that case, it will be able of decoding more codewords simultaneously, increasing the efficiency and aggregate throughput of the decoder.
Processing a complete iteration inside the SPE is performed in two phases:
Kernel 1 performs the horizontal processing according to the Tanner graph, and the
In kernel 2 data is processed in a columnmajor order. According to the Tanner graph, each BN updates all the CNs connected to it and holds the addresses necessary to complete the update of all
The computation is performed in the SPE for a predefined number of iterations. One of the purposes of this work is to assess the performance of the proposed solutions in terms of throughput. Pursuing this goal, we decided to develop a solution where the number of iterations is fixed to allow a fair comparison between different approaches, where the processing workload is known
Algorithm 1 PPE side of the algorithm  

Synchronization between the PPE and the SPEs is performed using mailboxes. This approach tries to exploit dataparallelism and data locality by performing the partitioning and mapping of the algorithm and data structures over the multiple cores, while at the same time minimizes delays caused by latency and synchronization.
5.2. Processing on the PPE
The part of the algorithm that executes on the PPE side is presented in Algorithm 1. We force the PPE to communicate with only one SPE, called MASTER SPE, which performs the control over the remaining SPEs. This is more efficient than putting the PPE controlling all the SPEs.
Algorithm 2 MASTER SPE side of the algorithm  

The PPE receives the y_{n} information from the channel and calculates probabilities p_{n}, after which it sends a
Algorithm 3 SLAVE SPE side of the algorithm  

Finally, when all the iterations are completed, the MASTER SPE sends an
5.3. Processing on the SPE
The SPEs are used in the intensive task of updating all BNs and CNs by executing kernels 1 and 2 (either for the SPA or for the MSA), in each decoding iteration. Each thread running on the SPEs accesses data in the main memory by using DMA and computes data according to the Tanner graph, as defined in the H matrix (figure 2). The MASTER SPE side of the procedure is described in Algorithm 2. The
We initialize the process and start an infinite loop, waiting for communications to arrive from the PPE (in the case of the MASTER SPE), or from the MASTER SPE (for all remaining SPEs). In the MASTER SPE, the only kind of message expected from the PPE is a
The processing starts and terminates when the number of iterations is reached and an
The intensive part of the computation in LDPC decoding on the Cell/B.E. architecture takes advantage of the processing power and SIMD instruction set available on the SPEs, which means that several codewords are decoded in parallel.
6. Experimental evaluation
To evaluate the performance of the proposed LDPC decoder, the Cell/B.E. was programmed using:
Serial mode  Parallel m ode  
Platform  PPE  STI Cell/B.E.  
Language  C  C  
OS  Linux (Fedora) kernel 2.6.16  
PPE  SPE  
Clock frequency  3.2GHz  3.2GHz  3.2GHz 
Memory  256MB  256MB  256KB 
6.1. Serial versus parallel execution modes
The serial mode depicted in figure 7 uses a dual thread approach and exploits SIMD instructions. It should be noted that by performing the comparison based on the time per bit decoded, the serial solution that uses only the PPE is slower than the execution on a single SPE, because the PPE accesses slow main memory, while the SPE accesses faster local storage memory.
Code (n, k)  Edges  Occupancy of data structures on the local storage of a SPE (Bytes) 
(504, 252)  1512  70560 
(1024, 512)  3072  143360 
On the parallel approach the experimental results were also obtained using SIMD instructions on the SPEs, which are responsible for executing the intensive decoding part of the algorithm. In this case the PPE orchestrates the execution on the SPEs as explained before, while inside each SPE several codewords are being simultaneously decoded in parallel. All the processing times were measured for a number of iterations ranging from 10 to 100. In literature, the average number of iterations considered for WiMAX LDPC decoders to work under realistic conditions is typically below 20 iterations [Brack et al., 2006, Seo et al., 2007, Liu et al., 2008].
Table 3 shows the dimensions of two regular LDPC codes with
6.2. LDPC decoding using the SPA
The first parallel approach mentioned in 6.1 uses the SPA. Data elements have 32bit floatingpoint precision, and 4 floatingpoint elements are packed and operated on a single instruction, making it possible to decode 4 codewords in parallel on each SPE. Then, with 6 SPEs available, the global architecture can decode 24 codewords in simultaneous. We assessed the results for regular codes, which typically execute faster than irregular ones. The average throughput obtained is presented in table 4, and it ranges from 69.1 to 69.5 Mbps, when decoding regular codes (504, 252) and (1024, 512) in 10 iterations. It should be noticed that the decoding time per bit and per iteration remains approximately constant. Although reallife performances demand throughputs which can be typically in the order of 40 Mbps per channel, the theoretical maximum required by the WiMAX standard can go up to approximately 75 Mbps per channel. The throughputs reported in table 4 are inferior to 70 Mbps and do not guarantee such requirements. Also, adapting the algorithm to support the necessary irregular codes used in the WiMAX would produce even worst results, because in that case accesses to memory depend on a variable number of edges per row/column. Therefore, optimizing the LDPC decoding algorithm to make it execute in a shorter period of time became mandatory. One possible solution consisted of exploiting the computationally less demanding MSA described in section 3.2.
Code ( n, k )  r ate  10 iter.  25 iter.  50 iter. 
(504, 252)  1/2  69.1  28.3  14.2 
(1024, 512)  1/2  69.5  28.4  14.3 
6.3. LDPC decoding using the MSA
To increase the efficiency of the LDPC decoder we implemented the MSA on the Cell/B.E. It requires less computation, based essentially in addition and comparison operations [Falcão et al., 2009b]. Additionally, we also adopted the ForwardandBackward simplification of the algorithm [Mackay, 1999] that avoids redundant computation and eliminates repeated accesses to memory. In the MSA data elements have 8bit integer precision, which allows packing 16 data elements per 128bit memory access. This increases the arithmetic intensity of the algorithm, here defined as the number of arithmetic operations per memory access, which favors the global performance of the LDPC decoder. The instruction set of the Cell/B.E. architecture supports intrinsic instructions to deal efficiently with these parallel 128bit data types. Moreover, because there are 6 SPEs available, the algorithm now supports the simultaneous decoding of 96 codewords in parallel. However, the set of 8bit integer intrinsic parallel instructions of the Cell/B.E. is more limited than those of the 32bit floatingpoint family of instructions. This explains that the speedup obtained when changing from the SPA to the MSA is lower than we would expect. Table 5 shows the throughputs obtained for some example codes used in the WiMAX IEEE 802.16e standard. For 10 iterations, in some cases they approach quite well while in others they even surpass the 75 Mbps required by the standard to work in (theoretical) worst case conditions.
Code ( n, k )  r ate  10 iter.  25 iter.  50 iter. 
(576, 288)  1/2  79.8  32.7  16.5 
(576, 432)  3/4  7 3 . 1  29. 9  15.1 
(576, 480)  5/6  7 9 . 3  3 2 . 5  16.4 
(672, 448)  2/3  74.8  30.6  15.4 
(672, 504)  3/4  72.6  29.7  15.0 
(672, 560)  5/6  78.5  32.2  16.2 
(960, 480 )  1/2  79.6  32.6  16.4 
(960, 640 )  2/3  74.7  30.6  15.4 
(960, 720 )  3/4  72.6  29.7  15.0 
(960, 800 )  5/6  78.4  32.1  16.2 
( 1152 , 576 )  1/2  79.6  32.6  16.4 
( 1152 , 768 )  2/3  74.6  30.5  15.4 
( 1152 , 864 )  3/4  72.6  29.7  15.0 
( 1152 , 960 )  5/6  78.4  32.1  16.2 
(1248, 624)  1/2  79.6  32. 6  16.4 
(1248, 832)  2/3  78.5  32.2  16.2 
(1248, 936)  3/4  72. 7  29. 7  15.0 
(1248, 1040)  5/6  78. 4  32. 1  16.2 
For codes with
6.4. Discussion
In multicore architectures, efficient parallel programming, both in terms of computation and memory accesses, represent a significant challenge. The Cell/B.E. is based on a distributed memory model where the problem of data collisions can decrease when properly handled by the programmer. The reported experimental results allow assessing the performance of LDPC decoders based on multicores. We have shown that for LDPC decoders running the SPA on the Cell/B.E., throughputs can range from 68 to nearly 70 Mbps [Falcão et al., 2009a]. Concerning the MSA, a more efficient solution is achieved producing throughputs that range from 72 to 80 Mbps [Falcão et al., 2008]. Regarding to nonscalable hardware dedicated ASIC solutions, which typically adopt 5 to 6bit precision arithmetic [Liu, 2008], the parallel programmable architecture here proposed allows using 8bit data precision or even more, which produces lower Bit Error Rates (BER) and superior coding gains as depicted in figure 8. The adoption of specific parallelization techniques on a lowcost multicore platform allowed us to achieve throughputs that approach well those obtained with ASICbased solutions for WiMAX [Brack, 2006, Seo, 2007, Liu, 2008]. They also guarantee enough bandwidth for LDPC codes used in the WiMAX standard to work in worst case conditions.
7. Conclusions
The advent of inexpensive multicore architectures has allowed to develop a novel programmable LDPC decoding solution for the WiMAX standard, with excellent throughputs, on the Cell/B.E. architecture. The LDPC decoder here presented exploits parallelism and data locality and is scalable to future generations of the Cell/B.E. architecture that are expected to have more SPEs, and should therefore improve the performance even further, processing more channels/subcarriers per second. The proposed decoder compares well with nonscalable and hardwarededicated typical ASIC LDPC decoding solutions, reporting superior BER performances and throughputs above 72 Mbps.
On going additional work related with LDPC decoders running on alternative parallel architectures can be found in [Falcão et al., 2009b; Seo et al., 2007].
References
 1.
Brack T. Alles M. Kienle F. Wehn N. 2006 A Synthesizable IP Core for WIMAX 802.16E LDPC Code Decoding,  2.
Falcão G. Silva V. Sousa L. Marinho J. 2008 High coded data rate and multicodeword WiMAX LDPC decoding on the Cell/BE.  3.
Falcão G. Sousa L. Silva V. Marinho J. 2009a Parallel LDPC Decoding on the Cell/B.E. Processor,  4.
Falcão G. Silva V. Sousa L. 2009b How GPUs Can Outperform ASICs for Fast LDPC Decoding,  5.
Gallager R. 1962 LowDensity ParityCheck Codes.  6.
Guilloud F. Boutillon E. Danger J. L. 2003 λmin decoding algorithm of regular and irregular LDPC codes.  7.
Hofstee H. 2005 Power Efficient Processor Architecture and the Cell Processor,  8.
IEEE P802.16e/D12 2005 Draft IEEE Standard for Local and Metropolitan Area Networks. Part 16: Air Interface for Fixed and Mobile Broadband Wireless Access Systems, October 2005.  9.
International Business Machines Corporation 2007  10.
Lin S. Costello D. 2004  11.
Liu C. H. Yen S. W. Chen C. L. Chang H. C. Lee C. Y. Hsu Y. S. Jou S. J. 2008 An LDPC Decoder Chip Based on SelfRouting Network for IEEE 802.16e Applications.  12.
Mackay D. Neal R. 1996 Near Shannon Limit Performance of Low Density Parity Check Codes.  13.
Mackay D. 1999 Good ErrorCorrecting Codes Based on Very Sparse Matrices. .  14.
Seo S. Mudge T. Zhu Y. Chakrabarti C. 2007 Design and Analysis of LDPC Decoders for Software Defined Radio ,  15.
Sony Computer Entertainment Incorporated 2005  16.
Tanner R. 1981 A Recursive Approach to Low Complexity Codes. .