# Patent

## Title
Trellis state based stopping criterion for turbo-decoding

## Abstract

A stopping criterion for a turbo-coding method. The criterion is based on states of a trellis determined by forward-backward recursion. If, for at least one elementary decoding stage, a transition ending state of a previous symbol is found identical to a transition starting state of a current symbol, for every symbol of the block but a first one and a last one, the decoding path is considered as consistent, a hard decision on the extrinsic information is made, and the turbo-decoding stops.

## Background
TECHNICAL FIELD
The present application relates to the field of turbo codes and more particular to turbo-decoding.
PRIOR ART
The turbo-codes were introduced by C. Berrou et al. in the seminal article entitled “Near Shannon limit error-correcting coding and decoding: Turbo Codes”, Proceedings of ICC '93 pp. 1064-1070, have encountered since then widespread success. The remarkable performances of the turbo-codes in terms of bit error rate or BER (Bit Error Rate), close to those of random coding, are explained by the presence of one or more interleaver(s) between different elementary coders. They are used as error correcting codes in many digital communication standards.
In its most common form, a turbo-encoder can be regarded as a parallel or a serial concatenation of systematic elementary encoders separated by interleavers.
At the receiving side, turbo-decoding is achieved by an iterative process involving as many elementary decoders as the turbo-encoder has elementary encoders, each iteration improving the reliability of the decoded codeword.
FIG. 1 illustrates an example of the structure of a turbocoder comprising two parallel concatenated elementary recursive systematic convolutional (RSC) encoders.
In this example, a block of information bits, I, are coded by two elementary encoders of the systematic convolutional type, arranged in parallel. Each elementary encoder is constituted by a (shared) systematic path, leaving by definition the information bits unchanged, and by a convolutional encoder. The first convolutional encoder 110 outputs parity bits P1 as a function of the information bits I. The block of parity bits is hereafter referred to as the first redundancy part. Similarly, the second convolutional encoder 120 outputs second parity bits P2 as a function of the information bits I previously interleaved by the interleaver 130. The block of parity bits P2 is referred to as the second redundancy part.
The multiplexer 150 multiplexes the information bits I (systematic part) with the parity bits P1 (first redundancy part) and P2 (second redundancy part) before transmission over the communication channel 160. More specifically, the multiplexed bits are converted into M-ary symbols (where M is the cardinal of the modulation alphabet) prior to carrier modulation.
FIG. 2 illustrates an example of turbo-decoder for decoding a block encoded by the turbo-encoder of FIG. 1.
The turbo-decoder comprises a first elementary decoder 210 corresponding to encoder 110, a second elementary decoder 220 corresponding to encoder 120. The decoders are of the SISO type (Soft In Soft Out) and may carry out the MAP (Maximum A posteriori Probability) decoding algorithm or one of its derivatives e.g. the Log-MAP or Max-Log-MAP decoding algorithm as known in the art.
The turbo-decoder receives from the symbol demodulator a noisy version of the information bits, the first parity bits and the second parity bits, respectively denoted Ĩ, {tilde over (P)}1 and {tilde over (P)}2. The systematic bits Ĩ and first parity bits {tilde over (P)}1 are supplied to the first elementary decoder 110. The first elementary decoder also inputs a priori information (also called extrinsic information) from the second elementary decoder.
Similarly, the second elementary decoder 220 inputs the received information bits Ĩ, after having being interleaved in interleaver 230, along with the received parity bits {tilde over (P)}2. The second elementary decoder additionally inputs extrinsic information from the first elementary decoder after it has been interleaved in interleaver 230′. The interleavers 230 and 230′ exhibit the same interleaving pattern Π as interleaver 130. The extrinsic information provided by the second decoder is de-interleaved in de-interleaver 240 before being supplied to the first elementary decoder. The de-interleaver has the inverse interleaving pattern Π−1 of interleaver 130.
The encoded block is subjected to iterative decoding, each decoding iteration comprising a first half-iteration in decoder 210 and a subsequent second half-iteration in decoder 220. The update and exchange of extrinsic information, i.e. of the extrinsic values relative to the different information bits, between the first and second elementary decoder, at each iteration, increases the reliability of the decoded block. It should be noted that the extrinsic information of the first decoder is initialized at values indicative of a lack of prior knowledge of bit reliability (0 if LLR values are used).
The extrinsic information is classically expressed in terms of soft values, e.g. LLRs (Log Likelihood Ratios) indicating the reliability of the decoding of each binary symbol. After completion of a given number of iterations or, more generally, when a predetermined stopping criterion is met, the decoding process is stopped and a hard decision is taken in 250 on the soft values to provide hard bit values. The hard decision is taken by performing a simple comparison with a given threshold (0 in case of LLR values).
The power consumption and the latency linearly depend upon the number of iterations of the decoder. It is therefore important to design an efficient stopping criterion, which does not lead to unnecessary iterations while simultaneously achieving a reasonable level of reliability of the decoded values.
Several stopping criteria have been proposed in the literature, based on soft and/or hard values.
US2007/0300139 discloses a stopping criterion based on the comparison of the LLR values output by an elementary decoder for two consecutive iterations. The implementation of such a stopping criterion requires however large storage capacity since a soft value (e.g. coded with a byte) has to be stored for each binary symbol of the block.
EP-A-1455457 further proposes to compare the minimum absolute value of the LLR values of an block with a given threshold. Once this minimum absolute value exceeds the threshold, the iterative decoding process is stopped. In other words, the decoding process stops when the reliability level of the less reliable bit is high enough.
In practice, this stopping criterion is quite sensitive to the threshold value. A too high threshold may result in a frequent rejection of correctly decoded blocks.
An alternative stopping criterion is based on the cross entropy of the LLR related to two consecutive iterations. This criterion is efficient but requires extra computation and considerable memory capacity.
Further stopping criteria are based on monitoring the sign changes in the extrinsic information related to two consecutive iterations. Indeed if a sign of a soft value oscillates from on iteration to the text, this indicates that the corresponding bit is not yet reliable. This stopping criterion requires considerable memory capacity, as the signs of the LLR values for at least two blocks of extrinsic information need to be stored.
The aim of the present invention is therefore to propose a new stopping criterion for a turbodecoding process, which is robust without needing computational overhead or large memory capacity.
DISCLOSURE OF THE INVENTION
The present invention is defined in the appended independent claims. Various advantageous embodiments are given in the dependent claims.



