# Patent

## Title
Flexible channel decoder

## Abstract

A configurable Turbo-LDPC decoder having A set of P>1 Soft-Input-Soft-Output decoding units (DP0-DPP-1; DPi) for iteratively decoding both Turbo- and LDPC-encoded input data, each of the decoding units having first (I1i) and second (I2i) input ports and first (O1i) and second (O2i) output ports for intermediate data; First and second memories (M1, M2) for storing the intermediate data, each of the first and second memories comprising P independently readable and writable memory blocks having respective input and output ports; and A configurable switching network (SN) for connecting the first input and output ports of the decoding units to the output and input ports of the first memory, and the second input and output ports of the decoding units to the output and input ports of the second memory.

## Background
FIELD OF THE INVENTION
The invention relates to a flexible and configurable channel decoder suitable for decoding both Turbo codes and Low Density Parity Check (LDPC) codes, which are widely used in modern communication standards due to their remarkable error correction performances. Within this context, a decoder is considered “flexible” when it is compliant with different standard, characterized by different coding algorithm (Turbo- or LDPC), frame lengths, throughput and latency requirements.
BACKGROUND OF THE INVENTION
Nowadays the demand of multi-standard applications has become a must for the worldwide user. In such a scenario, a wide range of contents can be provided by integrating onto the same device the support of different communication protocols, both satellite and terrestrial. Flexibility is then the keyword in the design of modern modems and particular attention must be paid to the implementation of the advanced channel coding techniques which represents the most challenging task in terms of computational complexity, speed and power consumption. Indeed, particularly for mobile devices, flexibility has to be combined with low complexity and power consumption.
The evolution of the mobile phone market represents a valuable example of this overwhelming trend. Born exclusively for voice services, it has quickly grown up embracing different data services such as Short-Message-Service (SMS), Multimedia-Messaging-Service and Wireless-Application-Protocol (WAP) internet connections. Nowadays, modern “smartphones” are designed to be capable of connecting to high speed cellular networks for mobile internet (3GPP-HSPA, 3GPP-LTE), high speed wireless local and metropolitan area networks for wireless internet connections (IEEE 802.11n, IEEE 802.16e) and satellite networks to receive broadcast video and multimedia contents (DVB-SH). This wide range of applications demands ever-increasing data rates and high reliability so as to guarantee an adequate Quality of Service (QoS). Channel coding is an effective method to improve the communication performances and, among the possible candidates, low-density parity-check (LDPC) and Turbo codes are regarded as excellent solutions for advanced forward error correction (FEC).
LDPC codes were first discovered by Gallager in 1960 but, despite the remarkable error correction performance, they were soon given up as their decoding complexity was too high with respect to the computation capabilities of the time. Recently, the impressive improvement of the micro-electronics technology having made the decoding complexity manageable, LDPC codes have become one of the most hot research topic in the field of communication systems. At the same time, the industrial attention to the LDPC codes has widely grown to such an extent that they have been included in several communication standards; namely the Digital Video Broadcasting Satellite Second generation DVB-S2, the second generation digital transmission system for cable and terrestrial systems DVB-C2 and DVB-T2, as well as IEEE 802.11n, IEEE 802.16e and IEEE 802.3an for new generation Ethernet connections.
Turbo codes were invented by Berrou in 1993 and have proved to be very effective forward error correcting codes featuring performance very close to the theoretical Shannon limit. The strength point of this invention was the introduction of the iterative decoding of the constituent convolutional codes. Nowadays, the Turbo code scheme is the preferred choice of many communication standards, such as, the 3rd generation partnership project standards (3GPP-UMTS, 3GPP-HSPA and 3GPP-LTE), the Digital video Broadcasting-Service to Handheld (DVB-SH), the Digital Video Broadcasting-return channel via satellite (DVB-RCS) and the IEEE 802.16e.
An advanced FEC channel decoder is often the most computational demanding block of the whole transceiver and consequently represents the bottleneck in terms of hardware-complexity, achievable data-rate and power consumption. Moreover the channel decoder must be compliant with all the communication standards specified by the particular device. In this sense, flexibility, i.e. the capability of supporting different communication standards with the minimum software/hardware utilization, represents the driving factor to keep complexity, latency and power consumption under control.
The most straightforward solution to attain flexibility is the design of one separated core for each channel decoding scheme (either LDPC or Turbo Codes or both) defined by all the communication standards to be supported. Although optimized in terms of data-rate and error correction performances, this approach is very demanding in terms of area and power consumption thus violating the strict budget of a mobile/portable device.
As an alternative way, it is possible to design two different cores implementing a Turbo and a LDPC flexible decoder architecture, respectively. Each core must be designed to be compliant with all the required standards, and commonalities between different code classes must be identified in order to efficiently share hardware resources and reduce the overall complexity. In this regard, Masera et al. proposes a flexible LDPC decoder compliant with IEEE 802.11n and IEEE 802.16e [1] and Lee et al. designed a flexible unified LDPC decoder architecture capable of supporting IEEE 802.11n, IEEE 802.16e and DVB-S2 [2]. As far as Turbo decoding is concerned, it is also worth mentioning the Flexible binary/duo-binary Turbo decoder architecture compliant with UMTS and IEEE 802.16e by Martina et al. [3] and the parallel radix-4 Turbo decoder for IEEE 802.16e and 3GPP-LTE by Kim et al. [4]. This last strategy allows a considerable reduction of the overall channel decoding platform complexity and power consumption; however it still requires two separate cores making it unsuitable for application where very strict area and power constraints are demanded, like in small mobile devices.
Application-Specific Instruction-set Processors (ASIP) allow the implementation of single-core flexible decoders. They are programmable circuits (processors) wherein a dedicated instruction-set is directly mapped on optimized hardware for improved performances. This optimized software/hardware configuration, tailored for the specific application, allows an high degree of flexibility with relatively low complexity. As an example, Alles at al. purpose the so-called FlexiChaP architecture [5], capable of supporting binary/duo-binary turbo codes as well as LDPC codes for IEEE 802.11n and IEEE 802.16e with a chip area of only 0.622 mm2 using a 65 nm CMOS technology. The key of such a design is the identification of common hardware resources that can be re-used among different decoding schemes and efficiently mapped into a software instruction. Another interesting ASIP channel decoding platform is proposed by Naessens et al. [6, 7] where the support of the IEEE 802.16e and IEEE 802.11n codes is achieved with a chip area of 0.96 mm2 using a 45 nm CMOS technology. The main drawback of this approach is the achievable data-rate (throughput) and the power consumption. Actually due to the very low hardware complexity, all the decoding steps must be performed in a time division manner. Consequently, in order to reduce the decoding time, the operating clock frequency is generally high with a considerable increase in the overall power consumption. As an example in [5] the operating clock frequency was pushed to 400 MHz and the attainable throughput was anyway not enough to fully support the IEEE 802.16e standard.
Joint minimization of hardware complexity and power consumption under demanding throughput constraints can only be achieved by an ASIC (Application Specific Integrated Circuit) implementation. Cavallaro et al. describes a preliminary ASIC flexible decoding architecture supporting both Turbo and LDPC codes [8]; however, such an architecture is not used to implement a Multi-Standard decoder but different ad-hoc single-standard solutions. Trofimenko et al. [9] disclose a “unified” decoder capable of supporting Turbo, LDPC and convolutional codes with a single core. However, this core is not optimized in terms of hardware complexity. Moreover, the critical issue of standard-dependent parallelization is not discussed. Three of the present inventors (Massimo Rovini, Giuseppe Gentile and Luca Fanucci) have disclosed an ASIC-implemented state-metric recursive unit, usable for both Turbo- and LDPC-decoding [10]. This unit, however, is only a component (albeit an important one) of a full flexible decoder.
SUMMARY OF THE INVENTION
The invention aims at providing a flexible Turbo/LDPC decoder overcoming all or part of the drawbacks of the cited prior art.
A configurable Turbo-LDPC decoder according to the invention comprises:

    
    
        A set of P>1 Soft-Input-Soft-Output decoding units for iteratively decoding both Turbo- and LDPC-encoded input data, each of said decoding units having first and second input ports and first and second output ports for intermediate data;
        First and second memories for storing said intermediate data, each of said first and second memories comprising P independently readable and writable memory blocks having respective input and output ports; and
        A configurable switching network for connecting the first input and output ports of said decoding units to the output and input ports of said first memory, and the second input and output ports of said decoding units to the output and input ports of said second memory.
    
    


This architecture allows implementing different parallelization schemes with minimal hardware overhead. Parallelization is important to achieve a high throughput, and different parallelization schemes have to be used when dealing with different communication standards. More particularly, the switching network of the inventive decoder allows the selective implementation of the following parallelization schemes:

    
    
        simultaneous decoding of several Turbo-encoded frames by at least some of said P decoding units;
        parallelized decoding of a single Turbo-encoded frame by at least some of said P decoding units; and
        parallelized decoding of a single LDPC-encoded frame by at least some of said P decoding units, each processing one or more parity-check constraints.
    
    


Advantageous embodiments of the inventive flexible decoder and of some of its sub-units constitute the subject-matter of the dependent claims.
Another object of the invention is a Soft-Input-Soft-Output Turbo- and LDPC-decoding unit having:

    
    
        a first input port for input reliabilities used in Turbo-decoding, and for check-to-variable metrics used in LDPC-decoding;
        a second input port for extrinsic reliabilities used in Turbo-decoding and for intermediate soft outputs used for LDPC-decoding;
        a first output port for check-to-variable metrics updated during LDPC-decoding; and
        a second output port for extrinsic reliabilities obtained as intermediate or final results of Turbo-decoding, and for soft outputs obtained as intermediate or final results of LDPC-decoding;
    
    


said decoding unit comprising the following functional blocks:

    
    
        A by-passable channel cumulative computation unit for computing channel cumulative messages by adding-up input reliabilities;
        A state-metric recursive unit for successively performing recursive computation of forward- and backward metrics, taking said channel cumulative messages as inputs;
        A state-metric memory for storing already-computed forward metrics while the state-metric recursive unit is computing backward metrics, or vice-versa; and
        An extrinsic reliabilities processor for computing extrinsic reliabilities, for Turbo-decoding, and soft outputs and check-to-variable metrics, for LDPC decoding, taking said forward metrics, backward metrics and channel cumulative messages as its inputs.
    
    


Advantageously, said Soft-Input-Soft-Output Turbo- and LDPC-decoding unit can also comprise configurable distribution networks for transferring data from the input ports of the decoding units to its functional block, and between said functional blocks, according to different data formats and decoding algorithms.
Still another object of the invention is an extrinsic reliability processor for computing extrinsic reliabilities in Turbo-decoding, and soft outputs and check-to-variable metrics, in LDPC decoding, having input ports for forward metrics, backward metrics and channel cumulative messages corresponding to different trellis edges, and comprising:

    
    
        a first stage of adders, for adding forward, backward and channel cumulative messages corresponding to a same trellis edge;
        a number 2M of max* or max trees equal to the number of said alphabet symbols;
    
    


a number K of 2M×2M permutation networks equal to the number of said trellis states, connecting output ports of said adders to input ports of said max* or max trees, wherein each of said max* or max trees has K input ports, each one being connected to a different one of said permutation networks;

    
    
        a third stage of adders for computing extrinsic reliabilities as sums of outputs of said max* or max trees; and
        fourth and fifth stages of adders for computing updated check-to-variable metrics and LDPC-soft outputs by combining input and outputs of first stages of said max* or max trees.
    
    


Still another object of the invention is a state-metric recursive unit for performing recursive computation of forward- and backward metrics according to the BCJR algorithm, comprising a plurality of state metric processors for computing forward and backward metrics of respective states of a code trellis, interconnected by a configurable recursion network, each said state metric processor comprising:

    
    
        first input ports for receiving, through said recursion network, forward/backward metrics;
        second input ports for receiving channel cumulative messages corresponding to different edges reaching a same state of a code trellis;
        a first stage of adders, for adding forward, backward and channel cumulative messages corresponding to a same code symbol;
        third input ports for receiving a posteriori reliabilities/Soft-outputs;
        a second stage of adders, for adding said a posteriori reliabilities to the sums performed by the adders of said first stages;
        a max* or max tree taking as inputs the sums computed by the adders of said second stage; and
        first output ports for updated values of said forward/backward metrics.
    
    


The Soft-Input-Soft-Output Turbo- and LDPC-decoding unit, the extrinsic processor and the state-metric recursive unit of the invention can be used as elements of a flexible Turbo/LDPC decoder as described above, but they can also be realized as independent devices (preferably implemented as ASICs) or as elements of other more complex devices.



BRIEF DESCRIPTION OF THE DRAWINGS
Additional features and advantages of the present invention will become apparent from the subsequent description, taken in conjunction with the accompanying drawings, which show:
FIGS. 1A to 1C, the block diagrams of a Recursive Systematic Convolutional (RSC) error-correcting code, of a Parallel Concatenated Convolutional Code (PCCC), and of a Serial Concatenated Convolutional Code (SCCC), respectively;
FIG. 2, an exemplary code trellis;
FIGS. 3A and 3B, the block diagrams of PCCC and SCCC decoding algorithms, respectively;
FIGS. 4A, 4B and 4C, examples of a Parity Check Matrix, of a Tanner graph representing a LDPC code and of the equivalent 2-state trellis of a LDPC check node;
FIG. 5, the high-level block diagram of a flexible Turbo and LDPC decoder according to the invention;
FIGS. 6A, 6B and 6C, three different parallelization schemes which can be implemented using the architecture of FIG. 5;
FIGS. 7A1-9C, 20A and 20B, arrangements of the different memories of an exemplary decoder based on the architecture of FIG. 5;
FIGS. 10-19B, 21-27 and 31, preferred implementations of logic units forming said exemplary decoder;
FIGS. 28 and 29, a modified decoding units for processing SCCC Turbo-codes; and
FIG. 30 the trellis of an exemplary non-binary LDPC code over GF(4).



DETAILED DESCRIPTION
Before describing the invention in detail, it will be necessary to recall some basic facts on Turbo- and LDPC-codes and on their decoding algorithms.
The constituent block of a Turbo code is a recursive systematic convolutional code (RSC-code) which is produced by a linear feedback shift register. FIG. 1A shows an example of a binary RSC-code encoder with rate R=1/2, constraint length L=4, and generator vector equals to:




  
    
      
        G
        =
        
          [
          
            1
            ,
            
              
            
            ⁢
            
              
                1
                +
                D
                +
                
                  D
                  2
                
              
              
                1
                +
                D
                +
                
                  D
                  3
                
              
            
          
          ]
        
      
    
    
      
        (
        1
        )
      
    
  




