Abstract:
An embodiment of the invention relates to a method of determining an optimum sequence of algorithms, wherein each algorithm defines a receiver function of a receiver, which has a plurality of receiver functions and which is adapted to receive bits sent by a transmitter.

Description:
[0001]    The present invention relates to receivers, and more particularly to algorithms defining receiver functions and sequences of such algorithms. 
       BACKGROUND OF THE INVENTION 
       [0002]    In order to determine an optimum sequence of algorithms for receiver functions, many different approaches are discussed in the literature, from stochastic decoding analysis to convergence prediction of iterative MIMO (multiple inputs, multiple outputs) detection-decoding. 
         [0003]    Iterative detection-decoding for coded MIMO transmission is known capable of achieving near-capacity performance [1]. The usage of iterative processing naturally leads to the question of convergence. 
         [0004]    Extrinsic information transfer charts (EXIT charts) are widely used for predicting and illustrating convergence of iterative decoding of concatenated codes [2], [3]. The model underlying the chart assumes that the log-likelihood ratios (LLRs) of the transmit bit values are distributed after the symbol demapper according to BPSK transmission over an AWGN (AWGN: additive white Gaussian noise) channel resulting in a 1-parametric conditional Gaussian distribution (conditioned on the transmit bit value). EXIT charts have also been used to model convergence of iterative MIMO detection-decoding. In document [4] they are applied to optimize irregular repeat accumulate codes for MIMO transmission and iterative receiver processing. An optimization of Turbo coded space-time block code transmission based on EXIT charts is presented in [5]. Documents [6, 7] uses EXIT charts to analyse and optimize MIMO transmission with low-density parity-check codes. 
       OBJECTIVE OF THE PRESENT INVENTION 
       [0005]    An objective of the present invention is to provide a method of determining an optimum sequence of algorithms, wherein each algorithm defines a receiver function of a receiver. 
         [0006]    A further objective of the present invention is to provide a method for manufacturing a receiver, wherein an optimum sequence of algorithms is determined and implemented in receiver hardware and/or software. 
         [0007]    Another objective of the present invention is to provide a method for simulating sequences of algorithms in order to determine an optimum sequence. 
       BRIEF SUMMARY OF THE INVENTION 
       [0008]    An embodiment of the invention relates to a method of determining an optimum sequence of algorithms, each algorithm defining a receiver function of a receiver, which has a plurality of receiver functions and which is adapted to receive bits sent by a transmitter, the method comprising the steps of: 
         [0009]    (a) for each receiver function, picking an algorithm out of a predefined group of algorithms available for the respective receiver function, and virtually combining predefined models of the picked algorithms in order to model the receiver, wherein each predefined model is capable of mapping at least one input probability density to at least one output probability density, and wherein said combined models form a sequence of model algorithms; 
         [0010]    (b) determining an input probability density based on a predefined signal-to-noise ratio, said input probability density indicating the probability density of values received by the receiver at the predefined signal-to-noise ratio; 
         [0011]    (c) inputting the input probability density to said sequence of model algorithms; 
         [0012]    (d) determining the output probability density at the output of said sequence of model algorithms, said output probability density indicating the bit density of the bits sent by the transmitter; 
         [0013]    (e) determining the bit-error rate of the receiver for said sequence of model algorithms based on said output probability density; 
         [0014]    (f) repeating steps (a)-(e) for all algorithms comprised by said predefined groups of algorithms for all receiver functions; and 
         [0015]    (g) determining the optimum sequence of algorithms taking the bit-error rates of the sequences of model algorithms into account. 
         [0016]    An advantage of this embodiment of the invention is that the optimum sequence of algorithms for a specific receiver may be determined based on predefined models of algorithms, only. Instead of carrying out a complete simulation of each algorithm and each sequence of algorithms in its entirety, the embodiment of the invention considers algorithm models which provide limited functionality and which are preferably merely capable of mapping input probability densities to output probability densities like the algorithms they model. As such, an optimum sequence of algorithms may be found faster and with less simulation effort than on the basis of a complete simulation of all aspects of each algorithm. 
         [0017]    According to a preferred embodiment a total receiver complexity value is determined by adding algorithm complexity values of all algorithms picked in step (a), wherein in step (g), the total receiver complexity values of the picked algorithms are taken into account for determining the optimum set of algorithms. 
         [0018]    Further, the algorithms picked in step (a) may be combined to generate a preliminary sequence of algorithms; and a delay time may be determined for each preliminary sequence of algorithms; and in step (g) the step of determining the optimum set of algorithms may further take the delay time of each preliminary sequence of algorithms into account. 
         [0019]    Furthermore, a set of signal-to-noise ratios may be predefined. Then, steps (a)-(g) may be repeated for all signal-to-noise ratios of said set of signal-to-noise ratios, and the optimum sequence of algorithms may be determined taking at least the signal-to-noise ratios and the respective bit-error rates into account. 
         [0020]    Preferably, groups of algorithms are taken into account for at least one of the following receiver functions: decoding, mapping, demapping, and channel estimation. 
         [0021]    The step of forming said sequence of model algorithms may include combing the model algorithms in a parallel and/or a serial fashion. 
         [0022]    According to a further preferred embodiment, the input and output probability densities may each be defined by a mean value and a variance of a 2-parametric Gaussian density function. A 2-parametric Gaussian density may be used to model bit densities by describing mean and variance of the density of their log-likelihood ratios or log-probability ratios conditioned on the transmit bit value. 
         [0023]    A 2-parametric Gaussian density may be used to describe the probability density of complex random variables in channel estimation and estimation of transmit symbols by determining mean value and variance. 
         [0024]    The model of an algorithm as mapping from input probability densities to output probability densities may be obtained as analytic formula or by Monte-Carlo simulation of this algorithm or semi-analytically. 
         [0025]    The probability density of the received values as ‘evidence’ in dependence on SNR (signal to noise ratio), as input to an algorithm sequence, may also be determined as analytic formula or by Monte-Carlo simulation using a channel model, or semi-analytically. 
         [0026]    Preferably, the model of at least one algorithm of at least one receiver function accounts for MIMO (multiple input-multiple output) reception. In particular, the model of at least one demapping algorithm, at least one channel estimation algorithm, and/or at least one mapping algorithm may account for MIMO reception. 
         [0027]    According to a further preferred embodiment, an individual name may be assigned to each possible combination of receiver function and algorithm/algorithm model. Then, the sequence of model algorithms may be defined by a vector comprising the names as vector elements, and the search for determining the optimum sequence may be based on said vectors. 
         [0028]    Each name preferably forms a word of a description language. The description language is preferably regular. 
         [0029]    The search space for determining the optimum sequence of algorithms may be defined by a plurality of operations applied to the names and/or vectors. 
         [0030]    Furthermore, the optimum sequence of algorithms may be determined taking at least two users into account, wherein an individual signal-to-noise ratio is assigned to each user and wherein at least one receiver function considers the individual signal-to-noise ratios of the at least two users. 
         [0031]    A further embodiment of the present invention relates to a method for manufacturing a receiver
       wherein an optimum sequence of algorithms is determined, each algorithm defining a receiver function of a receiver, which has a plurality of receiver functions and which is adapted to receive bits sent by a transmitter;   the algorithms of the optimum sequence are assigned to one or more processors; and   the algorithms of the optimum sequence are implemented in receiver hardware and/or receiver software.       
 
         [0035]    Preferably the step of determining the optimum sequence of algorithms comprises the steps of: 
         [0036]    (a) for each receiver function, picking an algorithm out of a predefined group of algorithms available for the respective receiver function, and virtually combining predefined models of the picked algorithms in order to model the receiver, wherein each predefined model is capable of mapping at least one input probability density to at least one output probability density, and wherein said combined models form a sequence of model algorithms; 
         [0037]    (b) determining an input probability density based on a predefined signal-to-noise ratio, said input probability density indicating the probability density of values received by the receiver at the predefined signal-to-noise ratio; 
         [0038]    (c) inputting the input probability density to said sequence of model algorithms; 
         [0039]    (d) determining the output probability density at the output of said sequence of model algorithms, said output probability density indicating the bit density of the bits sent by the transmitter; 
         [0040]    (e) determining the bit-error rate of the receiver for said sequence of model algorithms based on said output probability density; 
         [0041]    (f) repeating steps (a)-(e) for all algorithms comprised by said predefined groups of algorithms for all receiver functions; and 
         [0042]    (g) determining the optimum sequence of algorithms taking the bit-error rates of the sequences of model algorithms into account. 
         [0043]    According to a further preferred embodiment a total receiver delay time value may be determined based on the processing times of the algorithms during processing by said one or more processors. This total receiver delay time value resulting from the picked algorithms may also be taken into account for determining the optimum set of algorithms. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0044]    In order that the manner in which the above-recited and other advantages of the invention are obtained will be readily understood, a more particular description of the invention briefly described above will be rendered by reference to specific embodiments thereof which are illustrated in the appended figures and tables. Understanding that these figures and tables depict only typical embodiments of the invention and are therefore not to be considered to be limiting of its scope, the invention will be described and explained with additional specificity and detail by the use of the accompanying drawings in which 
           [0045]      FIG. 1  shows a factor graph for decoding of Turbo coded MIMO transmission, wherein the variable nodes (information bits u, parity bits c 1 , c 2 ) are vector-valued; 
           [0046]      FIG. 2  shows a LLR (log likelihood ratio) conditional probability density function for 4×4 QPSK (Quadrature Phase Shift Keying) MIMO transmission with uncorrelated Rayleigh fading and max-log-APP (a posteriori probability) demapping, wherein the corresponding conditional density according to the 1-parametric Gaussian model is shown: both densities have the same MI (mutual information) with the transmit bits; 
           [0047]      FIG. 3  shows a for the Rayleigh fading MIMO channel, wherein EXIT chart based prediction produces a large error; in  FIG. 3  (4×4 QPSK, max-log-APP demapper) the prediction error corresponds to more than 1 dB channel SNR, and the simulation uses maximum LTE (Long Term Evolution) packet length of 6144 information bits; 
           [0048]      FIG. 4  shows mapping LLR distribution parameters to mutual information, wherein the mutual information is determined by the ratio q of mean value and standard deviation, wherein ‘Full’ MI corresponds to BER (bit error rate) smaller 10 −4  achieved for q&gt;3.7, and wherein the 1-parametric model is included as special case and shown as curve in the MI surface; 
           [0049]      FIG. 5  shows a LLR probability density for positive transmit bits from the example in  FIG. 2 , and the corresponding 2-parametric Gaussian density, the two densities having the same mean and variance, but different MI (LLRs: 0.39; Gauss: 0.34); 
           [0050]      FIG. 6  shows a verifying MI prediction accuracy for predicted and measured MI for the three different schedules (packet length 6144 information bits); 
           [0051]      FIG. 7  shows a predicted and measured bit error rate for one example schedule, using very long packets (106 bits), wherein the curves for smaller packet length (6144 information bits) differ only insignificantly; 
           [0052]      FIG. 8  shows a factor graph of joint probability density, wherein variable nodes are circles, factor nodes are squares, and ‘Evidence’ y is shaded, and wherein all variable nodes are vectors, and H (t)  are matrices; 
           [0053]      FIG. 9  shows MU (multi user)-MIMO with joint MIMO demapping and separate decoding; 
           [0054]      FIG. 10  shows a table of a theoretically achievable cycle count for elementary operations on 128 bit wide Cell SPU (SPU: Synergistic processor unit) and SIMD (SIMD: single instruction, multiple data) parallel implementation; 
           [0055]      FIG. 11  shows an example search graph specifying the receiver design space (without channel estimation); 
           [0056]      FIG. 12  shows a computational effort of the considered signal processing blocks on Cell SPU; and 
           [0057]      FIG. 13  shows results for 4×4 QPSK (Quadrature Phase Shift Keying). 
       
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT 
       [0058]    The preferred embodiment of the present invention will be best understood by reference to the drawings, wherein identical or comparable parts are designated by the same reference signs throughout. 
         [0059]    It will be readily understood that the present invention, as generally described herein, could vary in a wide range. Thus, the following more detailed description of the exemplary embodiments of the present invention, is not intended to limit the scope of the invention, as claimed, but is merely representative of presently preferred embodiments of the invention. 
         [0060]    System model 
         [0061]    Considering standard processing at the transmitter for Turbo coded MIMO transmission: the information bit vector u to transmit is transformed into code word b by adding code bits c 1  of the first constituent encoder and code bits c 2  of the second constituent encoder. b i  is written for a single bit of the bit vector b at position i. At time instance t the symbol vector x (t)  is transmitted (as part of x) over channel matrix H (t) : 
         [0000]        y   (t)   =H   (t)   ·x   (t) ( b   (t) )+ n   (t) .   (1)
 
         [0062]    Concerning channel estimation, knowledge of channel matrices H (t)  and noise variance at the receiver is assumed as channel estimation is known per se. 
         [0063]    Optimum receiver performance means finding the information word with highest a posteriori probability given the received vectors and channel knowledge: 
         [0000]    
       
         
           
             
               
                 
                   
                     u 
                     ^ 
                   
                   = 
                   
                     arg 
                      
                     
                         
                     
                      
                     
                       
                         max 
                         u 
                       
                        
                       
                         
                           P 
                            
                           
                             ( 
                             
                               
                                 u 
                                 | 
                                 y 
                               
                               , 
                               H 
                             
                             ) 
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
           
         
       
     
         [0064]    Since this joint detection and decoding is too complex for practical implementation, the practical approach is an iterative approximation of the information bit a posteriori probabilities 
         [0000]      P(u i |y, H)   (3)
 
         [0000]    by local computation. This is an application of the mathematical framework of Bayesian Belief Propagation [8] with 2 loops. Conditional independencies of variables are exploited by factorizing the joint probability density function into factors which depend only on subsets of the variables. In this case it is: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           P 
                            
                           
                             ( 
                             
                               u 
                               , 
                               y 
                               , 
                               H 
                             
                             ) 
                           
                         
                         = 
                           
                          
                         
                           
                             
                               f 
                               Det 
                             
                              
                             
                               ( 
                               
                                 u 
                                 , 
                                 
                                   c 
                                   1 
                                 
                                 , 
                                 
                                   c 
                                   2 
                                 
                                 , 
                                 y 
                                 , 
                                 H 
                               
                               ) 
                             
                           
                            
                           
                             
                               
                                 f 
                                 
                                   Dec 
                                    
                                   
                                       
                                   
                                    
                                   1 
                                 
                               
                                
                               
                                 ( 
                                 
                                   u 
                                   , 
                                   
                                     c 
                                     1 
                                   
                                 
                                 ) 
                               
                             
                             · 
                             · 
                           
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             f 
                             
                               Dec 
                                
                               
                                   
                               
                                
                               2 
                             
                           
                            
                           
                             ( 
                             
                               u 
                               , 
                               
                                 c 
                                 2 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             ( 
                             
                               
                                 ∏ 
                                 t 
                               
                                
                               
                                 
                                   
                                     f 
                                     Det 
                                   
                                   ~ 
                                 
                                  
                                 
                                   ( 
                                   
                                     
                                       b 
                                       
                                         ( 
                                         t 
                                         ) 
                                       
                                     
                                     , 
                                     
                                       y 
                                       
                                         ( 
                                         t 
                                         ) 
                                       
                                     
                                     , 
                                     
                                       H 
                                       
                                         ( 
                                         t 
                                         ) 
                                       
                                     
                                   
                                   ) 
                                 
                               
                             
                             ) 
                           
                           · 
                           · 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             
                               f 
                               
                                 Dec 
                                  
                                 
                                     
                                 
                                  
                                 1 
                               
                             
                              
                             
                               ( 
                               
                                 u 
                                 , 
                                 
                                   c 
                                   1 
                                 
                               
                               ) 
                             
                           
                            
                           
                             
                               
                                 f 
                                 
                                   Dec 
                                    
                                   
                                       
                                   
                                    
                                   2 
                                 
                               
                                
                               
                                 ( 
                                 
                                   u 
                                   , 
                                   
                                     c 
                                     2 
                                   
                                 
                                 ) 
                               
                             
                             . 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
           
         
       
     
         [0065]    The factors are one MIMO demapper for each time instance, and the two constituent decoders. The corresponding receiver architecture is shown in  FIG. 1  as factor graph (factor graphs are described in [9], [10]). Factor nodes perform a posteriori probability (APP) computation on subsets of variables, where the involved variables are depicted as variable nodes neighbouring to the factor node. A factor node outputs only the information increment gained by computation, which is often called extrinsic information [2]. To avoid the effort for normalizing probability densities and to further reduce computational effort, implementation uses log-likelihood ratios (LLRs) instead of bit probabilities themselves (multiplications are turned into additions in the log domain). The messages passed in  FIG. 1  are therefore vectors of LLRs. L a  denotes a priori LLR, L p  a posteriori LLR. A factor node computes a posteriori LLRs, but outputs only the extrinsic LLRs L e =L p −L a  [8], [9], [11]. Variable nodes compute sums of the incident LLR vectors, so that the a posteriori values of information bits are 
         [0000]        L   p ( u   i )= L   e   (det) ( u   i )+ L   e   (dec1) ( u   i )+ L   e   (dec2)(   u   i )   (5).
 
         [0066]    For a decoding architecture with two factor nodes like in the case of Turbo decoding without iterative demapping, the order of factor node updates is clear: the two factors are updated in turn. For this case with three nodes, the order is arbitrary (which was pointed out in the context of iterative decoding of arbitrarily concatenated codes in [3], [12]). Based on the generic receiver architecture illustrated in  FIG. 1 , an actual receiver is described by its factor node update schedule. 
         [0067]    The aim is to predict convergence of the described iterative receiver processing for any schedule. The approach is to track the conditional LLR distributions corresponding to the messages in  FIG. 1  for all node updates. Receiver performance is then given by the mutual information (MI) between the L p (u) and the transmit bits u: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       I 
                        
                       
                         ( 
                         
                           u 
                           , 
                           
                             L 
                             p 
                           
                         
                         ) 
                       
                     
                     = 
                     
                       ∑ 
                       
                         ∑ 
                         
                           
                             p 
                              
                             
                               ( 
                               
                                 
                                   L 
                                   p 
                                 
                                 , 
                                 u 
                               
                               ) 
                             
                           
                            
                           ln 
                            
                           
                               
                           
                            
                           
                             
                               p 
                                
                               
                                 ( 
                                 
                                   
                                     L 
                                     p 
                                   
                                   , 
                                   u 
                                 
                                 ) 
                               
                             
                             
                               
                                 
                                   p 
                                   
                                     L 
                                     p 
                                   
                                 
                                  
                                 
                                   ( 
                                   
                                     L 
                                     p 
                                   
                                   ) 
                                 
                               
                               · 
                               
                                 
                                   p 
                                   u 
                                 
                                  
                                 
                                   ( 
                                   u 
                                   ) 
                                 
                               
                             
                           
                         
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   6 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where p(L p , u) is the joint distribution, and p u (u) and pL p (L p  ) are the marginal distributions. To evaluate the accuracy of the presented prediction method for concrete demapper/decoder schemes, the following common algorithms are picked: the constituent decoders perform log-APP decoding according to the BCJR algorithm [13], the MIMO demapper uses max-log-APP detection [1]. 
         [0068]    The extrinsic demapper LLRs are therefore [1]: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       L 
                       e 
                       
                         ( 
                         Det 
                         ) 
                       
                     
                      
                     
                       ( 
                       
                         b 
                         i 
                       
                       ) 
                     
                   
                   ≈ 
                   
                     
                       
                         max 
                         
                           
                             x 
                             
                               ( 
                               t 
                               ) 
                             
                           
                           ∈ 
                           
                             χ 
                             i 
                             + 
                           
                         
                       
                        
                       
                         ( 
                         
                           
                             
                               
                                 
                                   
                                     - 
                                     
                                       1 
                                       
                                         2 
                                          
                                         
                                           σ 
                                           N 
                                           2 
                                         
                                       
                                     
                                   
                                    
                                   
                                     
                                        
                                       
                                         
                                           y 
                                           
                                             ( 
                                             t 
                                             ) 
                                           
                                         
                                         - 
                                         
                                           
                                             H 
                                             
                                               ( 
                                               t 
                                               ) 
                                             
                                           
                                            
                                           
                                             
                                               x 
                                               
                                                 ( 
                                                 t 
                                                 ) 
                                               
                                             
                                              
                                             
                                               ( 
                                               
                                                 b 
                                                 
                                                   ( 
                                                   t 
                                                   ) 
                                                 
                                               
                                               ) 
                                             
                                           
                                         
                                       
                                        
                                     
                                     2 
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 
                                   ∑ 
                                   
                                     n 
                                     ≠ 
                                     i 
                                   
                                 
                                  
                                 
                                   min 
                                    
                                   
                                     ( 
                                     
                                       
                                         
                                           b 
                                           n 
                                           
                                             ( 
                                             t 
                                             ) 
                                           
                                         
                                          
                                         
                                           
                                             L 
                                             a 
                                             
                                               ( 
                                               Det 
                                               ) 
                                             
                                           
                                           ( 
                                           
                                             b 
                                             n 
                                             
                                               ( 
                                               t 
                                               ) 
                                             
                                           
                                            
                                           
                                               
                                           
                                           ) 
                                         
                                       
                                       ; 
                                       0 
                                     
                                     ) 
                                   
                                 
                               
                             
                           
                         
                          
                         
                             
                         
                         ) 
                       
                     
                     - 
                     
                       
                         max 
                         
                           
                             x 
                             
                               ( 
                               t 
                               ) 
                             
                           
                           ∈ 
                           
                             χ 
                             i 
                             - 
                           
                         
                       
                        
                       
                         ( 
                         
                           
                             
                               - 
                               
                                 1 
                                 
                                   2 
                                    
                                   
                                     σ 
                                     N 
                                     2 
                                   
                                 
                               
                             
                              
                             
                               
                                  
                                 
                                   
                                     y 
                                     
                                       ( 
                                       t 
                                       ) 
                                     
                                   
                                   - 
                                   
                                     
                                       H 
                                       
                                         ( 
                                         t 
                                         ) 
                                       
                                     
                                      
                                     
                                       
                                         x 
                                         
                                           ( 
                                           t 
                                           ) 
                                         
                                       
                                        
                                       
                                         ( 
                                         
                                           b 
                                           
                                             ( 
                                             t 
                                             ) 
                                           
                                         
                                         ) 
                                       
                                     
                                   
                                 
                                  
                               
                               2 
                             
                           
                           + 
                           
                             
                               ∑ 
                               
                                 n 
                                 ≠ 
                                 i 
                               
                             
                              
                             
                               min 
                                
                               
                                 ( 
                                 
                                   
                                     
                                       b 
                                       n 
                                       
                                         ( 
                                         t 
                                         ) 
                                       
                                     
                                      
                                     
                                       
                                         L 
                                         a 
                                         
                                           ( 
                                           Det 
                                           ) 
                                         
                                       
                                        
                                       
                                         ( 
                                         
                                           b 
                                           N 
                                           
                                             ( 
                                             t 
                                             ) 
                                           
                                         
                                         ) 
                                       
                                     
                                   
                                   ; 
                                   0 
                                 
                                 ) 
                               
                             
                           
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
           
         
       
     
         [0000]    wherein X i   +  is the set of all possible transmit vectors x (t) , wherein the bit whose LLR is to be computed has the value +1. For the channel uncorrelated Rayleigh fading for each time instance t, and noise variance σ 2   N  is assumed. Three different schedules for which prediction accuracy is assessed are arbitrarily picked:
   schedule 1: ‘normal’ receiver with Turbo decoder. First the demapper is updated once, then the constituent decoders are run alternatingly.   schedule 2: the demapper is run first, and then again always after four Turbo decoder iterations (eight constituent decoder updates).   schedule 3: ‘round-robin’ schedule. Demapper, decoder 1 and decoder 2 are run periodically in this order (demapper update after each Turbo decoder iteration).   
 
         [0072]    For simulation 4×4 QPSK transmission, and channel coding with the 3GPP (Third Generation Partnership Project)LTE Turbo code (rate 1/3) is further assumed. 
         [0073]    Shortcoming of 1-Parametic Gaussian Model 
         [0074]    EXIT charts [2], [3] are based on a 1-parametric conditional 
         [0075]    Gaussian distribution model of LLRs. This model is derived from the assumption of BPSK transmission over an AWGN channel: 
         [0000]        y=x ( b )+ n    (8)
 
         [0076]    Under this assumption the extrinsic LLRs generated by the demapper follow a (conditional) Gaussian distribution with the special property that the (conditional) absolute expectancy value is half of the (conditional) variance [2]: 
         [0000]    
       
         
           
             
               
                 
                   
                      
                     
                       E 
                        
                       
                         ( 
                         
                           
                             
                               L 
                               e 
                               
                                 ( 
                                 det 
                                 ) 
                               
                             
                              
                             
                               ( 
                               b 
                               ) 
                             
                           
                           | 
                           b 
                         
                         ) 
                       
                     
                      
                   
                   = 
                   
                     
                       1 
                       2 
                     
                      
                     
                       
                         Var 
                          
                         
                           ( 
                           
                             
                               
                                 L 
                                 e 
                                 
                                   ( 
                                   det 
                                   ) 
                                 
                               
                                
                               
                                 ( 
                                 b 
                                 ) 
                               
                             
                             | 
                             b 
                           
                           ) 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
           
         
       
     
         [0077]    An LLR distribution is therefore completely described by one parameter, e.g. by the standard deviation σ. As consequence, there is a bidirectional mapping J: σ→I between this parameter and the mutual information carried by this distribution (MI of LLRs with the transmit bits, Eq. (6)). This mapping is the basis of EXIT charts [2]. EXIT charts assume that the 1-parametric distribution property is sustained after a 
         [0078]    BCJR decoder. The parameter transfer I(L a )→I(L e ) is tabularised in a table T, its graph is the EXIT curve. To track LLR density evolution for convergence prediction, I(L e ) can be looked up from this table for known I(L a ) for information bits and code bits: 
         [0000]        I   e ( b )= T ( I   a ( u ),  I   a ( c ))   (10)
 
         [0079]    The 1-parametric property (Eq. (9)) is also sustained for summation of LLRs, since mean and variance of the sum distribution are the sum of the means and variances, respectively. The MI of the LLR sum can therefore be determined by using J-1 and adding the variances [2]: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       I 
                       sum 
                     
                      
                     
                       ( 
                       u 
                       ) 
                     
                   
                   = 
                   
                     J 
                     ( 
                     
                       
                         
                           ∑ 
                           i 
                         
                          
                         
                           
                             
                               J 
                               
                                 - 
                                 1 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   I 
                                   e 
                                   
                                     ( 
                                     i 
                                     ) 
                                   
                                 
                                  
                                 
                                   ( 
                                   u 
                                   ) 
                                 
                               
                               ) 
                             
                           
                           2 
                         
                       
                     
                     ) 
                   
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
           
         
       
     
         [0080]    To see why this model is less favorable in this scenario, EXIT charts are applied to predict convergence of schedule 1 (‘normal’ receiver, no iterative demapping) for channel SNR of 1 dB. The prediction of MI after each factor node update is shown in  FIG. 3 . The Figure also shows the measured MI, which is obtained by Monte Carlo simulation of the complete receiver processing and non-parametric conditional LLR distribution estimation after each factor update number. While EXIT charts predict convergence after 8 node updates, measurement shows a saturation at MI of 0.53. An EXIT chart prediction for 0 dB channel SNR predicts saturation at higher MI than 0.53. The prediction error in this case is therefore larger than 1 dB, which is so large that it renders the prediction method useless. 
         [0081]    The misprediction is explained by the actual LLR distribution after the demapper (max-log-APP demapping [1], uncorrelated Rayleigh fading), which is shown in  FIG. 2 . While it does resemble a conditional Gaussian distribution, Eq. (9) is clearly violated: the mean value is not half the variance.  FIG. 2  also shows a conditional Gaussian distribution with the same MI which satisfies Eq. (9) (mean and variance are different from the measured distribution). This is the curve which EXIT chart prediction assumes for this MI value, and it is the reason for the wrong prediction trend. The problem is not that the demapper or decoder EXIT curves would be wrong: histogram based measurement of the extrinsic MI as in [2] is indeed correct. The problematic 1-parametric fitting occurs when the output LLRs become input for the next factor node, because the EXIT curves are computed with 1-parametric input distributions. 
         [0082]    Extended Gaussian Model: 2 Parameters 
         [0083]    It is noted that while EXIT charts track the MI value corresponding to an LLR distribution, they could equivalently track a different parameter describing the 1-parametric Gaussian distribution, e.g. the standard deviation [7]. 
         [0084]    In the previous section the conclusion is drawn that the 1-parametric Gaussian model where the expectancy μ is half the variance σ 2  (Eq. (9)) is less adequate in this scenario. But it could still be the case that another 1-parametric model, maybe with a nonlinear relation between μ and σ 2 , can be used. To test this, a Monte-Carlo simulation of the complete receiver processing according to schedule 3 (‘round robin’) is run, and μ and σ of the LLR distributions after each factor update number are measured. Looking at the value pairs of μ and σ, the result is that a 1-parametric description does not work. 
         [0085]    Therefore one parameter is added to the model and in accordance with [7] it is assumed that the LLRs as conditionally Gaussian distributed with arbitrary mean μ and standard deviation σ, leaving out Eq. (9). Table look-ups for the extrinsic information transfer of decoders or demapper now have more dimensions: based on mean and standard deviation of the input distributions, the mean and standard deviation of the extrinsic output distribution are looked up. A decoder look-up becomes: 
         [0000]      (μ e )( b ), σ e ( b ))= T ((μ a ( u ), σ a ( u )); (μ a ( c ), σ a ( c )))   (12).
 
         [0086]    The MIMO demapper look-up in this scenario has six input values (three input vectors with two parameters each, compare  FIG. 1 ). The mapping from distribution parameters (μ, σ) to MI (function J) now has one more dimension. MI of the Gaussian distribution is only determined by the ratio q=μ/σ of mean value and standard deviation, the corresponding bit error rate (for a posteriori LLRs) is given by the tail probability [7]: 
         [0000]      BER= Q ( q )   (13).
 
         [0087]    As coordinates for the 2-dimensional mapping function mean value p, quotient q=μ/σ, and MI are therefore used: 
         [0000]    
       
         
           
             
               
                 
                   
                     J 
                      
                     
                       : 
                     
                      
                     
                       ( 
                       
                         μ 
                         , 
                         
                           μ 
                           σ 
                         
                       
                       ) 
                     
                   
                   ↦ 
                   
                     I 
                     . 
                   
                 
               
               
                 
                   ( 
                   14 
                   ) 
                 
               
             
           
         
       
     
         [0088]    The function is illustrated in  FIG. 4 . The Figure also shows the curve for the 1-parametric case, embedded as special case in the MI surface. 
         [0089]    A BER smaller than 10 −4  corresponds to q&gt;3.7.  FIG. 4  therefore also shows the parameter range which has to be covered by the look-up tables. Since there are infinitely many Gaussian distributions with the same quotient q, the function J is no longer invertible. Due to this, the distributions are tracked for iterative decoding using only their Gaussian parameters μ and σ, the mapping to MI (or BER) is only necessary when the iterations are stopped. For a sum of LLRs, instead of Eq. (11) the following equation will be obtained: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         μ 
                         
                           ( 
                           sum 
                           ) 
                         
                       
                        
                       
                         ( 
                         u 
                         ) 
                       
                     
                     = 
                     
                       
                         ∑ 
                         i 
                       
                        
                       
                         
                           μ 
                           
                             ( 
                             i 
                             ) 
                           
                         
                          
                         
                           ( 
                           u 
                           ) 
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                     
                       
                         σ 
                         
                           ( 
                           sum 
                           ) 
                         
                       
                        
                       
                         ( 
                         u 
                         ) 
                       
                     
                     = 
                     
                       
                         
                           ∑ 
                           i 
                         
                          
                         
                           
                             ( 
                             
                               σ 
                               
                                 ( 
                                 i 
                                 ) 
                               
                             
                             ) 
                           
                           2 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   15 
                   ) 
                 
               
             
           
         
       
     
         [0000]    i.e. the sum is still (conditionally) Gaussian distributed. 
         [0090]    Compensating Mutual Information Offset for Higher Order Moments of LLR Distribution 
         [0091]    As expected, the more flexible 2-parametric model reproduces the actual MI evolution trend and yields better accuracy—but beginning from the first demapping, the prediction has an MI offset compared to the measured MI. This offset can be explained by the fact that the MIMO demapper LLRs do not exactly follow a Gaussian distribution: not all cumulants of the distribution for order larger than 2 are zero. This is illustrated in  FIG. 5 . The Figure shows the LLR distribution from the MIMO example as well as the Gaussian distribution which has the same mean and variance. The measured LLR distribution shows a nonzero skewness, it is not symmetric. MI of the assumed Gaussian distribution is smaller, causing the initial prediction offset. It is assumed that the Gaussian distribution can either have the same mean and variance as the real distribution, or the same MI—but not both. 
         [0092]    For a consistent concatenation of table look-ups, the demapper table using the Gaussian distribution with same mean and variance as the real one is determined. To compensate the initial MI loss, it is also computed at table generation time. For one channel SNR value, the demapper table now is a mapping from 6 input dimensions to 3 output dimensions (compare  FIG. 1 ): 
         [0000]      (μ e ( b ), σ e ( b ), I offset )= T ((μ a ( u ), σ a ( u ); (μ a ( c   1 ), σ a ( c   1 )); (μ a ( c   2 ), σ a ( c   2 )))   (16).
 
         [0093]    Adding channel SNR as input dimension makes the demapper table input 7-dimensional. For the prediction results presented here, the input LLR distributions were sampled with 8 points per dimension (0≦μ≦15, 0≦q≦5), resulting in 260000 entries in the demapper table per channel SNR value. Using the fact that the roles of u, c 1  and c 2  are interchangeable for the demapper, only 46000 table entries have to be computed. The table for a constituent decoder was already described in the previous section (4 input dimensions to 2 output dimensions). Since the two constituent decoders are identical for the LTE Turbo codes which were used, they are both described by the same table. For table look-ups linear interpolation between neighbouring sample points are used. 
         [0094]    The predicted Gaussian parameters (μ p , σ p ) of the distribution of the a posteriori LLRs L p (u) are then mapped to MI by table look-up (function J), and the I offset  value returned by the last demapper table look-up for L e   (det) (b) is added: 
         [0000]    
       
         
           
             
               
                 
                   
                     I 
                     predict 
                   
                   = 
                   
                     
                       J 
                        
                       
                         ( 
                         
                           
                             μ 
                             p 
                           
                           , 
                           
                             
                               μ 
                               
                                 p 
                                  
                                 
                                     
                                 
                               
                             
                             
                               σ 
                               p 
                             
                           
                         
                         ) 
                       
                     
                     + 
                     
                       
                         I 
                         offset 
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   17 
                   ) 
                 
               
             
           
         
       
     
         [0095]    Mutual Information Prediction Accuracy for Different Schedules 
         [0096]    Verifying MI prediction accuracy by comparison with MI measurement, for the three receiver processing schedules have been described above. ‘Prediction’ uses the described concatenation of table look-ups, where the concatenation order of look-ups from the two tables is determined by the schedule. ‘Measurement’ performs Monte-Carlo simulation of the complete receiver and measures MI using nonparametric estimation of the joint distribution of a posteriori LLRs and transmit bits according to Eq. (6), independently for each schedule. 
         [0097]    The results of prediction and measurement are shown in  FIG. 6 . Schedule 1 (‘normal’ receiver) does not converge for this low SNR level, which is now correctly predicted. The MI of a posteriori LLRs saturates after around 7 factor computations (6 constituent decoder updates) at 0.53. Schedule 2 converges after around 40 factor computations (including 5 demapper updates and 35 constituent decoder updates). A demapper update only brings a small MI improvement in itself, but afterwards decoder updates gain more again. Schedule 3 (‘round-robin’) converges already with around 25 factor computations. 
         [0098]    All periodic schedules which include the same factors converge to the same MI limit value [3], since they completely use the same information sources. The maximum MI value which can be reached by the extrinsic MIMO demapper output L e   (det)  is that of SIMO maximum ratio combining for (shifted) BPSK modulation [14]: if the demapper a priori LLRs L a   (det)  have full MI (implying that the receiver algorithm has already converged), for each LLR to compute, all transmit bits of the MIMO vector are known except one, meaning that only two symbol constellation points remain. The MI prediction curves in  FIG. 6  do show small deviations from the also shown measurement curves, which are due to higher order cumulants (order higher than 2) of LLR distributions and finite granularity of the look-up tables. 
         [0099]    Verifying BER and Threshold Prediction 
         [0100]    Prediction of the APP LLR distribution includes bit error rate (BER) prediction according to Eq. (13). To verify BER and SNR threshold prediction, this mapping from the LLR distribution to BER is applied for the two models and compared with measurement for very long packets. For the proposed method one obtains: 
         [0000]    
       
         
           
             
               
                 
                   
                     BER 
                     = 
                     
                       Q 
                        
                       
                         ( 
                         
                           
                             μ 
                             p 
                           
                           
                             σ 
                             p 
                           
                         
                         ) 
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   18 
                   ) 
                 
               
             
           
         
       
     
         [0000]    while for EXIT chart based prediction this reduces to one parameter: 
         [0000]    
       
         
           
             
               
                 
                   BER 
                   = 
                   
                     
                       Q 
                       ( 
                       
                         
                           
                             μ 
                             p 
                           
                           2 
                         
                       
                       ) 
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   19 
                   ) 
                 
               
             
           
         
       
     
         [0101]    Prediction and measurement for varying SNR (for a fixed schedule) with focus on the SNR threshold required for a target BER like e.g. 10 −4  are evaluated.  FIG. 7  illustrates results for the ‘normal’ schedule with 21 factor updates. As implied by MI prediction ( FIG. 3 ), EXIT charts predict the threshold for this schedule more than 1.5 dB too small, while the proposed method predicts it 0.1 dB too high. For BER prediction, no compensation is applied to the MI offset, as this would affect the complete BER curve and not only the BER threshold. MI offset causes the SNR threshold to be predicted too high. 
         [0102]    As apparent from the above, EXIT charts in the normal way as applied to AWGN channels are not applicable to some practically relevant scenarios with fading MIMO channels. How well the underlying 1-parametric model fits the demapper LLR distribution depends on the demapper algorithm, modulation and MIMO fading distribution. This may explain why the results discussed here seem to differ from [6], where a ‘good match’ was found between simulation and EXIT chart based prediction in a different scenario. 
         [0103]    The 2-parameter extension improves prediction performance by better fitting to the real LLR distribution. Together with offset compensation for higher order distribution moments it achieves satisfactory MI prediction accuracy. For non-Gaussian distributions a systematic error remains (higher order moments), so that prediction performance is less accurate than for AWGN channels. Prediction accuracy for other channel models—especially intersymbol interference (ISI) channels—has not been investigated. The proposed method is however applicable to MIMO-OFDM, as OFDM (orthogonal frequency division multiplexing) converts an ISI channel into a set of individually flat fading channels. 
         [0104]    The higher dimensionality of the extended charts causes the charts to be less illustrative. Complexity of look-up table computation increases due to the higher dimensionality. On the other hand, computational effort is reduced a bit again by the parametric density estimation: estimating mean and variance is faster than estimating MI (with non-parametric density estimation like histograms or kernel methods). This could also be used for computation of normal EXIT charts, as it is also consistent with the 1-parametric model. In principle, the prediction accuracy can be improved by increasing the number of parameters used to describe LLR distributions: look-up tables could be extended to include higher order moments. This is limited in practice by the time necessary to compute the tables, the advantage of fast prediction compared to slow link-level simulation would erode. 
         [0105]    The proposed prediction method may serve as a basis for receiver optimization at receiver design time (choice of algorithms and processing schedule). Comparing all receivers for the described scenario (three factor nodes) which have a schedule length of exactly 20 factor node updates (106 different receivers) may well be too much for link-level simulation based comparison. Using the proposed method, all of them can be compared after generating only two look-up tables. Comparison of different factor computation algorithms (especially demapper algorithm alternatives) can be done by changing the respective factor look-up table. A criterion for optimization can be the sum of computational cost for reaching the target MI (corresponding to a required packet error rate) at a certain SNR. The prediction accuracy of the proposed method is sufficient to reduce the receiver design space to a few interesting algorithm candidates, which can then be verified by more time-consuming link-level simulation. 
         [0106]    Factorizing Joint Probability Density Function 
         [0107]    MIMO transmission at time instance t over the channel matrix H (t)  can be denoted as 
         [0000]        y   (t)   =H   (t)   ·x   (t) ( b   (t) )+ n   (t) .   (20).
 
         [0108]    It can be assumed that the channel does not have memory, which can also be considered as subcarrier model in MIMO-OFDM transmission. b (t)  is a vector of transmit bits as part of the complete codeword b, x (t)  is the corresponding vector of modulated symbols. The complete set of received symbol values of the message (all time instances) is denoted y. The transmitter uses Turbo coding, so that the code word b consists of the information bits u, parity bits c 1  of the first constituent encoder and parity bits c 2  of the second constituent encoder. b i  is written for a single bit of the bit vector b at position i.  FIGS. 8 and 9  illustrate the encoding and modulation signal flow at the transmitter (without channel estimation). 
         [0109]    Maximum receiver performance would be reached if computing the maximum likelihood solution on codeword basis: 
         [0000]    
       
         
           
             
               
                 
                   
                     u 
                     ^ 
                   
                   = 
                   
                     arg 
                      
                     
                         
                     
                      
                     
                       
                         max 
                         u 
                       
                        
                       
                         
                           P 
                            
                           
                             ( 
                             
                               u 
                               | 
                               y 
                             
                             ) 
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   21 
                   ) 
                 
               
             
           
         
       
     
         [0110]    As this is practically infeasible, the practical approach is an iterative local approximation of the information bit APPs with subsequent binary quantization. The joint probability density can be factorized: 
         [0000]    
       
         
           
             
               
                 
                   
                     P 
                      
                     
                       ( 
                       
                         u 
                         , 
                         y 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ( 
                       
                         
                           ∏ 
                           t 
                         
                          
                         
                           
                             f 
                             Dem 
                           
                            
                           
                             ( 
                             
                               
                                 b 
                                 
                                   ( 
                                   t 
                                   ) 
                                 
                               
                               , 
                               
                                 y 
                                 
                                   ( 
                                   t 
                                   ) 
                                 
                               
                               , 
                               
                                 H 
                                 
                                   ( 
                                   t 
                                   ) 
                                 
                               
                             
                             ) 
                           
                         
                       
                       ) 
                     
                     · 
                     
                       
                         f 
                         
                           Dec 
                            
                           
                               
                           
                            
                           1 
                         
                       
                        
                       
                         ( 
                         
                           u 
                           , 
                           
                             c 
                             1 
                           
                         
                         ) 
                       
                     
                     · 
                     
                       
                         f 
                         
                           Dec 
                            
                           
                               
                           
                            
                           2 
                         
                       
                        
                       
                         ( 
                         
                           u 
                           , 
                           
                             c 
                             2 
                           
                         
                         ) 
                       
                     
                     · 
                     · 
                     
                       
                         f 
                         CE 
                       
                        
                       
                         ( 
                         
                           y 
                           , 
                           x 
                         
                         ) 
                       
                     
                     · 
                     
                       ( 
                       
                         
                           ∏ 
                           t 
                         
                          
                         
                           
                             f 
                             Map 
                           
                            
                           
                             ( 
                             
                               b 
                               
                                 ( 
                                 t 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   22 
                   ) 
                 
               
             
           
         
       
     
         [0000]    which corresponds to a detector for each different time instance, the two constituent decoders, a soft symbol mapper for each time instance and channel estimation (for all symbol positions of the codeword). The received vectors y are ‘evidence’. 
         [0111]    The complete factor graph including channel estimation is shown in  FIG. 9 . This section describes the update of factor nodes and variable nodes from  FIG. 8  and specifies the messages passed between them according to Belief propagation. Usage of a factor graph for visualization does not mean that only optimal and complex a posteriori probability computation by an algorithm is considered. The method is also applied for suboptimal algorithms which approximate the a posteriori probability with less complexity. 
         [0112]      FIG. 8  shows a factor graph of joint probability density. Variable nodes are circles, factor nodes are squares. ‘Evidence’ y is shaded. All variable nodes are vectors, H (t)  are matrices. 
         [0113]      FIG. 9  further shows joint MIMO demapping and separate decoding for MU-MIMO in an exemplary fashion. 
         [0114]    The blocks called ‘Channel estimation’, ‘mapper’, ‘demapper’, ‘decoder’, and ‘decoder 2’ in  FIGS. 8 and 9  form predefined models of algorithms in order to model the receiver. Each predefined model is capable of mapping at least one input probability density to at least one output probability density. As such, the blocks allow inputting an input probability density, which has been determined based on a predefined signal-to-noise ratio, to a sequence of model algorithms, and determining the output probability density at the output of the sequence of model algorithms in order to determine the bit-error rate of the receiver for the respective sequence of model algorithms. 
         [0115]    Optimization Criteria 
         [0116]    The task is an optimal distribution of algorithms to a number of homogeneous multiprocessor cores, where the number of cores as well as the update schedules and algorithm components for each factor update are flexible. For given a transmission mode (modulation, MIMO scheme and code rate) and channel characteristics, receiver processing quality can be described by operational SNR (SNR: signal-to-noise ratio, wherein the SNR is minimal where reception works with predefined error rate), receiver complexity and processing delay. In the 3-dimensional (complexity, target SNR, processing delay) pareto-optimal receiver algorithm space, the following optimization criteria could be chosen (among any other weighted combinations): 
         [0117]    1. Minimum operational SNR for fixed complexity. Which receiver algorithm satisfies the operational requirements with minimum computational effort? The answer to this question could be used to choose adequate hardware, e.g. the number of processor cores, clock speed or width of parallel processing (single instruction multiple data, SIMD). 
         [0118]    2. Minimum complexity for fixed target hardware. Given a fixed hardware with certain computational power, what are the achievable operating conditions (and with which algorithm can this be reached)? 
         [0119]    3. Minimum delay for fixed operational SNR. How far can the processing delay be reduced by parallelizing node updated schedules using different cores? Differing from the serial schedule which was used so far, processing is described by a parallel schedule. 
         [0120]    Receiver Algorithm Description Language 
         [0121]    To describe node update schedules, where different algorithms for each update are possible, a description language may be used which is explained in an exemplary fashion hereinafter. The language preferably has a regular grammar and can thus be parsed by a finite state automation (Chomsky hierarchy type 3 language). A receiver then corresponds to a path through the finite state algorithm. 
         [0122]    Factor Graph Notation: Directed Bipartite Graph 
         [0123]    A factor graph F is given by the sets of its vertices (nodes) and directed edges F=V, E, with the property that the graph is bipartite: the set of nodes consists of two disjoint subsets, where every edge is between nodes belonging to different sets. For the factor graph describing the generic receiver architecture, the first node subset comprises the factor nodes: 
         [0000]      V 1 ={ce, dem, dec1, dec2, map}  (23).
 
         [0124]    The used node abbreviations may be listed in a table together with the corresponding factor node and the factor node type. The second subset comprises the variable nodes: 
         [0000]      V 2 ={u, c 1 , c 2 , y, H}.   (24)
 
         [0125]    The complete set of nodes in this case is: 
         [0000]      V=V 1 ∪V 2    (25).
 
         [0126]    The general set of edges E ⊂ V×V with the bipartite graph property is 
         [0000]        E=E   1   ∪E   2 ; with  E   1     ⊂ V   1   ×V   2   , E   2     ⊂ V   2   ×V   1    (26)
 
         [0000]    where the adjacency matrix can be described as: 
         [0000]    
       
         
           
             
               
                 
                   A 
                   = 
                   
                     
                       ( 
                       
                         
                           
                             0 
                           
                           
                             
                               A 
                               1 
                             
                           
                         
                         
                           
                             
                               
                                 A 
                                 2 
                               
                                
                               
                                   
                               
                             
                           
                           
                             0 
                           
                         
                       
                       ) 
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   27 
                   ) 
                 
               
             
           
         
       
     
         [0127]    In the receiver graph case the edges are: 
         [0000]        E ={( y,  ce), ( x,  ce), ( H,  dem), ( y,  dem), ( u,  dec1), ( c   1  , dec1), ( u,  dec2), ( c   2 , dec2), ( u,  map), ( c   1 , map), ( c   1 , map), (ce,  H ), (map,  x ), (dem,  u ), (dem,  c   1 ), (dem,  c 2), (dec1,  u ), (dec1,  c   1 ),   (28)
 
         [0000]    
       
         
               
               
               
               
             
           
               
                   
                   
               
               
                   
                 Factor node 
                 Type 
                 Abbreviation 
               
               
                   
                   
               
             
             
               
                   
                 Channel estimation 
                 channel estimation 
                 ce 
               
               
                   
                 MIMO demapper 
                 demapping 
                 dem 
               
               
                   
                 Constituent decoder 1 
                 decoding 
                 dec1 
               
               
                   
                 Constituent decoder 2 
                 decoding 
                 dec2 
               
               
                   
                 Soft Mapper 
                 mapping 
                 map 
               
               
                   
                   
               
             
          
         
       
     
         [0128]    Algorithm Notation 
         [0129]    After naming the factor nodes, now the mapping of an algorithm to a node will be described. The considered algorithms may be listed in a table, together with algorithm type and abbreviation. The set of algorithm abbreviations for the example list is 
         [0000]        A ={wif, snd, ummse, hummse-ml ( m=m ),  bcjr}   (29).
 
         [0130]    To map an algorithm to a factor node, the abbreviations of node and algorithm are concatenated. Algorithm and factor node should have the same type (e.g. the BCJR algorithm is not applicable for channel estimation). 
         [0131]    The set of valid algorithm mappings to factor nodes is the alphabet E (set of symbols) of the receiver description language: 
         [0000]      Σ={( v   —   a )| v ε V   1   , a ε A,  factor node  v  and algorithm  a  have same type}  (30)
 
       EXAMPLES 
       [0132]    ce_wif: channel estimation using Wiener interpolation filter. 
         [0133]    dem_hummse-ml (m=8): MIMO demapping using the hybrid unbiased MMSE/max-log-APP algorithm with parameter m=8. 
         [0134]    dec2_bcjr: constituent decoder 2 implementing the BCJR algorithm. 
         [0000]    
       
         
               
               
               
             
           
               
                   
               
               
                 Algorithm 
                 Type 
                 Abbreviation 
               
               
                   
               
             
             
               
                 Wiener interpolation filter 
                 channel estimation 
                 wif 
               
               
                 2nd order model CE 
                 channel estimation 
                 snd 
               
               
                 unbiased MMSE 
                 demapping 
                 ummse 
               
               
                 hybrid uMMSE/max-log-APP, 
                 demapping 
                 hummse-ml 
               
               
                 m LLRs linear 
                   
                 (m = m) 
               
               
                 BCJR 
                 decoding 
                 bcjr 
               
               
                   
               
             
          
         
       
     
         [0135]    Schedule Notation: Regular Expression 
         [0136]    A schedule is a valid word from the regular receiver description language L. The language can be defined by a starting set of valid words and ‘construction rules’. 
         [0137]    Starting Set: 
         [0138]              (θ): ‘empty’ receiver is in          . 
         [0000]    
       
         
           
             
               
                 ∀ 
                 
                   s 
                   ∈ 
                   ∑ 
                 
               
                
               
                  
                 
                   ( 
                   s 
                   ) 
                 
               
             
             = 
             
               s 
                
               
                 : 
               
             
           
         
       
     
         [0000]    only one factor node update 
         [0139]    Construction Rules: 
         [0000]    
       
         
           
             
               
                 ∀ 
                 
                   
                     s 
                     . 
                     t 
                     . 
                   
                   ∈ 
                   ∑ 
                 
               
                
               
                  
                 
                   ( 
                   
                     s 
                     | 
                     t 
                   
                   ) 
                 
               
             
             = 
             
               
                 
                    
                   
                     ( 
                     s 
                     ) 
                   
                 
                 ⋃ 
                 
                    
                   
                     ( 
                     t 
                     ) 
                   
                    
                   
                     : 
                   
                    
                   
                       
                   
                    
                   alternative 
                    
                   
                     
 
                   
                    
                    
                   
                     ( 
                     st 
                     ) 
                   
                 
               
               = 
               
                 
                   
                     { 
                     
                       
                         α 
                          
                         
                             
                         
                          
                         β 
                       
                       | 
                       
                         α 
                          
                         
                             
                         
                         ∈ 
                         
                            
                           
                             
                               ( 
                               s 
                               ) 
                             
                             ⋀ 
                             β 
                           
                         
                         ∈ 
                         
                            
                           
                             ( 
                             t 
                             ) 
                           
                         
                       
                     
                     } 
                   
                    
                   
                     : 
                   
                    
                   
                       
                   
                    
                   sequence 
                    
                   
                     
 
                   
                    
                    
                   
                     ( 
                     
                       a 
                       * 
                     
                     ) 
                   
                 
                 = 
                 
                   
                     
                       ⋃ 
                       
                         i 
                         ≥ 
                         0 
                       
                     
                      
                     
                       
                         i 
                       
                        
                       
                         ( 
                         a 
                         ) 
                       
                        
                       
                         : 
                       
                        
                       
                           
                       
                        
                       repetition 
                        
                       
                         
 
                       
                        
                        
                       
                         ( 
                         
                           a 
                           + 
                         
                         ) 
                       
                     
                   
                   = 
                   
                     
                       ⋃ 
                       
                         i 
                         ≥ 
                         1 
                       
                     
                      
                     
                       
                         i 
                       
                        
                       
                         ( 
                         a 
                         ) 
                       
                        
                       
                         : 
                       
                        
                       
                           
                       
                        
                       nonzero 
                        
                       
                           
                       
                        
                       repetition 
                        
                       
                           
                       
                        
                       
                         ( 
                         
                           at 
                            
                           
                               
                           
                            
                           least 
                            
                           
                               
                           
                            
                           once 
                         
                         ) 
                       
                     
                   
                 
               
             
           
         
       
     
         [0140]    A receiver design space (search space) is a subset            ⊂            and can be given as a regular expression. Examples: 
         [0141]    R normal =(ce wif dem ummse) (dec1 bcjr dec2 bcjr)* describes a ‘normal’ linear receiver with turbo decoder (at least one turbo decoder iteration). 
         [0142]    R iterative-1 =(ce wif) (dem ummse|dem max log|dec1 bcjr|dec2 bcjr)* describes a receiver with possibly iterative demapping 
         [0143]    decoding allowing free concatenation of four demapping/decoding components. 
         [0144]    Automatic Receiver Optimization 
         [0145]    Complexity Measure 
         [0146]    The complexity of an algorithm may be given by the amount and type of its elementary operations, which is an implementation-independent measure. The computational cost on a certain hardware (like processor or coprocessor) is evaluated by counting the theoretically necessary cycles to perform the operations (in an optimal implementation). 
         [0147]    The algorithm complexity vs. implementation complexity (hardware independent/dependent) may be benchmarked vs. theoretical upper limit (optimal utilization). 
         [0148]    For a hardware independent assessment of complexities the elementary operations of the considered signal processing blocks are counted: for example for the candidate algorithms ZF and MMSE detector, M-detector and Turbo decoder. While ZF/MMSE use multiply-accumulate (MAC) operations, and table look-ups (LU) for the soft demodulator (for LTE-like modulation possible because of separable I/Q components), the M-detector uses MAC and Select (SEL, conditional move) operations. For the sorting step of the M-detector the bubblesort algorithm is assumed, because it is suited for SIMD parallel implementation. The turbo decoder uses Add-Compare-Select (ACS) operations for trellis traversal and Compare-Select (CS) operations for LLR reconstruction. 
         [0149]    To enable comparison and joint optimization, the complexities and different operations may be expressed in a common cost metric. This is a hardware dependent mapping. Theoretically achievable cycles on the target hardware are counted. The numbers of operations per cycle on the SPU using SIMD parallel implementation are given in the table shown in  FIG. 10 . It would also be possible to choose implementation benchmarks instead of theoretically achievable cycle count. Load/store operations can be done in parallel to arithmetic operations (different processor pipelines) for all blocks except the turbo interleaver, where they are preferably counted explicitly. The resulting block complexities measured in cycles/LLR are illustrated in  FIG. 12  for QPSK. 
         [0150]    The SPU has been chosen as target hardware due to its general-purpose signal processing architecture and high performance. It is used in an SDR (software defined radio) testbed, which give implementation benchmarks and discuss how close an actual implementation with reasonable programming effort (C-language using vector intrinsics) can reach the theoretical cycle count. 
         [0151]    Operational SNR Versus Receiver Complexity 
         [0152]      FIG. 11  shows an example search graph specifying the receiver design space (without channel estimation).  FIG. 12  shows a computational effort of the considered signal processing blocks on Cell SPU.  FIG. 13  shows results for 4×4 QPSK. 
         [0153]    For any receiver specified as sequence of signal processing blocks the performance can now be estimated (as MI at target SNR), and the computational effort can be obtained by summing up the blocks&#39; cycles/LLR. 
         [0154]    A search space of considered receiver architectures may be specified as directed graph (state transition graph) of signal processing blocks, alternatively to a description according to the receiver description language. The optimal receiver algorithm combination (among the set of receivers specified by the graph) is the one satisfying the operational requirements (target MI at target SNR) with minimal cycle count. It is found by graph search, where each state can be an end state. An example graph is given in  FIG. 11 .