BRIEF DESCRIPTION OF THE DRAWINGS
The present invention will be better understood from the description of the following embodiments, by way of illustration and in no way limitative thereto:
FIG. 1 schematically illustrates an example of turbo-encoder known from the prior art;
FIG. 2 schematically illustrates an example of turbo-decoder known from the prior art;
FIG. 3 schematically represents a coding path in a trellis of an elementary encoder;
FIG. 4 schematically illustrates a trellis diagram used for in an elementary decoder of a turbo-decoder;
FIG. 5A represents a path in the trellis, going through transition starting states, for consecutive turbo-decoding iterations;
FIG. 5B represents a path in the trellis, going through transition ending states, for consecutive turbo-decoding iterations;
FIG. 6 schematically represents a flowchart of a turbo-decoding method using a stopping criterion according to an embodiment of the invention.



DETAILED DISCLOSURE OF PARTICULAR EMBODIMENTS
We will consider again in the following a turbo-decoder for decoding blocks of binary symbols which have been encoded by a turbo-encoder. The term block can be construed here as a frame or a codeword. The binary symbols processed by the turbo-decoder are expressed in terms of soft values (soft information), typically in terms of LLRs as known in the art.
The turbo-encoder may be constituted by a plurality P of parallel or serially concatenated elementary coders or a combination of such serial and parallel concatenated elementary coders (hybrid turbocoder). Without loss of generality we will assume that the elementary coders are RSC (Recursive Systematic Convolutional) encoders. It will nevertheless be understood by the man skilled in the art that other types of encoders can be used while remaining in the scope of present invention.
The turbo-decoder is constituted by the same plurality P of elementary decoders and performs an iterative decoding process as set out above. It is recalled that each elementary decoder corresponds to an elementary encoder of the turbo-encoder and processes the same kind of information as the one output by the corresponding elementary encoder. More specifically, each elementary decoder inputs the systematic part of the received block (e.g. after propagation over the communication channel), possibly interleaved, and a redundancy part corresponding to the one generated by said elementary encoder. In addition, the elementary decoder receives extrinsic information from at least another elementary decoder. Each elementary decoder generates its own extrinsic information from the input systematic part, redundancy part and extrinsic information. The extrinsic information thus generated is supplied in turn to at least another elementary decoder.
Before describing the operation of an elementary decoder, we first consider the corresponding elementary encoder in the turbo-encoder. This elementary encoder, as any convolutional encoder, can be regarded as a finite state machine, the transitions of which are determined by the generator polynomial. If the memory of the encoder is of size v (v shift register stages), the finite state machine may take 2v states, each state being defined by the contents of the memory. It should be noted that the various elementary encoders of the turbo-encoder may have different memory sizes (i.e. shift registers having different lengths) and hence different numbers of states.
The coding operation may be regarded as a path in a trellis diagram as represented in FIG. 4.
Conventionally, the possible states of the encoder have been represented vertically by circles whereas the horizontal direction is the time axis. Each column of states corresponds to a clock cycle. At each input bit, on progresses rightwards in the trellis, and the encoder goes from a state a time k to a subsequent state at time k+1. The transition between the state at time k and the state at time k+1 is therefore represented by an edge in the trellis (and by an arc in the state diagram). The coding of a block of bits results therefore in a path within the trellis. At each time k, the encoder outputs a parity bit (in addition to the systematic bit) which depends upon the state of the encoder and the input bit.
The corresponding elementary decoder implements a forward-backward algorithm as know in the art. By forward-backward algorithm we mean here the MAP decoding algorithm or one of its derivatives such as the Log-MAP or the Max-Log-MAP algorithm. A description of the MAP algorithm can be found in the original paper of Bahl et al. entitled “Optimal decoding of linear codes for minimizing symbol error rate” published in IEEE Trans. on Information Theory, pp. 284-287, March 1974. A description of the Max-Log-MAP algorithm can be found e.g. in the article of C. Hye-Mi et al. entitled “Low power hybrid turbo decoding based in reverse calculation, ISCAS 2006.
The forward-backward algorithm is based on the same trellis as the coding trellis described above. More specifically, the forward-backward algorithm mainly comprises three steps: a forward recursion, a backward recursion and an extrinsic information (e.g. values) LLR calculation.
In the forward recursion, the algorithm recursively calculates the forward state probability of being in each state of the trellis at each time k given the knowledge of all the previous received symbols. The forward state probability, also called forward state metrics, is recursively obtained by:




  
    
      
        
          
            
              α
              k
            
            ⁡
            
              (
              s
              )
            
          
          =
          
            
              
                ∑
                
                  s
                  ′
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    α
                    
                      k
                      -
                      1
                    
                  
                  ⁡
                  
                    (
                    
                      s
                      ′
                    
                    )
                  
                
                ⁢
                
                  
                    γ
                    k
                  
                  ⁡
                  
                    (
                    
                      
                        s
                        ′
                      
                      ,
                      s
                    
                    )
                  
                
                ⁢
                
                  
                
                ⁢
                k
              
            
            =
            1
          
        
        ,
        
          
            ...
            ⁢
            
              
            
            ⁢
            N
          
          -
          1
        
      
    
    
      
        (
        1
        )
      
    
  




