PATENT DOCUMENT

Abstract:
A decoder for a communication system includes a channel detection module configured to receive initial estimates of respective code words, wherein the initial estimates of the respective code words correspond to a signal received via a communication channel, arrange the initial estimates of the respective code words into a plurality of groups, and generate probability information associated with selected data bits of the respective code words in the plurality of groups, wherein the probability information indicates probabilities of decoding decisions of the selected data bits. A computation module is configured to generate bit estimations for each of the selected data bits based on the probability information and feedback information. A decoding module is configured to selectively generate, the feedback information and an estimate signal corresponding to the respective code words.

Full Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
     The present disclosure is a continuation of U.S. patent application Ser. No. 13/684,895 (now U.S. Pat. No. 8,572,454), filed Nov. 26, 2012, which is a continuation of U.S. patent application Ser. No. 13/470,495 (now U.S. Pat. No. 8,321,749), filed on May 14, 2012, which is a continuation of U.S. patent application Ser. No. 12/323,995 (now U.S. Pat. No. 8,181,081), filed on Nov. 26, 2008, which claims the benefit of U.S. Provisional Application No. 60/991,502, filed on Nov. 30, 2007. The entire disclosures of the applications referenced above are incorporated herein by reference. 
    
    
     FIELD 
     The present disclosure relates to communication channels, and more particularly to channel decoding systems. 
     BACKGROUND 
     The background description provided herein is for the purpose of generally presenting the context of the disclosure. Work of the presently named inventors, to the extent the work is described in this background section, as well as aspects of the description that may not otherwise qualify as prior art at the time of filing, are neither expressly nor impliedly admitted as prior art against the present disclosure. 
     In communication systems, channel noise may cause transmission errors between a source and a receiver. Error correction coding (ECC) techniques may detect and correct channel transmission errors. Low-density parity-check (LDPC) codes are examples of ECC block codes that may provide coding gains to improve performance. 
     A coding gain is an amount of additional noise that an ECC coded system may handle compared to an uncoded system. In other words, the coding gain may enable the ECC coded system to transmit at a lower bit error rate (BER) than an uncoded system. Therefore, in applications in which transmit power may be limited, the coding gains of LDPC codes may make the difference between reliable and unreliable communication. 
     Referring now to  FIG. 1 , a functional block diagram illustrating a conventional communication system  10  is shown. The communication system  10  may include an LDPC encoder  12 , a modulator  14 , a channel  16 , a demodulator  18 , and an iterative LDPC decoder  20 . The iterative LDPC decoder  20  may include a channel detector  22 , such as a soft-output Viterbi algorithm (SOVA) detector, and an LDPC decoder  24 . 
     Using a given LDPC code, the LDPC encoder  12  encodes a stream of datawords (u) from a source. A dataword may refer to a group of binary data bits that is suitable for input to the LDPC encoder  12 . The LDPC encoder  12  outputs a stream of codewords (c) which may be in the form of binary data. A codeword may refer to a group of bits generated by the LDPC encoder  12  based on an input dataword. 
     LDPC codes are block codes and thus an LDPC code may be represented by an (M×N) parity-check matrix (H) that includes M rows and N columns. M may represent a number of constraints, such as parity-check equations. N may represent a number of bits. Entries of the parity-check matrix may be a one or a zero. For example, a bit v n  participates in a constraint c m  if H m,n =1. 
     The modulator  14  modulates the frequency, amplitude, and/or phase of the stream of codewords to generate a transmitted signal (w) that includes a modulated communication or storage signal. For example, the channel  16  may include a storage medium, such as a magnetic storage medium, an optical storage medium, or an electrical storage medium. The channel  16  may also include a communication channel. The channel  16  provides a received signal (w′), which may represent the transmitted signal corrupted by noise (n) or other interference. 
     The demodulator  18  demodulates the received signal and provides an initial estimate signal (r′) of the stream of codewords. The channel detector  22  of the iterative LDPC decoder  20  receives the initial estimate signal, which may be based on hard information in blocks of data. The initial estimate signal may include corrupted bits. Hard information represents hard decisions on whether data bits are ones or zeros. In other words, a hard decision for a bit may be either a one or a zero. 
     The channel detector  22  may generate soft information via a soft decision that is based on the initial estimate signal and data from the channel  16 . Soft information represents soft decisions on whether data bits are ones or zeros. In other words, a soft decision for a bit may be a real number that represents a probability or a likelihood of belief that the bit is a one or a zero. 
     For example, the soft information may be log-likelihood ratios (LLRs). An LLR is equal to the logarithm of the probability (Pr) that a bit is equal to one divided by the probability that the bit is equal to zero. In other words, the LLR of a bit v may be defined as: 
     
       
         
           
             
               LLR 
               ⁡ 
               
                 ( 
                 v 
                 ) 
               
             
             = 
             
               log 
               ⁢ 
               
                   
               
               ⁢ 
               
                 
                   
                     Pr 
                     ⁡ 
                     
                       ( 
                       
                         v 
                         = 
                         1 
                       
                       ) 
                     
                   
                   
                     Pr 
                     ⁡ 
                     
                       ( 
                       
                         v 
                         = 
                         0 
                       
                       ) 
                     
                   
                 
                 . 
               
             
           
         
       
     
     The sign of the LLR indicates a most likely value of the bit v. For example, a negative LLR relates to a higher probability of the bit being a 0. The value of the LLR indicates certainty of the value. For example, a larger value LLR relates to a higher certainty of the bit being a 0 or a 1. 
     For example, the channel detector  22  may generate the soft information based on the Viterbi algorithm. The channel detector  22  may also generate the soft information based on channel factors such as a type of modulation used by the modulator  14  and channel parameters such as additive white Gaussian noise (AWGN). 
     The LDPC decoder  24  receives the soft information and may attempt satisfying M parity-check equations of the parity-check matrix using the soft information. However, if one or more of the parity-check constraints are not satisfied, the LDPC  24  decoder may generate feedback information. For example, a message-passing algorithm such as a sum-product algorithm may be used to generate the feedback information. And in such an example, feedback messages from check nodes may be summed to generate the feedback information for a bit. 
     The channel detector  22  receives the feedback information and may update the soft information from the channel based on the feedback information. For example, the channel detector  22  may sum the soft information and the feedback information to generate updated soft information. The LDPC decoder  24  receives the updated soft information, and the process repeats. 
     For example, the iterative LDPC decoder  20  may repeat this process for numerous iterations to decode an entire block of data. The iterative LDPC decoder  20  may continue until a valid codeword is found that satisfies all M parity-check equations. The iterative LDPC decoder  20  may also continue until an allotted time has elapsed or when a certain number of iterations have occurred. 
     The iterative LDPC decoder  20  generates an estimate signal (r) based on the soft information and the iterative decoding process. The estimate signal represents an estimate of the original transmitted stream of datawords. For example, the estimate signal may include the most likely datawords. The estimate signal may also include the original stream of datawords if no error exists. 
     Referring now to  FIG. 2A , the LDPC decoder  24  may include a plurality of nodes  30 . The nodes  30  illustrate the iterative message-passing process between variable and check nodes (described above) which is used by a typical LDPC decoder  24 . For example, the nodes  30  represents the following parity-check matrix H: 
     
       
         
           
             H 
             = 
             
               
                 [ 
                 
                   
                     
                       1 
                     
                     
                       1 
                     
                     
                       1 
                     
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                   
                   
                     
                       1 
                     
                     
                       0 
                     
                     
                       0 
                     
                     
                       1 
                     
                     
                       1 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       1 
                     
                     
                       1 
                     
                     
                       0 
                     
                     
                       0 
                     
                     
                       1 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                     
                       1 
                     
                     
                       1 
                     
                     
                       1 
                     
                   
                 
                 ] 
               
               . 
             
           
         
       
     
     The nodes  30  may include check nodes c 0  ( 34 - 0 ), c 1  ( 34 - 1 ), c 2  ( 34 - 2 ), and c 3  ( 34 - 3 ) (collectively referred to as check nodes  34 ). The nodes  30  may also includes variable nodes v 0  ( 36 - 0 ), v 1  ( 36 - 1 ), v 2  ( 36 - 2 ), v 3  ( 36 - 3 ), v 4  ( 36 - 4 ), and v 5  ( 36 - 5 ) (collectively referred to as variable nodes  36 ). 
     Referring now to  FIG. 2B , the relationship between the check nodes  34 , the variable nodes  36 , and the parity-check matrix H is shown. The variable nodes  36  correspond to the N columns of the parity-check matrix H. The check nodes  34  correspond to the M rows of the parity-check matrix H. 
     The interacting nodes  30  may be referred to as a bipartite graph because no nodes of the same type (i.e., variable nodes and check nodes) are connected to each other. Communication lines connect check nodes  34  to variable nodes  36 . In other words, one of the check nodes  34  is connected to one of the variable nodes  36  if the corresponding entry in the parity-check matrix is a one. For example, check node c 0  ( 34 - 0 ) is connected to variable node v 0  ( 36 - 0 ) because H 0,0 =1. 
     Information received from the channel  16  is communicated to the variable nodes  36  via the channel detector  22 . The variable nodes  36  may pass the information up to the check nodes  34 . For example, variable node v 0  ( 36 - 0 ) may pass a message (i.e., channel information) to check nodes c 0  ( 34 - 0 ) and c 1  ( 34 - 1 ) because the nodes are connected. 
     The check nodes  34  may compute messages based on the information received from the variable nodes  36 . For example, one of the check nodes  34  may compute a message by summing all messages received from variable nodes  36 . The check nodes  34  may then pass the messages back to respective variable nodes  36 . 
     For example, check node c 0  ( 34 - 0 ) may compute a message by summing messages received from variable nodes v 0  ( 36 - 0 ), v 1  ( 36 - 1 ), and v 2  ( 36 - 2 ) because the nodes are connected. Check node c 0  ( 34 - 0 ) may also send the message back to variable nodes v 0  ( 36 - 0 ), v 1  ( 36 - 1 ), and v 2  ( 36 - 2 ) because the nodes are connected. 
     The variable nodes  36  may then compute messages based on the messages received from the check nodes  34 . For example, one of the variable nodes  36  may compute a message by summing all messages received from check nodes  36 . For example, variable node v 0  ( 36 - 0 ) may compute a feedback signal by summing messages received from check nodes c 0  ( 34 - 0 ) and c 1  ( 34 - 1 ) because the nodes are connected. 
     The check nodes  34  may send the feedback signals back to the channel detector  22 . The channel detector  22  may generate updated soft information based on the feedback signals and the soft information. The LDPC decoder  24  then receives the updated soft information. 
     The iterative message-passing process may be repeated until a predetermined condition is satisfied. After the predetermined condition is satisfied, the iterative LDPC decoder  20  may generate and output an estimate signal r. For example, the iterative message-passing process may continue until a predetermined number of iterations have occurred or until all parity-check equations are satisfied. For example, the parity-check equations corresponding to the parity-check matrix H are: 
     
       
         
           
             
               c 
               0 
             
             = 
             
               
                 v 
                 0 
               
               + 
               
                 v 
                 1 
               
               + 
               
                 v 
                 2 
               
             
           
         
       
       
         
           
             
               c 
               1 
             
             = 
             
               
                 v 
                 0 
               
               + 
               
                 v 
                 3 
               
               + 
               
                 v 
                 4 
               
             
           
         
       
       
         
           
             
               c 
               2 
             
             = 
             
               
                 v 
                 1 
               
               + 
               
                 v 
                 2 
               
               + 
               
                 v 
                 5 
               
             
           
         
       
       
         
           
             
               c 
               3 
             
             = 
             
               
                 v 
                 3 
               
               + 
               
                 v 
                 4 
               
               + 
               
                 
                   v 
                   5 
                 
                 . 
               
             
           
         
       
     
     Referring now to  FIG. 3A , an exemplary variable node computation is shown. A variable node  38  receives an initial bit estimate (y), which may be an LLR, from a channel detector (not shown). The variable node  38  may also receive return messages x 0 , x 1 , and x 2  from the different check nodes. The variable node  38  may generate return messages based on the received return messages and the initial bit estimate. For example, the variable node  38  may generate return messages for each check node by summing all of the other received messages, as shown in  FIG. 3B . 
     SUMMARY 
     A decoding system for a communication channel includes N parallel channel detection modules that generate N first probability vectors based on sequences of X correlated bits in each of N groups of correlated bits, respectively. The decoding system also includes N parallel updating modules that generate M second probability vectors based on the N first probability vectors and N feedback signals. The decoding system also includes N parallel estimation modules that generate estimates of the X correlated bits in each of the N groups of correlated bits based on the M second probability vectors. The decoding system also includes N parallel decoding modules that generate the N feedback signals and N output signals based on the estimates of the X correlated bits in each of the N groups of correlated bits. X is an integer greater than one, M is an integer greater than or equal to one, and N is an integer greater than or equal to M. 
     In other features, the decoding system further includes N parallel reference modules that selectively set the N feedback signals and a portion of at least one of the M second probability vectors to a reference voltage based on a difference between K and X. K is based on a number of adders in each of the N parallel updating modules, and K is an integer greater than or equal to X. 
     In other features, the decoding system further includes a distribution module that selectively distributes the N first probability vectors and the N feedback signals to the N parallel updating modules based on a difference between K and X. K is based on a number of adders in each of the N parallel updating modules, and K is an integer greater than or equal to X. 
     In other features, the decoding system further includes an interleaving module that receives the N feedback signals, that interleaves the N feedback signals, and that selectively distributes the N interleaved feedback signals to the N parallel updating modules based on a difference between K and X. The decoding system also includes a deinterleaving module that receives interleaved estimates of the X correlated bits in each of the N groups of correlated bits from the N parallel estimation modules, that deinterleaves the interleaved estimates of the X correlated bits in each of the N groups of correlated bits, and that outputs the estimates of the X correlated bits in each of the N groups of correlated bits. K is based on a number of adders in each of the N parallel updating modules, and K is an integer greater than or equal to X. 
     In still other features, the systems and methods described above are implemented by a computer program executed by one or more processors. The computer program can reside on a computer readable medium such as but not limited to memory, nonvolatile data storage, and/or other suitable tangible storage mediums. 
     Further areas of applicability of the present disclosure will become apparent from the detailed description, the claims and the drawings. The detailed description and specific examples are intended for purposes of illustration only and are not intended to limit the scope of the disclosure. 
    
    
     
       BRIEF DESCRIPTION OF DRAWINGS 
       The present disclosure will become more fully understood from the detailed description and the accompanying drawings, wherein: 
         FIG. 1  is a functional block diagram of a conventional communication system; 
         FIG. 2A  is a functional block diagram of a conventional LDPC decoder; 
         FIG. 2B  is a parity-check matrix representing an exemplary LDPC code; 
         FIGS. 3A and 3B  are schematics illustrating an exemplary variable node computation; 
         FIG. 4A  is a functional block diagram of an iterative decoding module according to the present disclosure; 
         FIG. 4B  is a schematic illustrating an iterative decoding process of a group of correlated information bits according to the present disclosure; 
         FIG. 5  is a functional block diagram of a communication system according to the present disclosure; 
         FIG. 6  is a functional block diagram of a parallel iterative decoding module according to the present disclosure; 
         FIG. 7A  is a functional block diagram of a first embodiment of a parallel computation module according to the present disclosure; 
         FIG. 7B  is a flow diagram illustrating a method for operating the first embodiment of the parallel computation module according to the present disclosure; 
         FIG. 8A  is a functional block diagram of a second embodiment of the parallel computation module according to the present disclosure; 
         FIG. 8B  is a schematic illustrating an exemplary computation performed by the second embodiment of the parallel computation module according to the present disclosure; 
         FIG. 8C  is a flow diagram illustrating a method for operating the second embodiment of the parallel computation module according to the present disclosure; 
         FIG. 9A  is a functional block diagram of a third embodiment of the parallel computation module according to the present disclosure; 
         FIG. 9B  is a functional block diagram of an exemplary third embodiment of the parallel computation module according to the present disclosure; 
         FIG. 9C  is a flow diagram illustrating a method for operating the third embodiment of the parallel computation module according to the present disclosure; 
     
    
    
     DESCRIPTION 
     The following description is merely exemplary in nature and is in no way intended to limit the disclosure, its application, or uses. For purposes of clarity, the same reference numbers will be used in the drawings to identify similar elements. As used herein, the phrase at least one of A, B, and C should be construed to mean a logical (A or B or C), using a non-exclusive logical or. It should be understood that steps within a method may be executed in different order without altering the principles of the present disclosure. 
     As used herein, the term module may refer to, be part of, or include an Application Specific Integrated Circuit (ASIC), an electronic circuit, a processor (shared, dedicated, or group) and/or memory (shared, dedicated, or group) that execute one or more software or firmware programs, a combinational logic circuit, and/or other suitable components that provide the described functionality. The software or firmware programs can be tangibly stored on a computer-usable or computer-readable medium. For the purposes of this description, a computer-usable or computer readable medium can be any apparatus that can contain, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device. The medium can be an electronic, magnetic, optical, electromagnetic, or semiconductor system (or apparatus or device) or a propagation medium. Examples of a computer-readable medium include a semiconductor or solid state memory, magnetic tape, a removable computer diskette, a random access memory (RAM), a read-only memory (ROM), a rigid magnetic disk and an optical disk. Current examples of optical disks include compact disk—read only memory (CD-ROM), compact disk—read/write (CD-R/W) and DVD. 
     Inputs and outputs of a communication channel may include correlated data. The correlated data may include statistical relationships between different data bits. For example, communication systems that include channels with memory may output correlated data. Channels with memory may include partial-response channels in data storage applications. 
     For example, communication systems using tensor-product codes (TPCs) may also include channels that output correlated data. TPCs include two levels of code (e.g., C1 and C2), and thus the data that is output from the outer level of code C2 may be correlated to the input and/or output of inner level code C1. 
     For example, a multi-constellational transmission system such as a quadrature amplitude modulation (QAM) system may include a channel that outputs correlated data. The QAM system may group and map data bits to signal points for transmission. Thus, the data bits in the same groups may be correlated. 
     Typical decoders assume that all input data bits are statistically independent. The present disclosure improves decoders by modifying the iterative decoding process with regard to correlated data, which may result in a higher performance (e.g., faster) decoder. If a channel outputs correlated data, the correlation may only span a few data bits. Therefore, data bits that are likely to have correlated information may be grouped together and decoded together. The number of data bits in each group may vary, and data bits within a particular group need not be consecutive. 
     Furthermore, in high-performance applications, such as magnetic recording data storage, stringent size and power constraints may require efficient decoder implementations. Typical hardware systems only provide for single bit (i.e., bit-by-bit) error correction. In other words, typical hardware systems do not provide for a single error correction architecture that may operate concurrently on several different groups and/or sequences of correlated data bits. Additionally, typical hardware systems do not provide for a single error correction architecture that may operate at various error correction code rates and on various lengths (or sizes) of correlated input data sequences. 
     Referring now to  FIG. 4A , an iterative decoding module  40  is shown. The iterative decoding module  40  may include a channel detection module  42 , a computation module  44 , and a decoding module  46 . For example, the channel detection module  42  may include, for example, a soft-output Viterbi algorithm (SOVA) detector. The decoding module  46  may include, for example, an LDPC decoder. 
     The iterative decoding module  40  may decode LDPC encoded data bits based on an iterative decoding process using soft information. The soft information may be probabilities or likelihoods of belief that the data bits are ones or zeros. For example, the soft information may be log-likelihood ratios (LLRs) for each of the data bits. 
     The channel detection module  42  receives an initial estimate signal (r′) from a channel via a demodulator (not shown). The channel detection module  42  may group k correlated data bits together from the received signal. The channel detection module  42  generates the soft information based on the k correlated data bits. More specifically, the channel detection module  42  generates an initial probability vector P i  of length 2 k −1. For example, the initial probability vector P i  may include LLRs for each possible sequence of the k correlated data bits. 
     The computation module  44  receives the initial probability vector P i . The computation module  44  also receives feedback signals P f (x 0 )−P f (x k−1 ) (collectively referred to as feedback signals P f (x)) for each of the k data bits from the decoding module  46 . For example, the feedback signals P f (x) may be LLRs for each of the k data bits to be used in the next decoding iteration. 
     The computation module  44  generates bit estimations P(x 0 )−P(x k−1 ) (collectively referred to as bit estimations P(x)) for each of the k data bits based on the initial probability vector P i  and the feedback signals P f (x). The bit estimations P(x) may be LLRs for each of the k data bits. 
     The decoding module  46  receives the bit estimations P(x). The decoding module  46  may generate an estimate signal (r) based on the bit estimations P(x) if a predetermined condition has been satisfied. The condition may require, for example, that a predetermined number of decoding iterations occur or that all parity-check equations be satisfied. If the condition is satisfied, the decoding module  46  may output the estimate signal. 
     If the predetermined condition is not satisfied, the decoding module  46  generates the feedback signals P f (x) for each of the k data bits. The feedback signals P f (x) may be generated based on typical message-passing decoding between nodes. For example, a feedback signal P f (x) for a data bit may be a sum of check node messages received at a variable node corresponding to the data bit. The decoding module  46  sends the feedback signals P f (x) the computation module  44  to be used in another decoding iteration. This iterative decoding process may be repeated until the predetermined condition is satisfied. 
     Referring now to  FIG. 4B , a schematic  50  illustrates the iterative decoding process of a group of k correlated data bits discussed above with regard to  FIG. 4A . Typically, channel detectors only generate LLRs for individual data bits. In other words, typical decoders perform iterative LDPC decoding in a bit-by-bit process. For example, for a group of k data bits x 0 , x 1 , x k−1 , the initial probabilities (Pr) may be: 
     
       
         
           
             
               log 
               ⁢ 
               
                   
               
               ⁢ 
               
                 
                   Pr 
                   ⁡ 
                   
                     ( 
                     
                       
                         x 
                         0 
                       
                       = 
                       1 
                     
                     ) 
                   
                 
                 
                   Pr 
                   ⁡ 
                   
                     ( 
                     
                       
                         x 
                         0 
                       
                       = 
                       0 
                     
                     ) 
                   
                 
               
             
             , 
             
               log 
               ⁢ 
               
                   
               
               ⁢ 
               
                 
                   Pr 
                   ⁡ 
                   
                     ( 
                     
                       
                         x 
                         1 
                       
                       = 
                       1 
                     
                     ) 
                   
                 
                 
                   Pr 
                   ⁡ 
                   
                     ( 
                     
                       
                         x 
                         1 
                       
                       = 
                       0 
                     
                     ) 
                   
                 
               
             
             , 
             
               … 
               ⁢ 
               
                   
               
               ⁢ 
               log 
               ⁢ 
               
                   
               
               ⁢ 
               
                 
                   
                     Pr 
                     ⁡ 
                     
                       ( 
                       
                         
                           x 
                           
                             k 
                             - 
                             1 
                           
                         
                         = 
                         1 
                       
                       ) 
                     
                   
                   
                     Pr 
                     ⁡ 
                     
                       ( 
                       
                         
                           x 
                           
                             k 
                             - 
                             1 
                           
                         
                         = 
                         0 
                       
                       ) 
                     
                   
                 
                 . 
               
             
           
         
       
     
     However, the channel detection module  42  generates an initial probability vector P i  for the group x of k correlated data bits, where x=x 0 , . . . , x k−1 . For example, the channel detection module  42  may generate an initial probability vector P i  of length 2 k −1 that includes LLRs for each of the sequences of k correlated data bits: 
     
       
         
           
             
               P 
               i 
             
             = 
             
               [ 
               
                 
                   
                     
                       log 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         
                           Pr 
                           ⁡ 
                           
                             ( 
                             
                               x 
                               = 
                               
                                 0 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 01 
                               
                             
                             ) 
                           
                         
                         
                           Pr 
                           ⁡ 
                           
                             ( 
                             
                               x 
                               = 
                               
                                 0 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 00 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                 
                 
                   
                     
                       log 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         
                           Pr 
                           ⁡ 
                           
                             ( 
                             
                               x 
                               = 
                               
                                 0 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 10 
                               
                             
                             ) 
                           
                         
                         
                           Pr 
                           ⁡ 
                           
                             ( 
                             
                               x 
                               = 
                               
                                 0 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 00 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                 
                 
                   
                     
                       log 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         
                           Pr 
                           ⁡ 
                           
                             ( 
                             
                               x 
                               = 
                               
                                 0 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 11 
                               
                             
                             ) 
                           
                         
                         
                           Pr 
                           ⁡ 
                           
                             ( 
                             
                               x 
                               = 
                               
                                 0 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 00 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                 
                 
                   
                     ⋮ 
                   
                 
                 
                   
                     
                       log 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         
                           Pr 
                           ⁡ 
                           
                             ( 
                             
                               x 
                               = 
                               
                                 1 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 11 
                               
                             
                             ) 
                           
                         
                         
                           Pr 
                           ⁡ 
                           
                             ( 
                             
                               x 
                               = 
                               
                                 0 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 … 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 00 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
               ] 
             
           
         
       
     
     Each entry of the initial probability vector P i  is measured against an all-zero sequence x=0 . . . 00. The all-zero sequence entry may be omitted as an entry in the initial probability vector P i  because measuring the all-zero sequence against the all-zero sequence is trivial: 
     
       
         
           
             
               log 
               ⁢ 
               
                   
               
               ⁢ 
               
                 
                   Pr 
                   ⁡ 
                   
                     ( 
                     
                       x 
                       = 
                       
                         0 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         … 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         00 
                       
                     
                     ) 
                   
                 
                 
                   Pr 
                   ⁡ 
                   
                     ( 
                     
                       x 
                       = 
                       
                         0 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         … 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         00 
                       
                     
                     ) 
                   
                 
               
             
             = 
             0. 
           
         
       
     
     The initial probability vector P i  may be combined with a feedback probability vector P f  to generate an updated probability vector P u . However, for the first decoding iteration P f =0 because a decoding module  54  has not generated feedback signals P f (x) yet. Therefore, P u =P i  for the first decoding iteration. 
     An estimation module  52  generates initial bit estimations P e (x 0 ). P e (x 1 ) . . . , P e (x k−1 ) (collective referred to as initial bit estimations P e (x)) based on the updated probability vector P u . For example, the estimation module  52  may generate the initial bit estimations P e (x) as follows: 
     
       
         
           
             
               
                 
                   P 
                   e 
                 
                 ⁡ 
                 
                   ( 
                   
                     x 
                     i 
                   
                   ) 
                 
               
               = 
               
                 
                   log 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   
                     
                       Pr 
                       ⁡ 
                       
                         ( 
                         
                           
                             x 
                             i 
                           
                           = 
                           1 
                         
                         ) 
                       
                     
                     
                       Pr 
                       ⁡ 
                       
                         ( 
                         
                           
                             x 
                             i 
                           
                           = 
                           0 
                         
                         ) 
                       
                     
                   
                 
                 = 
                 
                   log 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   
                     
                       
                         ∑ 
                         
                           
                             a 
                             i 
                           
                           = 
                           1 
                         
                       
                       ⁢ 
                       
                         Pr 
                         ⁡ 
                         
                           ( 
                           
                             x 
                             = 
                             a 
                           
                           ) 
                         
                       
                     
                     
                       
                         ∑ 
                         
                           
                             a 
                             i 
                           
                           = 
                           0 
                         
                       
                       ⁢ 
                       
                         Pr 
                         ⁡ 
                         
                           ( 
                           
                             x 
                             = 
                             a 
                           
                           ) 
                         
                       
                     
                   
                 
               
             
             , 
           
         
       
     
                   P   e     ⁡     (     x   i     )       ≈         max       a   i     =   1       ⁢     (       P   u     ⁡     (   a   )       )       -       max       a   i     =   0       ⁢     (       P   u     ⁡     (   a   )       )           ,         
where a i  represents a binary value of the i th  entry in the sequence of correlated data bits x. P u (a i ) represents entries of the updated probability vector P u . The first line of the above formula may be used to generate exact initial bit estimations P e (x). However, to reduce overall complexity the initial bit estimations P e (x) may be generated based on the second line of the above formula.
 
     The bit estimations P(x) to be used by the decoding module  54  may be generated by subtracting the feedback signals P f (x) from the initial bit estimations P e (x). However, for the first decoding iteration P f (x)=0. Therefore, the decoding module  54  receives the bit estimations P(x), which for this iteration are the initial bit estimations P e (x). 
     The decoding module  54  receives the bit estimations P(x). The decoding module  54  may generate an estimate signal (r) based on the bit estimations P(x) if a predetermined condition has been satisfied. The condition may require, for example, that a predetermined number of decoding iterations occur or that all parity-check equations be satisfied. If the condition is satisfied, the decoding module  46  may output the estimate signal. For example, the estimate signal may be most probable datawords, or the original stream of datawords (u) if no error exists. 
     If the predetermined condition is not satisfied, the decoding module  54  generates the feedback signals P f (x) for each of the k data bits. The feedback signals P f (x) may be generated based on typical message-passing decoding between variable and check nodes. 
     For example, a feedback signal P f (x) for a data bit may be a sum of check node messages received at a variable node corresponding to the data bit. More specifically, a feedback signal P f (x i ) may be computed for a bit x i  by summing messages from check nodes to a variable node corresponding to data a bit (v). In one implementation, if α 0 , . . . , α k−1  represent the messages from k check nodes to the variable node corresponding to the data bit, then the feedback signal for the data bit is:
 
 P   f ( v )=α 0 + . . . +α k−1 .
 
     The decoding module  46  sends the feedback signals P f (x) to the computation module  44  to be used in another decoding iteration. An updating module  56  receives the feedback signals P f (x) and generates the feedback probability vector P f  based on the feedback signals P f (x). For example, the updating module  56  may generate the feedback probability vector P f  as follows, where each entry of the feedback probability vector P f  corresponds to a bit sequence on the right: 
     
       
         
           
             
               P 
               f 
             
             = 
             
               
                 [ 
                 
                   
                     
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             0 
                           
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             1 
                           
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               0 
                             
                             ) 
                           
                         
                         + 
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               1 
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             2 
                           
                           ) 
                         
                       
                     
                   
                   
                     
                       ⋮ 
                     
                   
                   
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               
                                 k 
                                 - 
                                 2 
                               
                             
                             ) 
                           
                         
                         + 
                         … 
                         + 
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               1 
                             
                             ) 
                           
                         
                         + 
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               0 
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             
                               k 
                               - 
                               1 
                             
                           
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               
                                 k 
                                 - 
                                 1 
                               
                             
                             ) 
                           
                         
                         + 
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               0 
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               
                                 k 
                                 - 
                                 1 
                               
                             
                             ) 
                           
                         
                         + 
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               1 
                             
                             ) 
                           
                         
                         + 
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               0 
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               
                                 k 
                                 - 
                                 1 
                               
                             
                             ) 
                           
                         
                         + 
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               2 
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       ⋮ 
                     
                   
                   
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               
                                 k 
                                 - 
                                 1 
                               
                             
                             ) 
                           
                         
                         + 
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               
                                 k 
                                 - 
                                 2 
                               
                             
                             ) 
                           
                         
                         + 
                         … 
                         + 
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               1 
                             
                             ) 
                           
                         
                         + 
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               0 
                             
                             ) 
                           
                         
                       
                     
                   
                 
                 ] 
               
               ⁢ 
               
                 
                   
                     -&gt; 
                   
                 
                 
                   
                     -&gt; 
                   
                 
                 
                   
                     -&gt; 
                   
                 
                 
                   
                     -&gt; 
                   
                 
                 
                   
                     -&gt; 
                   
                 
                 
                   
                     -&gt; 
                   
                 
                 
                   
                     -&gt; 
                   
                 
                 
                   
                     -&gt; 
                   
                 
                 
                   
                     -&gt; 
                   
                 
                 
                   
                     -&gt; 
                   
                 
                 
                   
                     -&gt; 
                   
                 
                 
                   
                     -&gt; 
                   
                 
               
               ⁢ 
               
                 
                   
                     
                       00 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       … 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       001 
                     
                   
                 
                 
                   
                     
                       00 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       … 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       010 
                     
                   
                 
                 
                   
                     
                       00 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       … 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       011 
                     
                   
                 
                 
                   
                     
                       00 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       … 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       100 
                     
                   
                 
                 
                   
                     ⋮ 
                   
                 
                 
                   
                     
                       01 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       … 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       011 
                     
                   
                 
                 
                   
                     
                       10 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       … 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       000 
                     
                   
                 
                 
                   
                     
                       10 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       … 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       001 
                     
                   
                 
                 
                   
                     
                       10 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       … 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       011 
                     
                   
                 
                 
                   
                     
                       10 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       … 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       100 
                     
                   
                 
                 
                   
                     ⋮ 
                   
                 
                 
                   
                     
                       11 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       … 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       111 
                     
                   
                 
               
             
           
         
       
     
     The updated probability vector P u  may be generated based on the initial probability vector P i  and the feedback probability vector P f . For example, the updated probability vector P u  may be generated by summing the initial probability vector P i  and the feedback probability vector P f  (P u =P i +P f ). 
     The estimation module  52  may generate new initial bit estimations P e (x) based on the updated probability vector P u . For example, the estimation module  52  may generate the new initial bit estimations P e (x) based on the same method used in the first decoding iteration (above). 
     New bit estimations P (x) for a new decoding cycle may then be generated based on the new initial bit estimations P e (x) and the feedback signals P f (x). For example, the new bit estimations P(x) may be generated by subtracting the feedback signals P f (x) from the corresponding new initial bit estimations P e (x):
 
 P ( x )= P   e ( x )− P   f ( x ).
 
     The decoding module  54  receives the new bit estimations P(x). The decoding module  54  may generate and output the estimate signal based on the new bit estimations P(x) if the predetermined condition has been satisfied. If the predetermined condition has not been satisfied, the decoding module  54  may generate new feedback signals P f (x) and the process may repeat for another decoding iteration. 
     Referring now to  FIG. 5 , a communication system  60  is shown. The communication system may include an encoder  62 , a modulator  64 , a communication channel  66 , a demodulator  68 , and a parallel iterative decoding module  70 . For example, the communication system  60  may encode and/or decode data using low-density parity-check (LDPC) codes and techniques. 
     The encoder  62  encodes a stream of datawords (u) from a source using a code (C) such as an LDPC code. A dataword may refer to a group of binary data that is suitable for input to the encoder  62 . The encoder  62  outputs a stream of codewords (c) which may be in the form of binary data. A codeword may refer to a group of bits generated by the encoder  62  based on an input dataword. 
     The modulator  64  modulates the frequency, amplitude, and/or phase of the stream of codewords (c) to generate a transmitted signal (w), such as a communication or storage signal. The channel  66  may be a storage medium, such as a magnetic storage medium, an optical storage medium, or an electrical storage medium. The channel  66  may also be a communication channel. 
     The channel  66  provides a received signal (w′), which may be a corrupted version of the transmitted signal due to noise (n) or interference. The demodulator  68  demodulates the received signal and provides an initial estimate signal (r′) of the stream of codewords. 
     The parallel iterative decoding module  70  receives the initial estimate signal. The initial estimate signal may include corrupted bits. The parallel iterative decoding module  70  may group the initial estimate signal into b groups of correlated data bits. The parallel iterative decoding module  70  may generate soft information, such as LLRs, based on the b groups of correlated data bits. 
     For example, the parallel iterative decoding module  70  may generate soft information based on the Viterbi algorithm. The parallel iterative decoding module  70  may also generate the soft information based on channel factors such as the type of modulation used by the modulator  64  and channel parameters such as additive white Gaussian noise (AWGN). 
     The parallel iterative decoding module  70  may decode more than one of the b groups concurrently. Additionally, the parallel iterative decoding module  70  may decode groups of different sizes (or lengths), up to k bits each. Thus, the parallel iterative decoding module  70  may be faster than and may provide a higher bit-throughput than typical bit-by-bit decoders. The parallel iterative decoding module  70  may also achieve a constant bit-throughput for different sizes of groups by interleaving the received data bits and disabling adders used in processing. 
     The parallel iterative decoding module  70  generates an estimate signal (r). For example, the parallel iterative decoding module  70  may generate the estimate signal by combining b group estimate signals r 0 , r 1 , . . . , r b−1  corresponding to the b groups of correlated information bits. The estimate signal represents an estimate of the original stream of datawords (u) after encoding, transmission, and decoding. In one implementation, the estimate signal represents an estimate of the original stream of datawords because the original stream of data words may be corrupted due to channel noise. For example, the estimate signal r may be most probable datawords, or it may be the same as the original stream of datawords u if no error exists. 
     Referring now to  FIG. 6 , a functional block diagram of a parallel iterative decoding module  70  is shown. The parallel iterative decoding module  70  may include b parallel channel detection modules  80 - 1 ,  80 - 2 , . . . ,  80 - b  (collectively referred to as channel detection modules  80 ). The parallel iterative decoding module  70  may also include a decoding control system  90 , hereinafter referred to as computation control module  90 . The parallel iterative decoding module  70  may further include b parallel decoding modules  100 - 1 ,  100 - 2 , . . .  100 - b  (collectively referred to as decoding modules  100 ). 
     The channel detection modules  80  receive the initial estimate signal (r′) from a channel via a demodulator (not shown). The channel detection modules  80  may group the initial estimate signal into b groups of up to k correlated bits each. The maximum number of bits k per group b may be based on a number of adders and/or multiplexers in the channel detection modules  80 , the computation control module  90 , and the decoding modules  100 . 
     The channel detection modules  80  may also include soft-output Viterbi algorithm (SOVA) detectors. The channel detection modules  80  generate soft information based on the b groups of correlated data bits. For example, the channel detection modules  80  may generate LLRs based on sequences of correlated data bits within each of the b groups. 
     In one implementation, the channel detection modules  80  generate b initial probability vectors P i,0 , P i,1 , . . . , P i,b−1  (collectively referred to as initial probability vectors P i ). The initial probability vectors may include LLRs for each possible sequence of bits within each of the b groups. In one implementation, each of the initial probability vectors P i  may correspond to one of the b groups of bits. For example, each of the initial probability vectors P i  may be of length 2 k −1, where k is the maximum number of bits per group b: 
     
       
         
           
             
               P 
               i 
             
             = 
             
               
                 [ 
                 
                   
                     
                       
                         log 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             Pr 
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 = 
                                 
                                   0 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   … 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   01 
                                 
                               
                               ) 
                             
                           
                           
                             Pr 
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 = 
                                 
                                   0 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   … 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   00 
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         log 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             Pr 
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 = 
                                 
                                   0 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   … 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   10 
                                 
                               
                               ) 
                             
                           
                           
                             Pr 
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 = 
                                 
                                   0 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   … 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   00 
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         log 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             Pr 
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 = 
                                 
                                   0 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   … 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   11 
                                 
                               
                               ) 
                             
                           
                           
                             Pr 
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 = 
                                 
                                   0 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   … 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   00 
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                   
                     
                       ⋮ 
                     
                   
                   
                     
                       
                         log 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             Pr 
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 = 
                                 
                                   1 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   … 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   11 
                                 
                               
                               ) 
                             
                           
                           
                             Pr 
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 = 
                                 
                                   0 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   … 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   00 
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                 
                 ] 
               
               . 
             
           
         
       
     
     The computation control module  90  receives the initial probability vectors P i . The computation control module  90  also receives b×k feedback signals P f (x 0,0 ), P f (x 0,1 ), . . . , P f (x b−1,k−1 ) (collectively referred to as feedback signals P f (x)) from the decoding modules  100 . The computation control module  90  generates b×k bit estimations P(x 0,0 ), P(x 0,1 ), . . . , P(x b−1,k−1 ) (collectively referred to as bit estimations P(x)) corresponding to each of the k bits in each of the b groups. The computation control module  90  may generate the bit estimations P(x) based on the initial probability vectors P i  and the feedback signals P f (x). 
     The decoding modules  100  receive the bit estimations P(x) from the computation control module  90 . For example, decoding module  100 - 0  may receive bit estimations P(x 0,0 )-P(x 0,k−1 ) corresponding to each of the k bits in a first group (i.e., group 0). The decoding modules  100  may further include LDPC decoders. The decoding modules  100  may generate the b group estimate signals r 0 , r 1 , . . . , r b−1  based on the bit estimations P(x) if conditions have been satisfied. For example, the decoding modules  100  may generate the b group estimate signals if a certain number of decoding iterations have occurred or if all parity-check equations are satisfied. 
     If the conditions are not satisfied, the decoding modules  100  may generate the feedback signals P f (x). The decoding modules  100  may generate the feedback signals P f (x) based on the bit estimations P(x) and a typical message-passing decoding process between nodes. For example, the decoding modules  100 . The decoding modules  100  may send the feedback signals P f (x) back to the computation control module  90  to be used in another decoding iteration. This iterative decoding process may be repeated until the conditions are satisfied. 
     Referring now to  FIG. 7A , a first embodiment of the computation control module  150  is shown. The computation control module  150  may ground signals and/or probability vector entries. For example, grounding signals and/or probability vector entries may prevent unused adders for groups of less than k bits in size from affecting probability computation (and thus decoding). Thus, the computation control module  150  may provide for processing of a constant number of groups b of up to k bits each. 
     The computation control module  150  may include b parallel updating modules  160 - 1 ,  160 - 2 , . . . ,  160 - b  (collectively referred to as updating modules  160 ). The computation control module  150  may also include b parallel reference modules  170 - 1 ,  170 - 2 , . . . ,  170 - b  (collectively referred to as reference modules  170 ). The computation control module  150  may further include b parallel estimation modules  180 - 1 ,  180 - 2 , . . . ,  180 - b  (collectively referred to as estimation modules  180 ). 
     Furthermore, one of the updating modules  160  and one of the estimation modules  180  may collectively be referred to as a computation module (as seen previously in  FIG. 4B ). For example, updating module  160 - b  and estimation module  180 - b  may be referred to collectively as computation module b (i.e., the b th  computation module). Each computation module may process up to k bits per cycle. 
     The updating modules  160  receive respective initial probability vectors P i  and the feedback signals P f (x). For example, updating module  160 - 1  may receive initial probability vector P 0  and feedback signals P f (x 0,0 )-P f (x 0,k−1 ). In one implementation, updating module  160 - 1  may receive feedback signals corresponding to each of the bits in the first group (i.e., group 0). 
     The updating modules  160  generate b feedback probability vectors P f,0 , P f,1 , . . . , P f,b−1  (collectively referred to as feedback probability vectors P f ) based on the feedback signals P f (x). For example, for a group of k bits: 
     
       
         
           
             
               P 
               f 
             
             = 
             
               [ 
               
                 
                   
                     
                       
                         P 
                         f 
                       
                       ⁡ 
                       
                         ( 
                         
                           x 
                           0 
                         
                         ) 
                       
                     
                   
                 
                 
                   
                     
                       
                         P 
                         f 
                       
                       ⁡ 
                       
                         ( 
                         
                           x 
                           1 
                         
                         ) 
                       
                     
                   
                 
                 
                   
                     
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             0 
                           
                           ) 
                         
                       
                       + 
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             1 
                           
                           ) 
                         
                       
                     
                   
                 
                 
                   
                     
                       
                         P 
                         f 
                       
                       ⁡ 
                       
                         ( 
                         
                           x 
                           2 
                         
                         ) 
                       
                     
                   
                 
                 
                   
                     ⋮ 
                   
                 
                 
                   
                     
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             
                               k 
                               - 
                               2 
                             
                           
                           ) 
                         
                       
                       + 
                       … 
                       + 
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             1 
                           
                           ) 
                         
                       
                       + 
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             0 
                           
                           ) 
                         
                       
                     
                   
                 
                 
                   
                     
                       
                         P 
                         f 
                       
                       ⁡ 
                       
                         ( 
                         
                           x 
                           
                             k 
                             - 
                             1 
                           
                         
                         ) 
                       
                     
                   
                 
                 
                   
                     
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             
                               k 
                               - 
                               1 
                             
                           
                           ) 
                         
                       
                       + 
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             0 
                           
                           ) 
                         
                       
                     
                   
                 
                 
                   
                     
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             
                               k 
                               - 
                               1 
                             
                           
                           ) 
                         
                       
                       + 
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             1 
                           
                           ) 
                         
                       
                       + 
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             0 
                           
                           ) 
                         
                       
                     
                   
                 
                 
                   
                     
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             
                               k 
                               - 
                               1 
                             
                           
                           ) 
                         
                       
                       + 
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             2 
                           
                           ) 
                         
                       
                     
                   
                 
                 
                   
                     ⋮ 
                   
                 
                 
                   
                     
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             
                               k 
                               - 
                               1 
                             
                           
                           ) 
                         
                       
                       + 
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             
                               k 
                               - 
                               2 
                             
                           
                           ) 
                         
                       
                       + 
                       … 
                       + 
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             1 
                           
                           ) 
                         
                       
                       + 
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             0 
                           
                           ) 
                         
                       
                     
                   
                 
               
               ] 
             
           
         
       
     
     However, for groups of bits of size less than k, computation of the bit estimations P(x) may be modified as follows: 
                           P   ⁡     (     x   i     )       =       ⁢     log   ⁢           ⁢         ∑       a   i     =   1       ⁢     P   ⁡     (       x   1   k     =     a   1   k       )             ∑       a   i     =   0       ⁢     P   ⁡     (       x   1   k     =     a   1   k       )                           =       ⁢     log   ⁢           ⁢           ∑         a   i     =   1     ,       a   m     =   0         ⁢     P   ⁢     (       x   1   k     =     a   1   k       )         +       ∑         a   i     =   1     ,       a   m     =   1         ⁢     P   ⁡     (       x   1   k     =     a   1   k       )                 ∑         a   i     =   0     ,       a   m     =   0         ⁢     P   ⁡     (       x   1   k     =     a   1   k       )         +       ∑         a   i     =   0     ,       a   m     =   1         ⁢     P   ⁡     (       x   1   k     =     a   1   k       )                 ,               ≈       ⁢       max   (       max   (         P   u           a   i     =   1     ,       a   m     =   0         ⁡     (     a   1   k     )       )     ,     max   (         P   u           a   i     =   1     ,       a   m     =   1         ⁡     (     a   1   k     )       )       )     -                     ⁢       max   (       max   (         P   u           a   i     =   0     ,       a   m     =   0         ⁡     (     a   1   k     )       )     ,     max   (         P   u           a   i     =   0     ,       a   m     =   1         ⁡     (     a   1   k     )       )       )     ,                   
