# Patent

## Title
Adaptive desaturation in min-sum decoding of LDPC codes

## Abstract

A system implements adaptive desaturation for the min-sum decoding of LDPC codes. Specifically, when an-above threshold proportion of messages from check nodes to variable nodes (CN-to-VN messages) are saturated to a maximum fixed-precision value, all CN-to-VN messages are halved. This facilitates the saturation of correct messages and boosts error correction over small trapping sets. The adaptive desaturation approach reduces the error floor by orders of magnitudes with negligible add-on circuits.

## Background
BACKGROUND
Field of the Invention
This invention relates to systems and methods for implementing a low density parity check (LDPC) decoding algorithm.
Background of the Invention
A. LDPC Codes and Min-Sum Decoding
Low-density parity-check (LDPC) codes were discovered by Gallager in 1962, and rediscovered and shown to be Shannon-limit approaching in the late 1990's. Its very low density of 1's in H matrix renders it convenient to represent an LDPC code by a bipartite graph, called a Tanner Graph. There are two types of nodes in a Tanner graph, namely, variable nodes (VN's) and check nodes (CN's). Each variable node (or check node) corresponds to a column (or row) of the parity-check matrix H. We denote by V={v1, v2, . . . vn} the set of variable nodes, and by C={c1, c2, . . . cm} the set of check nodes. We also index each row of H by ={1, 2, . . . , m} and each column of H by V={1, 2, . . . , n}. In the Tanner graph, VN vi is connected to CN cj via an edge if Hj,i=1, and the set of edges on the Tanner graph is denoted by set E (see FIGS. 4A and 4B).
Quasi-cyclic (QC) LDPC codes are a special class of the LDPC codes with structured H matrix which can be generated by the expansion of an mb×nb base matrix. Each 1's element in the base matrix can be expanded by a circularly right-shifted b×b identity sub-matrix. QC-LDPC codes have advantages over other types of LDPC codes in hardware implementations of both encoding and decoding. Encoding of a QC-LDPC code can be efficiently implemented using simple shift registers. In hardware implementation of a QC-LDPC decoder, the QC structure of the code simplifies the wire routing for message passing.
The message-passing (MP) algorithm is the most efficient to achieve near-optimal decoding of LDPC codes. We now briefly introduce the variable node (VN) and check node (CN) update rules of message passing decoding. In the sequel, for notational conciseness, we simply use i, instead of vi, to denote a VN, and, j, instead of cj, to denote a CN. A VN i receives an input message Lich from the channel, typically the log-likelihood ratio (LLR) of the corresponding channel output, defined as follows:




  
    
      
        
          L
          i
          ch
        
        =
        
          
            log
            ⁡
            
              (
              
                
                  Pr
                  ⁡
                  
                    (
                    
                      
                        R
                        i
                      
                      =
                      
                        
                          
                            r
                            i
                          
                          |
                          
                            c
                            i
                          
                        
                        =
                        0
                      
                    
                    )
                  
                
                
                  Pr
                  ⁡
                  
                    (
                    
                      
                        R
                        i
                      
                      =
                      
                        
                          
                            r
                            i
                          
                          |
                          
                            c
                            i
                          
                        
                        =
                        1
                      
                    
                    )
                  
                
              
              )
            
          
          =
          log
        
      
    
    
      
        (
        1
        )
      
    
  




where ciε{0,1} is the code bit and ri is the corresponding received symbol.
The conventional iterative MP decoder alternates between two phases, a “VN-to-CN” phase during which VN's send messages to CN's along their adjacent edges, and a “CN-to-VN” phase during which CN's send messages to their adjacent VN's. The message update rules, whose details will be given later in this section, are depicted schematically in Tables. 1 and 2, respectively. In the initialization step of the decoding process, VN i forwards the same message to all of its neighboring CN's, V(i), namely the LLR Lich derived from the corresponding channel output. In the CN-to-VN message update phase, CN j uses the incoming messages and CN update rule to compute and forward, to VN iε(j) a new “CN-to-VN” message, Lj→i. VN i then processes its incoming messages according to VN update rule and forwards to each adjacent CN, (i), an updated “VN-to-CN” message, Li→j. After a pre-specified number of iterations, VN i sums all of the incoming LLR messages to produce an estimate of the corresponding code bit i. Note that all of the “CN-to-VN” message updates can be done in parallel, as can all of the “VN-to-CN” message updates. This enables efficient, high-speed software and hardware implementations of the iterative MP decoding algorithms.
Denote by Li→j and Lj→i the messages sent from VN i to CN j and from CN j to VN i, respectively. Denote by (i) the set of CN's directly connected to VN i and V(j), the set of VN's directly connected to CN j. Then, the message sent from VN i to CN j in SPA (sum-product algorithm) decoding is given by:

Li→j=Lich+Lj′→i,  (2)