where s is the current state and s′ is the preceding state, αk-1(s′) is the forward state probability of being at state s′ at time k−1, and γk(s′,s) is the branch probability of the transition between state s′ and state s, given the received symbol, N is the size of the block. The state s′ at the beginning of the transition s′→s will be referred to as the transition starting state whereas the state will be referred to as the transition ending state. The branch probability is also called the branch metrics.

The forward recursion is initialized by forcing the starting state to state 0 and setting:

α0(0)=1 and α0(s)=0 for s≠0  (2)

Similarly, in the backward recursion, the algorithm recursively calculates the backward state probability of being in each state of the trellis at each time k given the knowledge of all the following symbols. The backward state probability, also called backward state metrics, is recursively obtained by:




  
    
      
        
          
            
              β
              
                k
                -
                1
              
            
            ⁡
            
              (
              
                s
                ′
              
              )
            
          
          =
          
            
              
                ∑
                s
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    β
                    k
                  
                  ⁡
                  
                    (
                    s
                    )
                  
                
                ⁢
                
                  
                    γ
                    k
                  
                  ⁡
                  
                    (
                    
                      
                        s
                        ′
                      
                      ,
                      s
                    
                    )
                  
                
                ⁢
                
                  
                
                ⁢
                k
              
            
            =
            N
          
        
        ,
        ...
        ⁢
        
          
        
        ,
        2
      
    
    
      
        (
        3
        )
      
    
  