On the figure, ui represent the input bit sequence, and ci,1, ci,2 the generated code bits.
The rate of the code can be defined as the ratio between the number of the encoder input and output bits in a single time slot, while the constraint length equals the register number of the encoder plus 1. The generator vector of such an encoder features as many components as the number of output bits and indicates how to connect the input and the output of the registers to achieve the desired results. Particularly, in (1) the first output ci,1 is merely short circuited with the input (systematic), while the second ci,2 is the combination of a forward and a backward path. The forward path, represented by the numerator, involves the first, the second and the third tap (a tap is a connection feeding or coming out of a register) while the backward path, represented by the denominator, is the sum of the input, the second and the fourth tap.
The most popular class of Turbo codes is the Parallel Concatenated Convolutional Codes (PCCC). FIG. 1B shows an example of such an encoder architecture which is composed of two RSC-code encoders (constituent encoders) plus an interleaver Π which feeds the second RSC-encoder with a different-ordered version ûi of the input sequence ui.
The other class of Turbo codes is the Serial Concatenated Convolutional Codes (SCCC). The architecture of the related encoder is shown in FIG. 1C and it is composed of two RSC encoders serially connected through an interleaver.
Turbo codes can be binary or M-binary. In the latter case, the constituent RSC codes are fed with an input symbol representing M>1 bits. In practice, only binary and duo-binary (M=2) codes are used, but this is not a fundamental limitation, and alphabets with more than 22=4 symbols can also be used.
The turbo decoding algorithm reflects the encoder structure so it is composed of two “SISO” (Soft-Input-Soft-Output) decoding units, decoding the constituent RSC-code, iteratively exchanging information (through interleavers) to improve the reliability of the received codeword. Before going into details of the Turbo-decoding, it is expedient to recall the BCJR (Bahl, Cocke, Jelinek and Raviv) algorithm, used for decoding the constituent RSC codes. As it will be discussed further, the BCJR can also be used for decoding LDPC codes, making it particularly useful for the realization of a flexible decoder.
Let us consider an (RSC) encoder fed by an information word u0, u1, . . . , ui, . . . , uK-1 where each symbol ui is composed of M bits (M=1 in case of binary codes and M=2 in case of duo-binary codes). The encoder produces then an N-bit output codeword c0, c1, . . . , cN-1 with R=K·M/N the rate of the code. The BCJR algorithm provides the a-posteriori probabilities of the information symbol given the received codeword, in the Log-Likelihood Ratio (LLR) format




  
    
      
        
          
            Λ
            i
            APO
          
          ⁡
          
            (
            U
            )
          
        
        =
        
          ln
          ⁢
          
            
              P
              ⁡
              
                (
                
                  
                    u
                    i
                  
                  =
                  
                    U
                    |
                    r
                  
                
                )
              
            
            
              P
              ⁡
              
                (
                
                  
                    u
                    i
                  
                  =
                  
                    
                      U
                      o
                    
                    |
                    r
                  
                
                )
              
            
          
        
      
    
    
      
        (
        2
        )
      
    
  




where U is one of the possible values of the input symbol ui, U0 is a value of the input symbol taken as a reference and r is the information available at the receiver after the transmission over the noisy channel.
The operations of a convolutional encoder can be described by means of a particular graph, named trellis, tracking the evolution of the register states depending on the input symbol. Actually, the state of the encoder at the time i (Si) and then its outputs (ci), depends only on the state of the encoder at the previous time slot (Si−1) and on the current information symbol (Ui). An example of trellis graph for an eight-state convolutional encoder is shown on FIG. 2.
The BCJR algorithm is based on the trellis representation of the encoding process, and the a-posteriori LLR of the information symbols can be evaluated as:




  
    
      
        
          
            Λ
            i
            APO
          
          ⁡
          
            (
            U
            )
          
        
        =
        
          ln
          ⁢
          
            
              
                ∑
                
                  
                    e
                    :
                    
                      u
                      i
                    
                  
                  =
                  U
                
                
                  
                
              
              ⁢
              
                
                  
                    α
                    i
                  
                  ⁡
                  
                    (
                    
                      S
                      e
                      l
                    
                    )
                  
                
                ⁢
                
                  
                    β
                    
                      i
                      +
                      1
                    
                  
                  ⁡
                  
                    (
                    
                      S
                      e
                      r
                    
                    )
                  
                
                ⁢
                
                  P
                  ⁡
                  
                    (
                    
                      
                        u
                        i
                      
                      =
                      U
                    
                    )
                  
                
                ⁢
                
                  
                    ∏
                    n
                    
                      
                    
                  
                  ⁢
                  
                    
                  
                  ⁢
                  
                    P
                    ⁡
                    
                      (
                      
                        
                          c
                          
                            i
                            ,
                            n
                          
                        
                        =
                        
                          c
                          n
                          e
                        
                      
                      )
                    
                  
                
              
            
            
              
                ∑
                
                  
                    e
                    :
                    
                      u
                      i
                    
                  
                  =
                  
                    U
                    0
                  
                
                
                  
                
              
              ⁢
              
                
                  
                    α
                    i
                  
                  ⁡
                  
                    (
                    
                      S
                      e
                      l
                    
                    )
                  
                
                ⁢
                
                  
                    β
                    
                      i
                      +
                      1
                    
                  
                  ⁡
                  
                    (
                    
                      S
                      e
                      r
                    
                    )
                  
                
                ⁢
                
                  P
                  ⁡
                  
                    (
                    
                      
                        u
                        i
                      
                      =
                      
                        U
                        0
                      
                    
                    )
                  
                
                ⁢
                
                  
                    ∏
                    n
                    
                      
                    
                  
                  ⁢
                  
                    
                  
                  ⁢
                  
                    P
                    ⁡
                    
                      (
                      
                        
                          c
                          
                            i
                            ,
                            n
                          
                        
                        =
                        
                          c
                          n
                          e
                        
                      
                      )
                    
                  
                
              
            
          
        
      
    
    
      
        (
        3
        )
      
    
  




Where “e: ui=U” is the set of edges with the information symbol equal to U, αi(Sel) is the “forward” metric of the state at the left of the considered edge (starting state), βi+1(Ser) is the “backward” metric of the state at the right of the considered edge (ending state), P(ui=U) is the probability of the information symbol and




  
    ∏
    n
    
      
    
  
  ⁢
  
    
  
  ⁢
  
    P
    ⁡
    
      (
      
        
          c
          
            i
            ,
            n
          
        
        =
        
          c
          n
          e
        
      
      )
    
  




is the product of the probabilities of the coded bits associated to the edge whose number is equal to the number of output bits per clock cycle of the RSC encoder.