and the message from CN j to VN i is computed as




  
    
      
        
          L
          
            j
            →
            i
          
        
        =
        
          2
          ⁢
          
            
          
          ⁢
          
            
              
                tanh
                
                  -
                  1
                
              
              ⁡
              
                (
                
                  
                    Π
                    
                      
                        i
                        ′
                      
                      ∈
                      
                        
                          v
                          ⁡
                          
                            (
                            j
                            )
                          
                        
                        ⁢
                        \
                        ⁢
                        
                          
                        
                        ⁢
                        i
                      
                    
                  
                  ⁢
                  tanh
                  ⁢
                  
                    
                      L
                      
                        
                          i
                          ′
                        
                        -
                        j
                      
                    
                    2
                  
                
                )
              
            
            .
          
        
      
    
    
      
        (
        3
        )
      
    
  




Denote by Pi a posterior probability (APP) message of VN i,

Pi=Lich+Lj′→i  (4)

In practically prevailing min-sum decoding, a VN takes log-likelihood ratios of received information from the channel as initial input message, i.e., Li→j=Lich, and the following equivalent CN update rule is employed

Lj→i=[Πi′εV(j)\isign(Li′→j)]·α·(β+mini′εV(j)\i|Li′→j|),  (5)

where 0<α,β<1 are the attenuation factor and offset, respectively, which can be a fixed constant or adaptively adjusted [1]. We next introduce some notations to simplify the above calculation in the algorithmic procedure. Let

Si→jsign(Li→j).  (6)

Denote by S(j) the product sign of all VN i's to the CN j

S(j)Πi′εV(j)Si′→j.  (7)

Denote by Lmin1(j) and imin1(j) the normalized minimum VN message to the CN j and its associated index, respectively,

Lmin1(j)α·(β+mini′εV(j)|Li′→j|),imin1(j)arg mini′εV(j)|Li′→j|  (8)

and by Lmin2(j) the normalized second minimum VN message to the CN j




  
    
      
        
          L
          
            m
            ⁢
            
              
            
            ⁢
            i
            ⁢
            
              
            
            ⁢
            n
            ⁢
            
              
            
            ⁢
            2
          
          
            (
            j
            )
          
        
        ⁢
        
          =
          Δ
        
        ⁢
        
          α
          ·
          
            (
            
              β
              +
              
                
                  min
                  
                    
                      i
                      ⁢
                      
                        
                      
                      ⁢
                      ′
                    
                    ∈
                    
                      
                        V
                        ⁡
                        
                          (
                          j
                          )
                        
                      
                      ⁢
                      \
                      ⁢
                      
                        
                      
                      ⁢
                      
                        i
                        
                          m
                          ⁢
                          
                            
                          
                          ⁢
                          i
                          ⁢
                          
                            
                          
                          ⁢
                          n
                          ⁢
                          
                            
                          
                          ⁢
                          1
                        
                        
                          (
                          j
                          )
                        
                      
                    
                  
                
                ⁢
                
                  
                  
                    L
                    
                      
                        i
                        ⁢
                        
                          
                        
                        ⁢
                        ′
                      
                      ->
                      j
                    
                  
                  
                
              
            
            )
          
        
      
    
    
      
        (
        9
        )
      
    
  