The backward recursion is initialized by forcing the ending state to state 0 and setting:

βN(0)=1 and βN(s)=0 for s≠0  (4)

The output LLR for each bit uk at time k is given by:




  
    
      
        
          L
          ⁡
          
            (
            
              u
              k
            
            )
          
        
        =
        
          
            ln
            ⁢
            
              
                P
                ⁡
                
                  (
                  
                    
                      u
                      k
                    
                    =
                    
                      
                        +
                        1
                      
                      ❘
                      
                        y
                        k
                      
                    
                  
                  )
                
              
              
                P
                ⁡
                
                  (
                  
                    
                      u
                      k
                    
                    =
                    
                      
                        -
                        1
                      
                      ❘
                      
                        y
                        k
                      
                    
                  
                  )
                
              
            
          
          =
          
            ln
            ⁢
            
              
                
                  ∑
                  
                    
                      
                        u
                        k
                      
                      =
                      
                        +
                        1
                      
                    
                    
                      (
                      
                        
                          s
                          ′
                        
                        ,
                        s
                      
                      )
                    
                  
                
                ⁢
                
                  
                
                ⁢
                
                  
                    
                      α
                      
                        k
                        -
                        1
                      
                    
                    ⁡
                    
                      (
                      
                        s
                        ′
                      
                      )
                    
                  
                  ⁢
                  
                    
                      γ
                      k
                    
                    ⁡
                    
                      (
                      
                        
                          s
                          ′
                        
                        ,
                        s
                      
                      )
                    
                  
                  ⁢
                  
                    
                      β
                      k
                    
                    ⁡
                    
                      (
                      s
                      )
                    
                  
                
              
              
                
                  ∑
                  
                    
                      
                        u
                        k
                      
                      =
                      
                        -
                        1
                      
                    
                    
                      (
                      
                        
                          s
                          ′
                        
                        ,
                        s
                      
                      )
                    
                  
                
                ⁢
                
                  
                
                ⁢
                
                  
                    
                      α
                      
                        k
                        -
                        1
                      
                    
                    ⁡
                    
                      (
                      
                        s
                        ′
                      
                      )
                    
                  
                  ⁢
                  
                    
                      γ
                      k
                    
                    ⁡
                    
                      (
                      
                        
                          s
                          ′
                        
                        ,
                        s
                      
                      )
                    
                  
                  ⁢
                  
                    
                      β
                      k
                    
                    ⁡
                    
                      (
                      s
                      )
                    
                  
                
              
            
          
        
      
    
    
      
        (
        5
        )
      
    
  




where yk is the modulation symbol received on the communication channel at time k and where the bit values have been noted ±1. The upper summation in (5) is carried out over all branches with input label +1 and the lower summation is carried out over all branches with input label −1.

For an AWGN (Additive White Gaussian Noise) channel, the branch metrics γk(s,s′) can be obtained as:




  
    
      
        
          
            γ
            k
          
          ⁡
          
            (
            
              
                s
                ′
              
              ,
              s
            
            )
          
        
        =
        
          exp
          (
          
            -
            
              
                
                  
                  
                    
                      y
                      k
                    
                    -
                    
                      x
                      k
                    
                  
                  
                
                2
              
              
                2
                ⁢
                
                  σ
                  2
                
              
            
          
          )
        
      
    
    
      
        (
        6
        )
      
    
  




where σ2 is the noise variance and xk is the expected symbol for the transition s′ to s.