The forward (backward) metrics are evaluated by initializing the values at the beginning (end) of the trellis and by recursively proceeding through the trellis itself:




  
    
      
        {
        
          
            
              
                
                ⁢
                
                  
                    
                      α
                      0
                    
                    ⁡
                    
                      (
                      S
                      )
                    
                  
                  =
                  
                    
                      α
                      init
                    
                    ⁡
                    
                      (
                      S
                      )
                    
                  
                
              
            
          
          
            
              
                
                ⁢
                
                  
                    
                      α
                      
                        i
                        +
                        1
                      
                    
                    ⁡
                    
                      (
                      S
                      )
                    
                  
                  =
                  
                    
                      ∑
                      
                        e
                        :
                        
                          
                            S
                            *
                          
                          →
                          S
                        
                      
                      
                        
                      
                    
                    ⁢
                    
                      
                        
                          α
                          i
                        
                        ⁡
                        
                          (
                          
                            S
                            *
                          
                          )
                        
                      
                      ⁢
                      
                        P
                        ⁡
                        
                          (
                          
                            
                              u
                              i
                            
                            =
                            
                              U
                              e
                            
                          
                          )
                        
                      
                      ⁢
                      
                        
                          ∏
                          n
                          
                            
                          
                        
                        ⁢
                        
                          
                        
                        ⁢
                        
                          P
                          ⁡
                          
                            (
                            
                              
                                c
                                
                                  i
                                  ,
                                  n
                                
                              
                              =
                              
                                c
                                n
                                e
                              
                            
                            )
                          
                        
                      
                    
                  
                
              
            
          
          
            
              
                
                ⁢
                
                  
                    
                      β
                      K
                    
                    ⁡
                    
                      (
                      S
                      )
                    
                  
                  =
                  
                    
                      β
                      init
                    
                    ⁡
                    
                      (
                      S
                      )
                    
                  
                
              
            
          
          
            
              
                
                ⁢
                
                  
                    
                      β
                      i
                    
                    ⁡
                    
                      (
                      S
                      )
                    
                  
                  =
                  
                    
                      ∑
                      
                        e
                        :
                        
                          
                            S
                            *
                          
                          →
                          S
                        
                      
                      
                        
                      
                    
                    ⁢
                    
                      
                        
                          β
                          
                            i
                            +
                            1
                          
                        
                        ⁡
                        
                          (
                          
                            S
                            *
                          
                          )
                        
                      
                      ⁢
                      
                        P
                        ⁡
                        
                          (
                          
                            
                              u
                              i
                            
                            =
                            
                              U
                              e
                            
                          
                          )
                        
                      
                      ⁢
                      
                        
                          ∏
                          n
                          
                            
                          
                        
                        ⁢
                        
                          
                        
                        ⁢
                        
                          P
                          ⁡
                          
                            (
                            
                              
                                c
                                
                                  i
                                  ,
                                  n
                                
                              
                              =
                              
                                c
                                n
                                e
                              
                            
                            )
                          
                        
                      
                    
                  
                
              
            
          
        
      
    
    
      
        (
        4
        )
      
    
  




where “e: S*→S” is the set of states at time i(i+1) connected to the state S at time i+1(i).
Initialization of equations (4) is made possible by the fact that Turbo codes are either terminated (initial and final state known) or circular (initial and final states unknown, but identical). It should be noted that αi is computed starting from the first state S0 of the code trellis (“forward recursion”) while β is computed starting from the last state SK of the trellis (“backward recursion”). Actually, β-recursion (the same is also true for α-recursion) can also start from an unknown state SK′ provided that it is sufficiently far than the state Si to be estimated. The first estimations of the metrics are poor, but after a few recursions (“training sequence”) they become sufficiently reliable. This is important, as it allows subdividing a long trellis—corresponding to a long codeword—into smaller “sub-trellises” which can be processed serially or in parallel.
Equation (3) contains multiplications, which would substantially increase the implementation complexity. Therefore, it is useful to rewrite it using the LLR versions of the involved factors, and particularly




  
    
      
        α
        i
        LLR
      
      ⁡
      
        (
        S
        )
      
    
    =
    
      ln
      ⁢
      
        
          
            α
            i
          
          ⁡
          
            (
            S
            )
          
        
        
          
            α
            i
          
          ⁡
          
            (
            
              S
              0
            
            )
          
        
      
    
  
  ,
  
    
      
        β
        i
        LLR
      
      ⁡
      
        (
        S
        )
      
    
    =
    
      
        ln
        ⁢
        
          
            
              β
              i
            
            ⁡
            
              (
              S
              )
            
          
          
            
              β
              i
            
            ⁡
            
              (
              
                S
                0
              
              )
            
          
        
        ⁢
        
          
        
        ⁢
        and
        ⁢
        
          
        
        ⁢
        
          λ
          
            i
            ,
            n
          
        
      
      =
      
        ln
        ⁢
        
          
            
              P
              ⁡
              
                (
                
                  
                    c
                    
                      i
                      ,
                      n
                    
                  
                  =
                  1
                
                )
              
            
            
              P
              ⁡
              
                (
                
                  
                    c
                    
                      i
                      ,
                      n
                    
                  
                  =
                  0
                
                )
              
            
          
          .
        
      
    
  




It can be shown that:





  
    
      
        
          
            Λ
            i
            APO
          
          ⁡
          
            (
            U
            )
          
        
        =
        
          ln
          ⁢
          
            
              
                P
                ⁡
                
                  (
                  
                    
                      u
                      i
                    
                    =
                    U
                  
                  )
                
              
              
                P
                ⁡
                
                  (
                  
                    
                      u
                      i
                    
                    =
                    
                      U
                      0
                    
                  
                  )
                
              
            
            ·
            
              
                
                  ∑
                  
                    
                      e
                      :
                      
                        u
                        i
                      
                    
                    =
                    U
                  
                  
                    
                  
                
                ⁢
                
                  exp
                  ⁡
                  
                    (
                    
                      
                        
                          α
                          i
                          LLR
                        
                        ⁡
                        
                          (
                          
                            S
                            e
                            l
                          
                          )
                        
                      
                      +
                      
                        
                          β
                          
                            i
                            +
                            1
                          
                          LLR
                        
                        ⁡
                        
                          (
                          
                            S
                            e
                            r
                          
                          )
                        
                      
                      +
                      
                        
                          ∑
                          n
                          
                            
                          
                        
                        ⁢
                        
                          
                            c
                            n
                            e
                          
                          ·
                          
                            λ
                            
                              i
                              ,
                              n
                            
                          
                        
                      
                    
                    )
                  
                
              
              
                
                  ∑
                  
                    
                      e
                      :
                      
                        u
                        i
                      
                    
                    =
                    
                      U
                      0
                    
                  
                  
                    
                  
                
                ⁢
                
                  exp
                  ⁡
                  
                    (
                    
                      
                        
                          α
                          i
                          LLR
                        
                        ⁡
                        
                          (
                          
                            S
                            e
                            l
                          
                          )
                        
                      
                      +
                      
                        
                          β
                          
                            i
                            +
                            1
                          
                          LLR
                        
                        ⁡
                        
                          (
                          
                            S
                            e
                            r
                          
                          )
                        
                      
                      +
                      
                        
                          ∑
                          n
                          
                            
                          
                        
                        ⁢
                        
                          
                            c
                            n
                            e
                          
                          ·
                          
                            λ
                            
                              i
                              ,
                              n
                            
                          
                        
                      
                    
                    )
                  
                
              
            
          
        
      
    
    
      
        (
        5
        )
      
    
  




where the factor





  
    
      Λ
      i
      APR
    
    ⁡
    
      (
      U
      )
    
  
  =
  
    ln
    ⁢
    
      
    
    ⁢
    
      
        P
        ⁡
        
          (
          
            
              u
              i
            
            =
            U
          
          )
        
      
      
        P
        ⁡
        
          (
          
            
              u
              i
            
            =
            
              U
              0
            
          
          )
        
      
    
  




can be regarded as the a-priori reliability of the information symbol coming, in a Turbo decoding, from the neighbor convolutional “SISO” decoder.

Equation (5) can be written in a simpler form by using the “max*” operator:




   
  
    {
    
      
        
          
            
              
                max
                *
              
              ⁢
              
                (
                
                  a
                  ,
                  b
                
                )
              
            
            =
            
              
                ln
                ⁡
                
                  (
                  
                    
                      e
                      a
                    
                    +
                    
                      e
                      b
                    
                  
                  )
                
              
              =
              
                
                  max
                  ⁡
                  
                    (
                    
                      a
                      ,
                      b
                    
                    )
                  
                
                +
                
                  ln
                  ⁡
                  
                    (
                    
                      1
                      +
                      
                        e
                        
                          -
                          
                            
                            
                              a
                              -
                              b
                            
                            
                          
                        
                      
                    
                    )
                  
                
              
            
          
        
      
      
        
          
            
              
                max
                *
              
              ⁢
              
                (
                
                  a
                  ,
                  b
                  ,
                  c
                
                )
              
            
            =
            
              
                
                  max
                  *
                
                ⁢
                
                  (
                  
                    a
                    ,
                    
                      
                        max
                        *
                      
                      ⁢
                      
                        (
                        
                          b
                          ,
                          c
                        
                        )
                      
                    
                  
                  )
                
              
              =
              
                ln
                ⁡
                
                  (
                  
                    1
                    +
                    
                      e
                      a
                    
                    +
                    
                      e
                      b
                    
                    +
                    
                      e
                      c
                    
                  
                  )
                
              
            
          
        
      
    
  




The final expression of the a-posteriori reliability is:




  
    
      
        
          
            Λ
            i
            APO
          
          ⁡
          
            (
            U
            )
          
        
        =
        
          
            
              Λ
              i
              APR
            
            ⁡
            
              (
              U
              )
            
          
          +
          
            
              
                max
                
                  
                    e
                    :
                    
                      u
                      i
                    
                  
                  =
                  U
                
              
              *
            
            ⁢
            
              
                
                  (
                  
                    
                      
                        α
                        i
                        LLR
                      
                      ⁡
                      
                        (
                        
                          S
                          e
                          l
                        
                        )
                      
                    
                    +
                    
                      
                        β
                        
                          i
                          +
                          1
                        
                        LLR
                      
                      ⁡
                      
                        (
                        
                          S
                          e
                          r
                        
                        )
                      
                    
                    +
                    
                      
                        ∑
                        n
                        
                          
                        
                      
                      ⁢
                      
                        
                          c
                          n
                          e
                        
                        ·
                        
                          λ
                          
                            i
                            ,
                            n
                          
                        
                      
                    
                  
                  )
                
                --
              
              ⁢
              
                
                  
                    max
                    
                      
                        e
                        :
                        
                          u
                          i
                        
                      
                      =
                      
                        U
                        0
                      
                    
                  
                  *
                
                ⁢
                
                  
                    (
                    
                      
                        
                          α
                          i
                          LLR
                        
                        ⁡
                        
                          (
                          
                            S
                            e
                            l
                          
                          )
                        
                      
                      +
                      
                        
                          β
                          
                            i
                            +
                            1
                          
                          LLR
                        
                        ⁡
                        
                          (
                          
                            S
                            e
                            r
                          
                          )
                        
                      
                      +
                      
                        
                          ∑
                          n
                          
                            
                          
                        
                        ⁢
                        
                          
                            c
                            n
                            e
                          
                          ·
                          
                            λ
                            
                              i
                              ,
                              n
                            
                          
                        
                      
                    
                    )
                  
                  .
                
              
            
          
        
      
    
    
      
        (
        6
        )
      
    
  




In order to simplify the implementation, the “max*” operator can be replaced by the “max” operator.
The recursive expressions of the forward and backward metrics can also be rewritten in the LLR form using the max* (or max) operator:




  
    
      
        
          
            α
            
              i
              +
              1
            
            LLR
          
          ⁡
          
            (
            S
            )
          
        
        =
        
          
            
              max
              
                e
                :
                
                  
                    S
                    *
                  
                  →
                  S
                
              
            
            *
          
          ⁢
          
            
              
                (
                
                  
                    
                      α
                      i
                      LLR
                    
                    ⁡
                    
                      (
                      
                        S
                        *
                      
                      )
                    
                  
                  +
                  
                    
                      U
                      e
                    
                    ·
                    
                      
                        Λ
                        i
                        APR
                      
                      ⁡
                      
                        (
                        
                          U
                          e
                        
                        )
                      
                    
                  
                  +
                  
                    
                      ∑
                      n
                      
                        
                      
                    
                    ⁢
                    
                      
                        c
                        n
                        e
                      
                      ·
                      
                        λ
                        
                          i
                          ,
                          n
                        
                      
                    
                  
                
                )
              
              --
            
            ⁢
            
              
                
                  max
                  
                    e
                    :
                    
                      
                        S
                        *
                      
                      →
                      
                        S
                        0
                      
                    
                  
                
                *
              
              ⁢
              
                (
                
                  
                    
                      α
                      i
                      LLR
                    
                    ⁡
                    
                      (
                      
                        S
                        *
                      
                      )
                    
                  
                  +
                  
                    
                      U
                      e
                    
                    ·
                    
                      
                        Λ
                        i
                        APR
                      
                      ⁡
                      
                        (
                        
                          U
                          e
                        
                        )
                      
                    
                  
                  +
                  
                    
                      ∑
                      n
                      
                        
                      
                    
                    ⁢
                    
                      
                        c
                        n
                        e
                      
                      ·
                      
                        λ
                        
                          i
                          ,
                          n
                        
                      
                    
                  
                
                )
              
            
          
        
      
    
    
      
        (
        7
        )
      
    
  
  
    
      
        
          
            β
            i
            LLR
          
          ⁡
          
            (
            S
            )
          
        
        =
        
          
            
              max
              
                e
                :
                
                  S
                  →
                  
                    S
                    *
                  
                
              
            
            *
          
          ⁢
          
            
              
                (
                
                  
                    
                      β
                      
                        i
                        +
                        1
                      
                      LLR
                    
                    ⁡
                    
                      (
                      
                        S
                        *
                      
                      )
                    
                  
                  +
                  
                    
                      U
                      e
                    
                    ·
                    
                      
                        Λ
                        i
                        APR
                      
                      ⁡
                      
                        (
                        
                          U
                          e
                        
                        )
                      
                    
                  
                  +
                  
                    
                      ∑
                      n
                      
                        
                      
                    
                    ⁢
                    
                      
                        c
                        n
                        e
                      
                      ·
                      
                        λ
                        
                          i
                          ,
                          n
                        
                      
                    
                  
                
                )
              
              --
            
            ⁢
            
              
                
                  max
                  
                    e
                    :
                    
                      
                        S
                        0
                      
                      →
                      
                        S
                        *
                      
                    
                  
                
                *
              
              ⁢
              
                
                  (
                  
                    
                      
                        β
                        
                          i
                          +
                          1
                        
                        LLR
                      
                      ⁡
                      
                        (
                        
                          S
                          *
                        
                        )
                      
                    
                    +
                    
                      
                        U
                        e
                      
                      ·
                      
                        
                          Λ
                          i
                          APR
                        
                        ⁡
                        
                          (
                          
                            U
                            e
                          
                          )
                        
                      
                    
                    +
                    
                      
                        ∑
                        n
                        
                          
                        
                      
                      ⁢
                      
                        
                          c
                          n
                          e
                        
                        ·
                        
                          λ
                          
                            i
                            ,
                            n
                          
                        
                      
                    
                  
                  )
                
                .
              
            
          
        
      
    
    
      
        (
        8
        )
      
    
  




Having briefly introduced the BCJR algorithm, it is now possible to discuss BCJR-based Turbo decoding.
The PCCC decoding algorithm iteratively exploits two BCJR algorithms to update the reliability of the transmitted word. Each BCJR (SISO) block belongs to the corresponding RSC encoder and exchanges “extrinsic” information with the other one. Let Λt-1,1→2APR be the “extrinsic” information transmitted from SISO1 to SISO2 at the end of step i−1. SISO2 uses this information, together with the input reliability λi,n coming from the channel, to compute the a-posteriori reliability Λ′iAPO. The “extrinsic” information transmitted from SISO2 to SISO1, Λ1,2→1APR is obtained by subtracting from Λ′iAPO the extrinsic information SISO1→SISO2 and by applying permutation Π−1 (the inverse of those performed by the encoding interleaver): Λi,2→iAPR=Π−1(Λ′iAPO−Λi−1,1→2APR). Then SISO1 uses this extrinsic information to compute, ΛiAPO and Λi,1→2APR, and so on. The exchanging of extrinsic information is the core of turbo decoding, and allows attaining convergence with a reasonable number of decoding iteration.
FIG. 3A shows the architecture of a PCCC turbo decoder. According to eq. (6) each SISO takes as input the reliabilities coming from the channel and the A-priori input reliabilities from the neighbor block. Due to the presence of the interleaver in the encoder, data must be shuffled according to the interleaver law to always guarantee the data consistency between the two BCJR blocks; reference Π indicates an interleaver equivalent to that used for encoding, Π−1 the inverse interleaver. The decoding process runs then iteratively either for a fixed number of iteration or until convergence is reached. It is worth to note that in this context convergence means that the APP-LLRs output by each SISO are at least approximately equal and they do not change (or change slowly) with other iterations.
The architecture of a SCCC Turbo decoder is shown in FIG. 3B. Differently from the PCCC scheme the SISO1 decoder only receives the extrinsic reliabilities of the output bits vi (see FIG. 1C) as it is not directly interfaced with the channel. Nevertheless, besides the APP-LLR of each transmitted bit, SISO1 also computes the reliabilities of the intermediate codeword vk (the output of the first RSC-encoder) which is in turn feed to the SISO2 as “extrinsic” information. Within a SISO decoder the evaluation of the to LLR reliability associated to a generic RSC output bit ci can be performed similarly to eq. (6) as:




  
    
      
        
          
            Λ
            i
            CH
          
          ⁡
          
            (
            
              c
              k
            
            )
          
        
        =
        
          
            
              Λ
              i
              APR
            
            ⁡
            
              (
              
                c
                k
              
              )
            
          
          +
          
            
              
                max
                
                  
                    e
                    :
                    
                      c
                      k
                    
                  
                  =
                  1
                
              
              *
            
            ⁢
            
              
                
                  (
                  
                    
                      
                        α
                        i
                        LLR
                      
                      ⁡
                      
                        (
                        
                          S
                          e
                          l
                        
                        )
                      
                    
                    +
                    
                      
                        β
                        
                          i
                          +
                          1
                        
                        LLR
                      
                      ⁡
                      
                        (
                        
                          S
                          e
                          r
                        
                        )
                      
                    
                    +
                    
                      
                        Λ
                        i
                        APO
                      
                      ⁡
                      
                        (
                        
                          U
                          e
                        
                        )
                      
                    
                    +
                    
                      
                        ∑
                        
                          n
                          ≠
                          k
                        
                        
                          
                        
                      
                      ⁢
                      
                        
                          c
                          n
                          e
                        
                        ·
                        
                          λ
                          
                            i
                            ,
                            n
                          
                        
                      
                    
                  
                  )
                
                --
              
              ⁢
              
                
                  
                    max
                    
                      
                        e
                        :
                        
                          c
                          k
                        
                      
                      =
                      0
                    
                  
                  *
                
                ⁢
                
                  (
                  
                    
                      
                        α
                        i
                        LLR
                      
                      ⁡
                      
                        (
                        
                          S
                          e
                          l
                        
                        )
                      
                    
                    +
                    
                      
                        β
                        
                          i
                          +
                          1
                        
                        LLR
                      
                      ⁡
                      
                        (
                        
                          S
                          e
                          r
                        
                        )
                      
                    
                    +
                    
                      
                        Λ
                        i
                        APO
                      
                      ⁡
                      
                        (
                        
                          U
                          e
                        
                        )
                      
                    
                    +
                    
                      
                        ∑
                        
                          n
                          ≠
                          k
                        
                        
                          
                        
                      
                      ⁢
                      
                        
                          c
                          n
                          e
                        
                        ·
                        
                          λ
                          
                            i
                            ,
                            n
                          
                        
                      
                    
                  
                  )
                
              
            
          
        
      
    
    
      
        (
        9
        )
      
    
  




where ΛiCH (ck) is the A-posteriori reliability of the output bit ck at time i, ΛiAPR(ck) the a-priori reliability received from the neighbor decoder, “e: ck=1” is the set of edges with ck=1 and ΛiAPO(Ue) is the a-posteriori reliability of the symbol associated to the edge e.
It is worth noting that the SISO decoders operate alternatively, and not simultaneously. Therefore, in actual hardware implementations, a single decoding unit plays the role of both SISO1 and SISO2.
LDPC codes are linear block codes which can be described with two different means: the parity check matrix and the tanner graph. More precisely, each codeword produced by a particular LDPC encoder x belongs to the null space of a corresponding parity check matrix H:

HxT=0  (10)

The parity check matrix H (FIG. 4A) is a sparse matrix having a number of columns (N) equals to the bits of the codeword and a number of rows (R) equals to the parity bits added by the LDPC encoder. Each row of this matrix can then be considered as a “parity check constraint”, i.e. a linear equation linking a subset of the codeword bits: when element hi,j is equal to one, then the jth bit of the transmitted codeword appears in the ith parity check constraint.
LDPC codes can be also described by means of a bi-partite graph named Tanner Graph (FIG. 4B) which is arranged in variable and check nodes. Each variable node (b01-bN-1) represents a bit of the transmitted codeword and corresponds to a column of the parity check matrix. Every check node (c0-cR-1) represents a particular parity check constraint and corresponds to a row of the parity check matrix. Edges connect the variable nodes to the check nodes representing parity checks constraints to which the corresponding bits participate; in other words, the XOR of all the bits corresponding to variable nodes connected to a same check node has to be equal to zero. Each node can be characterized through the so-called degree; the variable node degree (dv) is the number of parity check constraints in which a particular variable is involved while the check node degree (dc) is the number of variable nodes participating in a particular parity check constraint. In a regular LDPC code, labeled c(i,j), all the variable nodes have degree i and all the check nodes have degree j.
The two main techniques for decoding LDPC codes are “belief propagation” and “layered decoding”; they will be briefly outlined here. “Turbo decoding message passing” (TDMP) is a particular form of layered decoding, which is used in a preferred embodiment of the invention as it allows optimal hardware sharing with BCJR Turbo decoders.
Whenever the noisy transmitted codeword has been received, the LDPC decoder is in charge of retrieving the correct information word by detecting and removing the possible errors introduced by the channel. To this aim, the decoder follows a particular decoding algorithm which iteratively improves the reliability of the transmitted bits. Each transmitted bit (bn) can be characterized by the a-posteriori log-likelihood ratio (APP-LLR) which can be expressed as:




  
    
      
        
          λ
          
            b
            n
          
        
        =
        
          log
          ⁢
          
            
              P
              (
              
                
                  b
                  n
                
                =
                
                  1
                  ⁢
                  
                    
                    r
                    )
                  
                
              
            
            
              P
              (
              
                
                  b
                  n
                
                =
                
                  0
                  ⁢
                  
                    
                    r
                    )
                  
                
              
            
          
        
      
    
    
      
        (
        11
        )
      
    
  




with r the whole received codeword and P(.) represents the probability function. From eq. (11) it can be noted that the sign of λbn provides an estimate of the corresponding transmitted bit (0 when λbn≦0 and 1 when λbn>0), while the magnitude indicates its reliability (the greater is the magnitude and the higher is the reliability of the transmitted bit).
In the “belief propagation” algorithm, the a-posteriori LLR is computed as:




  
    
      
        
          λ
          
            b
            n
          
        
        =
        
          
            log
            ⁢
            
              
                P
                (
                
                  
                    r
                    n
                  
                  ⁢
                  
                    
                    
                      
                        b
                        n
                      
                      =
                      1
                    
                    )
                  
                
              
              
                P
                (
                
                  
                    r
                    n
                  
                  ⁢
                  
                    
                    
                      
                        b
                        n
                      
                      =
                      0
                    
                    )
                  
                
              
            
          
          +
          
            log
            ⁢
            
              
                P
                (
                
                  
                    b
                    n
                  
                  =
                  
                    1
                    ⁢
                    
                      
                      
                        r
                        
                          i
                          ≠
                          n
                        
                      
                      )
                    
                  
                
              
              
                P
                (
                
                  
                    b
                    n
                  
                  =
                  
                    0
                    ⁢
                    
                      
                      
                        r
                        
                          i
                          ≠
                          n
                        
                      
                      )
                    
                  
                
              
            
          
        
      
    
    
      
        (
        12
        )
      
    
  




rn being the received bit corresponding to the transmitted bit bn, and the expression ri≠n addresses all the bits of the received codeword except rn.

The first term in the right part of equation (12) only depends on the features of the channel, so it is called intrinsic or channel LLR, while the second term is an estimate of the APP-LLR of the bit bn which does not depend on the corresponding received bit rn. This latter is also known as extrinsic LLR and is updated iteration by iteration during the decoding process.
At the decoding start-up, the APP-LLR of each transmitted bit is initialized with the channel LLR and each check node receives the channel information related to the connected check nodes (variable to check message). Each check node, then, evaluates the parity check constraint and returns one piece of information for each of the connected variable nodes for a total of dc messages (check to variable message). Each variable node, in turn, receives exactly dv messages and is then able to compute the extrinsic LLR for the next iteration. The algorithm stops when the estimated transmitted codeword satisfies equation (10)—convergence reached—or after a fixed number Nit of iterations.
Let us define:

    
    
        λch,n the channel reliabilities, provided as inputs;
        λbn,cm the message from variable node bn to check node cm;
        λcm,bm the message from check node cm to variable node bn;
        b(cm) the variable nodes connected to check node cm;
        b(cm)\bn the variable nodes connected to check node cm except bn;
        c(bn) the check nodes connected to the variable node bn;
        c (bn) \cm the check nodes connected to variable node bn except cm;
        Φ(x)=Φ(x)−1=−log(tan h(x/2))
    
    


Then, the belief propagation algorithm can be written, in pseudocode:










Algorithm 1: Belief propagation decoding algorithm
















 
input : channel LLR λchn, n = 0, 1, ..., N − 1



output: transmitted bit decision λbn, n = 0, 1, ..., N − 1










1
// Messages initialization



2
λbn = λchn, λbn,cm = λbn, ∀n = 0, ..., N − 1, ∀m = 0, ..., M − 1;



3
repeat











4
|
// Check node phase



5
|
for m ← 0 to P − 1 do












6
|
|
forall n ε b (cm) do













7
|
|
|
// Sign update



8
| |
| |
| |




  
    
      -
      
        sgn
        ⁡
        
          (
          
            
              λ
              
                
                  c
                  m
                
                ,
                
                  b
                  n
                
              
            
            ⁢
          
          )
        
      
    
    =
    
      
        
          ∏
          
            i
            ⁢
            
              
            
            ⁢
            ε
            ⁢
            
              
            
            ⁢
            
              
                b
                ⁡
                
                  (
                  
                    c
                    m
                  
                  )
                
              
              ⁢
              \
              ⁢
              
                b
                n
              
            
          
        
        ⁢
        
          
        
        ⁢
      
      -
      
        sgn
        ⁡
        
          (
          
            
              λ
              
                
                  b
                  i
                
                ,
                
                  c
                  m
                
              
            
            ⁢
          
          )
        
      
    
  
  ⁢







9
|
|
|
// Magnitude update



10
| |
| |
| |




  
    
      
      
        
          λ
          
            
              c
              m
            
            ,
            
              b
              n
            
          
        
        ⁢
      
      
    
    =
    
      
        Φ
        
          -
          1
        
      
      ⁢
      
        
          ∑
          
            i
            ⁢
            
              
            
            ⁢
            ε
            ⁢
            
              
            
            ⁢
            
              
                b
                ⁡
                
                  (
                  
                    c
                    m
                  
                  )
                
              
              ⁢
              \
              ⁢
              
                b
                n
              
            
          
        
        ⁢
        
          
        
        ⁢
        
          Φ
          ⁡
          
            (
            
              
              
                
                  λ
                  
                    
                      b
                      i
                    
                    ,
                    
                      c
                      m
                    
                  
                
                ⁢
              
              
            
            )
          
        
      
    
  
  ;
















11
|
|
end











12
|
end



13
|
// Variable node phase



14
|
for n ← 0 to N − 1 do












15
|
|
// APP-LLR update



16
| |
| |




  
    =
    
      
        ∑
        
          i
          ⁢
          
            
          
          ⁢
          ε
          ⁢
          
            
          
          ⁢
          
            c
            ⁡
            
              (
              
                b
                n
              
              )
            
          
        
      
      ⁢
      
        
          λ
          
            
              c
              i
            
            ,
            
              b
              n
            
          
        
        ⁢
      
    
  
  ;















17
|
| forall m ε c(bn) do













18
|
|
|
// Variable to check messages update



19
| |
| |
| |




  
    =
    
      +
      
        
          ∑
          
            i
            ⁢
            
              
            
            ⁢
            ε
            ⁢
            
              
            
            ⁢
            
              
                c
                ⁡
                
                  (
                  
                    b
                    n
                  
                  )
                
              
              ⁢
              \
              ⁢
              
                c
                m
              
            
          
        
        ⁢
      
    
  
  ;
















20
|
|
end











21
|
end



22
|
iter++;










23
until (iter < Nit & !convergence);









Where “&” means AND, “!” means NOT and “++” is the increment operator.
“Layered decoding” is obtained by reworking the “belief propagation” algorithm in order to reduce the number of iterations required to achieve convergence.
The layered decoding algorithm counts one single phase, i.e. either check node phase (CN-centric) or variable node one (VN-centric). In a CN-centric solution all the check nodes are sequentially updated and the variable node operations are spread over each check node while in a VN-centric solution all the variable nodes are sequentially updated and the check node operations are spread over each variable node. Here only the CN-centric solution is discussed as the VLSI implementation of the VN algorithm poses several problems.
The CN-centric algorithm still receives as input the channel reliability of the transmitted codeword and as a first step, each APP-LLR takes the value of the corresponding channel LLR. The algorithm then proceeds check node by check node (or layer by layer) and the variable to check messages are retrieved on-the-fly considering that:

λbn,cmq=λbnq−λcm,bnq  (13)

where “q” is the index for the decoding iteration.
The check node computation is exactly the same of the belief propagation while after one single check node operation, the corresponding APP-LLRs are immediately updated and made available to the next check node. In such a way, all the on-the-fly variable-to-check computations can be performed by always using the most updated APP-LLR values, thus considerably increasing, and even doubling, the convergence speed of the algorithm. In pseudocode:










Algorithm 2: CN-centric Layered Decoding
















 
input : channel LLR λchn, n = 0, 1, ..., N − 1



output: transmitted bit decision λbn, n = 0, 1, ..., N − 1










1
// Messages initialization



2
λbn = λchn, λbn,cm = λbn, ∀n = 0, ..., N − 1, ∀m = 0, ..., M − 1;



3
repeat











4
|
// Loop on all layers



5
|
for m ← 0 to P − 1 do












6
|
|
// Check-node update 



7
|
|
forall n ε b (cm) do













8
|
|
|
// Sign update



9
| |
| |
| |




  
    
      -
      
        sgn
        ⁡
        
          (
          
            
              λ
              
                
                  c
                  m
                
                ,
                
                  b
                  n
                
              
              
                (
                
                  q
                  +
                  1
                
                )
              
            
            ⁢
          
          )
        
      
    
    =
    
      
        
          ∏
          
            i
            ⁢
            
              
            
            ⁢
            ε
            ⁢
            
              
            
            ⁢
            
              
                b
                ⁡
                
                  (
                  
                    c
                    m
                  
                  )
                
              
              ⁢
              \
              ⁢
              
                b
                n
              
            
          
        
        ⁢
        
          
        
        ⁢
      
      -
      
        sgn
        ⁡
        
          (
          
            
              λ
              
                b
                i
              
            
            -
            
              
                λ
                
                  
                    c
                    m
                  
                  ,
                  
                    b
                    i
                  
                
                
                  (
                  q
                  )
                
              
              ⁢
            
          
          )
        
      
    
  
  ⁢







10
|
|
|
// Magnitude update



11
| |
| |
| |




  
    
      
      
        ⁢
        
          λ
          
            
              c
              m
            
            ,
            
              b
              n
            
          
          
            (
            
              q
              +
              1
            
            )
          
        
      
      
    
    =
    
      
        Φ
        
          -
          1
        
      
      ⁢
      ⁢
      
        
          ∑
          
            i
            ⁢
            
              
            
            ⁢
            ε
            ⁢
            
              
            
            ⁢
            
              
                b
                ⁡
                
                  (
                  
                    c
                    m
                  
                  )
                
              
              ⁢
              \
              ⁢
              
                b
                n
              
            
          
        
        ⁢
        
          Φ
          ⁡
          
            (
            
              
              
                
                  ⁢
                  
                    λ
                    
                      b
                      i
                    
                  
                
                -
                
                  
                    λ
                    
                      
                        c
                        m
                      
                      ,
                      
                        b
                        i
                      
                    
                    
                      (
                      q
                      )
                    
                  
                  ⁢
                
              
              
            
            )
          
        
      
    
  
  ;







12
|
|
|
// Soft-output update



13
|
|
|
λbn[k + 1] = λbn[k] − λcm,bn(q) + λcm,bn(q+1);












14
|
|
end











15
|
end



16
|
q++;










17
until (q < Nit & !convergence);









Both algorithms are complex to implement because of the nonlinear function Φ. This problem is solved by the Turbo Decoding Message Passing (TDMP) algorithm which is based on the following remark.
The transmitted codeword produced by the LDPC encoder has to satisfy a particular set of parity check constraints, so that the XOR operation of the transmitted bits involved in a particular check node (those marked with one), must be equal to 0 (even parity). Actually it is possible to describe this constraint by means of a 2-states trellis graph, in which the single state at the generic stage k, represents the parity after the k-th bits belonging to that constraint. Such a trellis, shown in FIG. 4C, has a length equal to the check node degree and the first and last state must be the even parity state (SE). Under these features, particular forward (a) and backward (β) metrics can be defined to calculate the updated check-to-variable messages through the BCJR algorithm:




  
    
      
        {
        
          
            
              
                
                  
                    α
                    
                      k
                      +
                      1
                    
                  
                  ⁡
                  
                    (
                    
                      S
                      E
                    
                    )
                  
                
                =
                
                  
                    max
                    *
                  
                  ⁢
                  
                    (
                    
                      
                        
                          α
                          k
                        
                        ⁡
                        
                          (
                          
                            S
                            E
                          
                          )
                        
                      
                      ,
                      
                        
                          
                            α
                            k
                          
                          ⁡
                          
                            (
                            
                              S
                              O
                            
                            )
                          
                        
                        +
                        
                          λ
                          
                            
                              b
                              k
                            
                            ,
                            
                              c
                              m
                            
                          
                        
                      
                    
                    )
                  
                
              
            
          
          
            
              
                
                  
                    α
                    
                      k
                      +
                      1
                    
                  
                  ⁡
                  
                    (
                    
                      S
                      O
                    
                    )
                  
                
                =
                
                  
                    max
                    *
                  
                  ⁢
                  
                    (
                    
                      
                        
                          
                            α
                            k
                          
                          ⁡
                          
                            (
                            
                              S
                              E
                            
                            )
                          
                        
                        +
                        
                          λ
                          
                            
                              b
                              k
                            
                            ,
                            
                              c
                              m
                            
                          
                        
                      
                      ,
                      
                        
                          α
                          k
                        
                        ⁡
                        
                          (
                          
                            S
                            O
                          
                          )
                        
                      
                    
                    )
                  
                
              
            
          
          
            
              
                
                  
                    β
                    k
                  
                  ⁡
                  
                    (
                    
                      S
                      E
                    
                    )
                  
                
                =
                
                  
                    max
                    *
                  
                  ⁢
                  
                    (
                    
                      
                        
                          β
                          
                            k
                            +
                            1
                          
                        
                        ⁡
                        
                          (
                          
                            S
                            E
                          
                          )
                        
                      
                      ,
                      
                        
                          
                            β
                            
                              k
                              +
                              1
                            
                          
                          ⁡
                          
                            (
                            
                              S
                              O
                            
                            )
                          
                        
                        +
                        
                          λ
                          
                            
                              b
                              k
                            
                            ,
                            
                              c
                              m
                            
                          
                        
                      
                    
                    )
                  
                
              
            
          
          
            
              
                
                  
                    β
                    k
                  
                  ⁡
                  
                    (
                    
                      S
                      O
                    
                    )
                  
                
                =
                
                  
                    max
                    *
                  
                  ⁢
                  
                    (
                    
                      
                        
                          
                            β
                            
                              k
                              +
                              1
                            
                          
                          ⁡
                          
                            (
                            
                              S
                              E
                            
                            )
                          
                        
                        +
                        
                          λ
                          
                            
                              b
                              k
                            
                            ,
                            
                              c
                              m
                            
                          
                        
                      
                      ,
                      
                        
                          β
                          
                            k
                            +
                            1
                          
                        
                        ⁡
                        
                          (
                          
                            S
                            O
                          
                          )
                        
                      
                    
                    )
                  
                
              
            
          
          
            
              
                
                  λ
                  
                    
                      c
                      m
                    
                    ,
                    
                      b
                      k
                    
                  
                
                =
                
                  
                    
                      max
                      *
                    
                    ⁢
                    
                      (
                      
                        
                          
                            
                              α
                              k
                            
                            ⁡
                            
                              (
                              
                                S
                                E
                              
                              )
                            
                          
                          +
                          
                            
                              β
                              k
                            
                            ⁡
                            
                              (
                              
                                S
                                O
                              
                              )
                            
                          
                        
                        ,
                        
                          
                            
                              α
                              k
                            
                            ⁡
                            
                              (
                              
                                S
                                O
                              
                              )
                            
                          
                          +
                          
                            
                              β
                              k
                            
                            ⁡
                            
                              (
                              
                                S
                                E
                              
                              )
                            
                          
                        
                      
                      )
                    
                  
                  -
                
              
            
          
          
            
              
                
                  
                
                ⁢
                
                  
                    max
                    *
                  
                  ⁢
                  
                    (
                    
                      
                        
                          
                            α
                            k
                          
                          ⁡
                          
                            (
                            
                              S
                              E
                            
                            )
                          
                        
                        +
                        
                          
                            β
                            k
                          
                          ⁡
                          
                            (
                            
                              S
                              E
                            
                            )
                          
                        
                      
                      ,
                      
                        
                          
                            α
                            k
                          
                          ⁡
                          
                            (
                            
                              S
                              O
                            
                            )
                          
                        
                        +
                        
                          
                            β
                            k
                          
                          ⁡
                          
                            (
                            
                              S
                              O
                            
                            )
                          
                        
                      
                    
                    )
                  
                
              
            
          
        
      
    
    
      
        (
        14
        )
      
    
  




where λbk,cm represents the message from the k-th variable node connected to the considered check node m and λcm,bk corresponding message from the check node m back to the k-th variable node connected.
These equations can be used within algorithms 1 and 2 to compute the check node operations on line 10 and 11 instead of using the Φ function. In such a way, it is possible to implement one single BCJR engine to allow the decoding of an ordinary Turbo code and the computation of the check node phase of the LDPC algorithm, which is the most complex part of the LDPC decoding, thus achieving a great flexibility in the design of a configurable advanced error-correcting codes platform.
The use of the BCJR algorithm for decoding LDPC codes is known from the prior art. It has to be noted, however, that this does not solve alone the problem of designing a flexible hardware architecture with low complexity, low power consumption and high throughput. In particular, the present inventors have realized that parallelization is necessary in order to comply with the high data rates of modern communication standards without relying on too-high clock frequencies, which increase power consumption. They have also realized that flexibility requires the possibility of implementing different parallelization schemes with maximal hardware reusing in order to limit complexity. Efficient memory management is also of paramount importance, as channel decoders are often “memory dominated” and memory resources play a major role in complexity, power consumption and costs of the architecture implementation.
The invention will now be described with reference to a particular embodiment, implemented as an ASIC and able to comply with the requirements of the communication standards listed in Table I:












TABLE I





Stand.
Applic.
Code
Code Length
Code Rate
Max Speed







UMTS 3GPP-HSDPA
Mobile Internet
Binary Turbo
40-5114
1/3 & rate
14.4 Mbps  






matching



IEEE 802.16e
WMAN
Duo-Binary
64-8192
1/2 2/3 3/4
70 Mbps




Turbo

5/6 7/8



IEEE 802.16e
WMAN
LDPC
576-2304 
1/2 2/3 3/4
70 Mbps






5/6



IEEE 802.11n
WLAN
LDPC
648-1296-1944
1/2 2/3 3/4
100 Mbps 






5/6



DVB-SH
Satellite Multimedia
Binary Turbo
1946-12282 
1/5 2/9 2/7
18 Mbps



Contents


2/5 2/3









FIG. 5 illustrates the general architecture of a flexible decoder according to the invention. Basically, such a decoder comprises:

    
    
        A set of P Soft-Input-Soft-Output (SISO) decoding units DP0-DPP-1 having first (I1i) and second (I2i) input ports and first (O1i) and second (O2i) output ports. The number P of decoding units can be typically comprised between 4 and 16 and preferably between 8 and 12.
        First and second memories M1 and M2, each comprising P independently readable and writable memory blocks having respective input and output ports. In order to save hardware resources, these memory will preferably be single-port, respective temporary buffers being provided to avoid read/write collisions. And:
        A configurable switching network SN for connecting the first input and output ports of the decoding units to the output and input ports of the first memory, and the second input and output ports of the decoding units to the output and input ports of the second memory. The switching memory also manages inputs, coming from the channel (or, more precisely, from a suitable demodulator) and outputs. FIG. 5 illustrates a preferred, but not limiting, embodiment of the switching network; the person skilled in the art of digital electronic will be able to design alternative (although in general sub-optimal in terms of hardware complexity) architectures of the switching network SN.
    
    


A possible—and particularly efficient—architecture for the decoding units DP0-DPP-1 will be described later with reference to FIG. 10. Alternative architectures could be devised. Whatever the implementation details, minimal hardware complexity will be achieved by using single-core decoding units, e.g. using a BCJR, or forward-backward, algorithm for performing both Turbo- and LDPC-decoding. More particularly, the above-described TDMP algorithm will be preferably used for LDPC decoding.
For the time being, however, it will be sufficient to consider the decoding units DP0-DPP-1 as black boxes. Independently from its actual implementation, each of said SISO decoding units has:

    
    
        a first input port I1i for input reliabilities λi,n used in Turbo-decoding, and for check-to-variable metrics λcmbn used in LDPC-decoding. For the sake of an easier notation hereafter input reliabilities and check-to-variable messages are also referred to as λ and cv2 respectively;
        a second input port I2i for extrinsic reliabilities Λ′i,1→2APR(Λ′i,2→1APR) hereafter simply referred to as Λ used in Turbo-decoding and for intermediate soft outputs λbn (or simply SO) used for LDPC-decoding;
        a first output port O1i for check-to-variable metrics updated during LDPC-decoding; and
        a second output port O2i for extrinsic reliabilities obtained as intermediate or final results of Turbo-decoding, and for soft outputs obtained as intermediate or final results of LDPC-decoding.
    
    


Note that, for the sake of an easier notation the I2i and O2i lines are also labeled with Δ meaning Λ when turbo decoding is performed and SO during LDPC decoding. Δ is in turn a vector composed of K elements (Δ0 . . . Δk).
Input reliabilities, extrinsic reliabilities, check-to-variable metrics, extrinsic reliabilities and LDPC soft output have been defined above.
Input reliabilities coming from the channel are injected into memory M1 (for Turbo decoding) through a first input port ID1 of the decoder and a first switching unit SW1, or into memory M2 (for LDPC decoding) through a second input port ID2 of the decoder and a second switching unit SW2.
The general architecture of FIG. 5 allows implementing three different parallelization schemes:

    
    
        the so-called “Multi-MAP” schedule—where “MAP” stands for “maximum a posteriori”—suitable for decoding Turbo codes with comparatively short codewords (or frames);
        the so-called “Multi-SISO” schedule, suitable for decoding Turbo codes with longer codewords (or frames); and
        a layered decoding schedule for LDPC.
    
    


Multi-MAP decoding is illustrated on FIG. 6A. The idea is to process P frames in parallel in a pipelined manner. Actually each decoding unit performs only a limited amount of iterations and passes the estimated result to the following unit in a pipelined manner. As far as the memory resources are concerned, P different blocks must be envisaged both for the extrinsic reliabilities Λ (M2) and for the input LLR λ (M1) as data for P different frames must be concurrently processed (M2: blocks are designated as Λ#1-Λ#P−1; M1: blocks are designated as λ#1-λ#P−1). The reading/writing management of the second or “extrinsic” memory M2 is rather simple as data are written and read from the same block but at the end of the last iteration when they are written to the following memory block (or given as output of the architecture in the case of the last decoding unit), through a straightforward system of multiplexer. Each decoding units performs both the “SISO1” and “SISO2” processing; the binary signal “Half_it” driving the multiplexer takes the value “0” during the first (SISO1) “half iteration” and “1” during the second one (SISO2), or vice-versa. In practice, however, as it will be explained later, this system of multiplexer will be implemented using a more complex network (permutation network PN1, see FIG. 10).
The management of the input LLR λ (M1) memory is slightly different as during the decoding process the memory must only be read. For this reason data regarding each frame are in a fixed block (λ#0-λ#P−1) for all the decoding time while the processing of each frame slides form block to block due to the pipeline of the operations. The “From_channel” line inputs channel reliabilities λ which are stored in the M1 memory before being processed.
A proper reading can be performed by using the Circular Shifting Network CSN, which allows data to be retrieved from the proper memory block. An effective implementation of such a network is described in [11]. Advantages of this parallelization scheme are the management of the memory resources, which is rather simple, and the possibility of using highly optimized interleaved address generators (not requiring Look-Up Tables) within the decoding units, depending on the code under processing. On the other hand, the main drawback relies on the memory complexity which could be very high as in this solution the throughput is increased by processing several frames in parallel. This implies that each block must provide a number of locations equal to the information word length which, depending on the standard implemented, could be very high, thus making this solution impracticable (for example DVB-SH has an information word length of 12282 bits).
Multi-SISO constitutes an alternative solution to speed-up the decoding processing, better suited for long-frame codes than Multi-MAP. This parallelization scheme is illustrated on FIG. 6B. It allows reducing the decoding time of the single decoding units by parallelizing the operations of a single frame. In other words, only one frame at a time is decoded, but the associated trellis is divided into P different windows processed in parallel by P SISO (DPi) decoding units, each acting on a limited portion of the trellis.
In this solution, since P processing, requiring different data, are performed in parallel, the memory resources must be still divided into P blocks (λ B0 . . . λ BP-1 for M1, Λ B0 . . . Λ BP-1 for M2), but each block comprises only K/P locations, with K the information word length, thus allowing a considerable saving in memory with respect to the multi-MAP solution.
A very critical issue of Multi-SISO parallelization is to find the proper memory allocation of the extrinsic data yielding no memory conflicts. Actually, during the second half of each iteration, extrinsic data must be processed in the interleaved order, then a proper memory allocation must guarantee that, in each of the two half iterations, all the groups of P data that are concurrently processed, will be always retrieved from different memory blocks. This problem was carefully studied by Tarable et al. [12], who developed a general algorithm capable of solving memory conflicts no matter of the code under processing and the interleaver used. The hardware overhead of this solution consists of two P×P permutation networks (PN1 on writing path and PN2 on the reading path) in order to properly select data from the different blocks.
It will be noted that the writing permutation network (PN1) is also used in Multi-MAP parallelization. This hardware sharing is clearly advantageous from the point of view of complexity.
LDPC parallelization is made possible by the fact that actual codes are based on parity check matrices having a block structure (“architecture-aware” codes). FIG. 6C shows the high level architecture of an LDPC decoding implementing the Turbo Decoding Message Passing for architecture-aware LDPC codes. Each decoding unit runs the BCJR algorithm on one or more parity-check constraints and computes both the updated Soft-Output (SO) and check-to-variable (c2v) messages to be stored into the related memories. After being read by the memory (or before being stored in memory), the new Soft-Output values must be rotated in order to be properly acquired during the following processing step. Aiming at the development of a low-complexity flexible architecture, it can be noticed that all the building blocks required by the LDPC decoding are already used into the Turbo decoding Processing thus allowing a considerable level of hardware reusing. Particularly the first memory M1 can be used to store the check-to-variable metrics, the second memory M2 stores the Soft-Output values and the rotation can be easily performed by using either the first (PN1) or the second (PN2) permutation network. (PN2 is used in the depicted embodiment).
It can then be understood that switching from one parallelization scheme to another can easily be obtained by acting on the configurations of CSN, SW3 (which switches CSN in or out the data path), PN1, PN2 and—of course—of the decoding units. This is done by a control unit CM, which can be an element of the decoder itself or an external unit.
It is worth mentioning that, depending on the specific code to be processed and on the required throughput, it may be possible to use a number P′<P of decoding units, and also P′ of the P blocks of the first and second memories. In this case, the control unit CM will advantageously switch the unused decoding units and memory blocks off in order to save power.
Having described the general architecture of a flexible decoder according to the invention, it is now possible to describe its constitutive units, namely the first and second permutation networks, the circular switching network, the first and second memory and the individual decoding units, referring to exemplary and non-limitative embodiments. Hardware—and particularly integrated—implementation of these constituent units is preferred; however, some or all of them can also be partly or wholly implemented as software run on a suitable programmable circuit. Switching units SW1-SW4 are trivial, and the person of average skill will be able to realize the control unit CM as a programmable or hard-wired circuit, e.g. in the form of a finite state machine whose state transitions and operations depend on the code under processing. The exemplary embodiments discussed here refer to a decoder comprising P=12 decoding units and able to process binary and duo-binary Turbo codes as well as LDPC codes, with different codeword lengths K and characterized by trellises having up to νmaw=8 states.
Before that, however, it is expedient to briefly discuss the data representation, which is one of the most critical issues in implementing an algorithm into a real architecture. Indeed, the precision of the operations must be carefully set as a trade-off between complexity and implementation loss. Aiming at a low-complexity implementation of the flexible channel decoding platform, the decoding algorithm must be modeled into the fixed point domain so as to process only integer values with a limited number of bits. In an exemplary embodiment, on which is based the following description of the inventive decoder, the maximum tolerable implementation loss due to the fixed point representation and to the false detection rate is set to 0.4 dB. As a result, the LLR metrics are coded on 5 bits while the state-metric and extrinsic metrics are represented on 7 bits. Furthermore, one bit truncation is introduced before the storage into the M1 and M2 memories so as to reduce the overall memory complexity.
The first (or “writing”) and second (or “reading”) permutation networks PN1, PN2 are required, according to Tarable et al. [12] to avoid data conflicts between the SISO1 and SISO2 processing due to the interleaver law when a Multi-SISO approach is pursued. These permutation networks could be implemented as fully-configurable crossbar switches, but optimized implementation can reduce their hardware complexity.
FIG. 26 illustrates an optimized architecture for the first permutation network PN1. It can be proven that at most three of the 8 metrics Δ0-Δ7 outputted by each of the P (in this exemplary embodiment, P=12) decoding units have to be permuted (in the duo-binary Turbo-code case) while the remaining ones are written with no permutation in memory (LDPC case). For this reason the overall architecture is composed of three P×P (here, 12×12) Benes networks which are configured to be transparent when a Multi-MAP or LDPC decoding is on-going. On FIG. 26, and on FIG. 27 as well, Δi-duj indicates the ith output of the jth decoding unit.
The second (“reading”) permutation network PN2 is more complex, because it also serves, in LDPC, to perform a circular rotation over a number of elements equal to the codeword-size. The architecture of such a network is illustrated on FIG. 27 where two stages of permutation can be identified. Particularly the first stage PS1 locally permutes the elements of each decoding unit and the resulting output vector is properly routed by a hard-wired network HWN to the second stage PS2. Note that, in the case of Turbo decoding, the first stage is actually not needed and is configured so as to be transparent.
Standard Benes and Banyans networks are not suitable to implement the P×P circular switching network CSN because P is not, in general, a power of two. As already mentioned, in [11] some of the present inventors have disclosed an efficient multiplexer-based architecture which can advantageously been used in the implementation of the inventive decoder. FIG. 31 illustrates a 12×12 CSN of this kind, constituted by 48 2×1 multiplexers arranged in four stages. The network of FIG. 31 is based on the principle of the “barrel shifter”; in the most general case, the number of stages is n=┌log2 P┐ and the number of multiplexer per stage is equal to P. On FIG. 31, I0-I11 are the labels of the input ports and O0-O11 those of the output ports of the CSN.
Multiplexers on the i-th stage of the shifter, with 0≦i<n, are connected in such a way to circularly shift (rotate) the input vector by 2i if the control bit belonging to the control vector R=[r0, r1, r2, r3], is set; otherwise, the stage is transparent to the input. In this way, the arbitrary rotation ρ=0,1, . . . N−1 is decomposed into n consecutive rotations by powers-of-2.
The advantage of a barrel shifter with respect to a Banyan network is that not only it requires less multiplexers by removing the power-of-2 constraint on N, but also it does not need to store or pre-compute any configuration bit, since its stages are directly driven by the bits ri of the binary representation of ρ, i.e., ρ=rn-1, . . . , r1, r0.
Memory organization constitutes the bottleneck in terms of complexity and power consumption. While the global number of locations should be limited by the maximum supported codeword length, the proper number of blocks must be selected in order to support all the codeword lengths and the parallelism degrees defined by the reference scenario. Particularly, the maximum codeword length is defined by the DVB-SH standard with a value of K=12282.
The single-port memory M2 stores the a-posteriori extrinsic reliabilities produced by each SISO and the Soft Output reliabilities of the LDPC decoding. Although the architecture would support the decoding of two concurrent frames of a turbo binary code, as a design choice to decrease the memory complexity, only one single binary frame at a time is processed by each decoding unit. Accordingly, each memory location should comprise one single Δ value in the case of binary Turbo Codes, three different values in the duo-binary case (Δ(0), Δ(1), Δ(2)) and eight Soft Output values when an LDPC code is processed. As discussed above, in order not to replicate memory resources, the Multi-SISO mode must be used for long codeword lengths thus forcing the minimum number of banks to be equal to the parallelism degree (in the exemplary embodiment considered here, P=12) so as to guarantee no memory conflicts. Memory M2 is then split into 12 blocks (Mi) whose dimension (Li) is given by:

Li=┌Kmax/P┐=┌12282/12┐=1024

This arrangement is also able to support the maximum codeword length of a binary code using the Multi-MAP mode, e.g. the 3GPP having K=2045. Actually in this case, only 6 data-paths are required so the extrinsic reliabilities can be stored into two memory blocks with an overall capacity of 2048 messages.
The storage capacity of a single block should be able to support the Multi-MAP duo-binary mode for the IEEE 802.16e (WiMAX) standard, where the maximum frame length is equal to 240 symbols (for longer words, Multi-SISO will be used instead of multi-MAP). Considering that 3 metrics per symbol have to be stored, the single block storage capacity should be equal to 240×3=720. The maximum codeword length for the LDPC considered here is Kmax=2304 (IEEE 802.16e standard). The number of data (i.e. metrics) which has to be stored by each block is Kmax/P=2304/12=192. Finally, since each decoding unit manages 8 SO data in parallel, the aspect ratio of the memory bank is 24*8.
FIGS. 7A1, 7A2, 7B and 7C show the final extrinsic (M2) memory arrangement with the related filling strategy for the Turbo binary—Multi-MAP, Turbo binary—Multi-SISO, Turbo duo-binary and LDPC case respectively. On FIG. 7C, “macro-column” refers to the block structure of the parity check matrix H for “architecture aware” codes. Indeed each macro-column is composed of a certain set of variable nodes which defines the maximum degree of parallelism in LDPC codes.
Memory M2 also comprises a temporary buffer TB-M2 which must be able to store a number of reliabilities per decoding unit equal to the maximum window length (Wmax=74) within the Turbo case and to the maximum check-node degree (dc,max=22) in LDPC processing. The concept of “window length” refers to the fact that, in order to speed-up backward and forward recursion, the coding trellis is split into shorter windows (“sliding window algorithm”, known from prior art and which will be discussed with some detail when describing the architecture of the decoding units). As a result, the buffer is composed of P=12 blocks (one per decoding unit), in turn arranged into 9 memory banks of 22 elements each.
Indeed, for binary turbo codes, a maximum of 74 data (Wmax) can be stored in the first three banks. For duo-binary turbo codes, a maximum of 74×3 data (i.e. metrics) must be stored for a total of 222 metrics. Then the first 25×3 data are stored in the first three banks and so on to cover the 9 available banks. For LDPC codes, the maximum number of data to be stored per check node is equal to the maximum check node degree; since each decoding unit manages 8 check nodes, it follows that the memory has to store 8×22 messages.
Such a configuration allows the support of all the reference scenario configurations with the minimum waste of memory. FIGS. 8A, 8B and 8C detail the filling strategy of the buffer for the binary, duo-binary and LDPC case respectively.
As a conclusion, the total number of bits required for the M2 “extrinsic” memory and temporary buffer are:




   
  
    {
    
      
        
          
            
              Bit
              
                M
                ⁢
                
                  
                
                ⁢
                2
              
            
            =
            
              
                12
                ×
                8
                ×
                128
                ×
                6
              
              =
              73728
            
          
        
      
      
        
          
            
              Bit
              
                TB
                ⁢
                
                  -
                
                ⁢
                M
                ⁢
                
                  
                
                ⁢
                2
              
            
            =
            
              
                12
                ×
                9
                ×
                25
                ×
                6
              
              =
              16200
            
          
        
      
      
        
          
            
              Bit
              
                
                  M
                  ⁢
                  
                    
                  
                  ⁢
                  2
                
                -
                tot
              
            
            =
            
              
                
                  Bit
                  
                    M
                    ⁢
                    
                      
                    
                    ⁢
                    2
                  
                
                +
                
                  Bit
                  
                    TB
                    ⁢
                    
                      -
                    
                    ⁢
                    M
                    ⁢
                    
                      
                    
                    ⁢
                    2
                  
                
              
              =
            
          
        
      
    
  




It should be stressed that the optimal memory organization depends on the reference scenario, i.e. on the codes considered when designing the decoders. A different reference scenario would have led to a different memory management strategy.
Although not indicated on the general architectural scheme of FIG. 5, data coming out form the first P×P permutation network PN1 must be properly arranged by a suitable writing interface before being stored into the memory M2 with the filling strategy of FIGS. 7A1-7C. FIG. 24 shows the architecture of the writing interface W1-M2 for one single block of the memory M2; it is a simple circuit, only constituted by 2-to-1 and 3-to1 multiplexers where Δ0,rp . . . Δ7,rp are the 8 Λ/SO data coming out from each single Decoding Unit (after permutation through PN1) while Δ0,mem . . . Δ7,mem are the corresponding data read from memory.
O2i is a vector of 8 elements (Δ0 . . . Δ7). In the binary Turbo-code case, only Δ0 is valid since only one metric is provided per processing unit; consequently this value can be stored in any of the memory locations. In the duo-Binary Turbo-code case the valid data are Δ0, Δ1 and Δ2, as three metrics must be provided per each symbol. This means that Δ0 can be stored either in the first or fourth bank, Δ1 either in the second or fifth bank and Δ2 either in the third or sixth bank. Finally in the LDPC case all the 8 values are valid and can be stored in the corresponding banks (with same index).
After being stored into the M2 memory, data must be then read and re-arranged so as to attain the same configuration output by the decoding units. FIG. 25 shows the architecture of the reading interface for one single block of the memory. Again, this is a simple circuit consisting of multiplexers and direct connections where Δ0,mem . . . Δ7,mem are the 8 Λ/SO data coming out from memory while Δ0,wp . . . Δ7,wp are the corresponding data feeding PN2.
Focusing on the binary turbo decoding, data are spread in memory across all the 8 banks and must be then routed to the first line of the output vector. To this extent a 8-to-1 multiplexer properly driven by the control logic is required.
On the other hand, the second and third output could represent a valid data both in the duo-binary and LDPC case. Consequently these lines could be connected to the corresponding input (second and third) in the LDPC case or when a duo-binary data is retrieved from the first three banks, while input 4 and 5 are promoted as output on lines 2 and 3 when a duo-binary data is read from banks #3, #4 and #5. Basically this procedure is the dual of the filling strategy for the memory: data must be brought back in the same way they were output by the processing unit.
Finally the last 5 outputs are directly connected to the corresponding input and can be considered valid only into the LDPC case.
The single-port λ/c2v (or M1) memory stores the input reliabilities coming from the channel for the Turbo codes and the check-to-variable messages for the LDPC decoding. Again, the total number of locations must be set according to the worst-case configuration, that is still the DVB-SH with K=12282. In such a case each stage of the trellis requires 5 values, which are the LLR of the systematic bit and two LLRs regarding the parity bits of each convolutional encoder. Consequently the total number of messages to be stored is equal to 12285×5=61425. Note that 3 extra trellis stages have been added so as to take into account the termination values. In the duo-binary case, 6 messages must be stored per trellis stage (2 systematic bit LLRs and 4 parity bit LLRs) and, considering the maximum symbol (i.e. trellis) length equal to N=2400 the total amount of storage required is equal to 2400×6=14400.
As far as the LDPC codes are concerned, the maximum number of messages to be stored is equal to the maximum value of the product codeword-size×Non-null blocks of the prototype matrix which is equal to 96×88=8448 in the IEEE 802.16e standard. Note that in this case 96 messages must be concurrently read/stored in memory in order to guarantee the proper architectural parallelism.
In view of the above-mentioned aspects the M1 memory is arranged into 12 blocks each one comprising 2 banks of 512 locations. Each location is in turn capable of storing 5λ/c2v messages.
Focusing on a single block it is then possible to process, 5, 6 or 8 data in parallel for the binary, duo-binary and LDPC case respectively.
FIGS. 9A1, 9A2, 9B and 9C show the filling strategy of the memory for the binary Multi-MAP, binary Multi-SISO, duo-binary and LDPC case respectively. Note that again here the filling schedule for the binary case is different depending on the decoding mode selected.
As a final result, considering that each message is represented on 5 bits, the total number of bits required for this memory is:

Bitchan=12×2×512×5×5=307200

It will be understood that all the numerical values provided here are only exemplary and non-limitative.
The decoding units DP are the other main elements of the inventive decoder. In a preferred embodiment, illustrated on FIG. 10, they are designed to perform Turbo decoding based on the BCJR sliding windows algorithm, and LDPC decoding based on the TDMP algorithm (which, in turn, relies on the BCJR algorithm).
The decoding unit DP; of FIG. 10 comprises four main functional blocks (CCC, SMRU, SMM, EP) connected with each other and with the first and second input ports through configurable “distribution” or “adaptation” networks (CMD, CCD, ED, SMD, σD). These adaptation networks are important for implementing flexibility: their role is to modify the data format depending on the particular code processed by the decoding unit. The detailed description of the individual functional blocks and adaptation networks will be preceded by a general overview of the operation of the decoding unit.
FIG. 11 shows the data schedule of the BCJR sliding windows algorithm used for Turbo decoding. More precisely, FIG. 11 shows the schedule of the Multi-SISO approach in which different sub-trellises are processed in parallel. This is the most general case, as the data schedule of the multi-MAP approach is obtained by removing the upper sub-trellis processing. The SISO2 will perform the same processing of SISO1 but considering a different frame.
The entire trellis is arranged into different windows with length W which are processed consecutively. The initialization values for the different backward recursions are retrieved through the use of W-long training sequences as described in [13]. Aiming at a low complexity solution, only one single processor (State-Metric Recursive Unit, SMRU) is designated to perform the whole recursion process, then a single window computation is divided into three stages:

    
    
        Forward recursion: the SMRU takes as input the extrinsic reliabilities for the considered window which are read from the M2 memory (through PN2 and ED) and the cumulative messages which can be derived from the channel LLR (λ) through the channel cumulative computation (CCC) and distribution (CCD) networks, whose architecture and operation will be discussed later. In order to implement single port memories, data read from the M2 memory are stored into a temporary Last-In First-Out (LIFO) buffer. The forward metrics are finally computed and stored into the state-metric memory (SMM).
        Backward training: the SMRU is initialized with all-zero values and a W-long backward recursion is performed. In this case data belonging to the next window must be taken as input and no intermediate metrics need to be stored.
        Backward recursion and extrinsic reliabilities update: the backward recursion is finally performed and concurrently the updated extrinsic metrics are calculated by the extrinsic processor (EP), whose architecture and operation will be discussed later, and stored back into memory. In this case while the M2 memory is being written, input data for the backward recursion are retrieved from the temporary LIFO buffer. The EP is finally the block in charge of updating the extrinsic reliabilities by reading the forward metrics from the SMM and on-the-fly receiving the updated backward data.
    
    


The initial forward metrics at the beginning of the first window might be unknown (e.g. circular turbo codes or multi-SISO schedule), then in such a case an extra W-long forward training sequence must be performed.
As already mentioned, the LDPC decoding relies on the TDMP algorithm in which each check node can be represented by means of a two-state trellis with length equal to the check node degree (number of variable nodes connected to a check node) and processed using the BCJR algorithm. Given the relatively low check-node degrees defined by the modern communication standards (i.e. not greater than 22), the sliding window data-schedule is no longer needed; then the whole trellis is processed in two stages only:

    
    
        Forward recursion: Check-to-variable messages are read from the related memory and turned into the proper format by the channel metric distribution (CMD), as it will be described later. In this case, since the updated data must be wrote back into the M1 memory during the backward recursion phase, the read c2v metrics are also stored into a LIFO buffer so as to keep the M1 memory as a single port RAM. The CCC block is then simply by-passed since no arithmetic operations are needed while the CCD block is used to produce the proper input configuration to the SMRU. Soft Output (SO) reliabilities are retrieved from memory M2 (again data are also stored into a LIFO buffer) and the P×P permutation network PN2 is used to perform a circular data rotation for the Architecture-Aware LDPC codes. The forward recursion can be then performed by the SMRU and the intermediate metrics stored into memory. Note that, since the most common Turbo codes define 8-states or 16-states trellises, more than one 2-statetrellis (i.e. check nodes) can be processed in parallel by the SMA.
        Backward recursion and metrics update: Check-to-variable and soft output messages are retrieved in this case from the related LIFO buffers and while the backward metrics are being evaluated by the SMRU, the forward metrics are read from the SMM and the updated messages can be concurrently evaluated by the EP and stored back into the corresponding memories. Note that in this case no permutation is required.
    
    


Both in the LDPC and in the Turbo case, recursive decoding can be carried out for a fixed number or iteration, or until a suitable stopping rule is satisfied (in practice, when a stopping rule is used, a maximum allowable number of iterations is also set to avoid being stuck in case of non-convergence of the decoding). Use of stopping rules is much preferred in order to save power; however, the added complexity introduced by their implementation has to be minimized.
LDPC stopping rules are not an issue, as a simple XOR parity check of the estimated output is sufficient.
Several stopping rules for Turbo codes are known from the prior art. A preferred embodiment of the invention implements a modified version of the “Hard Decision Aided” (HDA) rule [2], whose reference scheme is illustrated by FIG. 12, where HD indicates hard decision; “==” an equality check (output equal to 1 if and only if the two inputs are equal to each other) and ED an error detector. Convergence can be declared either when one (single-consistency) or both (double-consistency) the flags signal the data consistency. A detailed analysis shows that duo-binary codes require both the flags to be asserted in order to avoid floor issues, while one single flag asserted is enough to guarantee good performance for binary codes. In actual implementations, each decoding unit DPi plays the role of both SISO1 and SISO2. Therefore, the complexity overhead is only due to two hard decision blocks and one simple finite state machine to perform the consistency check (error detector).
It is now possible to describe in detail the operation and structure of the different functional blocks and adaptation networks forming the decoding units DPi, according to a preferred embodiment of the invention.
As apparent from FIG. 10, the LLR values λ (for Turbo decoding) and the check-to-variable messages c2v (for LDPC decoding) stored in the first memory M1 enter the decoding unit from the first input port I11 and are formatted by the “channel metric distribution” network CMD, a possible implementation of which is illustrated on FIG. 13 where the data stored in memory are simply denoted with λi,mem, data in the temporary buffer with λi,buf and output data with λi.
As already mentioned, in the exemplary embodiment a single memory block is composed of two banks whose locations comprise five messages. Consequently when a binary Turbo code is processed, the five required data can be read either from the first bank or the second one following the filling strategy depicted in FIG. 9A1/9A2. This schedule is guaranteed by a first stage of multiplexers which are driven by the control logic.
Moreover the required output are three (1 systematic plus 2 parities) and this must be selected depending on the decoding phase; this selection is performed by multiplexers driven by the binary control signal s2. Actually when the SISO1 decoding is in place the first three output of the first multiplexing stage are directly routed to the output while in case of SISO2 the first output must be 0 (no systematic information for the second encoder) while the last two data of the multiplexing stage must be promoted as valid output on line 1 and 2 respectively.
For duo-binary Turbo codes (“duo” signal is set to one), 6 data are available in memory according to FIG. 9B, then the “ctrl” (control) pin of first multiplexing stage is set to 1. Differently from the binary case four data are required as output and during the SISO1 phase the first four data in memory are routed to the output while during the SISO2 processing the first two output are set to 0 (no systematic information for the second encoder) while memory data 4 of the first bank and 0 of the second one are promoted to the third and fourth output lines.
Finally, within the LDPC decoding the 8 required data are routed directly from the memory to the output during the forward recursion and the backward training phases. On the other hand, during the backward computation, since the single port memory is being written, data are retrieved from a temporary buffer B.
The channel cumulative messages




  γ
  =
  
    ⁢
    
      
        c
        n
        e
      
      ·
      
        λ
        
          i
          ,
          n
        
      
    
  




(see equation 5) are derived from the input LLRs and the particular edge to be addressed. Given a generic convolutional encoder, the number of input LLRs per trellis stage is equal to the number of the encoder output (NO) and consequently the overall number of channel cumulative messages is equal to NC=2No. As a strategy to reduce the memory complexity, only the input LLRs are stored in memory M1, while channel cumulative messages are computed on-the-fly through an ad-hoc adder network CCC.

In the technical literature, “channel cumulative messages” are also referred to as “branch metrics”. However, the expression “branch metrics” is somehow ambiguous, as it is sometimes used for designating α and β as well as γ.
An example of such a network is shown on FIG. 14; this is able to cope with NO=3 for the binary codes and NO=4 for the duo-binary ones, which is sufficient to deal with all the codes of the modern communication standards. If higher NO values were necessary, however, extension of the architecture would be straightforward. The network of FIG. 14 can evaluate channel cumulative messages for two concurrent binary frames, A and B (even if, as discussed above, this feature has not been used in the exemplary embodiment in order to minimize the memory complexity); signals in brackets refer to said two concurrent binary frames, and signals without brackets refer to a single duo-binary frame. When binary frames are processed, the “is_duo” signal is set to 0; for duo-binary frames, this signal is set to one. The “is_duo” signal drives four 2×1 multiplexer, thus ensuring the configurability of the CCC unit.
As an arbitrary choice, on FIG. 14 the output signals are marked with the decimal representation of the edge label where the information symbols are always considered in the least significant position. For example, the output 11 in the duo-binary case, corresponds to “1011”, thus meaning that the first and second parity bits are “1” and “0” respectively while the information symbol is “11”(3).
The architecture of the CCC network has been optimized to minimize the number of adders which turns to be eleven, for a network supporting two concurrent binary frames. This level of optimization has been achieved by replicating two of the four input LLRs when a duo-binary code is processed (λ0, λ1). The adders in dark grey on the figure serve to implement the flexibility between binary and duo-binary codes.
Finally it is important to note that when a code with a certain No value is decoded, only the channel cumulative messages marked with a number less than NC−1 can be regarded as valid output.
As already mentioned, for LDPC decoding, the CCC network can be simply by-passed as the check-to-variable messages c2v from the memory M1 directly feed the State Metric Recursive Unit SMRU and do not need to be cumulated.
Channel cumulative messages, computed on-the-fly at each trellis stage, must be then properly distributed to the eight forward/backward processors. An optimized channel cumulative distribution network CCD is composed of eight sub-networks CCDi, individually feeding the forward/backward processor SMRU. FIG. 15 illustrates the structure of an optimized sub-network, comprising four 4-to-1 multiplexers and one 4×4 permutation network. This architecture is based on a general property of trellis graphs associated to recursive codes generated by linear feedback shift registers, namely the fact that each state of a trellis stage is connected with the states of the previous stage through edges labeled with different information symbols. The “edge configuration signal” depends on the set of transmitted bits labeling the edges of the trellis. Therefore, the control of the multiplexers and permutation networks depends on the trellis under processing.
Actually, considering the duo-binary case, the final output must be composed of four metrics having different information symbols, thus allowing the use of four input 4-to-1 multiplexers each one selecting among metrics with the same information symbol (metrics spaced by four). Finally, the 4×4 permutation network again allows different data distributions depending on the code under processing.
In the binary case, the architecture is split into two independent networks as the 4×4 permutation network is configured as two crossbar switches. The upper part then distributes data for the first frame while the lower part copes with the second one. This network, too, can be used to cope with two concurrent binary frames.
It is important to note that the overall network implements the flexibility, since a simple hard-wired network would be required in case of an optimized solution capable of decoding only one code family.
Within the LDPC decoding, this network can be configured to produce the proper input configuration of the forward/backward processor as shown in FIG. 19B.
FIG. 16 illustrates an exemplary embodiment of the Extrinsic Distribution block ED which is in charge of producing the proper extrinsic/Soft Output input configuration to the State Metric Recursive Unit SMRU indicated by Δi,j=0 . . . 7, j=0 . . . 4. Actually 8 data per decoding unit are produced from the P×P permutation network PN2 (Δ0,ED . . . Δ7,ED) and only the first one (Δ0,ED) is valid in the binary case. On the other hand three values (Δ0,ED, Δ1,ED and Δ2,ED) are valid in the duo-binary case while all the 8 values must be use in the LDPC case. Note that only five multiplexers are required in this case to provide the proper extrinsic/Soft-Output configuration for all the supported codes. The “is_tdmp” input of the multiplexers is set to 1 when a LDPC has to be processed.
The State Metric Recursive Unit SMRU, performing the forward and backward recursions, has already been described in [11].
As illustrated on FIG. 17, the unit is composed of ν state-metric processors (SMP0-SMPν-1) and a multiplexer-based recursion network. When the parameter ν is set to the maximum trellis width (number of states) to be supported, the SMA is able to process any trellis width less than ν and particularly ν two-state trellises (i.e. ν check node processing). In the exemplary embodiment of FIG. 18A, ν=8.
One or more state-metric processors are used for normalization. In this case, their outputs are equal to zero, and their output norms n0, n1 are distributed to other processors, which receive them through their normalization input ports ν0, ν1.
Normalization is a known feature of the BCJR algorithm, contributing to its numerical stability.
The recursion network RN represents a key element to achieve flexibility and make the SMRU capable of decoding different families of codes.
In principle, every state-metric input of the generic SMP could be connected to one of the 2ν outputs of the SMR unit, and its selection should involve a number of 4ν 2ν-to-1 multiplexers (32 16-to-1 multiplexer, in the exemplary embodiment). However, an optimal mapping onto the SMP in the SMRU can greatly reduce the size of the feedback multiplexers. This optimization is particularly advantageous in view of the fact that the multiplexers lie in the critical path of the SMRU, and the lower is the number of inputs, the smaller is their propagation delay and so the latency of the unit.
Specifically, when the SMRU supports every 8-state duo-binary, 8-state binary and 2-state binary code and serves both the forward and the backward recursion, the maximum number of inputs of the multiplexers in the feedback network can be reduced to 4. Indeed, as also shown in FIG. 18, out of the 4ν=32 state-metric inputs of the SMRU, 18 are driven by 2-to-1 multiplexers, 6 by 3-to-1 multiplexers and 6 by 4-to-1 multiplexers, while 2 inputs are simply hard-wired connected (input 0 of processor 0 and input 1 of processor 7).
FIGS. 18B, 18C and 18D represent the mappings of the states of Turbo-LDPC codes into the SMP's for the exemplary embodiment. The configuration of the recursion network and normalization connections directly depend on this mappings.
They correspond to 8-state duo-binary codes, 8 state binary codes and 2-state binary codes (used for LDPC) respectively.
A multiplexer-based interconnection network is also used to distribute the normalizations signals among the processors in the SMRU. The presence of such a network is justified by the observation that the computation of the normalization metric (associated to the state S0) is mapped on different SMs for different codes, so that a given processor, when acting as a regular processor, can receive its normalization input from different sources. Similarly to the feedback network, the normalization network can be also optimized with an optimum mapping of the state-metric updates onto the SM processors. Particularly, for the support of 8-state duo-binary, 8-state binary and 2-state binary codes, and with the mapping of FIG. 18B-D, only 6 2-to-1 multiplexers are needed, (see FIG. 18A), while the remaining 10 inputs are hard-wired connected to the respective norm processors.
FIG. 19A shows the internal structure of each individual State Metric Processor SMP, in charge of performing the operations of a single state for binary/duo-binary turbo codes and a single check-node update for LDPC codes. As far as the duo-binary processing is concerned (signals not in brackets on FIG. 19A), each state receives exactly four edges, then the max*(max) operation among four elements is performed. Input data to the max*(max) tree are computed by summing the proper forward/backward metrics retrieved at the previous trellis stage with the channel cumulative and extrinsic messages associated to each edge. The “max” operator is simply a comparator, while the “max*” operator can be implemented using a comparator plus a look-up table.
Note that the extrinsic reliabilities Δ must be properly routed depending on the code under decoding through a 4×4 permutation network. Finally the max*(max) tree output is normalized by the output adders so as to reach the final updated forward/backward metric.
Besides the updated forward/backward metrics, this unit also outputs the sum of the input metrics with the channel cumulative messages (σ0(i) . . . σ3(i)) which can be directly used within the extrinsic computation. This architecture is also capable of coping with two parallel frames of a binary code (signals in brackets) as, once the multiplexers are switched to “0”, two independent data-paths can be identified. Indeed, in a binary code, only two edges are connected to each state thus requiring one single max*(max) operator. Focusing on the LDPC two-state trellis, the same unified SMP with a different output interconnection scheme is used to perform a single check-node update. The detailed architecture is shown in FIG. 19B where two independent sub-processors are identified and used to perform the update described in [14]. In this case the variable-to-check input messages (λb,c or “v2c” for short) are computed as the difference between the Soft-Output λb (or “SO” for short) and the check-to-variable message λc,b (or “c2v” for short) performed with the second stage of adders.
The State Metric Processors perform first forward metrics α and then backward metrics β (or the other way around, it is perfectly equivalent). As both backward and forward metrics are needed to compute extrinsic reliabilities, the latter have to be stored in a State Metric Memory SMM while the processors perform backward recursion.
The single-port State-Metric Memory SMM stores all the metrics of the forward recursion within one single window to be used for the computation of the final a-posteriori extrinsic reliabilities/Soft Output messages.
In the case of binary/duo-binary turbo codes (FIG. 20A), the memory stores 7 metrics per window stage for a maximum of Wmax×7=74×7=518 data.
As far as the LDPC decoding is concerned (FIG. 20B), 8 forward metrics (i.e. the number of trellis processed by SMA) must be stored per trellis stage for a total of dc,max×8=22×8=176 metrics. As a result, the memory is arranged into 2 banks of 37 locations, each one containing 7 messages. FIGS. 20A and 20B illustrates the memory filling strategy for the Turbo and LDPC case respectively.
As a final result, considering that each message is represented on 6 bits, the total number of bits required for this memory is:

Bitsm=12×2×37×7×6=37296

The forward metrics α and the σ computed during backward recursion (σ=β+γ) are eventually passed to the Extrinsic Processor EP which updates extrinsic reliabilities Δ and check-to-variable messages c2v. Before, however, these data are formatted by respective adaptation networks, called State Metric Distribution (SMD) and σ-Distribution (σD) networks.
FIG. 21 shows the state metric distribution architecture which properly routes the data retrieved from the SMM to the EP. As already detailed, the memory comprises two banks whose locations store 7 forward metrics. Focusing on the turbo decoding and according to the filling schedule of FIG. 20A, the required 7 data can be read either from the first or second bank depending on the trellis stage under processing. Consequently the first multiplexing stage of the SMD, properly driven by the control logic CM, is in charge of performing this selection. Finally, the 7 selected forward metrics are replicated and output according to the configuration required by the EP. As far as the LDPC decoding is concerned, the 8 required data are retrieved and selected from memory according to the scheme of FIG. 20B and outputted in the proper configuration through the second stage of multiplexers.
FIG. 22 illustrates the sigma distribution (σD) architecture. Actually, while within the turbo decoding the σ values produced by the SMRU are already properly ordered for the EP, when an LDPC code is processed (“is_tdmp”=1), data must-be rearranged in order to properly evaluate the updated c2v messages.
The Extrinsic Processor EP is in charge of producing the updated extrinsic reliabilities for Turbo codes as well as Soft Output and check-to-variable messages for the LDPC case. According to the BCJR data schedule, this block takes as input the forward metrics retrieved from the SMM and the σ values computed on-the-fly by the SMUR during the backward recursion (equivalently, it could take as inputs α, β and γ, given that σ=β+γ). An exemplary embodiment of an EP copying with 8-state trellises is illustrated on FIG. 23.
Let us consider first the duo-binary Turbo case in which three updated extrinsic reliabilities have to be computed. This is accomplished by performing four independent max*(max) operations among the edge metrics labeled with same information symbol and by computing a final normalization. Each max*(max) must be executed among 8 input, and then a three stages tree structure is used. Note that, the support of trellis widths larger than 8 can be easily achieved by adding one or more stages to the max*(max) tree. As far as the edge metrics are concerned, they can be effectively evaluated by using the output σ0(i), . . . σ3(i) produced by the SMRU during the backward recursion. Actually, while evaluating the backward metric for a certain state βk(Si), the summation of the backward metrics of each connected states with the related channel cumulative message is carried out, then the metrics related to four edges can be attained by simply adding the forward metric αk(Si) retrieved from memory (two equal values are read from memory and then duplicated). The structure of the trellis assures that the four calculated metrics are related to edges labeled with different information symbols, then a 4×4 permutation network is required to deliver the messages to the proper operator. This processing is executed for all the 8 states (extension is straightforward) thus finally achieving the metrics for all the 32 edges of the trellis.
This architecture can also produce the extrinsic reliabilities for two parallel binary frames. Actually, the four edge metrics carried out for each state are related to two different frames (two edge metrics per frame). Each 4×4 permutation network is then configured as two independent crossbar switches, the former feeding the first two max*(max) operators while the latter the remaining ones. Finally, thanks to the output multiplexer (in white on the figure) switched to “0”, two independent normalizations are performed to achieve the two final extrinsic reliabilities. Here, “normalization” corresponds to the subtraction in equation (6), and is implemented by the adders (in white on FIG. 23) connected to the outputs of the max* trees.
The support of LDPC decoding is attained thanks to the last two adder stages (in dark gray on the figure). Actually, according to the algorithm defined in [14], the evaluation of the updated check-to-variable messages only involves max*(max) operations between two elements; particularly, the update of 8 metrics in parallel exactly involves 16 max*(max) operation. This computation can be then accomplished by the first stage of max*(max) operators whose output must be then combine with a stage of 8 adders (extension is again straightforward). The architecture produces then 8 check-to-variable metrics (c2vi), and while the last five output are dedicated for the LDPC the first three are shared with the turbo computation thus requiring three additional multiplexers to select the proper data. Finally, the updated check-to-variable metrics (c2vi), before being stored into the M1 memory, are used as input to the last stage of adders to evaluate the Soft-Output metrics according to the layered algorithm [15].
The inventive decoder has been described in detail considering an embodiment suitable for decoding LDPC and PCCC-Turbo codes. However, it can be easily adapted to decode SCCC turbo codes. FIG. 3B shows that the reliability messages exchanged between the two SISO blocks refer to the bits labeled with vi in FIG. 1c which are actually the interleaved coded bit of the first RSC encoder. Consequently a SISO block for SCCC support, besides the reliabilities of the information symbols ui which are necessary to provide the decoder output, must also evaluate the reliability messages of the coded bits. Again in this case, the BCJR algorithm can be used to calculate these metrics according to Eq. (9). The architecture of FIG. 5 can be then also used for the decoding of SCCC codes, while the internal architecture of each DP must be slightly modified so as to evaluate equation 9. Particularly FIG. 28 shows the modification to be performed on each SMP where a new set of output (ρ) must be envisaged. This is actually necessary as in this case also the reliabilities of the information symbols must be included in the calculation of the reliabilities for the coded bit. Finally, for each coded bit, it is necessary to add, in parallel to the extrinsic processor EP, a network SCCCN whose architecture is shown in FIG. 29. This network takes as inputs the forward metrics previously stored in the SMM and the p metrics generated by the modified SMP's and produces as output the reliability of the considered coded bit. Note that, in the exemplary architecture of FIG. 29, data of two concurrent frames can be processed.
With minimal modification, the inventive decoder is also suitable for decoding non-binary LDPC over GF(q) (i.e. over a Galois field of order “q”, “q” being a power of two. These codes are not used by any current standard, but are the object of intense research.
Indeed, each check node constraint, being a parity check equation over a GF(q), can be represented by a q-state trellis with a length equal to the check node degree. An exemplary trellis representing a check node constraints over GF(4) is shown in FIG. 30 where the edge labels represent the product—in GF(4)—of the transmitted symbol involved in the parity check constraint and the corresponding entry—still in GF(4)—of the parity check matrix. The LLR reliability of this product is a vector representing the variable-to-check message. Once generated, the variable to check messages are used as input for the check node processing which, according to the TDMP method, is performed using the BCJR algorithm. Besides this processing over a q-state trellis, the remaining of the TDMP algorithm does not change, except for the fact that a vector of reliabilities (three in the case of GF(4)) must be managed for each single message instead of the only one required by the binary LDPC algorithm. In view of this fact, the flexible LDPC/Turbo architecture of the invention can be easily used to decode non-binary LDPC codes over GF(q). More in detail the SMRU will be in charge of copying with the forward/backward computation of the check node processing; for example considering an embodiment with 8 SMP's, two check node recursions can be performed in parallel for an LDPC code over GF(4). The extrinsic processor will be in charge of evaluating the new c2v and SO vector. The only difference would be in the final two adder stages whose input must be taken from different stages of the max*/max trees. For example in an embodiment supporting LDPC over GF(4) four max*/max operations between four elements must be envisaged per each check node, then the adder of the two last stages must be fed by the second stage of the max/max* tree. More in general it is straightforward to add a small adaptation network to manage different LDPC code over different GF(q) by selecting the most suitable input for the adders evaluating the c2v and SO messages.
The rest of the decoder will basically remain unchanged. Note also that the permutation networks PN1(PN2) can be used to evaluate the product over GF(q) of the reliabilities associated to the transmitted bits and the non-zero entries in the parity check matrix, because in GF(q) this product is simply a q×q permutation.
The characterization of the architecture described here (FIGS. 5-26), implemented as an ASIC, has been carried-out through logical synthesis on a 45 nm standard-cell CMOS technology with high-density of integration (CMOS-45HD) and a supply voltage of 0.95V. This library is particularly suitable for mobile application as it guarantees an high level of optimization in terms of area (high-density process) and power consumption (low-leakage transistors).
The operating clock frequency has been set to 150 MHz which guarantees the strict throughput constraints to be met with reduced dynamic power consumption.
Table II reports the complexity breakdown of the logic resources for an overall occupied area of 0.45 mm2. Particularly, the most area demanding blocks are the 12 instances of the SMRU which counts for the 35% of the overall complexity. Furthermore it is important to note that the support of different coding schemes (LDPC and Turbo codes) results in a considerable contribution of the control unit (CM) to the logic complexity (20.3%).











TABLE II







Unit Area
Area



Block
# units
(μm2)
(μm2)
Weight



















CCC
12
691
 8202
 1.8%


CCD
96
482
46272
10.3%


CMD
1
91480
91480
20.3%


EP
12
8018
96216
21.4%


SMRU
12
13407
160884 
35.8%


PN1
1
2471
 2471
 0.5%


PN2
1
13020
13020
 2.9%


Interfaces & glue logic
1
31365
31365
  7%








Total
0.45 mm2









Table III details the breakdown complexity related to the memory blocks. As expected the M1 memory plays a major role (≈69% of the total area) as it contains five channel reliabilities per information bit in the worst case code (DVB-SH K=12282). Finally it is important to note that, thanks to the proper memory arrangement and filling strategy described above and to the hybrid Multi-SISO/Multi-MAP architecture it was possible to optimize the memory complexity which results roughly equal to the logic area.












TABLE III








Bit per
Tot. Area




Block
# banks
bank
(μm2)
Weight





















M2
96
768
76800
16.9%



TB-M2
108
150
20250
 4.5%



M1
24
12800
313470 
68.9%



SMM
24
1554
44400
 9.7%









Total
0.45 mm2










The power consumption of the implemented channel decoding platform has been estimated in the worst case condition, which applies when the decoder runs the maximum number of iterations with all the 12 data-paths activated. Table IV reports the results in terms of Dynamic and Static Power consumption, showing that, although the complexity are comparable, the memory power consumption is much higher than the logic one (almost doubled). Note that the low total power consumption of 86.1 maw is attained thanks to the low operating clock frequency which considerably reduces the dynamic power consumption. Finally, in view of the stopping rules implementation, it is possible to further reduce the power during the decoding processing depending on the channel conditions and data-paths required.











TABLE IV







Dynamic Power
Static Power
Total Power



Block
(mW)
(mW)
(mw)




















Logic
31.3
0.2
31.5



Memories
54
0.6
54.6









Total
86.1 mW










Table V shows a comparison with the prior art designs of [5], [6] and [8]. In order to have a technology independent complexity parameter (equivalent gate) the reported area values have been normalized to the area of the NAND2 gate for the related technology. These values are 0.99 μm2, 2.06 μm2 and 4.39 μm2 for the 45 nm, 65 nm and 90 nm technology respectively. As far as the power consumption is concerned a technology independent value has been considered as it follows:

PW−norm=P(MHz,Kgates)·fclk·A 

where fclk is the operating clock frequency, A is the complexity in Kgates and P(MHz,Kgates) is the power consumption of the inventive decoder normalized to the complexity and clock frequency:

P(MHz,Kgates)=86.1/(150·900)=638·10−6 W/(Kgates·MHz)

Design in [8] seems to outperform the inventive decoder in terms of complexity, but, although a unified approach is described, the results are given only for single standard solutions. Thus a certain overhead must be added in view of a multi-standard implementation of such a design. Furthermore the architecture is highly inefficient in terms of power consumption especially due to the very high clock frequency. Consequently the suitability to the integration into a mobile device must be carefully assessed.
The ASIP solution proposed in [5] features an extremely low complexity with a power consumption lower than our solution by 10%. Although these astonishing figures, the very important drawback of this architecture is that it is not fully compliant with the throughput requirements defined by the communication standards to be supported; more particularly, the required throughput for IEEE 802.16e (WiMAX) is not met. Actually the maximum achievable throughput (with only 5 iterations) for the duo-binary IEEE 802.16e Turbo codes is declared to be at maximum 37.2 Mbps which is well below the requirement of the standard (70 Mbps). Consequently, the architecture as it is cannot be used within a device supporting the above-mentioned standard. A solution to the problem could be for example, either increasing the operating clock frequency or adding new hardware resources, thus consequently increasing the complexity and making the architecture inefficient in terms of power consumption.











TABLE V






This work
[8]
[5]
[6]







Design
ASIC
ASIC
ASIP
ASIP


Multi-Standard
YES
NO
YES
YES


Technology
45 nm
90 nm
65 nm
45 nm


Clock Frequency (MHz)
150
500
400
333


Throughput met
YES
YES
NO
YES


Complexity (Kgates)
900
514
301
940


PW-norm (mW)
86.1
163.9
76.8
199.6









A complete and fair comparison can be indeed performed with the ASIP design of [6] which is a multi-standard decoder fully compliant with the supported standards in terms of throughput. As it is shown from tab. V, the present invention outperforms such an ASIP architecture both in terms of complexity and power consumption.
REFERENCES


    [1]: G. Masera, F. Quaglio, and F. Vacca “Implementation of a flexible LDPC decoder”, 54(6):542-546, June 2007.
    [2] Hye-Jin Ryu Jong-Yeol Lee “A 1-Gb/s flexible LDPC decoder supporting multiple code rates and block lengths”, IEEE Trans. Consumer Electron., 54:417-424, May 2008.
    [3] M. Martina, M. Nicola, and G. Masera “A flexible umts-wimax turbo decoder architecture”, IEEE Transaction on Circuit and System, Express Briefs, 55(4):369-373, April 2008.
    [4] In-Cheol Park Ji-Hoon Kim “A unified parallel radix-4 turbo decoder for mobile WiMAX and 3GPP-LTE”, IEEE Custom Integrated Circuits Conference, CICC '09, pages 487-490, September 2009.
    [5] M. Alles, T. Vogt, and N. When “FlexiChaP: A reconfigurable ASIP for convolutional, turbo, and LDPC code decoding”, IEEE 5th International Symposium on Turbo Codes and Related Topics, pages 84-89, September 2008.
    [6] F. Naessens, B. Bougard, S. Bressinck, L. Hollevoet, P. Raghavan, L. Van Der Perre, and F. Catthoor “A unified instruction set programmable architecture for multi-standard advanced forward error correction”, IEEE Workshop on Signal Processing Systems, SiPS 2008, pages 31-36, October 2008.
    [7] WO 2009/043918
    [8] Sun Yang and J. R. Cavallaro “Unified decoder architecture for LDPC/turbo codes”, IEEE Workshop on Signal Processing Systems, SiPS 2008, pages 13-18, October 2008.
    [9] WO 2008/153436
    [10] M. Rovini, G. Gentile, and L. Fanucci, “A flexible state-metric recursion unit for a multi-standard BCJR decoder,” 2009 3rd International Conference on Signals, Circuits and Systems (SCS), 11 2009, pp. 1-6.
    [11] M. Rovini, G. Gentile, and L. Fanucci “Multi-size circular shifting networks for decoders of structured LDPC codes”, IET Electr. Lett., 43(17):938-940, August 2007.
    [12] A. Tarable, S. Benedetto, and G. Montorsi “Mapping interleaving laws to parallel turbo and ldpc decoder architectures”, IEEE Transaction on Information Theory, 50(9):2002-2009, September 2004.
    [13] T. Brack, M. Alles, F. Kienle, and N. When “A synthesizable IP core for WiMAX 802.16e LDPC code decoding”, 17th IEEE Intern. Symp. on Personal, Indoor and Mobile Communic., pages 1-5, September 2006.
    [14] G. Gentile, M. Rovini, and L. Fanucci “Low-complexity architectures of a decoder for IEEE 802.16e LDPC codes”, 10th Euromicro Conference on Digital System Design (DSD), August 2007.
    [15] IEEE Standard for information technology—Telecommunications and information exchange between systems—Local and metropolitan area networks. Part 11 Wireless LAN Medium Access Control (MAC) and Physical Layer (PHY) Specifications. Amendment 5: Enhancement for Higher throughput, November 2009.

## Claims

1. A configurable Turbo-Low Density Parity Check (LDPC) decoder comprising:
A set of P>1 Soft-Input-Soft-Output decoding units (DP0-DPP-1; DPi) for iteratively decoding both Turbo- and LDPC-encoded input data, each of said decoding units having first (Iii) and second (I2i) input ports and first (O1i) and second (O2i) output ports for intermediate data;
First and second memories (M1, M2) for storing said intermediate data, each of said first and second memories comprising P independently readable and writable memory blocks having respective input and output ports; and
A configurable switching network (SN) for connecting the first input and output ports of said decoding units to the output and input ports of said first memory, and the second input and output ports of said decoding units to the output and input ports of said second memory,
wherein
each of said P>1 Soft-Input-Soft-Output decoding units (DP0-DPP-1; DPi) has:
a first input port (I1i) for input reliabilities (λ) used in Turbo-decoding, and for check-to-variable metrics (c2v) used in LDPC-decoding;
a second input port (I2i) for extrinsic reliabilities (Λ) used in Turbo-decoding and for intermediate soft outputs (SO) used for LDPC-decoding;
a first output port (O1i) for check-to-variable metrics updated during LDPC-decoding; and
a second output port (O2i) for extrinsic reliabilities obtained as intermediate or final results of Turbo-decoding, and for soft outputs obtained as intermediate or final results of LDPC-decoding; and
said configurable switching network comprises:
A first and second P×P permutation network (PN1, PN2);
A P×P circular switching network (PSN);
First switching means (SW1) connecting the input ports of said first memory with either the first output ports of said decoding units or with a first input port (ID1) of the Turbo-LDPC decoder;
Second switching means (SW2) connecting the input ports of said second memory with either the second output ports of said decoding units through said first P×P permutation network, or with a second input port (ID2) of the Turbo-LDPC decoder;
Third switching means (SW3) connecting the output ports of said first memory with the first input ports of said decoding units either directly or through said P×P circular switching network; and
Fourth switching means (SW4) connecting the output ports of said first memory with either the second input ports of said decoding units through said second P×P permutation network, or with an output port (OD) of the Turbo-LDPC decoder.

2. The configurable Turbo-LDPC decoder according to claim 1 also comprising control means (CM) for driving said switching network and said decoding units in order to selectively implement:
simultaneous decoding of several Turbo-encoded frames by at least some of said P decoding units;
parallelized decoding of a single Turbo-encoded frame by at least some of said P decoding units; and
parallelized decoding of a single LDPC-encoded frame by at least some of said P decoding units, each processing one or more parity-check constraints.

3. The configurable Turbo-LDPC decoder according to claim 1 also comprising control means (CM) for driving said first and second permutation network, said circular switching network, said first, second, third and fourth switching means and said decoding units in order to selectively implement:
simultaneous decoding of several Turbo-encoded frames by at least some of said P decoding units, whose first input ports are connected to the output ports of said first memory through said circular switching network, the Turbo-encoded frames to be decoded being received through said first input port of the decoder and stored in said first memory;
parallelized decoding of a single Turbo-encoded frame by at least some of said P decoding units, each processing a portion of a code trellis, whose first input ports are directly connected to the output ports of said first memory, the Turbo-encoded frames to be decoded being received through said first input port of the decoder and stored in said first memory; or
parallelized decoding of a single LDPC-encoded frame by at least some of said P decoding units, each processing one or more parity-check constraints, the LDPC-encoded frames to be decoded being received through said second input port of the decoder and stored in said second memory.

4. The configurable Turbo-LDPC decoder according to claim 1 wherein said first and second memories are single-port memories, respective temporary buffers being provided to avoid read/write collisions.

5. The configurable Turbo-LDPC decoder according to claim 1 wherein said decoding units are adapted for performing Turbo- and LDPC-decoding using a BCJR (Bahl, Cocke, Jelinek and Raviv), or forward-backward, algorithm.

6. The configurable Turbo-LDPC decoder according to claim 5 wherein said decoding units are adapted for performing LDPC-decoding using a TDMP algorithm.

7. The configurable Turbo-LDPC decoder according to claim 1 comprising a number P of decoding units comprised between 4 and 16.

8. The configurable Turbo-LDPC decoder according to claim 1 comprising means for switching off or on part of the decoding units and of the memory blocks of said first and second memory depending on a required decoding throughput.

9. The configurable Turbo-LDPC decoder according to claim 1 wherein each of said decoding units comprises a single processing core for both Turbo- and LDPC-decoding.

10. The configurable Turbo-LDPC decoder according to claim 9 wherein each of said decoding units (DPi) comprises the following functional blocks:
A by-passable channel cumulative computation unit (CCC) for computing channel cumulative messages (γ) by adding-up input reliabilities;
A state-metric recursive unit (SMRU) for successively performing recursive computation of forward (α) and backward (β) metrics, taking said channel cumulative messages (γ) as inputs;
A state-metric memory (SMM) for storing already-computed forward metrics while the state-metric recursive unit is computing backward metrics, or vice-versa; and
An extrinsic reliabilities processor (EP) for computing extrinsic reliabilities (A), for Turbo-decoding, and soft outputs and check-to-variable metrics (c2v), for LDPC decoding, taking said forward metrics, backward metrics and channel cumulative messages as its inputs.

11. The configurable Turbo-LDPC decoder according to claim 10 wherein each of said decoding units also comprises configurable distribution networks (CMD, CCD, ED, SMD, aD) for transferring data from the input ports of the decoding units to its functional blocks, and between said functional blocks, according to different data formats and decoding algorithms.

12. The configurable Turbo-LDPC decoder according to claim 10 wherein the extrinsic reliabilities processor of each decoding unit comprises:
input ports for receiving forward (α), backward (β) and channel cumulative messages (γ), or combinations thereof (σ), corresponding to different trellis edges;
a first stage of adders, for adding forward, backward and channel cumulative messages corresponding to a same trellis edge;
a number 2M of max* or max trees equal to the number of said alphabet symbols;
a number K of 2M×2M permutation networks equal to the number of said trellis states, connecting output ports of said adders to input ports of said max* or max trees, wherein each of said max* or max trees has K input ports, each one being connected to a different one of said permutation networks;
a third stage of adders for computing extrinsic reliabilities (Λ) as sums of outputs of said max* or max trees; and
fourth and fifth stages of adders for computing updated check-to-variable metrics (c2v) and LDPC-soft outputs (SO) by combining input and outputs of first stages of said max* or max trees.

13. The configurable Turbo-LDPC decoder according to claim 10 wherein the state-metric recursive unit (SMRU) of each decoding unit comprises a plurality of state metric processors (SMP0-SMP7) for computing forward and backward metrics of respective states of a code trellis, interconnected by a configurable recursion network.

14. The configurable Turbo-LDPC decoder according to claim 13 wherein each said state metric processor comprises:
first input ports for receiving, through said recursion network (RN), forward (α)/backward (β) metrics;
second input ports for receiving channel cumulative messages (γ) corresponding to different edges reaching a same state of a code trellis;
a first stage of adders, for adding forward/backward and channel cumulative messages corresponding to a same trellis edge;
third input ports for receiving a posteriori reliabilities (Λ)/Soft-outputs (SO);
a second stage of adders, for adding said a posteriori reliabilities to the sums performed by the adders of said first stages;
a max* or max tree taking as inputs the sums computed by the adders of said second stage; and
first output ports for updated values of said forward/backward metrics.

15. The configurable Turbo-LDPC decoder according to claim 13 wherein each said state metric processor further comprises second output ports for the sums (a) of forward/backward and channel cumulative messages corresponding to a same trellis edge.

16. The configurable Turbo-LDPC decoder according to claim 1, implemented as an Application Specific Integrated Circuit.

17. An extrinsic reliability processor for computing extrinsic reliabilities in Turbo-decoding, and soft outputs and check-to-variable metrics, in Low Density Parity Check (LDPC) decoding, having input ports for forward metrics, backward metrics and channel cumulative messages corresponding to different trellis edges:
a first stage of adders, for adding forward, backward and channel cumulative messages corresponding to a same trellis edge;
a number 2M of max* or max trees equal to the number of said alphabet symbols;
a number K of 2M×2M permutation networks equal to the number of said trellis states, connecting output ports of said adders to input ports of said max* or max trees, wherein each of said max* or max trees has K input ports, each one being connected to a different one of said permutation networks;
a third stage of adders for computing extrinsic reliabilities as sums of outputs of said max* or max trees; and
fourth and fifth stages of adders for computing updated check-to-variable metrics and LDPC-soft outputs by combining input and outputs of first stages of said max* or max trees.