where a 1   k  represents the following vector:
 
     
       
         
           
             
               a 
               1 
               k 
             
             = 
             
               
                 [ 
                 
                   
                     
                       
                         a 
                         0 
                       
                     
                   
                   
                     
                       
                         a 
                         1 
                       
                     
                   
                   
                     
                       ⋮ 
                     
                   
                   
                     
                       
                         a 
                         
                           k 
                           - 
                           1 
                         
                       
                     
                   
                 
                 ] 
               
               . 
             
           
         
       
     
     Thus, the updating modules  160  may selectively ground (i.e., set to zero) one or more feedback signals P f (x) to support processing of group sizes less than k bits. For example, the updating modules  160  may communicate with the reference modules  170 , and the reference modules  170  may selectively set one or more feedback signals to a reference voltage, such as ground. 
     For example, for processing of groups of size k−1 the updating modules  160  may communicate with the reference modules  170  to ground a vector of feedback signals P f (x 0−(b−1),k−1 ) (i.e., the k th  entry of each group). In one implementation, the reference modules  170  may effectively set the feedback signals P f (x) corresponding to the k th  bit to zero. Thus, the feedback probability vectors P f  may be generated based on these modified feedback signals P f (x). 
     The updating modules  160  may then generate updated probability vectors P u,0 , P u,1 , . . . , P u,b− 1 (collectively referred to as updated probability vectors P u ). For example, the updating modules  160  may generate the updated probability vectors P u  by summing the initial probability vectors P 1  with the corresponding feedback probability vectors P f  (P u =P i +P f ). 
     The estimation modules  180  receive the updated probability vectors P u . If the computation control module  150  is processing groups of k bits each, then the estimation modules  180  may not modify the updated probability vectors P u . However, if the computation control module  150  is processing groups of less than k bits each (i.e., k−1, k−2), then the estimation modules  180  may communicate with the reference modules  170  to modify the updated probability vectors P u . 
     For example, the reference modules  170  may ground half or more of the entries in each of the updated probability vectors P u . If the computation control module  150  is processing groups of size k−1, the reference modules  170  may ground the last half of the entries of the updated probability vectors P u . In one implementation, the reference modules  170  may zero the entries of the updated probability vectors P u  corresponding to the k th  bit being 1. 
     Grounding one or more vectors of feedback signals P f (x) and half or more entries of the updated probability vectors P u  may result in the following: 
     
       
         
           
             
               
                 
                   
                     P 
                     u 
                   
                   
                     
                       
                         a 
                         t 
                       
                       = 
                       1 
                     
                     , 
                     
                       
                         a 
                         k 
                       
                       = 
                       1 
                     
                   
                 
                 ⁡ 
                 
                   ( 
                   
                     a 
                     1 
                     k 
                   
                   ) 
                 
               
               = 
               0 
             
             , 
             
               
 
             
             ⁢ 
             
               
                 
                   
                     P 
                     u 
                   
                   
                     
                       
                         a 
                         t 
                       
                       = 
                       0 
                     
                     , 
                     
                       
                         a 
                         k 
                       
                       = 
                       1 
                     
                   
                 
                 ⁡ 
                 
                   ( 
                   
                     a 
                     1 
                     k 
                   
                   ) 
                 
               
               = 
               0 
             
             , 
             
               
 
             
             ⁢ 
             
               
                 
                   
                     P 
                     u 
                   
                   
                     
                       
                         a 
                         t 
                       
                       = 
                       1 
                     
                     , 
                     
                       
                         a 
                         k 
                       
                       = 
                       0 
                     
                   
                 
                 ⁡ 
                 
                   ( 
                   
                     a 
                     1 
                     k 
                   
                   ) 
                 
               
               = 
               
                 
                   
                     P 
                     u 
                   
                   
                     
                       a 
                       t 
                     
                     = 
                     1 
                   
                 
                 ⁡ 
                 
                   ( 
                   
                     a 
                     1 
                     
                       k 
                       - 
                       1 
                     
                   
                   ) 
                 
               
             
             , 
             
               
 
             
             ⁢ 
             
               
                 
                   
                     P 
                     u 
                   
                   
                     
                       
                         a 
                         t 
                       
                       = 
                       0 
                     
                     , 
                     
                       
                         a 
                         k 
                       
                       = 
                       0 
                     
                   
                 
                 ⁡ 
                 
                   ( 
                   
                     a 
                     1 
                     k 
                   
                   ) 
                 
               
               = 
               
                 
                   
                     
                       P 
                       u 
                     
                     
                       
                         a 
                         t 
                       
                       = 
                       0 
                     
                   
                   ⁡ 
                   
                     ( 
                     
                       a 
                       1 
                       
                         k 
                         - 
                         1 
                       
                     
                     ) 
                   
                 
                 . 
               
             
           
         
       
     
     Thus, the outputs of the estimation modules  180  are P(x i )=P e (x i )−P f (x i ), where P e (x i ) may be generated as follows: 
     
       
         
           
             
               
                 P 
                 e 
               
               ⁡ 
               
                 ( 
                 
                   x 
                   i 
                 
                 ) 
               
             
             ≈ 
             
               
                 max 
                 ( 
                 
                   
                     
                       P 
                       u 
                     
                     
                       
                         a 
                         t 
                       
                       = 
                       1 
                     
                   
                   ⁡ 
                   
                     ( 
                     
                       a 
                       1 
                       
                         k 
                         - 
                         1 
                       
                     
                     ) 
                   
                 
                 ) 
               
               - 
               
                 
                   max 
                   ( 
                   
                     
                       
                         P 
                         u 
                       
                       
                         
                           a 
                           t 
                         
                         = 
                         0 
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         a 
                         1 
                         
                           k 
                           - 
                           1 
                         
                       
                       ) 
                     
                   
                   ) 
                 
                 . 
               
             
           
         
       
     
     Further support for decreasing group sizes (e.g., k−2, k−3, etc.) may be achieved by grounding additional vectors of the feedback signals P f (x) and additional updated probability vector P u  entries corresponding to unused adders. In one implementation, each decrement of group size uses approximately half of the adders of a computation module. 
     Referring now to  FIG. 7B , a flow diagram illustrating steps performed by the first embodiment of the computation control module  150  begins in step  200 . In step  202 , the computation control module  150  determines the sizes of the b groups being processed. If the size is k (i.e., the maximum), control proceeds to step  204 . If the size is less than k, control proceeds to step  210 . 
     In step  204 , the computation control module  150  begins processing the b groups of k bits using an entire 2 k −1 vector operations (i.e., all adders of the computation modules). The computation control module  150  generates the feedback probability vectors P f  based on the feedback signals P f (x). 
     In step  206 , the computation control module  150  generates the updated probability vectors P u  based on the initial probability vectors P i  and the feedback probability vectors P f . In step  208 , the computation control module  150  generates the bit estimations P(x) based on the updated probability vectors P u  and control ends. 
     In step  210 , the computation control module  150  determines the difference d between k and the number of bits in each of the b groups. In step  212 , the computation control module  150  grounds one or more vectors of feedback signals P f (x) based on d. For example, if d=1 (i.e., group size k−1) then the computation control module  150  may ground the vector of feedback signals P f (x k−1 ) which corresponds to the k th  bit for each of the b groups. 
     In step  214 , the computation control module  150  generates the feedback probability vectors P f  based on the modified feedback signals P f (x). In step  216 , the computation control module  150  generates the updated probability vectors P u  based on the initial probability vectors P i  and the feedback probability vectors P f . 
     In step  218 , the computation control module  150  grounds half or more of the entries of the updated probability vectors P u  based on d. For example, if d=1 (i.e., group size k−1), the computation control module  150  may ground the bottom (i.e., last) half of the entries of the updated probability vectors P u  which correspond to the k th  bit. In step  220 , the computation control module  150  generates the bit estimations P(x) based on the updated probability vectors P u , and control ends. 
     Referring now to  FIG. 8A , a functional block diagram of a second embodiment of the computation control module  250  is shown. The computation control module  250  may reuse unused or idling adders for processing of multiple groups of less than k bits in size. Furthermore, computation control module  250  may disable unused computation modules in order to save power. For example, one computation module that may process k bits may also process two groups of k−1 bits by rerouting adders with multiplexers. Thus, the computation control module  250  may provide for constant adder utilization. 
     The computation control module  250  may include a distribution module  260 . The computation control module  250  may also include b parallel computation modules  270 - 1 ,  270 - 2 , . . . ,  270 - b  (collectively referred to as computation modules  270 ). Each of the computation modules  270  may include an updating module  280  and an estimation module  290 . For example, each of the computation modules  270  may process up to k bits per cycle. Each of the computation modules  270  may also include multiplexers (not shown) to reroute adders for processing of multiple groups of less than k bits in size. 
     The distribution module  260  receives the b initial probability vectors P 0 , P 1 , . . . , P b−1  (collectively referred to as initial probability vectors P i ). The distribution module  260  also receives the b×k feedback signals P f (x 0,0 ), P f (x 0,1 ), . . . , P f (x b− 1,k−1) (collectively referred to as feedback signals P f (x)). The distribution module  260  may distribute the initial probability vectors P i  and the corresponding feedback signals P f (x) to the computation modules  270  for processing. 
     However, if the computation control module  250  is processing groups of less than k bits (i.e., k−1, k−2, etc.), adders in each of the computation modules  270  may be rerouted using multiplexers and reused. In one implementation, the computation modules  270  may process more than one group of less than k bits in one cycle. The computation control module  250  may then disable any unused computation modules  270  after distributing the b groups in order to save power. 
     For example, two groups of k−1 bits may be processed using one of the computation modules  270 . A feedback probability vector P f  may be rearranged to illustrate the symmetry that allows for processing of two groups of k−1 bits: 
     
       
         
           
             
               P 
               f 
             
             = 
             
               
                 P 
                 f 
                 
                   
                     2 
                     k 
                   
                   - 
                   1 
                 
               
               = 
               
                 
                   [ 
                   
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               0 
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               1 
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 1 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 0 
                               
                               ) 
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               2 
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         ⋮ 
                       
                     
                     
                       
                         
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 
                                   k 
                                   - 
                                   2 
                                 
                               
                               ) 
                             
                           
                           + 
                           … 
                           + 
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 1 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 0 
                               
                               ) 
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               
                                 k 
                                 - 
                                 1 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 
                                   k 
                                   - 
                                   1 
                                 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 0 
                               
                               ) 
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             P 
                             f 
                           
                           ( 
                           
                             
                               x 
                               
                                 k 
                                 - 
                                 1 
                               
                             
                             + 
                             
                               
                                 P 
                                 f 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   x 
                                   1 
                                 
                                 ) 
                               
                             
                             + 
                             
                               
                                 P 
                                 f 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   x 
                                   0 
                                 
                                 ) 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 
                                   k 
                                   - 
                                   1 
                                 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 2 
                               
                               ) 
                             
                           
                         
                       
                     
                     
                       
                         ⋮ 
                       
                     
                     
                       
                         
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 
                                   k 
                                   - 
                                   1 
                                 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 
                                   k 
                                   - 
                                   2 
                                 
                               
                               ) 
                             
                           
                           + 
                           … 
                           + 
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 1 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 0 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                   ] 
                 
                 = 
                 
                     
                   
                     
                       [ 
                       
                           
                       
                       ⁢ 
                       
                         
                           
                             
                                 
                             
                           
                         
                         
                           
                             
                                 
                             
                           
                         
                         
                           
                             
                               P 
                               f 
                               
                                 
                                   2 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                 
                                 - 
                                 1 
                               
                             
                           
                         
                         
                           
                             
                                 
                             
                           
                         
                         
                           
                             
                                 
                             
                           
                         
                         
                           
                             
                               
                                 P 
                                 f 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   x 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                 
                                 ) 
                               
                             
                           
                         
                         
                           
                             
                               
                                 [ 
                                 
                                   
                                     
                                       
                                         
                                           P 
                                           f 
                                         
                                         ⁡ 
                                         
                                           ( 
                                           
                                             x 
                                             
                                               k 
                                               - 
                                               1 
                                             
                                           
                                           ) 
                                         
                                       
                                     
                                   
                                   
                                     
                                       
                                         
                                           P 
                                           f 
                                         
                                         ⁡ 
                                         
                                           ( 
                                           
                                             x 
                                             
                                               k 
                                               - 
                                               1 
                                             
                                           
                                           ) 
                                         
                                       
                                     
                                   
                                   
                                     
                                       ⋮ 
                                     
                                   
                                   
                                     
                                       
                                         
                                           P 
                                           f 
                                         
                                         ⁡ 
                                         
                                           ( 
                                           
                                             x 
                                             
                                               k 
                                               - 
                                               1 
                                             
                                           
                                           ) 
                                         
                                       
                                     
                                   
                                 
                                 ] 
                               
                               + 
                               
                                 P 
                                 f 
                                 
                                   
                                     2 
                                     
                                       k 
                                       - 
                                       1 
                                     
                                   
                                   - 
                                   1 
                                 
                               
                             
                           
                         
                       
                       ] 
                     
                     , 
                   
                 
               
             
           
         
       
     
     
       
         
           
             
               P 
               f 
               
                 
                   2 
                   
                     k 
                     - 
                     1 
                   
                 
                 - 
                 1 
               
             
             = 
             
               
                 [ 
                 
                   
                     
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             0 
                           
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             1 
                           
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               1 
                             
                             ) 
                           
                         
                         + 
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               0 
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       
                         
                           P 
                           f 
                         
                         ⁡ 
                         
                           ( 
                           
                             x 
                             2 
                           
                           ) 
                         
                       
                     
                   
                   
                     
                       ⋮ 
                     
                   
                   
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               
                                 k 
                                 - 
                                 2 
                               
                             
                             ) 
                           
                         
                         + 
                         … 
                         + 
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               1 
                             
                             ) 
                           
                         
                         + 
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               0 
                             
                             ) 
                           
                         
                       
                     
                   
                 
                 ] 
               
               . 
             
           
         
       
     
     An additional 2 k −1 adders are required to evaluate: 
     
       
         
           
             
               [ 
               
                 
                   
                     
                       
                         P 
                         f 
                       
                       ⁡ 
                       
                         ( 
                         
                           x 
                           
                             k 
                             - 
                             1 
                           
                         
                         ) 
                       
                     
                   
                 
                 
                   
                     
                       
                         P 
                         f 
                       
                       ⁡ 
                       
                         ( 
                         
                           x 
                           
                             k 
                             - 
                             1 
                           
                         
                         ) 
                       
                     
                   
                 
                 
                   
                     ⋮ 
                   
                 
                 
                   
                     
                       
                         P 
                         f 
                       
                       ⁡ 
                       
                         ( 
                         
                           x 
                           
                             k 
                             - 
                             1 
                           
                         
                         ) 
                       
                     
                   
                 
               
               ] 
             
             + 
             
               
                 P 
                 f 
                 
                   
                     2 
                     
                       k 
                       - 
                       1 
                     
                   
                   - 
                   1 
                 
               
               . 
             
           
         
       
     
     In order for one of the computation modules  270  to process k−1 bits, a vector of feedback signals P f (x) corresponding to the k th  bit may be grounded. This process was described previously in the first embodiment of the computation control module  150 . Therefore, the 2 k −1 adders no longer being used may be re-routed using multiplexers to evaluate another group of k−1 bits. In one implementation, a feedback probability vector P f  may be generated as a combination of two groups of bits b 0  and b 1 : 
     
       
         
           
             
               P 
               f 
             
             = 
             
               
                 [ 
                 
                   
                     
                       
                         
                           P 
                           f 
                           
                             
                               2 
                               
                                 k 
                                 - 
                                 1 
                               
                             
                             - 
                             1 
                           
                         
                         
                           , 
                           
                             b 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             0 
                           
                         
                       
                     
                   
                   
                     
                       0 
                     
                   
                   
                     
                       
                         
                           P 
                           f 
                           
                             
                               2 
                               
                                 k 
                                 - 
                                 1 
                               
                             
                             - 
                             1 
                           
                         
                         
                           , 
                           
                             b 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             1 
                           
                         
                       
                     
                   
                 
                 ] 
               
               . 
             
           
         
       
     
     Thus, a corresponding initial probability vector P i  may be rearranged for vector addition with P f  in order to generate an updated probability vector P u , thus reusing the 2 k −1 adders that may be idling: 
     
       
         
           
             
               P 
               t 
             
             = 
             
               
                 [ 
                 
                   
                     
                       
                         P 
                         
                           i 
                           , 
                           
                             k 
                             - 
                             1 
                           
                           , 
                           
                             b 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             0 
                           
                         
                       
                     
                   
                   
                     
                       0 
                     
                   
                   
                     
                       
                         P 
                         
                           i 
                           , 
                           
                             k 
                             - 
                             1 
                           
                           , 
                           
                             b 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             1 
                           
                         
                       
                     
                   
                 
                 ] 
               
               . 
             
           
         
       
     
     The rearrangement of data may result in partial terms being divided between the two groups b 0  and b 1  when evaluating the bit estimations P(x): 
     
       
         
           
             
               
                 max 
                 ⁡ 
                 
                   ( 
                   
                     
                       
                         P 
                         u 
                       
                       
                         
                           
                             a 
                             t 
                           
                           = 
                           1 
                         
                         , 
                         
                           
                             a 
                             k 
                           
                           = 
                           1 
                         
                       
                     
                     ⁡ 
                     
                       ( 
                       
                         a 
                         1 
                         k 
                       
                       ) 
                     
                   
                   ) 
                 
               
               ⁢ 
               
                 | 
                 k 
               
             
             -&gt; 
             
               
                 
                   max 
                   ⁡ 
                   
                     ( 
                     
                       
                         
                           P 
                           u 
                         
                         
                           
                             
                               a 
                               t 
                             
                             = 
                             1 
                           
                           , 
                           
                             b 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             0 
                           
                         
                       
                       ⁡ 
                       
                         ( 
                         
                           a 
                           1 
                           
                             k 
                             - 
                             1 
                           
                         
                         ) 
                       
                     
                     ) 
                   
                 
                 ⁢ 
                 
                   | 
                   
                     k 
                     - 
                     1 
                   
                 
                 ⁢ 
                 
                   
 
                 
                 ⁢ 
                 
                   max 
                   ⁡ 
                   
                     ( 
                     
                       
                         
                           P 
                           u 
                         
                         
                           
                             
                               a 
                               t 
                             
                             = 
                             1 
                           
                           , 
                           
                             
                               a 
                               k 
                             
                             = 
                             1 
                           
                         
                       
                       ⁡ 
                       
                         ( 
                         
                           a 
                           1 
                           k 
                         
                         ) 
                       
                     
                     ) 
                   
                 
                 ⁢ 
                 
                   | 
                   k 
                 
               
               -&gt; 
               
                 
                   
                     max 
                     ⁡ 
                     
                       ( 
                       
                         
                           
                             P 
                             u 
                           
                           
                             
                               
                                 a 
                                 t 
                               
                               = 
                               1 
                             
                             , 
                             
                               b 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               1 
                             
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             a 
                             1 
                             
                               k 
                               - 
                               1 
                             
                           
                           ) 
                         
                       
                       ) 
                     
                   
                   ⁢ 
                   
                     | 
                     
                       k 
                       - 
                       1 
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     max 
                     ⁡ 
                     
                       ( 
                       
                         
                           
                             P 
                             u 
                           
                           
                             
                               
                                 a 
                                 t 
                               
                               = 
                               0 
                             
                             , 
                             
                               
                                 a 
                                 k 
                               
                               = 
                               0 
                             
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             a 
                             1 
                             k 
                           
                           ) 
                         
                       
                       ) 
                     
                   
                   ⁢ 
                   
                     | 
                     k 
                   
                 
                 -&gt; 
                 
                   
                     
                       max 
                       ⁡ 
                       
                         ( 
                         
                           
                             
                               P 
                               u 
                             
                             
                               
                                 
                                   a 
                                   t 
                                 
                                 = 
                                 0 
                               
                               , 
                               
                                 b 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 0 
                               
                             
                           
                           ⁡ 
                           
                             ( 
                             
                               a 
                               1 
                               
                                 k 
                                 - 
                                 1 
                               
                             
                             ) 
                           
                         
                         ) 
                       
                     
                     ⁢ 
                     
                       | 
                       
                         k 
                         - 
                         1 
                       
                     
                     ⁢ 
                     
                       
 
                     
                     ⁢ 
                     
                       max 
                       ⁡ 
                       
                         ( 
                         
                           
                             
                               P 
                               u 
                             
                             
                               
                                 
                                   a 
                                   t 
                                 
                                 = 
                                 0 
                               
                               , 
                               
                                 
                                   a 
                                   k 
                                 
                                 = 
                                 1 
                               
                             
                           
                           ⁡ 
                           
                             ( 
                             
                               a 
                               1 
                               k 
                             
                             ) 
                           
                         
                         ) 
                       
                     
                     ⁢ 
                     
                       | 
                       k 
                     
                   
                   -&gt; 
                   
                     
                       max 
                       ⁡ 
                       
                         ( 
                         
                           
                             
                               P 
                               u 
                             
                             
                               
                                 
                                   a 
                                   t 
                                 
                                 = 
                                 0 
                               
                               , 
                               
                                 b 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 1 
                               
                             
                           
                           ⁡ 
                           
                             ( 
                             
                               a 
                               1 
                               
                                 k 
                                 - 
                                 1 
                               
                             
                             ) 
                           
                         
                         ) 
                       
                     
                     ⁢ 
                     
                       | 
                       
                         k 
                         - 
                         1 
                       
                     
                     . 
                   
                 
               
             
           
         
       
     
     Additionally, a comparator used to evaluate max[max(P u0 ,P u2 )| k −max(P u4 ,P u6 )| k ] may be re-routed to evaluate [max(P u0 ,P u2 )−max( 0 , P u1 )]| k−1 . The same strategy may be applied for evaluating other bit estimations P(x) for both groups b 0  and b 1 . The number of bits processed per cycle (i.e., the number of bit estimations P(x) generated) may approximately double for every integer decrement in group size. In other words, b×k| k ˜2b×k−2b| k−1 ˜4b×k−8b| k−2 . 
     Referring now to  FIG. 8B , an exemplary adder and multiplexer configuration of an updating module  280  (i.e., part of a computation module) that may process both k=3 bits and two sets of k−1=2 bits is shown. The updating module  280  may generate a feedback probability vector P f  for either sized group. The multiplexers  292 ,  294 ,  296  enable and/or disable (i.e., reroute) adders based on whether one group of k=3 bits or two groups of k−1=2 bits are being processed. 
     For example, a low (e.g., 0) multiplexer control enables processing for one group of k=3 bits. The updating module  280  may set P f (x 0,0 ) to P f (x 0 ), P f (x 0,1 ) to P f (x 1 ), P f (x 0,2 ) to P f (x 2 ), and thus may not use P f (x 0,3 ): 
     
       
         
           
             
               
                 P 
                 
                   f 
                   , 
                   
                     k 
                     = 
                     3 
                   
                 
               
               = 
               
                 
                   P 
                   f 
                   
                     
                       2 
                       2 
                     
                     - 
                     1 
                   
                 
                 = 
                 
                   [ 
                   
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               0 
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               1 
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 1 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 0 
                               
                               ) 
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               2 
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 2 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 0 
                               
                               ) 
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 2 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 1 
                               
                               ) 
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 2 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 1 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 0 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                   ] 
                 
               
             
             , 
           
         
       
     
     For example, a high (e.g., 1) multiplexer control enables processing for two groups of k−1=2 bits. Thus, the updating module  280  effectively sets the following inputs: 
     
       
         
           
             
               
                 P 
                 f 
               
               ⁡ 
               
                 ( 
                 
                   x 
                   0 
                 
                 ) 
               
             
             = 
             
               
                 P 
                 f 
               
               ⁡ 
               
                 ( 
                 
                   x 
                   
                     0 
                     , 
                     
                       b 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       0 
                     
                   
                 
                 ) 
               
             
           
         
       
       
         
           
             
               
                 P 
                 f 
               
               ⁡ 
               
                 ( 
                 
                   x 
                   1 
                 
                 ) 
               
             
             = 
             
               
                 P 
                 f 
               
               ⁡ 
               
                 ( 
                 
                   x 
                   
                     1 
                     , 
                     
                       b 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       0 
                     
                   
                 
                 ) 
               
             
           
         
       
       
         
           
             
               
                 P 
                 f 
               
               ⁡ 
               
                 ( 
                 
                   x 
                   2 
                 
                 ) 
               
             
             = 
             
               
                 P 
                 f 
               
               ⁡ 
               
                 ( 
                 
                   x 
                   
                     0 
                     , 
                     
                       b 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       1 
                     
                   
                 
                 ) 
               
             
           
         
       
       
         
           
             
               
                 
                   P 
                   f 
                 
                 ⁡ 
                 
                   ( 
                   
                     x 
                     3 
                   
                   ) 
                 
               
               = 
               
                 
                   P 
                   f 
                 
                 ⁡ 
                 
                   ( 
                   
                     x 
                     
                       1 
                       , 
                       
                         b 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         1 
                       
                     
                   
                   ) 
                 
               
             
             , 
           
         
       
     
     
       
         
           
             
               
                 P 
                 i 
               
               ⁡ 
               
                 ( 
                 
                   x 
                   0 
                 
                 ) 
               
             
             = 
             
               P 
               
                 
                   i 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   0 
                 
                 , 
                 
                   b 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   0 
                 
               
             
           
         
       
       
         
           
             
               
                 P 
                 i 
               
               ⁡ 
               
                 ( 
                 
                   x 
                   1 
                 
                 ) 
               
             
             = 
             
               P 
               
                 
                   i 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   1 
                 
                 , 
                 
                   b 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   0 
                 
               
             
           
         
       
       
         
           
             
               
                 P 
                 i 
               
               ⁡ 
               
                 ( 
                 
                   x 
                   2 
                 
                 ) 
               
             
             = 
             
               P 
               
                 
                   i 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   2 
                 
                 , 
                 
                   b 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   0 
                 
               
             
           
         
       
       
         
           
             
               
                 P 
                 i 
               
               ⁡ 
               
                 ( 
                 
                   x 
                   3 
                 
                 ) 
               
             
             = 
             0 
           
         
       
       
         
           
             
               
                 P 
                 i 
               
               ⁡ 
               
                 ( 
                 
                   x 
                   4 
                 
                 ) 
               
             
             = 
             
               P 
               
                 
                   i 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   0 
                 
                 , 
                 
                   b 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   1 
                 
               
             
           
         
       
       
         
           
             
               
                 P 
                 i 
               
               ⁡ 
               
                 ( 
                 
                   x 
                   5 
                 
                 ) 
               
             
             = 
             
               P 
               
                 
                   i 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   1 
                 
                 , 
                 
                   b 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   1 
                 
               
             
           
         
       
       
         
           
             
               
                 P 
                 i 
               
               ⁡ 
               
                 ( 
                 
                   x 
                   6 
                 
                 ) 
               
             
             = 
             
               
                 P 
                 
                   
                     i 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     2 
                   
                   , 
                   
                     b 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     1 
                   
                 
               
               . 
             
           
         
       
     
     Therefore, the updating module  280  may rearrange initial probability vector P i  and feedback probability vector P f  for vector addition to generate P u  for two groups of k−1=2 bits: 
     
       
         
           
             
               
                 P 
                 
                   f 
                   , 
                   
                     
                       k 
                       - 
                       1 
                     
                     = 
                     
                       2 
                       
                         , 
                         
                           b 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           0 
                         
                         , 
                         
                           b 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           1 
                         
                       
                     
                   
                 
               
               = 
               
                 
                   [ 
                   
                     
                       
                         
                             
                         
                       
                     
                     
                       
                         
                           P 
                           
                             f 
                             , 
                             
                               
                                 k 
                                 - 
                                 1 
                               
                               = 
                               
                                 2 
                                 
                                   , 
                                   
                                     b 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     0 
                                   
                                 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                             
                         
                       
                     
                     
                       
                         0 
                       
                     
                     
                       
                         
                             
                         
                       
                     
                     
                       
                         
                           P 
                           
                             f 
                             , 
                             
                               
                                 k 
                                 - 
                                 1 
                               
                               = 
                               
                                 2 
                                 
                                   , 
                                   
                                     b 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     1 
                                   
                                 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                             
                         
                       
                     
                   
                   ] 
                 
                 = 
                 
                   [ 
                   
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               
                                 0 
                                 , 
                                 
                                   b 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   0 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               
                                 1 
                                 , 
                                 
                                   b 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   0 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 
                                   1 
                                   , 
                                   
                                     b 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     0 
                                   
                                 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 
                                   0 
                                   , 
                                   
                                     b 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     0 
                                   
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                     
                       
                         0 
                       
                     
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               
                                 0 
                                 , 
                                 
                                   b 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   1 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               
                                 1 
                                 , 
                                 
                                   b 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   1 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 
                                   1 
                                   , 
                                   
                                     b 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     1 
                                   
                                 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 
                                   0 
                                   , 
                                   
                                     b 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     1 
                                   
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                   ] 
                 
               
             
             , 
           
         
       
     
     
       
         
           
             
               P 
               
                 u 
                 , 
                 
                   
                     k 
                     - 
                     1 
                   
                   = 
                   
                     2 
                     
                       , 
                       
                         b 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         0 
                       
                       , 
                       
                         b 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         1 
                       
                     
                   
                 
               
             
             = 
             
               
                 
                   P 
                   
                     f 
                     , 
                     
                       
                         k 
                         - 
                         1 
                       
                       = 
                       
                         2 
                         
                           , 
                           
                             b 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             0 
                           
                           , 
                           
                             b 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             1 
                           
                         
                       
                     
                   
                 
                 + 
                 
                   P 
                   
                     i 
                     , 
                     
                       
                         k 
                         - 
                         1 
                       
                       = 
                       
                         2 
                         
                           , 
                           
                             b 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             0 
                           
                           , 
                           
                             b 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             1 
                           
                         
                       
                     
                   
                 
               
               = 
               
                 
                   [ 
                   
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               
                                 0 
                                 , 
                                 
                                   b 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   0 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               
                                 1 
                                 , 
                                 
                                   b 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   0 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 
                                   1 
                                   , 
                                   
                                     b 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     0 
                                   
                                 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 
                                   0 
                                   , 
                                   
                                     b 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     0 
                                   
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                     
                       
                         0 
                       
                     
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               
                                 0 
                                 , 
                                 
                                   b 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   1 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           
                             P 
                             f 
                           
                           ⁡ 
                           
                             ( 
                             
                               x 
                               
                                 1 
                                 , 
                                 
                                   b 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   1 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 
                                   1 
                                   , 
                                   
                                     b 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     1 
                                   
                                 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               P 
                               f 
                             
                             ⁡ 
                             
                               ( 
                               
                                 x 
                                 
                                   0 
                                   , 
                                   
                                     b 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     1 
                                   
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                   ] 
                 
                 + 
                 
                   
                     [ 
                     
                       
                         
                           
                             P 
                             
                               
                                 i 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 0 
                               
                               , 
                               
                                 b 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 0 
                               
                             
                           
                         
                       
                       
                         
                           
                             P 
                             
                               
                                 i 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 1 
                               
                               , 
                               
                                 b 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 0 
                               
                             
                           
                         
                       
                       
                         
                           
                             P 
                             
                               
                                 i 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 2 
                               
                               , 
                               
                                 b 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 0 
                               
                             
                           
                         
                       
                       
                         
                           0 
                         
                       
                       
                         
                           
                             P 
                             
                               
                                 i 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 0 
                               
                               , 
                               
                                 b 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 1 
                               
                             
                           
                         
                       
                       
                         
                           
                             P 
                             
                               
                                 i 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 1 
                               
                               , 
                               
                                 b 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 1 
                               
                             
                           
                         
                       
                       
                         
                           
                             P 
                             
                               
                                 i 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 2 
                               
                               , 
                               
                                 b 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 1 
                               
                             
                           
                         
                       
                     
                     ] 
                   
                   . 
                 
               
             
           
         
       
     
     Referring now to  FIG. 8C , a flow diagram illustrating steps performed by the second embodiment of the computation control module  250  begins in step  300 . In step  302 , the computation control module  250  determines the size of the b groups being processed. If the size is the maximum size k, control proceeds to step  304 . If the size is less than k, control proceeds to step  310 . 
     In step  304 , the computation control module  250  begins processing the b groups of k bits using an entire 2 k −1 vector operations (i.e., all adders of the computation modules). The computation control module  250  generates the feedback probability vectors P f  based on the feedback signals P f (x). 
     In step  306 , the computation control module  250  generates the updated probability vectors P u  based on the initial probability vectors P i  and the feedback probability vectors P f . In step  308 , the computation control module  250  generates the bit estimations P(x) based on the updated probability vectors P u  and control ends. 
     In step  310 , the computation control module  250  determines the difference d between k and the number of bits in each of the b groups. In step  312 , the computation control module  250  distributes the b groups to the computation modules for processing based on d. For example, if d=1 (i.e., group size k−1) then the computation control module  250  may distribute two k−1 groups each one computation module to be processed concurrently. 
     In step  314 , the computation control module  250  disables any unused computation modules. For example, disabling unused computation modules may save power. In step  316 , the computation control module  250  generates the feedback probability vectors P f  based on the feedback signals P f (x). 
     In step  318 , the computation control module  250  generates the updated probability vectors P u  based on the initial probability vectors P i  and the feedback probability vectors P f . In step  320 , the computation control module  250  generates the bit estimations P(x) based on the updated probability vectors P u , and control ends. 
     Referring now to  FIG. 9A , a functional block diagram of a third embodiment of the computation control module  350  is shown. The computation control module  350  may interleave and redistribute bits for processing to different computation modules based on the group sizes being processed. Furthermore, the computation control module  350  may disable unused computation modules in order to save power. Thus, the computation control module  350  may provide for a constant number of bits to be processed per cycle (i.e., a constant bit-throughput). 
     The computation control module  350  may include an interleaving module  360 . The computation control module  350  may also include b parallel computation modules  370 - 1 ,  370 - 2 , . . . ,  370 - b  (collectively referred to as computation modules  370 ). For example, each of the computation modules  370  may include an updating module  380  and an estimation module  390 . The computation control module  350  may further include a deinterleaving module  400 . 
     To achieve a constant bit-throughput and/or to use the same interleaving module  360  and deinterleaving module  400  to support of both k and k−1 bits, a constraint may be necessary:
 
 b   k×k=2   ×b   k−1 ×( k− 1).
 
b k  represents a number of computation modules  370  processing b groups of k bits each. b k−1  represents a number of computation modules  370  processing b groups of k−1 bits each. k is the maximum numbers of bits that may be processed by each of the computation modules  370  per cycle.
 
     For example, four computation modules  370  may be used to process three bits each (b k =4, k=3) and the three of those four computation modules  370  may be used to process two groups of two bits each (b k−1 =3). In other words, 4×3=2×3×2 (i.e., 12=12), and the constraint is satisfied. 
     The interleaving module  360  may receive feedback signals P f (x 0,0 ), P f (x 0,1 ), . . . , P f (x b− 1,k−1) (collectively referred to as feedback signals P f (x)) corresponding to each of the k bits in each of the b groups. The interleaving module  360  may perform interleaving on the received data P f (x). Interleaving is a process of rearranging the bits of a signal that may be used to improve error correction. 
     For example, errors that occur in a transmission may tend to be focused over a span of a few bits and therefore may be referred to as a burst error. Thus, by interleaving the received signal, there may be a higher probability that all the incorrect bits may be corrected, as compared to a probability of consecutive incorrect bits being corrected. 
     In one implementation, the interleaving module  360  may rearrange the received data and may output the data in a non-linear way. For example, the interleaver may receive P f (x 0,0 ), P f (x 0,1 ), P f (x 0,2 ) and output P f (x 0,2 ), P f (x 0,0 ), and P f (x 0,1 ), in those orders. Therefore, if bits  2  and  3  (x 0,1  and x 0,2 , respectively) are incorrect, there may be a higher probability of correcting the bits because the bits are no longer grouped together (e.g., consecutively). 
     The interleaving module  360  may output the feedback signals P f (x) after interleaving. However, if the computation control module  350  is processing groups of less than k bits in size, the interleaving module  360  may re-route some feedback signals P f (x) to other computation modules  370 . In one implementation, if a computation module  370  is processing two groups of k−1 bits, the corresponding feedback signals P f (x) for that second group of k−1 bits may be rerouted. After re-routing data, any computation modules  370  that are not being used may be disabled. For example, disabling unused computation modules  370  may save power. 
     The computation modules  370  generate bit estimations P(x) based on the b groups of bits as shown in previous implementations. The computation control module  350  may reroute the bit estimations P(x) before deinterleaving. The deinterleaving module  400  receives the bit estimations P(x). The deinterleaving module  400  may output the bit estimations P(x) in a correct linear sequence (i.e., in order) after deinterleaving. Deinterleaving is an inverse process of interleaving. In one implementation, the deinterleaving module  400  may receive P(x 0,2 ), P(x 0,0 ), P(x 0,1 ) and output P(x 0,0 ), P(x 0,1 ), P(x 0,2 ), in those orders. 
     Referring now to  FIG. 9B , an exemplary configuration of the third embodiment of the computation control module  450  is shown. The computation control module  450  includes an interleaving module  460 , four computation modules  470 - 1 ,  470 - 2 ,  470 - 3 ,  470 - 4  (collectively referred to as computation modules  470 ), and a deinterleaving module  480 . For example, each computation module  470  may include an updating module  490  and an estimation module  500 . 
     In one implementation, the computation control module  450  may achieve a constant 12 bit-throughput. In other words, the computation control module  450  may process 12 bits per cycle. For example, the computation control module may process correlated bit groups of size k=3 and k−1=2. 
     If the computation control module  450  is processing groups of size k=3, each of the computation modules  470  may process a full k bits each. However, if the computation control module  450  is processing groups of size k−1 (i.e., k−1=2), computation modules  470 - 1 ,  470 - 2 , and  470 - 3  may each process two groups of two bits each. 
     The computation control module  450  may then disable computation module  470 - 4 . For example, disabling computation module  470 - 4  may save power. However, the computation control module  450  may re-route the feedback signals P f (x) from computation module  470 - 4  to computation modules  470 - 1 ,  470 - 2 ,  470 - 3  that are now processing the corresponding bit(s). 
     The computation modules  470 - 1 ,  470 - 2 , and  470 - 3  generate the bit estimations P(x). The computation control module  450  may reroute the bit estimations P(x) before deinterleaving. The deinterleaving module  480  receives the bit estimations P(x) and deinterleaves them to output the correct bit estimations P(x) (i.e., in order). 
     Referring now to  FIG. 9C , a flow diagram illustrating steps performed by the third embodiment of the computation control module  350  begins in step  550 . In step  552 , the computation control module  350  determines whether the constraint has been satisfied. If yes, control proceeds to step  554 . If no, control returns to step  552 . 
     In step  554 , the computation control module  350  determines the sizes of the b groups being processed. If the size is the maximum size k, control proceeds to step  556 . If the size is less than k, control proceeds to step  566 . 
     In step  556 , the computation control module  350  deinterleaves the feedback signals P f (x). In step  558 , the computation control module  350  begins processing the b groups of k bits using an entire 2 k −1 vector operations (i.e., all adders of the computation modules). The computation control module  350  generates the feedback probability vectors P f  based on the feedback signals P f (x). 
     In step  560 , the computation control module  350  generates the updated probability vectors P u  based on the initial probability vectors P i  and the feedback probability vectors P f . In step  562 , the computation control module  350  generates the bit estimations P(x) based on the updated probability vectors P u . In step  564 , the computation control module  350  deinterleaves the bit estimations P(x) and control ends. 
     In step  566 , the computation control module  350  determines the difference d between k and the number of bits in each of the b groups. In step  568 , the computation control module  350  interleaves the feedback signals P f (x) and distributes the b groups to the computation modules for processing based on d. For example, if d=1 (i.e., group size k−1) then the computation control module  350  may distribute two k−1 groups to each computation module to be processed concurrently. 
     In step  570 , the computation control module  350  reroutes feedback signals P f (x) from unused computation modules to the computation modules processing the corresponding bit(s). The computation control module  350  also disables any unused computation modules. For example, disabling unused computation modules may save power. 
     In step  572 , the computation control module  350  generates the feedback probability vectors P f  based on the feedback signals P f (x). In step  574 , the computation control module  350  generates the updated probability vectors P u  based on the initial probability vectors P i  and the feedback probability vectors P f . In step  576 , the computation control module  350  generates the bit estimations P(x) based on the updated probability vectors P. In step  578 , the computation control module  350  reroutes the bit estimations P(x) to the correct inputs of the deinterleaving module  480 . The computation control module  350  then deinterleaves the bit estimations P(x) and control ends. 
     The broad teachings of the disclosure can be implemented in a variety of forms. Therefore, while this disclosure includes particular examples, the true scope of the disclosure should not be so limited since other modifications will become apparent upon a study of the drawings, the specification, and the following claims.