The expressions (1)-(6) refer to the MAP algorithm. They can be simplified by using logarithmic values (Log-MAP algorithm) and even further simplified by retaining only the most significant values under the summation signs (Max-Log-MAP algorithm). In the latter case, denoting {hacek over (ρ)} for ln ρ:




  
    
      
        
          
        
        ⁢
        
          
            
              
                α
                ⋓
              
              k
            
            ⁡
            
              (
              s
              )
            
          
          =
          
            
              max
              
                s
                ′
              
            
            ⁢
            
              [
              
                
                  
                    
                      α
                      ⋓
                    
                    
                      k
                      -
                      1
                    
                  
                  ⁡
                  
                    (
                    
                      s
                      ′
                    
                    )
                  
                
                +
                
                  
                    
                      γ
                      ⋓
                    
                    k
                  
                  ⁡
                  
                    (
                    
                      
                        s
                        ′
                      
                      ,
                      s
                    
                    )
                  
                
              
              ]
            
          
        
      
    
    
      
        (
        
          1
          ′
        
        )
      
    
  
  
    
      
        
          
        
        ⁢
        
          
            
              
                α
                ⋓
              
              0
            
            ⁡
            
              (
              0
              )
            
          
          =
          
            
              0
              ⁢
              
                
              
              ⁢
              and
              ⁢
              
                
              
              ⁢
              
                
                  
                    α
                    ⋓
                  
                  0
                
                ⁡
                
                  (
                  s
                  )
                
              
            
            =
            
              
                
                  -
                  ∞
                
                ⁢
                
                  
                
                ⁢
                for
                ⁢
                
                  
                
                ⁢
                s
              
              ≠
              0
            
          
        
      
    
    
      
        (
        
          2
          ′
        
        )
      
    
  
  
    
      
        
          
        
        ⁢
        
          
            
              
                β
                ⋓
              
              
                k
                -
                1
              
            
            ⁡
            
              (
              
                s
                ′
              
              )
            
          
          =
          
            
              max
              
                s
                ′
              
            
            ⁢
            
              [
              
                
                  
                    
                      β
                      ⋓
                    
                    k
                  
                  ⁡
                  
                    (
                    s
                    )
                  
                
                +
                
                  
                    
                      γ
                      ⋓
                    
                    k
                  
                  ⁡
                  
                    (
                    
                      
                        s
                        ′
                      
                      ,
                      s
                    
                    )
                  
                
              
              ]
            
          
        
      
    
    
      
        (
        
          3
          ′
        
        )
      
    
  
  
    
      
        
          
        
        ⁢
        
          
            
              
                β
                ⋓
              
              N
            
            ⁡
            
              (
              0
              )
            
          
          =
          
            
              0
              ⁢
              
                
              
              ⁢
              and
              ⁢
              
                
              
              ⁢
              
                
                  
                    β
                    ⋓
                  
                  N
                
                ⁡
                
                  (
                  s
                  )
                
              
            
            =
            
              
                
                  -
                  ∞
                
                ⁢
                
                  
                
                ⁢
                for
                ⁢
                
                  
                
                ⁢
                s
              
              ≠
              0
            
          
        
      
    
    
      
        (
        
          4
          ′
        
        )
      
    
  
  
    
      
        
          L
          ⁡
          
            (
            
              u
              k
            
            )
          
        
        =
        
          
            
              max
              
                
                  
                    u
                    k
                  
                  =
                  
                    +
                    1
                  
                
                
                  (
                  
                    
                      s
                      ′
                    
                    ,
                    s
                  
                  )
                
              
            
            ⁢
            
              
            
            ⁢
            
              [
              
                
                  
                    
                      α
                      ⋓
                    
                    
                      k
                      -
                      1
                    
                  
                  ⁡
                  
                    (
                    
                      s
                      ′
                    
                    )
                  
                
                +
                
                  
                    
                      γ
                      ⋓
                    
                    k
                  
                  ⁡
                  
                    (
                    
                      
                        s
                        ′
                      
                      ,
                      s
                    
                    )
                  
                
                +
                
                  
                    
                      β
                      ⋓
                    
                    k
                  
                  ⁡
                  
                    (
                    s
                    )
                  
                
              
              ]
            
          
          -
          
            
              max
              
                
                  
                    u
                    k
                  
                  =
                  
                    -
                    1
                  
                
                
                  (
                  
                    
                      s
                      ′
                    
                    ,
                    s
                  
                  )
                
              
            
            ⁢
            
              
            
            ⁢
            
              [
              
                
                  
                    
                      α
                      ⋓
                    
                    
                      k
                      -
                      1
                    
                  
                  ⁡
                  
                    (
                    
                      s
                      ′
                    
                    )
                  
                
                +
                
                  
                    
                      γ
                      ⋓
                    
                    k
                  
                  ⁡
                  
                    (
                    
                      
                        s
                        ′
                      
                      ,
                      s
                    
                    )
                  
                
                +
                
                  
                    
                      β
                      ⋓
                    
                    k
                  
                  ⁡
                  
                    (
                    s
                    )
                  
                
              
              ]
            
          
        
      
    
    
      
        (
        
          5
          ′
        
        )
      
    
  
  
    
      
        
          
        
        ⁢
        
          
            
              
                γ
                ⋓
              
              k
            
            ⁡
            
              (
              
                
                  s
                  ′
                
                ,
                s
              
              )
            
          
          =
          
            
              -
              
                
                  1
                  
                    2
                    ⁢
                    
                      σ
                      2
                    
                  
                
                ⁡
                
                  [
                  
                    
                      
                        
                        
                          y
                          k
                        
                        
                      
                      2
                    
                    +
                    
                      
                        
                        
                          x
                          k
                        
                        
                      
                      2
                    
                  
                  ]
                
              
            
            +
            
              
                1
                
                  σ
                  2
                
              
              ⁢
              
                (
                
                  
                    y
                    k
                  
                  ·
                  
                    x
                    k
                  
                
                )
              
            
          
        
      
    
    
      
        (
        
          6
          ′
        
        )
      
    
  