With the above notations, (5) is conveniently re-expressed by




  
    
      
        
          L
          
            j
            ->
            i
          
        
        =
        
          
            S
            
              (
              j
              )
            
          
          ·
          
            S
            
              i
              ->
              j
            
          
          ·
          
            {
            
              
                
                  
                    L
                    
                      m
                      ⁢
                      
                        
                      
                      ⁢
                      i
                      ⁢
                      
                        
                      
                      ⁢
                      n
                      ⁢
                      
                        
                      
                      ⁢
                      1
                    
                    
                      (
                      j
                      )
                    
                  
                
                
                  
                    
                      if
                      ⁢
                      
                        
                      
                      ⁢
                      i
                    
                    ≠
                    
                      i
                      
                        m
                        ⁢
                        
                          
                        
                        ⁢
                        i
                        ⁢
                        
                          
                        
                        ⁢
                        n
                        ⁢
                        
                          
                        
                        ⁢
                        1
                      
                      
                        (
                        j
                        )
                      
                    
                  
                
              
              
                
                  
                    L
                    
                      m
                      ⁢
                      
                        
                      
                      ⁢
                      i
                      ⁢
                      
                        
                      
                      ⁢
                      n
                      ⁢
                      
                        
                      
                      ⁢
                      2
                    
                    
                      (
                      j
                      )
                    
                  
                
                
                  
                    
                      if
                      ⁢
                      
                        
                      
                      ⁢
                      i
                    
                    =
                    
                      i
                      
                        m
                        ⁢
                        
                          
                        
                        ⁢
                        i
                        ⁢
                        
                          
                        
                        ⁢
                        n
                        ⁢
                        
                          
                        
                        ⁢
                        1
                      
                      
                        (
                        j
                        )
                      
                    
                  
                
              
            
          
        
      
    
    
      
        (
        10
        )
      
    
  




A hardware amenable min-sum decoding algorithm is described in Algorithm 1 of Table 1.







TABLE 1





Flooding Min-Sum Decoding


Algorithm 1 Flooding Min-Sum Decoding















Intialization: Lmin1(j) = Lmin2(j) = 0, ∀j ε   


Iteration:








 1:
for ∀i ε V, do


 2:
 for ∀j ε   (i), do


 3:
  Read (old) {S(j), imin1(j), Lmin1(j), Lmin2(j)}


 


 4:
  



  
    Compute
    ⁢
    
      
    
    ⁢
    
      L
      
        j
        →
        i
      
    
  
  ←
  
    {
    
      
        
          
            
              
                S
                
                  (
                  j
                  )
                
              
              ·
              
                S
                
                  i
                  →
                  j
                
              
              ·
              
                L
                
                  min
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
                
                  (
                  j
                  )
                
              
            
            ,
          
        
        
          
            
              if
              ⁢
              
                
              
              ⁢
              i
            
            ≠
            
              i
              
                min
                ⁢
                
                  
                
                ⁢
                1
              
              
                (
                j
                )
              
            
          
        
      
      
        
          
            
              
                S
                
                  (
                  j
                  )
                
              
              ·
              
                S
                
                  i
                  →
                  j
                
              
              ·
              
                L
                
                  min
                  ⁢
                  
                    
                  
                  ⁢
                  2
                
                
                  (
                  j
                  )
                
              
            
            ,
          
        
        
          
            
              if
              ⁢
              
                
              
              ⁢
              i
            
            =
            
              i
              
                min
                ⁢
                
                  
                
                ⁢
                1
              
              
                (
                j
                )
              
            
          
        
      
    
  






 


 5:
 end for


 6:
 Compute Pi ← Lich +   Lj→i


 7:
 for ∀j ε   (i), do


 8:
  Compute Li→j ← Pi − Lj→i


 9:
  Store Si→j ← sign (Li→j)


10:
  Update CN j's new information, {S(j), imin1(j), Lmin1(j), Lmin2(j)},



  with respect to Li→j.


11:
 end for


12:
end for


13:
Store all {S, imin1, Lmin1, Lmin2}


14:
If the hard-decision of [P1, P2, . . . , Pn] yields the all-zero syndrome, 



then terminate









When a QC-LDPC code with b×b circulants is in use, each circulant of b bits are updated independently and in parallel. In [5], a new non-uniform quantization method was proposed to extend the message quantization range by using exponentially increased step size for large magnitudes while keeping fixed step size for small magnitudes. However, the proposed exponentially increased step size design is difficult for hardware implementation.
B. Layered Min-Sum Decoding
In the hardware implementation of iterative MP decoding, the decoding efficiency can be further improved by the layered decoding approach [2]-[4]. The layered decoding is based on a serial update of CN messages. Instead of sending all messages from VN's to CN's, and then all messages from CN's to VN's, the layered coding go over the CN's in sequential order such that, to each updating CN, all messages are sent in and processed, and then sent out to neighboring VN's. Such scheduled serial updates on CN's enables immediate propagation of the newly updated message; unlike the conventional flooding scheme where the updated messages can propagate only in next iteration.
The layered decoding roughly increases convergence speed by twice over the conventional flooding implementation. Moreover, it provides a good trade-off between speed and memory [3], [4]. This is achieved by iterating over dynamic CN-to-VN messages, denoted by Q{q1, Q2, . . . , Qn]. Specifically, let VN iεV(j), then Qi over a layer j is defined as

Qi(j)Lj→i=Lich+Lj′→i(last),  (11)

where the superscript(last) denotes the latest updated. It is worth noting that, in layered decoding the VN-to-CN message updated at the last layer (all but the last are from the current iteration) is utilized to update the CN-to-VN Qi in the current layer, whereas in the conventional flooding decoding updating a CN-to-VN message Lj→i utilizes the VN-to-CN messages each generated at the last iteration. Q  {Q1, Q2, . . . , Qn] memory is initialized with the channel messages Lch [L1ch, L2ch, . . . , Lnch], and no dedicated memory is needed to store Lch, whereas in flooding method, Lch is stored but not Q. Qi, i=1, 2, . . . , n, is iteratively calculated as follows. Let j be the current layer and ji be the preceding layer associated with VN i (herein a preceding layer is mathematically declared as follows. Let j1<j2< . . . <jk be all CN's directly connected of VN i, then jl is the preceding layer of jl+1 for l=1, 2, . . . , k−1, and jk is the preceding layer of j1.).
The APP (a-posterior probability) message Pi at the layer j is calculated as

Pi(j)=Qi(ji)+Lji→inew  (12)

where Lji→inew is newly updated and Qi is iteratively updated by

Qi(j)=Pi(j)−Lj→iold,  (13)

where Lj→iold was updated exactly one iteration back. The layered decoding can be applied to all types of iterative MP (message passing) decoding, including SAP and min-sum decoding. A hardware amenable layered min-sum decoding algorithm is described in Table 2.







TABLE 2





Layered Min-Sum Decoding.


Algorithm 2 Layered Min-Sum Decoding















Initialization: Lmin1(j) = Lmin2(j) = 0, ∀j ε   ; Qi = Lich, ∀i ε V;   = 0


Iteration:








 1:
for ∀j ε   do


 2:
 for ∀i ε V(j) do


 3:
  Read (new) {S(ji), imin1(ji), Lmin1(ji), Lmin2(ji)},



  where ji is the preceding layer of VN i


 


 4:
  



  
    Compute
    ⁢
    
      
    
    ⁢
    
      L
      
        
          j
          i
        
        →
        i
      
      new
    
  
  ←
  
    {
    
      
        
          
            
              
                S
                
                  (
                  
                    j
                    i
                  
                  )
                
              
              ·
              
                S
                
                  i
                  →
                  
                    j
                    i
                  
                
              
              ·
              
                L
                
                  min
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
                
                  (
                  
                    j
                    i
                  
                  )
                
              
            
            ,
          
        
        
          
            
              if
              ⁢
              
                
              
              ⁢
              i
            
            ≠
            
              i
              
                min
                ⁢
                
                  
                
                ⁢
                1
              
              
                (
                
                  j
                  i
                
                )
              
            
          
        
      
      
        
          
            
              
                S
                
                  (
                  
                    j
                    i
                  
                  )
                
              
              ·
              
                S
                
                  i
                  →
                  
                    j
                    i
                  
                
              
              ·
              
                L
                
                  min
                  ⁢
                  
                    
                  
                  ⁢
                  2
                
                
                  (
                  
                    j
                    i
                  
                  )
                
              
            
            ,
          
        
        
          
            
              if
              ⁢
              
                
              
              ⁢
              i
            
            =
            
              i
              
                min
                ⁢
                
                  
                
                ⁢
                1
              
              
                (
                
                  j
                  i
                
                )
              
            
          
        
      
    
  






 


 5:
  Compute Pi ← Qi + Lji→inew


 6:
  Read (old) {S(j), imin1(j), Lmin1(j), Lmin2(j)}.


 


 7:
  



  
    Compute
    ⁢
    
      
    
    ⁢
    
      L
      
        j
        →
        i
      
      old
    
  
  ←
  
    {
    
      
        
          
            
              
                S
                
                  (
                  j
                  )
                
              
              ·
              
                S
                
                  i
                  →
                  j
                
              
              ·
              
                L
                
                  min
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
                
                  (
                  j
                  )
                
              
            
            ,
          
        
        
          
            
              if
              ⁢
              
                
              
              ⁢
              i
            
            ≠
            
              i
              
                min
                ⁢
                
                  
                
                ⁢
                1
              
              
                (
                j
                )
              
            
          
        
      
      
        
          
            
              
                S
                
                  (
                  j
                  )
                
              
              ·
              
                S
                
                  i
                  →
                  j
                
              
              ·
              
                L
                
                  min
                  ⁢
                  
                    
                  
                  ⁢
                  2
                
                
                  (
                  j
                  )
                
              
            
            ,
          
        
        
          
            
              if
              ⁢
              
                
              
              ⁢
              i
            
            =
            
              i
              
                min
                ⁢
                
                  
                
                ⁢
                1
              
              
                (
                j
                )
              
            
          
        
      
    
  






 


 8:
  Compute Qi ← Pi − Lj→iold.


 9:
  Store Si→j = sign(Qi)


10:
  Update CN j's new information, {S(j), imin1(j), Lmin1(j), Lmin2(j)},



  with respect to (Qi).


11:
 end for


12:
 Store {S(j), imin1(j), Lmin1(j), Lmin2(j)}


13:
end for


14:
If the hard-decision of [P1, P2, . . . , Pn] yields the all-zero syndrome, 



then stop.


15:
Circularly increase layer number   by 1.









When a QC-LDPC code with b×b circulants is in use, b QC rows of H is naturally treated as a layer, that is, a layer contains b CN's, each being updated independently and in parallel.
The systems and methods disclosed herein provide an improved approach for performing LDPC decoding using Tanner graphs.



BRIEF DESCRIPTION OF THE DRAWINGS
In order that the advantages of the invention will be readily understood, a more particular description of the invention briefly described above will be rendered by reference to specific embodiments illustrated in the appended drawings. Understanding that these drawings depict only typical embodiments of the invention and are not therefore to be considered limiting of its scope, the invention will be described and explained with additional specificity and detail through use of the accompanying drawings, in which:
FIG. 1 is a schematic block diagram of a computer system suitable for implementing methods in accordance with embodiments of the invention;
FIG. 2 is a schematic block diagram of components for implementing methods in accordance with embodiments of the invention;
FIG. 3 is a process flow diagram of a method in accordance with an embodiment of the present invention; and
FIGS. 4A and 4B illustrate the passing of messages between check nodes (CN) and variable nodes (VN) in accordance with min-sum decoding.



DETAILED DESCRIPTION
It will be readily understood that the components of the present invention, as generally described and illustrated in the Figures herein, could be arranged and designed in a wide variety of different configurations. Thus, the following more detailed description of the embodiments of the invention, as represented in the Figures, is not intended to limit the scope of the invention, as claimed, but is merely representative of certain examples of presently contemplated embodiments in accordance with the invention. The presently described embodiments will be best understood by reference to the drawings, wherein like parts are designated by like numerals throughout.
The invention has been developed in response to the present state of the art and, in particular, in response to the problems and needs in the art that have not yet been fully solved by currently available apparatus and methods. Accordingly, the invention has been developed to provide apparatus and methods performing LDPC decoding. A method is disclosed for performing LDPC decoding, specifically layered min-sum decoding using a Tanner graph including check nodes (CN) and variable nodes (VN). Messages passed between nodes are quantized in a non-uniform manner. Values below a threshold are uniformly quantized whereas values above the threshold are non-uniformly quantized. A corresponding inverse-quantization is also defined.
Any combination of one or more computer-usable or computer-readable media may be utilized, including non-transitory media. For example, a computer-readable medium may include one or more of a portable computer diskette, a hard disk, a random access memory (RAM) device, a read-only memory (ROM) device, an erasable programmable read-only memory (EPROM or Flash memory) device, a portable compact disc read-only memory (CDROM), an optical storage device, and a magnetic storage device. In selected embodiments, a computer-readable medium may comprise any non-transitory medium that can contain, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device.
Computer program code for carrying out operations of the present invention may be written in any combination of one or more programming languages, including an object-oriented programming language such as Java, Smalltalk, C++, or the like and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The program code may execute entirely on a computer system as a stand-alone software package, on a stand-alone hardware unit, partly on a remote computer spaced some distance from the computer, or entirely on a remote computer or server. In the latter scenario, the remote computer may be connected to the computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider).
The present invention is described below with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions or code. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.
These computer program instructions may also be stored in a non-transitory computer-readable medium that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable medium produce an article of manufacture including instruction means which implement the function/act specified in the flowchart and/or block diagram block or blocks.
The computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide processes for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.
FIG. 1 is a block diagram illustrating an example computing device 100. Computing device 100 may be used to perform various procedures, such as those discussed herein. Computing device 100 can function as a server, a client, or any other computing entity. Computing device can perform various functions as discussed herein. Computing device 100 can be any of a wide variety of computing devices, such as a desktop computer, a notebook computer, a server computer, a handheld computer, tablet computer and the like. In some embodiments, a hardware device containing circuits implementing the methods disclosed herein may be included in the computing device 100 or embedded in any of the components of the computing device listed below.
Computing device 100 includes one or more processor(s) 102, one or more memory device(s) 104, one or more interface(s) 106, one or more mass storage device(s) 108, one or more Input/Output (I/O) device(s) 110, and a display device 130 all of which are coupled to a bus 112. Processor(s) 102 include one or more processors or controllers that execute instructions stored in memory device(s) 104 and/or mass storage device(s) 108. Processor(s) 102 may also include various types of computer-readable media, such as cache memory.
Memory device(s) 104 include various computer-readable media, such as volatile memory (e.g., random access memory (RAM) 114) and/or nonvolatile memory (e.g., read-only memory (ROM) 116). Memory device(s) 104 may also include rewritable ROM, such as Flash memory.
Mass storage device(s) 108 include various computer readable media, such as magnetic tapes, magnetic disks, optical disks, solid-state memory (e.g., Flash memory), and so forth. As shown in FIG. 1, a particular mass storage device is a hard disk drive 124. Various drives may also be included in mass storage device(s) 108 to enable reading from and/or writing to the various computer readable media. Mass storage device(s) 108 include removable media 126 and/or non-removable media.
I/O device(s) 110 include various devices that allow data and/or other information to be input to or retrieved from computing device 100. Example I/O device(s) 110 include cursor control devices, keyboards, keypads, microphones, monitors or other display devices, speakers, printers, network interface cards, modems, lenses, CCDs or other image capture devices, and the like.
Display device 130 includes any type of device capable of displaying information to one or more users of computing device 100. Examples of display device 130 include a monitor, display terminal, video projection device, and the like.
Interface(s) 106 include various interfaces that allow computing device 100 to interact with other systems, devices, or computing environments. Example interface(s) 106 include any number of different network interfaces 120, such as interfaces to local area networks (LANs), wide area networks (WANs), wireless networks, and the Internet. Other interface(s) include user interface 118 and peripheral device interface 122. The interface(s) 106 may also include one or more user interface elements 118. The interface(s) 106 may also include one or more peripheral interfaces such as interfaces for printers, pointing devices (mice, track pad, etc.), keyboards, and the like.
Bus 112 allows processor(s) 102, memory device(s) 104, interface(s) 106, mass storage device(s) 108, and I/O device(s) 110 to communicate with one another, as well as other devices or components coupled to bus 112. Bus 112 represents one or more of several types of bus structures, such as a system bus, PCI bus, IEEE 1394 bus, USB bus, and so forth.
For purposes of illustration, programs and other executable program components are shown herein as discrete blocks, although it is understood that such programs and components may reside at various times in different storage components of computing device 100, and are executed by processor(s) 102. Alternatively, the systems and procedures described herein can be implemented in hardware, or a combination of hardware, software, and/or firmware. For example, one or more application specific integrated circuits (ASICs) can be programmed to carry out one or more of the systems and procedures described herein.
Referring to FIG. 2, the illustrated system 200 may be used to perform the methods disclosed herein. The illustrated components may be specific electronic components or software modules executed by a computing device 100. The system 200 may include an input channel 202 from which data is received. The input channel 202 may be any device or interface. The data from the input channel 202 may be received by a decoding module 204 implementing the methods disclosed herein. As noted above, the decoding module 204 may be implemented by software or hard-coded circuits or a digital processor.
The data received from the input channel 202 may be data encoded according to an LDPC encoding algorithm. The decoding module 204 is programmed or configured with circuits implementing the methods disclosed herein in order to perform the decoding. To facilitate decoding, a memory 206 for storing intermediate results and an LLR table 208 may be coupled to the decoding module 204. The decoding module 204 generates an output 210 that is the data extracted from encoded data received from the input channel 202.
Referring to FIG. 3, the system 200, or some other device, such as a general purpose computer, may perform the illustrated method 300. The method 300 may include receiving 302 an input signal and determining 304 one or more log likelihood ratios (LLR) as defined above for one or more symbols in the input signal. The VNs of a Tanner graph as defined above may then be initialized 306 to the LLRs as described above or according to any of the methods described below. The method 300 may further include performing 308 min-sum decoding with adaptive desaturation to obtain a decoded value and outputting 310 the decoded value. Performing 308 min-sum decoding may include performing Algorithm 3 of Table 3 or Algorithm 4 of Table 4.
In intensive simulations conducted by the inventor of (layered) min-sum decoding on various LDPC codes, it was observed that the range of messages passed between VN's and CN's in the decoder has direct impact on the decoding performance in terms of both convergence speed and error-rate. It has been observed that, when fixed-point magnitude is not enforced, correct messages typically grow faster than incorrect messages, most errors due to small trapping sets are correctable. However, given limited precision in practice, after certain number of iterations, messages tend to saturate to the maximum fixed-point magnitude. In such scenarios, correct messages are not able to outweigh incorrect messages, and the message passing is gradually downgraded to bipolar messages.
These observations serve as the motivation for new adaptive quantization methods. One approach to expand the range of represented values by message index is to scale down the messages after certain criterion is met. For example, not limited to, if at the end of an iteration the number of saturated CN's, denoted by ΦC, is greater than a pre-defined threshold, denoted by Φ, then all the messages in the decoder will be scaled down by half at the next iteration. Herein a CN j is declared “saturated” if Lmin1(j) reaches the maximum finite-precision magnitude. This enables to effectively increase the quantization range without increasing complexity or memory.
Algorithm 3 of Table 3 incorporates modifications into the conventional flooding decoding to enable the above exemplary desaturation. Algorithm 4 of Table 4 incorporates modifications into the conventional layered decoding to enable the above exemplary desaturation.
At each end of an iteration, the number of saturated CN's is compared against a pre-defined threshold. If greater than the pre-defined threshold, then the desaturation signal, Ides, is set on for the next iteration. For flooding decoding, desaturation is simply achieved by halving each CN-to-VN message, Lj→i. For layered decoding, desaturation comprises two parts, one is to halve all APP messages at the first time (but not for the revisited) of the current iteration; the other is to halve all old VN-to-CN messages (generated during the preceding iteration). We observe that the two parts together equally halves the revisited Q and P messages during the iteration. Note that having a desaturation check at the end of iteration may introduce extra latency. To eliminate this latency, one may alternatively consider performing the desaturation check using partial CN's, e.g., up to the second to last layer. Based on the extensive simulations, desaturation decision based upon all but the last layer of CN's results in negligible performance degradation. With the above design, we observe that the LDPC error floor can be substantially reduced.







TABLE 3





Desaturated Flooding Min-Sum Decoding


Algorithm 3 Desaturated Flooding Min-Sum Decoding















Initialization: Lmin1(j) = Lmin2(j) = 0, ∀j ε   ; Ides = off


Iteration:








 1:
for ∀i ε V, do


 2:
 for ∀j ε   (i), do


 3:
  Read (old) {S(j), imin1(j), Lmin1(j), Lmin2(j)}


 


 4:
  



  
    Compute
    ⁢
    
      
    
    ⁢
    
      L
      
        j
        →
        i
      
    
  
  ←
  
    {
    
      
        
          
            
              
                S
                
                  (
                  j
                  )
                
              
              ·
              
                S
                
                  i
                  →
                  j
                
              
              ·
              
                L
                
                  min
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
                
                  (
                  j
                  )
                
              
            
            ,
          
        
        
          
            
              if
              ⁢
              
                
              
              ⁢
              i
            
            ≠
            
              i
              
                min
                ⁢
                
                  
                
                ⁢
                1
              
              
                (
                j
                )
              
            
          
        
      
      
        
          
            
              
                S
                
                  (
                  j
                  )
                
              
              ·
              
                S
                
                  i
                  →
                  j
                
              
              ·
              
                L
                
                  min
                  ⁢
                  
                    
                  
                  ⁢
                  2
                
                
                  (
                  j
                  )
                
              
            
            ,
          
        
        
          
            
              if
              ⁢
              
                
              
              ⁢
              i
            
            =
            
              i
              
                min
                ⁢
                
                  
                
                ⁢
                1
              
              
                (
                j
                )
              
            
          
        
      
    
  






 


 5:
  If Ides = on, then set Lj→i ← Lj→i/2.


 6:
 end for


 7:
 Compute Pi ← Lich +   Lj→i


 8:
 for ∀j ε   (i), do


 9:
  Compute Li→j ← Pi − Lj→i


10:
  Store Si→j← sign(Li→j)


11:
  Update CN j's new information, {S(j), imin1(j), Lmin1(j), Lmin2(j)}, 



  with respect to Li→j.


12:
 end for


13:
end for


14:
Store all {S, imin1, Lmin1, Lmin2}.


15:
If the number of saturated Lmin1 is greater than Θ,



then set Idea = on, otherwise off.


16:
If the hard-decision of [P1, P2, . . . , Pn] yields the all-zero syndrome, 



then stop.
















TABLE 4





Desaturated Layered Min-Sum Decoding


Algorithm 4 Layered Min-Sum Decoding















Initialization: Lmin(j) = Lmin2(j) = 0, ∀j ε   ; Qi = Lich, ∀i ε V; 


  = 0, Ides = off


Iteration:








 1:
for ∀j ε    do


 2:
 for ∀i ε V(j) do


 3:
  Read (new) {S(ji), imin1(ji), Lmin1(ji), Lmin2(ji)},



  where ji is the preceding layer of VN i.


 


 4:
  



  
    Compute
    ⁢
    
      
    
    ⁢
    
      L
      
        
          j
          i
        
        →
        i
      
      new
    
  
  ←
  
    {
    
      
        
          
            
              
                S
                
                  (
                  
                    j
                    i
                  
                  )
                
              
              ·
              
                S
                
                  i
                  →
                  j
                
              
              ·
              
                L
                
                  min
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
                
                  (
                  
                    j
                    i
                  
                  )
                
              
            
            ,
          
        
        
          
            
              if
              ⁢
              
                
              
              ⁢
              i
            
            ≠
            
              i
              
                min
                ⁢
                
                  
                
                ⁢
                1
              
              
                (
                
                  j
                  i
                
                )
              
            
          
        
      
      
        
          
            
              
                S
                
                  (
                  
                    j
                    i
                  
                  )
                
              
              ·
              
                S
                
                  i
                  →
                  j
                
              
              ·
              
                L
                
                  min
                  ⁢
                  
                    
                  
                  ⁢
                  2
                
                
                  (
                  
                    j
                    i
                  
                  )
                
              
            
            ,
          
        
        
          
            
              if
              ⁢
              
                
              
              ⁢
              i
            
            =
            
              i
              
                min
                ⁢
                
                  
                
                ⁢
                1
              
              
                (
                
                  j
                  i
                
                )
              
            
          
        
      
    
  






 


 5:
  Compute Pi ← Qi + Lji→inew


 6:
  If Ides = on and VN i is the first time visited,



  then divide Pi by 2.


 7:
  Read (old) {S(j), imin1(j), Lmin1(j), Lmin2(j)}.


 


 8:
  



  
    Compute
    ⁢
    
      
    
    ⁢
    
      L
      
        j
        →
        i
      
      old
    
  
  ←
  
    {
    
      
        
          
            
              
                S
                
                  (
                  j
                  )
                
              
              ·
              
                S
                
                  i
                  →
                  j
                
              
              ·
              
                L
                
                  min
                  ⁢
                  
                    
                  
                  ⁢
                  1
                
                
                  (
                  j
                  )
                
              
            
            ,
          
        
        
          
            
              if
              ⁢
              
                
              
              ⁢
              i
            
            ≠
            
              i
              
                min
                ⁢
                
                  
                
                ⁢
                1
              
              
                (
                j
                )
              
            
          
        
      
      
        
          
            
              
                S
                
                  (
                  j
                  )
                
              
              ·
              
                S
                
                  i
                  →
                  j
                
              
              ·
              
                L
                
                  min
                  ⁢
                  
                    
                  
                  ⁢
                  2
                
                
                  (
                  j
                  )
                
              
            
            ,
          
        
        
          
            
              if
              ⁢
              
                
              
              ⁢
              i
            
            =
            
              i
              
                min
                ⁢
                
                  
                
                ⁢
                1
              
              
                (
                j
                )
              
            
          
        
      
    
  






 


 9:
  If Ides = on, then divide Lj→iold by 2.


10:
  Compute Qi ← Pi − Lj→iold.


11:
  Store Si→j = sign(Qi)


12:
  Update CN j's new information, {S(j), imin1(j), Lmin1(j), Lmin2(j)},



  with respect to Qi.


13:
 end for


14:
 Store {S(j), imin1(j), Lmin1(j), Lmin2(j)}


15:
end for


16:
If the hard-decision of [P1, P2, . . . , Pn] yields the all-zero syndrome,



then stop.


17:
Update θC, the number of saturated Lmin1(j) of the current iteration,


18:
Circularly increase layer number   by 1.


19:
If    = 0 and θC > Θ, then set Ides = on, otherwise off; reset θC = 0.









The above description provides a novel adaptive desaturation method that is incorporated into the quantization operation in VN update of message-passing decoder of LDPC codes. Specifically, when a large portion of CN-to-VN messages are saturated to maximum fixed-precision values, halving all CN-to-VN messages facilitates the saturation of correct messages and improves error correction over small trapping sets. The proposed adaptive desaturation methods have been proved by simulations conducted by the inventor to reduce error floor by orders of magnitudes, with negligible add-on hardware. Though the proposed desaturation scheme is presented in the form of flooding min-sum decoding and layered min-sum decoding, it may be extended to all variants of message-passing decoding of LDPC codes, e.g., shuffled decoding (whose efficiency lies between flooding decoding and layered decoding) [6].
The present invention may be embodied in other specific forms without departing from its spirit or essential characteristics. The described embodiments are to be considered in all respects only as illustrative, and not restrictive. The scope of the invention is, therefore, indicated by the appended claims, rather than by the foregoing description. All changes which come within the meaning and range of equivalency of the claims are to be embraced within their scope

## Claims

1. A method comprising:
receiving, by an electronic device, input data; and
performing, by the electronic device, layered min-sum decoding of the input data using a Tanner graph to generate decoded output data, the layered min-sum decoding including passing messages from variable nodes (VNs) to check nodes (CNs) in VN-to-CN messages and from CNs to VNs in CN-to-VN messages, each VN and CN having a value associated therewith, the values of the VNs being updated in response to CN-to-VN messages and the values of the CNs being updated in response to VN-to-CN messages; and
during performing layered min-sum decoding, in response to detecting that a proportion of the values of the CNs that exceed a maximum value meets a threshold condition, halving all of the VN-to-CN messages and all first a-posterior probability (APP) messages of a current iteration of the layered min-sum decoding.

2. The method of claim 1, wherein performing layered min-sum decoding of the input data to generate decoded output data comprises performing algorithm 3 of Table 3.

3. The method of claim 1, wherein performing layered min-sum decoding of the input data to generate decoded output data comprises performing algorithm 4 of Table 4.

4. The method of claim 1, wherein performing layered min-sum decoding of the input data to generate decoded output data comprises iteratively performing a plurality of iterations, each iteration including passing of VN-to-CN messages followed by CN-to-VN messages, wherein halving at least one of all of the CN-to-VN messages and all of the VN-to-CN messages is performed between consecutive iterations of the plurality of iterations.

5. The method of claim 1, wherein performing layered min-sum decoding comprises
halving all of the CN-to-VN messages and all of the VN-to-CN messages.

6. The method of claim 1, wherein the electronic device is a dedicated hardware device.

7. The method of claim 1, wherein the Tanner graph implements a quasi-cyclic low density parity code matrix.

8. The method of claim 1, wherein the maximum value is a maximum fixed point value representable by the CNs.

9. An electronic device including circuits configured to:
receive input data; and
perform layered min-sum decoding of the input data using a Tanner graph to generate decoded output data, the min-sum layered decoding including passing messages from variable nodes (VNs) to check nodes (CNs) in VN-to-CN messages and from CNs to VNs in CN-to-VN messages, each VN and CN having a value associated therewith, the values of the VNs being updated in response to CN-to-VN messages and the values of the CNs being updated in response to VN-to-CN messages; and
during performing layered min-sum decoding, if a number of the values of the CNs that exceed a maximum value meets a threshold condition, halving all of the VN-to-CN messages.

10. The electronic device of claim 9, further comprising circuits configured to perform layered min-sum decoding of the input data to generate decoded output data according to algorithm 3 of Table 3.

11. The electronic device of claim 9, further comprising circuits configured to perform layered min-sum decoding of the input data to generate decoded output data according to algorithm 4 of Table 4.

12. The electronic device of claim 9, further comprising circuits configured to perform layered min-sum decoding by iteratively performing a plurality of iterations, each iteration including passing of VN-to-CN messages followed by CN-to-VN messages, wherein halving at least one of all of the CN-to-VN messages and all of the VN-to-CN messages is performed between consecutive iterations of the plurality of iterations if the number of the values of the CNs that exceed the maximum value meets the threshold condition.

13. The electronic device of claim 9, further comprising circuits configured to perform layered min-sum decoding, wherein halving at least one of all of the CN-to-VN messages and all of the VN-to-CN messages comprises halving all of the CN-to-VN messages and all of the VN-to-CN messages.

14. The electronic device of claim 9, further comprising circuits configured to, if the number of the values of the CNs that exceed the maximum value meets the threshold condition, halving all first a-posterior probability (APP) messages of a current iteration of the layered min-sum decoding.

15. The electronic device of claim 9, wherein the electronic device comprises a dedicated hardware device including specialized circuits implementing the layered min-sum decoding of the input data.

16. The electronic device of claim 9, wherein the Tanner graph implements a quasi-cyclic low density parity code matrix.

17. The electronic device of claim 9, further comprising one or more storage registers;
wherein the maximum value is a maximum fixed-point value representable by the one or more registers.