` #:414
`
`A synthesizable IP Core for DVB-S2 LDPC Code Decoding
`
`Frank Kienle, Torben Brack, Norbert Wehn
`Microelectronic System Design Research Group
`University of Kaiserslautern
`Erwin-Schr6dinger-Stral3e
`67663 Kaiserslautern, Germany
`{kienle, brack, wehn}@eit.uni-kl.de
`
`Abstract
`
`The new standard for digital video broadcast DVB-S2
`features Low-Density Parity-Check (LDPC) codes as their
`channel coding scheme. The codes are definedfor various
`code rates with a block size of 64800 which allows a trans-
`mission close to the theoretical limits.
`The decoding ofLDPC is an iterative process. For DVB-
`S2 about 300000 messages are processed and reordered
`in each of the 30 iterations. These huge data processing
`and storage requirements are a real challenge for the de-
`coder hardware realization, which has to fulfill the specified
`throughput of 255MB it/s for base station applications.
`In this paper we will show, to the best of our knowledge,
`the first published IP LDPC decoder core for the DVB-S2
`standard. We present a synthesizable IP block based on ST
`Microelectronics 0. 13pm CMOS technology.
`
`1 Introduction
`
`The new DVB-S2 standard [1] features a powerful for-
`ward error correction (FEC) system which enables trans-
`mission close to the theoretical limit (Shannon limit). This
`is enabled by using Low-Density Parity-Check (LDPC)
`codes [2] one of the most powerful codes known today
`which can even outperform Turbo-Codes 131. To provide
`flexibility 11 different code rates ranging from (R = 1/4 up
`to /io) are specified with a codeword length up to 64800
`bits. This huge maximum codeword length is the reason
`for the outstanding communications performance (0.7dB
`to Shannon) of this DVB-S2 LDPC code proposal, so in
`this paper we only focus on the codeword length of 64800
`bits. To yield this performance, the decoder has to iterate 30
`times. At each iteration up to 300 000 data are scrambled
`and calculated. This huge data processing, storage and net-
`work/interconnect requirements is a real challenge for the
`decoder realization.
`
`A LDPC code can be represented by a bipartite graph.
`For the DVB-S2 code 64800 so called variable nodes (\ TN)
`and 64800 * (1 - R) check nodes (CN) exist. The connec-
`tivity of these two type of nodes is specified in the standard
`[1]. For decoding the LDPC code messages are exchanged
`iteratively between this two type of nodes, while the node
`processing is of low complexity. Within one iteration first
`the variable nodes are procesed, then the check nodes.
`For a fully parallel hardware realization each node is
`instantiated and the connections between them are hard-
`wired. This was shown in [4] for a 1024 .bit LDPC code.
`But even for this relatively short block length severe rout-
`ing congestion problems exist. Therefore a partly paral-
`lel architecture becomes mandatory for larger block length,
`where only a subset of nodes are instantiated. A network
`has to provide the required connectivity between VN and
`CN nodes. But realizing any permutation pattern is very
`costly in terms of area, delay and power.
`To avoid this problem a decoder first design approach
`was presented in [5]. First an architecture is specified and
`afterwards a code is designed which fits this architecture.
`This approach is only suitable for regular LDPC code where
`each VN has the same number of incident edges, the CN
`respectively. But for an improved communications perfor-
`mance so called irregular LDPC codes are mandatory [6],
`where the VN nodes are of varying degrees. This is the case
`for the DVB-S2 code. In [7] we have presented a design
`method for irregular LDPC codes which can be efficiently
`processed by the decoder hardware. We used so called ir
`-
`regular repeat accumulate (IRA) codes [8] which are within
`the class of LDPC codes with the advantage of a very sim-
`ple (linear) encoding complexity. In general, LDPC code
`encoder are very difficult to implement due to the inherent
`complex encoding scheme.
`The LDPC codes as defined in the DVB-S2 standard
`are IRA codes, thus the encoder realization is straight for-
`ward. Furthermore, the DVB-S2 code shows regularities
`which can be exploited for an efficient hardware realization.
`
`1530-1591/05 $20.00 ' 2005 IEEE
`
`Exhibit G
`Page 105
`
`CALTECH - EXHIBIT 2002
`
`0001
`
`
`
`Case 2:13-cv-07245-MRP-JEM Document 29 Filed 03/06/14 Page 107 of 130 Page ID
` #:415
`
`K information nodes (IN) (cid:9)
`
`N parity nodes (PN)
`
`Rate
`
`I
`
`j
`I (cid:9) N]K
`k
`f3
`49600 16200
`4
`10800
`5400
`12
`5
`43200 21600
`14400
`7200
`12
`38880 25920
`17280
`6
`8640
`12
`32400 32400
`19440
`12960
`7
`8
`25920 38880
`12960 25920
`11
`12
`10 21600 1 43200
`13 1 (cid:9) 4320
`38880
`14
`16200 48600
`43200
`12
`5400
`45360 18
`12960 51840
`6480
`11
`5400
`48600 22 10800 54000
`13
`7200 1 50400 1 27
`7200
`4
`57600
`1 51840 1 30
`58320
`6480 (cid:9)
`6480
`4
`
`/4
`1/
`2/5
`
`/2
`3/
`2/3
`3/4
`4/5
`
`/6
`8/9
`
`9/io
`
`Table 1. Parameters describing the DVB-S2
`LDPC Tanner graph for different coderates
`
`parts: a random part dedicated to the systematic informa-
`tion, and a fixed part that belongs to the parity information.
`The Tanner graph for DVB-S2 is shown in Figure 1. There
`exist two types of variable nodes, the information (IN) and
`parity nodes (PN), corresponding to the systematic and par-
`ity bits respectively. The permutation H represents the ran-
`dom matrix part of the connectivity between IN and CN
`nodes, while the PN nodes are all of degree two and are
`connected in a fixed zigzag pattern to the CN nodes. The N
`check nodes have a constant degree k. The K information
`nodes consist of two subsets f, and f, with f the number
`of IN nodes of degree] and 3. Table 1 summarizes the code
`rate dependent parameters as defined in the standard [l].
`The connectivity of the IN and CN nodes is defined by
`the DVB-S2 encoding rule
`
`Pj=PjEDIm, j=(x+q(mmod360))modN. ( 2)
`Pj is the jth parity bit, ’m the mth information code bit, and
`x, q, and N are code rate dependent parameters specified
`by the DVB-S2 standard. Equation 2 determines the entries
`of the parity check matrix. The mth column has nonzero
`elements in each row j, thus the permutation H generates
`one edge between every CN m and IN j.
`The fixed zigzag connectivity of the PN and CN nodes is
`defined by the encoding scheme:
`
`PjPjPj-1, j=1,2,...,N(cid:151)l.
`
`(3)
`
`This is a simple accumulator. The corresponding part
`of the parity check matrix has two nonzero elements in
`each column, forming a square banded matrix. This type of
`LDPC codes with this simple encoding procedure are also
`called irregular repeat accumulate (IRA) codes [8].
`
`2.1 Decoding Algorithm
`
`LDPC codes can be decoded using the message pass-
`ing algorithm [2]. It exchanges soft-information iteratively
`
`f3
`Q.:.QQ:Q QQQQ
`Permutation H (cid:9)
`I
`
`degree k (cid:9)
`
`CN
`
`Figure 1. Tanner graph for the DVB-S2 LDPC
`code
`
`These regularities are also the base for our methodology in-
`troduced in [7].
`In this paper we show how to exploit these regulari-
`ties and present an efficient mapping of \TN and CN nodes
`to hardware instances. Memory area and access conflicts
`are most critical in this mapping process. Thus we used
`simulated annealing to minimize memory requirements and
`avoidance of RAM access conflicts.
`We present to the best of our knowledge the first IP core
`capable to process all specified code rates in the DVB-S2
`standard. We show synthesis results using a 0.1 3pm tech-
`nology.
`The paper is structured as follows: the DVB-S2 LDPC
`codes and the decoding algorithm are presented in Sec-
`tion 2. In Section 3 the mapping of nodes to hardware
`instances is explained. The overall decoder architecture is
`shown in Section 4. Section 5 gives synthesis results and
`Section 6 concludes the paper.
`
`2 DVB-S2 LDPC Codes
`
`LDPC codes are linear block codes defined by a sparse
`binary matrix (parity check matrix) H. The set of valid
`codewords x E C have to satisfy
`HXT==0, (cid:9)
`
`VxEC. (cid:9)
`
`(1)
`
`A column in H is associated to a bit of the codeword
`and each row corresponds to a parity check. A nonzero ele-
`ment in a row means that the corresponding bit contributes
`to this parity check. The code can best be described by
`a Tanner graph [6], a graphical representation of the as-
`sociations between code bits and parity checks. Code bits
`are shown as variable nodes (circles), and parity checks as
`check nodes (squares), with edges connecting them. The
`number of edges on each node is called the node degree. If
`the node degree is identical for all variable nodes, the cor -
`responding parity check matrix is called regular, otherwise
`it’s irregular.
`By carefully inspection of the construction rules, the
`DVB-S2 parity check matrix consists of two distinctive
`
`Exhibit 0
`Page 106
`
`0002
`
`(cid:9)
`(cid:149)(cid:149)
`(cid:9)
`(cid:9)
`(cid:9)
`
`
`Case 2:13-cv-07245-MRP-JEM Document 29 Filed 03/06/14 Page 108 of 130 Page ID
` #:416
`
`b (cid:9)
`
`panty node update (parallel)
`
`check node update (parallel)
`
`E( (cid:9) (cid:128)Y
`
`forward update (sequential)
`
`backward update (parallel)
`
`Figure 2. a) conventional message up-
`date scheme b) optimized message update
`scheme
`
`between the variable and check nodes. The update of the
`nodes can be done with a canonical scheduling [2]: In the
`first step all variable nodes must be updated, in the second
`step all check nodes respectively. The processing of indi-
`vidual nodes within one step is independent, and can thus
`be parallelized.
`The exchanged messages are assumed to be log-
`likelihood ratios (LLR). Each variable node of degree i cal-
`culates an update of message k according to:
`
`i(cid:151)i
`
`:X1, (cid:9)
`kch+ (cid:9)
`1=0 1
`with Xch the corresponding channel LLR of the VN and 2,
`the LLRs of the incident edges. The check node LLR up-
`dates are calculated according to
`
`(4)
`
`tanh(7.qj2) = [J tanh(71/2). (cid:9)
`
`i(cid:151)I
`
`(5)
`
`l=O,lk
`For fixed-point implementations it was shown in [91 that
`the total quantization loss is < 0.1db when using a 6 bit
`message quantization compared to infinite precision. For a
`5 bit message quantization the loss is 0.1-0.2 dB [6].
`
`2.2 Optimized update of degree 2 Parity Nodes
`
`The DVB standard supports LDPC codes ranging from
`code rate R = 1/4 to R = /io. Each code has one common
`property: the connectivity of the check nodes caused by the
`accumulator of the encoder. CN0 is aiway connected to CN,
`by a variable node of degree 2 and so on for all CN nodes.
`A variable node of degree 2 has the property that the input
`of the first incident edge is the output of the second incident
`edge (plus the received channel value) and vice versa. For a
`sequential processing of the check nodes (e.g. from left to
`right in Figure 1) an already updated message can directly
`passed to the next check node due to the simple zigzag con-
`nectivity. This immediate message update changes the con-
`
`Rate
`1/4
`1/3
`2/5
`
`1/2
`3/5
`2/3
`3/4
`4/5
`
`/6
`8/9
`9/lo
`
`I (cid:9)
`
`I (cid:9) EPN
`EIN (cid:9)
`97200
`97199
`129600
`86399
`77759
`155520
`64799
`162000
`51839
`233280
`172800
`43199
`194400
`32399
`25919
`207360
`21599
`216000
`14399
`180000
`12959 1 181440
`
`]
`
`_Addr
`270
`360
`432
`450
`648
`480
`540
`576
`600
`500
`504
`
`q
`135
`120
`108
`90
`72
`60
`45
`36
`30
`20
`18
`
`Table 2. Code rate dependent parameters,
`with E the number of incident edges of IN and
`PN nodes and Addr the number of values re-
`quired to store the code stucture
`
`ventional update scheme between CN an VN nodes (Equa-
`tion 4).
`The difference in the update scheme is presented in Fig-
`ure 2. Only the connectivity between check nodes and par-
`ity nodes is depicted, the incident edges from the informa-
`tion nodes are omitted. Figure 2a) shows the standard belief
`propagation with the two phase update. In the first phase all
`messages from the PN to CN nodes are updated, in the sec-
`ond phase the messages from CN to PN nodes respectively.
`The message update within one phase is commutative and
`can be frilly parallized. Figure 2b) shows our new message
`update scheme in which the new CN message is directly
`passed to the next CN node. This data flow is denoted as
`a forward update and corresponds to a sequential message
`update. The backwards update from the PN to CN nodes is
`again a parallel update. Note that a sequential backwards
`update would result in a maximum a posteriori (MAP) al-
`gorithm.
`This new update scheme improves the communications
`performance. For the same communications performance
`10 iterations can be saved i.e. 30 iterations instead of 40
`have to be used. Furthermore we need to store only one
`message instead of two messages for the next iteration,
`which is explained in more detail in Section 4.
`
`3 Hardware mapping
`
`As already mentioned only partly parallel architectures
`are feasible. Hence only a subset P of the nodes are instan-
`tiated. The variable and check nodes have to be mapped on
`these P functional units. All messages have to be stored dur -
`ing the iterative process, while taking care of RAM access
`conflicts. Furthermore we need a permutation networks
`which provides the connectivity of the Tanner graph. -
`
`Exhibit G
`Page 107
`
`0003
`
`
`
`Case 2:13-cv-07245-MRP-JEM Document 29 Filed 03/06/14 Page 109 of 130 Page ID
` #:417
`
`0 rir 1
`
`360 message RAM banks
`rn
`
`13621
`722
`110821
`114421
`118021
`
`.
`
`7211
`I 10191
`I 19I
`117991
`12159 1
`
`13601
`I 720 I (cid:9)
`[nfonnationNodes1
`18081
`message mapping 114401
`18001
`2160 11
`
`13611
`I 721
`110801
`114411
`18011
`
`shiftvolue
`
`iou
`I (cid:9) 304 I
`1081
`131
`
`1210 I
`I
`1140 (cid:9)
`Il
`
`tional unit a RAM is associated to hold the corresponding
`messages (edges). Please note that for each IN of degree
`8, 8 storage places are allocated to this VN, because each
`incident edge has to be stored.
`The check nodes mapping depends on the rate depen-
`dent factor q. For R = 1/2 the first q = 90 CN nodes are
`mapped to the first functional unit. The next 90 CN nodes
`are mapped to the next producer and so on. Again the CN
`number corresponds to CN degree storage locations.
`This node mapping is the key for an efficient hardware
`realization, since it enables to use a simple shuffling net-
`work to provide the connectivity of the Tanner graph. The
`shuffling network ensures that at each cycle 360 input mes-
`sages are shuffled to 360 distinct target memories. Thus we
`have to store Ejy1390 = 450 shuffling and addressing infor-
`mation for the R = 1/2 code, see Table 2 for the other code
`rates. The shuffling offsets and addresses can be extracted
`from the x tables provided by [1].
`
`4 Decoder Architecture
`
`Based on the message mapping described in the previ-
`ous chapter, the basic architecture of the DVB-S2 LDPC
`decoder is shown in Figure 4. It consists of functional units
`which can process the functionality of variable and check
`nodes. This is possible, since only one type of the node are
`processed during one half iteration. The IN message menlo-
`ries banks hold the messages which are exchanged between
`information and check nodes. Furthermore we have memo-
`ries for storing the exchanged messages for the parity nodes
`(PN message memories), which are all of degree two. The
`address and shuffling RAM together with the shuffling net-
`work provides the connectivity of the Tanner graph.
`As mentioned the decoder processes 360 nodes in par-
`allel so 360 messages have to be provided per cycle. All
`360 messages are read from the same address from the IN
`message memory bank. Though, for the information node
`processing we just increment the reading address. The func-
`tional unit can accept each clock cycle new data, while a
`control flag just labels the last message belonging to a node
`and starts the output processing. The newly produced 360
`messages are then written back to the same address loca-
`tion but with a cyclic shift, caused by the shuffling network.
`To process the check nodes we have to read from dedicated
`addresses, provided by the address RAM. These addresses
`were extracted from node mapping as described in the pre-
`vious chapter. Again 360 messages are read per clock cycle
`and written back to the same address after the processing
`via the shuffling network. This ensures that the messages
`are shuffled back to their original position.
`The processing of the parity nodes can be done con-
`currently during the check node processing, by using the
`update soheme described in Section 2.2. Each functional
`
`32041
`
`
`
`3204
`
`323
`
`I
`
`1 (cid:9)
`
`ii
`
`0
`1
`2
`
`I
`I
`I
`
`4
`I (cid:9)
`I
`6 II
`89
`
`". (cid:9)
`
`-._
`
`I (cid:9) 90 I
`I (cid:9) 91
`I
`I (cid:9) 92
`I 93
`I
`I (cid:9) 94
`95 I (cid:9)
`I (cid:9) 96
`
`I
`
`1180 I
`11811
`I 182 I
`I 883 I
`1184
`1185 I (cid:9)
`
`I 186J
`
`07911
`
`269 1
`
`I
`I (cid:9) (cid:149) (cid:149) (cid:149)
`I
`
`l3231
`b23 1
`I32312
`I3231a
`1323141
`I32315fl
`bntd I
`
`1323991
`
`I (cid:9)
`40
`I (cid:9)
`60
`113
`I (cid:9) 410
`330
`I
`I
`I (cid:9) 100
`’
`
`VN 0flotwl
`otr4ls
`
`shuffling
`network
`
`Check Nodes
`message mapping
`
`CN fiunctionol
`units
`
`Figure 3. Message and functional unit map-
`ping for R=
`
`We can split the set of edges E connecting the check
`nodes in two subsets EJN and Epg, indicating the connec-
`tions between CN/IN nodes and CNIPN nodes respectively.
`-
`The subsets are shown in Table 2 for each code rate. Fur
`thermore the q factor of Equation 2 is listed. The implemen-
`tation of EJN is the challenging part, since this connectivity
`(11) changes for each code rate. The realization of EPN is
`straightforward, thus we focus on the mapping of the IN
`and CN nodes.
`Due to the varying node degrees the functional nodes
`process all incoming messages in a serial manner. Thus a
`functional node can except one message per clock cycle and
`produces at most one updated message per clock cycle.
`A careful analysis of Equation 2 shows that the connec-
`tivity of 360 edges of distinct information nodes are deter-
`mined by just one value x, while q is a code rate dependent
`constant, see Table 2.
`These 360 edges can be processed simultaneously by
`P = 360 functional units. Within a half iteration a func-
`(k (cid:151)2) is the
`tional unit has to process q * (k (cid:151)2) edges.
`number of edges between one check node and information
`nodes. For each code rate q was chosen to satisfy the con-
`straint
`
`EJN1360=q*(k-2). (cid:9)
`
`(6)
`
`It guarantees that each functional unit has to process the
`same amount of nodes which simplifies the node mapping.
`Figure 3 shows the mapping of the IN and CN nodes for the
`LDPC code of rate R = 1/2. Always 360 consecutive VN
`nodes are mapped to 360 functional units. To each func-
`
`4
`
`Exhibit
`Page 108
`
`0004
`
`
`
`Case 2:13-cv-07245-MRP-JEM Document 29 Filed 03/06/14 Page 110 of 130 Page ID
` #:418
`
`Figure 4. Basic architecture of our LDPC decoder
`
`unit processes consecutive check nodes (Figure 3). The
`message which is passed during the forward update of the
`check nodes is kept in the functional unit. Only the mes-
`sages of the backward update has to be stored which re-
`duces the memory requirements for the zigzag connectivity
`to EpN12 messages. The PN message memories are only
`read and written during the check node phase, while the
`channel (CH) RAMs delivers the corresponding received
`channel value.
`We use single port SEAMs due to area and power ef-
`ficiency. Hence we have to take care of read/write con-
`flicts during the iterative process. Read/write conflicts oc-
`cur, since data are continously read from the 360 RAMs and
`provided to the functional units, while new processed mes-
`sages have to be written back.
`The check node processing is the most critical part.
`We have to read from dedicated addresses extracted dur-
`ing the mapping process. Therefore, the IN message mem-
`ory block is partitioned in 4 RAMs which is shown in Fig-
`ure 5. Even if the commutativity of the message processing
`within a check node is exploited all write conflicts can not
`be avoided. Therefore a buffer is required to hold a mes-
`sage if writing is not possible due to a conflict. We use
`simulated annealing to find the best addressing scheme to
`reduce RAM access conflicts and hence to minimize the
`buffer overhead. This optimization step ensures that only
`one buffer is required which holds for all code rates. Per
`clock cycle we read data from one RAM, and write at most
`2 data back to two distinct RAMs, coming from the buffers
`or the shuffling network. The two least significant bits of
`the addresses determines the assignment to a partition. This
`
`allows a simple control flow, which just has to compare the
`reading and the writing addresses of the current clock cycle.
`The resulting decoder throughput T is
`
`(7)
`
`T=_:_.f, (cid:9)
`#cyc
`with I the number of information bits to be decoded and
`#cyc the number of cycles to decode one block including
`the input/output (I/O) processing.
`The number of cycles is calculated as (cid:9)
`Thus Equation 7 yields:
`
`+It. (2. W).
`
`I
`+It (2.(+Tiatency))
`P
`
`P10 (cid:9)
`
`feycie. (cid:9)
`
`(8)
`
`The part C
`is the number of cycles for input/output
`Flo
`(110) processing. The decoder is capable to receive 10 chan-
`nel values per clock cycle. Reading a new codeword of size
`C and writing the result of the prior processed block can be
`done in parallel with reading/writing Pio data concurrently.
`The latency Tiazency for each iteration depends on the pro-
`cessing units and the shuffling network.
`
`5 Results
`
`The LDPC decoder is implemented as a synthesizable
`VHDL model. Results are obtained with the Synopsis
`Design Compiler based on a ST Microelectronics 0.1 3pm
`CMOS technology. The maximum clock frequency is 270
`MHz under worst case conditions. The decoder is capable
`to process all specified code rates of the DVB standard with
`
`Exhibit G
`Page 109
`
`0005
`
`
`
`Case 2:13-cv-07245-MRP-JEM Document 29 Filed 03/06/14 Page 111 of 130 Page ID
` #:419
`
`input
`
`IILr
`
`D (cid:9) 4J..,4J1
`ii (cid:9)
`It
`I (cid:9)
`l
`(a
`
`Q
`
`o
`
`I (cid:9)
`
`I
`
`I (cid:9) L\i
`
`I
`
`.11
`
`II’
`
`II’
`
`Figure 5. Hierarchical RAM structure
`
`the required throughput of 255Mbit/s. 30 iterations are as-
`sumed.
`Table 3 shows the synthesis results for a 6 bit message
`quantization of the channel values and the exchanged mes-
`sages. The overall area is 22.74mm 2. The area is deter-
`mined by different code rates.
`R = 1/4 has the largest set of parity nodes and defines
`the size of the PN message memories. While the rate R =
`31 has the most edges to the infonntion nodes and hence
`determines the size of the IN message memory banks. The
`size of a functional node depends on the maximum IN and
`PN degree, respectivly (R = 2/3 and R = 9/1o).
`The area is splitted in three parts: RAMs, logic and the
`shuffling network. Storing the messages yields the major
`part of the RAM area with 9.12mm 2. It is important to note,
`that only an area of 0.075mm 2 is required to store the con-
`nectivity of the Tanner graph. This shows the efficiency
`of our architectural approach. The logic area of the func-
`tional nodes with 10.8mm 2 is a major part of the overall
`area. This is due to the required flexibility of the different
`code rates. We also placed and routed the shuffling network
`to test routing congestions. Due to its regularity no conges-
`tions resulted, its area is dominated by the logic cells.
`
`6 Conclusion
`
`Low-Density Parity-Check codes are part of the new
`DVB-S2 standard. In this paper we presented to the best
`of our knowledge the first published IP core for DVB-52
`LDPC decoding. We explained how to explore the code
`structure for an efficient hardware mapping and presented
`a decoder architecture which can process all specified code
`rates ranging from R = 1/4 to R = /io.
`
`Table 3. Synthesis Results for the DVB-S2
`LDPC code decoder
`
`7 Acknowledgments
`
`The work presented in this paper was supported by the
`European 1ST project 4More 40 MC-CDMA multiple an-
`tenna system On chip for Radio Enhancements [10].
`Our special thanks goes to Friedbert Berens from the
`Advanced System Technology Group of STM, Geneva,
`Switzerland, for many valuable discussions.
`
`References
`
`[1] European Telecommunications Standards Institude (ETSI).
`Digital Video Broadcasting (DVB) Second generation fram-
`ing structure for broadband satellite applications; EN 302
`307 V1.1.l. www.dvb.org .
`[2] R. G. Gallager. Low-Density Parity-Check Codes. M.I.T.
`Press, Cambridge,Massachusetts, 1963.
`[3] C. Berrou. The Ten-Year-Old Turbo Codes are Entering
`into Service. IEEE Communications Magazine, 41:110-
`116, Aug. 2003.
`[4] A. Blanksby and C. J. Howland. A 690-mW 1-Gb/s, Rate-
`1/2 Low-Density Parity-Check Code Decoder. IEEE Journal
`of Solid-State Circuits, 37(3):404-412, Mar. 2002.
`[5] E. Boutillon, J. Castura, and F. Kschischang. Decoder-
`fi rat code design. In Proc. 2nd International Symposium
`on Turbo Codes & Related Topics, pages 459-462, Brest,
`France, Sept. 2000.
`[6] T. Richardson and R. Urbanke. The Renaissance of Gal-
`lager’s Low-Density Pariy-Check Codes. IEEE Communi-
`cations Magazine, 41:126-131, Aug. 2003.
`[7] F. Kienle and N. Wehn. Design Methodology for IRA
`Codes. In Proc. 2004 Asia South Pacfi c Design Automation
`Conference (ASP-DAC ’04), Yokohama, Japan, Jan. 2004.
`[8] H. Jin, A. Khandekar, and R. McEliece. Irregular Repeat-
`Accumulate Codes. In Proc. 2nd International Symposium
`on Turbo Codes & Related Topics, pages 1-8, Brest, France,
`Sept. 2000.
`[9] T. Zhang, Z. Wang, and K. Parhi. On finite precision im-
`plementation of low-density parity-check codes decoder. In
`Proc.International Symposium on Circuits and Systems (IS-
`CAS ’01), Antwerp,Belgium, May 2001.
`[10] http://ist-4more.org .
`
`Exhibit
`Page 110
`
`0006
`
`