As the first term between brackets is common to all branch metrics, it can be dropped for the purpose of calculating (1′), (3′) and (5′), in other words:




  
    
      
        
          
            
              γ
              ⋓
            
            k
          
          ⁡
          
            (
            
              
                s
                ′
              
              ,
              s
            
            )
          
        
        =
        
          
            1
            
              σ
              2
            
          
          ⁢
          
            (
            
              
                y
                k
              
              ,
              
                x
                k
              
            
            )
          
        
      
    
    
      
        (
        
          6
          ′′
        
        )
      
    
  




In expressions (6) or (6′′), the only changing parameter is xk. xk is a P+1 dimension vector (assuming one parity bit per elementary encoder), the elements of which are the systematic bit, denoted xks and the parity bits denoted xkrp, p=1, . . . , P. The soft value of the systematic bit in (6) or (6′′) is replaced by:

xks=yks+Le(uk)  (7)

where Le(uk) is the extrinsic information provided from another elementary decoder. Therefore, the γk(s′,s) values can be calculated at each turbo-decoding iteration.

For the sake of simplification, we will now restrict the description to the Max-Log-MAP algorithm. The forward metrics for time κ−1 and the backward metrics for time κ can be calculated for each state:




  
    
      
        
          
            
              α
              ⋓
            
            
              κ
              -
              1
            
          
          ⁡
          
            (
            s
            )
          
        
        =
        
          
            max
            
              s
              ′
            
          
          ⁢
          
            (
            
              
                ∑
                
                  k
                  =
                  0
                
                
                  κ
                  -
                  1
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    γ
                    ⋓
                  
                  k
                
                ⁡
                
                  (
                  
                    
                      s
                      ′
                    
                    ,
                    s
                  
                  )
                
              
            
            )
          
        
      
    
    
      
        (
        8
        )
      
    
  
  
    
      
        
          
            
              β
              ⋓
            
            κ
          
          ⁡
          
            (
            s
            )
          
        
        =
        
          
            max
            
              s
              ′
            
          
          ⁢
          
            (
            
              
                ∑
                
                  k
                  =
                  
                    κ
                    +
                    1
                  
                
                N
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    γ
                    ⋓
                  
                  k
                
                ⁡
                
                  (
                  
                    
                      s
                      ′
                    
                    ,
                    s
                  
                  )
                
              
            
            )
          
        
      
    
    
      
        (
        9
        )
      
    
  




Referring to expression (5′), there is a single couple (s′,s) of transition starting and ending states which maximizes {hacek over (α)}κ-1(s′)+{hacek over (γ)}κ(s′,s)+{hacek over (β)}κ(s)|uκ=1+. This couple of states is denoted (S′κ+1(i),Sκ+1(i)). It depends upon the values of {hacek over (γ)}k(s′,s), k=0, . . . , N which in turn depends upon the iteration i of turbo-decoding as these values are function of extrinsic information.
Similarly, there is a single couple of states (s,s′) which maximizes {hacek over (α)}κ-1(s′)+{hacek over (γ)}κ(s′,s)+{hacek over (β)}κ(s)|uκ=−1 in expression (5′). This couple of states is denoted (S′κ−1(i),Sκ−1(i)) for the same reasons as those stated above.
FIG. 5A illustrates a first path in the trellis, going through transition starting states S′κ+1(i), κ=1, . . . , N−1, for consecutive turbo-decoding iterations i. More specifically, for each turbo-decoding iteration i, a path π′+1(i) going through the states S′κ+1(i), κ=1, . . . , N of the trellis is determined for the elementary decoder considered.
Similarly, FIG. 5B illustrates a second path in the trellis, going through transition ending states Sκ+1(i), κ=N, . . . , 2, for consecutive turbo-decoding iterations i. More specifically, for each turbo-decoding iteration i, a path π+1(i) going through the states Sκ+1(i), κ=N, . . . , 2 of the trellis is determined for the elementary decoder considered.
The paths π′+1(i) and π+1(i) are illustrated for 10 consecutive iterations of an 8 states elementary decoder and an AWGN channel with SNR=0.9 dB. As it can be noticed after 4 iterations, the two paths coincide but for a one symbol shift, that is:

S′κ+1(i)=Sκ-1+1(i) for κ=2, . . . , N−1  (10)

Condition (10) means that the transition starting state of the current symbol is the same as the transition ending state of the previous symbol. It expresses therefore the continuity relation along a coding path.
Alternatively, we may consider a third path π′−1(i) in the trellis, going through transition starting states S′κ−1(i), κ=1, . . . , N−1, and a fourth path π−1(i), going through transition ending states S′κ−1(i), κ=1, . . . , N−1. Again, after several iterations the two paths coincide but for a one symbol shift, that is:

S′κ−1=Sκ-1−1 for κ=2, . . . , N−1  (11)

It can be shown that, if the turbo-decoding converges, the coincidence conditions (10) and (11) are met after the same number of iterations.
According to the invention, condition (10) or (11) is used as stopping criterion for the turbo-decoding iterations. The decisive advantage of such a criterion is that there is no need to compare values related to consecutive iterations (which would require a large memory capacity for the whole block) but values within a given iteration. The comparison can therefore be done on the fly with very little overhead.
FIG. 6 schematically represents a flow chart of a turbo-decoding method using a stopping criterion according to an embodiment of the invention.
As already stated in the outset, the turbo-decoding method consists in a plurality of iterations, each iteration being subdivided into P decoding operations, 6101, . . . , 610P sequentially performed by thee P elementary decoders.
The stopping criterion is implemented here in the pth decoder. More generally, it is implemented in at least one elementary decoder.
The pth decoder receives the systematic soft bits yks and the soft parity bits ykrp from the demodulator. It also inputs the extrinsic values Lep−1(uk) from the preceding decoder.
We consider here the ith turbo-decoding iteration. The decoding stage 610p starts with a forward-backward recursion in 611. The forward-backward algorithm can be MAP, Log-MAP or Max-Log-MAP.
The transition starting state S′κ+1(i) of the current symbol and the transition ending state Sκ-1+1(i) of the previous symbol are compared in 612 for κ=2, . . . , N−1, i.e. for every symbol of the trellis (or equivalently for every clock cycle) except the first one and the last one.
According to a variant, the transition starting state S′κ−1(i) of the current symbol and the transition ending state S′κ-1−1(i) of the previous symbol are compared for every symbol of the trellis except the first one and the last one.
In 613, it is checked whether the number of coincidences (successful comparisons) is equal to N−2. In the negative, the turbo-decoding goes on with the next decoding stage 610p+1. In the affirmative however, the turbo-decoding exits in 614 and a hard decision is taken on the extrinsic values Lep(uk), k=1, . . . , N. The turbo-decoding method finally stops at 615.
The trellis-state based stopping criterion described above merely requires storing the transition ending state of the current symbol (if one progresses rightwards in the trellis, according to a first variant) or the transition starting state of the current symbol (if one progresses leftwards in the trellis, according to a second variant). The stored transition state is retrieved and compared with the transition starting state of the next symbol (in the first variant) or with transition ending state of the previous symbol (in the second variant). Hence, in both variants, only v bits need to be stored, in contrast with the stopping criteria of the prior art according to which N extrinsic values of the systematic bits had to be stored.

## Claims

1. A turbo-decoding method for turbo-decoding a block of symbols having been coded by a turbo-encoder, the turbo-decoding comprising:
a plurality of iterations, each iteration comprising a plurality of decoding stages, each decoding stage being carried out by an elementary decoder corresponding to an elementary encoder of the turbo-encoder, each decoding stage performing a forward-backward recursion on a trellis of a corresponding encoder, the trellis representing different states of the encoder and transitions between the different states, each transition being defined by a starting state and by an ending state, each transition corresponding to a bit value input by the encoder and causing the encoder to output at least a parity bit used for generating a symbol of the block, a transition between a starting state and an ending state thereby associated with a symbol of the block;
wherein at least one of the decoding stages comprises:
a comparison in which a transition starting state of a current symbol of a forward recursion on the trellis is compared with a transition ending state of a previous symbol of a backward recursion on the trellis of a same iteration, the comparison being made for every symbol of the block except a first one and a last one;
if the comparison fails, the turbo-decoding iteration proceeds with a next decoding stage; and
if the comparison is successful, the turbo-decoding iterations are stopped.

2. A turbo-decoding method according to claim 1, wherein the transition starting state of the current symbol is compared with the transition ending state of the previous symbol for a transition corresponding to a bit value equal to one.

3. A turbo-decoding method according to claim 1, wherein the transition starting state of the current symbol is compared with the transition ending state of the previous symbol for a transition corresponding to a bit value equal to zero.

4. A turbo-decoding method according to claim 1, wherein the comparison stores the transition ending state of a symbol and retrieves it for comparing it with the transition starting state of a next symbol.

5. A turbo-decoding method according to claim 1, wherein the comparison stores the transition starting state of a symbol and retrieves it for comparing it with the transition state of the previous symbol.

6. A turbo-decoding method according to claim 1, wherein each decoding stage supplies extrinsic values of systematic bits to the next decoding stage and the last decoding stage supplies extrinsic values of the systematic bits to the first decoding stage.

7. A turbo-decoding method according to claim 6, wherein if the comparison is successful, a hard decision is taken on the extrinsic values supplied by the at least one decoding stage to provide hard decided systematic bits.

8. A turbo-decoding method according to claim 1, wherein the forward-backward recursion is performed according to a MAP decoding algorithm.

9. A turbo-decoding method according to claim 1, wherein the forward-backward recursion is performed according to a Log-MAP decoding algorithm.

10. A turbo-decoding method according to claim 1, wherein the forward-backward recursion is performed according to a Max-Log-MAP decoding algorithm.

11. A turbo-decoder for turbo-decoding a block of symbols having been coded by a turbo-encoder, comprising:
circuitry configured to perform
a plurality of iterations, each iteration comprising a plurality of decoding stages, each decoding stage being carried out by an elementary decoder corresponding to an elementary encoder of the turbo-encoder, each decoding stage performing a forward-backward recursion on a trellis of a corresponding encoder, the trellis representing different states of the encoder and transitions between the different states, each transition being defined by a starting state and by an ending state, each transition corresponding to a bit value input by the encoder and causing the encoder to output at least a parity bit used for generating a symbol of the block, a transition between a starting state and an ending state thereby associated with a symbol of the block;

wherein at least one of the decoding stages comprises:
a comparison in which a transition starting state of a current symbol of a forward recursion on the trellis is compared with a transition ending state of a previous symbol of a backward recursion on the trellis of a same iteration, the comparison being made for every symbol of the block except a first one and a last one;

if the comparison fails, the circuitry causes the turbo-decoding iteration to proceed with a next decoding stage; and
if the comparison is successful, the circuitry causes the turbo-decoding iterations to stop.