Abstract:
A system for cyclic redundancy check (CRC) calculations with modulo-2 multiplication is disclosed for repetitive CRC computations that optimizes processing efficiency and maximizes capacity. The resulting system results in the use of relatively fewer logical gates and conserves on power. The system receives a message ({right arrow over (m)}) including a plurality of blocks ({right arrow over (b)} i ) and a set of pre-computed coefficients ({right arrow over (β)} i ). The system performs a modulo-2 multiply-accumulate operation on the message ({right arrow over (m)}) using the relationship given by: 
     
       
         
           
             
               CRC 
                
               
                 ( 
                 
                   m 
                   → 
                 
                 ) 
               
             
             ≡ 
             
               
                 CRC 
                 ( 
                 
                   
                     ∑ 
                     i 
                   
                    
                   
                     
                       
                         b 
                         → 
                       
                       i 
                     
                     ⊗ 
                     
                       
                         β 
                         → 
                       
                       i 
                     
                   
                 
                 ) 
               
               .

Description:
TECHNICAL FIELD OF THE INVENTION 
       [0001]    The present invention relates generally to data processing systems and, more specifically, to systems and methods for optimizing the efficiency and capacity of cyclic redundancy check operations. 
       BACKGROUND OF THE INVENTION 
       [0002]    In current systems, parallel cyclic redundancy check (CRC) computations involve decomposing an N-bit message into small blocks. Each block has a fixed size (M). The fixed size typically equals the polynomial degree. Most approaches include computing the CRC of a message and performing a series of N/M Galois multiply-accumulate operations. Each of the N/M blocks is multiplied by a pre-stored coefficient, divided by the CRC polynomial, and added to the accumulator. Accordingly, these systems require N/M Galois parallel multiply-accumulate operations. 
         [0003]    There are a number of disadvantages to such approaches. For example, Galois multipliers typically require the use of special hardware with a considerable number of logical gates. Conventional Galois multiplier architectures consume large areas of silicon. Moreover, Galois operations are rarely used in common applications. Furthermore, the CRC ploynomial is typically hardwired into an efficient Galois multiplier. Such a design is not reconfigurable to support other polynomials. 
         [0004]    There is therefore a need for a system and method that includes modulo-2 multiplications for repetitive operations in CRC computations that optimize processing efficiency and maximize capacity. 
       SUMMARY OF THE INVENTION 
       [0005]    Embodiments of the present disclosure include a cyclic redundancy check (CRC) system with modulo-2 multiplications for repetitive CRC computations that optimize processing efficiency and maximize capacity. 
         [0006]    In one embodiment, a method for cyclic redundancy checks (CRC) is disclosed. The method includes receiving a message ({right arrow over (m)}). The message includes a plurality of blocks ({right arrow over (b)} i ) and a set of pre-computed coefficients ({right arrow over (β)} i ). The method also includes performing a modulo-2 multiply-accumulate operation on the message ({right arrow over (m)}), wherein the operation is given by: 
         [0000]    
       
         
           
             
               CRC 
                
               
                 ( 
                 
                   m 
                   → 
                 
                 ) 
               
             
             ≡ 
             
               
                 CRC 
                 ( 
                 
                   
                     ∑ 
                     i 
                   
                    
                   
                     
                       
                         b 
                         → 
                       
                       i 
                     
                     ⊗ 
                     
                       
                         β 
                         → 
                       
                       i 
                     
                   
                 
                 ) 
               
               . 
             
           
         
       
     
         [0007]    In another embodiment, a system for cyclic redundancy checks (CRC) is disclosed. The system includes a controller capable of receiving a message ({right arrow over (m)}). The message includes a plurality of blocks ({right arrow over (b)} i ) and a set of pre-computed coefficients ({right arrow over (β)} i ). The controller is also capable of performing a modulo-2 multiply-accumulate operation on the message ({right arrow over (m)}). The operation is given by: 
         [0000]    
       
         
           
             
               CRC 
                
               
                 ( 
                 
                   m 
                   → 
                 
                 ) 
               
             
             ≡ 
             
               
                 CRC 
                 ( 
                 
                   
                     ∑ 
                     i 
                   
                    
                   
                     
                       
                         b 
                         → 
                       
                       i 
                     
                     ⊗ 
                     
                       
                         β 
                         → 
                       
                       i 
                     
                   
                 
                 ) 
               
               . 
             
           
         
       
     
         [0008]    In still another embodiment, a process for cyclic redundancy checks (CRC) for use in a signal processing system is disclosed. The process includes receiving a message ({right arrow over (m)}). The message includes a plurality of blocks ({right arrow over (b)} i ) and a set of pre-computed coefficients ({right arrow over (β)} i ). The process also includes performing modulo-2 multiply-accumulate operations on the message ({right arrow over (m)}). 
         [0009]    Before undertaking the DETAILED DESCRIPTION OF THE INVENTION below, it may be advantageous to set forth definitions of certain words and phrases used throughout this patent document: the terms “include” and “comprise,” as well as derivatives thereof, mean inclusion without limitation; the term “or,” is inclusive, meaning and/or; the phrases “associated with” and “associated therewith,” as well as derivatives thereof, may mean to include, be included within, interconnect with, contain, be contained within, connect to or with, couple to or with, be communicable with, cooperate with, interleave, juxtapose, be proximate to, be bound to or with, have, have a property of, or the like; and the terms “element”, “construct” or “component” may mean any device, system or part thereof that performs a processing, control or communication operation; and such a device may be implemented in hardware, firmware or software, or some combination of at least two of the same. It should be noted that the functionality associated with any particular construct or component may be centralized or distributed, whether locally or remotely. Definitions for certain words and phrases are provided throughout this patent document, those of ordinary skill in the art should understand that in many, if not most instances, such definitions apply to prior, as well as future uses of such defined words and phrases. 
     
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0010]    For a more complete understanding of the present disclosure and its advantages, reference is now made to the following description taken in conjunction with the accompanying drawings, in which like reference numerals represent like parts: 
           [0011]      FIG. 1  illustrates a simplified block diagram of an exemplary digital signal processing system and controller for cyclic redundancy check calculations according to one embodiment of the present disclosure; and 
           [0012]      FIG. 2  is a simplified flowchart illustrating a method in accordance with one embodiment of the present disclosure. 
       
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
       [0013]      FIGS. 1 and 2 , discussed below, and the various embodiments used to describe the principles of the present disclosure in this patent document are by way of illustration only, and should not be construed in any way to limit the scope of the disclosure. Hereinafter, certain aspects of the present disclosure are described in relation to illustrative embodiments and operations of wireless communications systems and networks. Those skilled in the art, however, will understand that the principles and teachings of the present disclosure may be implemented in a variety of suitably arranged signal processing systems utilized in any number of end-equipment applications. 
         [0014]    Typical Galois multiply-accumulate systems include a message ({right arrow over (m)}) consisting of N bits. The message is a superposition of a plurality of blocks ({right arrow over (b)} i ). Each block ({right arrow over (b)} i ) is of a fixed size (e.g., M bits). The blocks are multiplied over a Galois Field of prime two (e.g., GF(2)) with unit vectors ({right arrow over (e)} i ) shifted by M bits with respect to each other. Thus, the message ({right arrow over (m)}) can be decomposed as shown by Equation 1 below: 
         [0000]    
       
         
           
             
               
                 
                   
                     m 
                     
                       
                           
                       
                       → 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         0 
                       
                       
                         
                           N 
                           / 
                           M 
                         
                         - 
                         1 
                       
                     
                      
                     
                       
                         
                           b 
                           → 
                         
                         i 
                       
                       ⊗ 
                       
                         
                           e 
                           → 
                         
                         i 
                       
                     
                   
                 
               
               
                 
                   [ 
                   
                     Eqn 
                     . 
                     
                         
                     
                      
                     1 
                   
                   ] 
                 
               
             
           
         
       
     
         [0015]    The summation and the multiplication operations included in Equation 1 are performed over GF(2). The GF(2) multiplication is shown as the symbol           while the GF(2) addition operation (an XOR operation) is shown as the symbol “⊕”. 
         [0016]    As an example of a typical application for Galois multiply-accumulate system, suppose a message ({right arrow over (m)}) containing sixteen bits (N=16) requires decomposition and is equal to the binary sequence [1101111100111010]. Suppose further that message ({right arrow over (m)}) is a superposition of blocks ({right arrow over (b)} i ) of a fixed number of bits (M). For example, suppose M=4 and is equal to the polynomial degree (or CRC width) W=3. Finally, suppose that the CRC polynomial ({right arrow over (p)}) is equal to [1010]. 
         [0017]    In a typical Galois application, message ({right arrow over (m)}) is first divided into four blocks [{right arrow over (b)} 3  {right arrow over (b)} 2  {right arrow over (b)} 1  {right arrow over (b)} 0 ] of four bits each, where {right arrow over (b)} 0 =1010, {right arrow over (b)} 1 =0011, {right arrow over (b)} 2 =1111 and {right arrow over (b)} 3 =1101. Moreover, message ({right arrow over (m)}) is the superposition of the blocks ({right arrow over (b)} i ) multiplied by unit vectors ({right arrow over (e)} i ) as given in Equation 2 below: 
         [0000]      {right arrow over (m)}={right arrow over (b)} 0           {right arrow over (e)} 0 ⊕{right arrow over (b)} 1           {right arrow over (e)} 1 ⊕{right arrow over (b)} 2           {right arrow over (e)} 2 ⊕{right arrow over (b)} 3           {right arrow over (e)} 3 .   [Eqn. 2] 
         [0018]    Continuing with the example above, suppose that the unit vectors ({right arrow over (e)} i ) are given by {right arrow over (e)} 0 =1, {right arrow over (e)} 1 =10000, {right arrow over (e)} 2 =100000000 and {right arrow over (e)} 3 =1000000000000. Next, the CRC of the message ({right arrow over (m)}) is given by the modulo-2 division of message ({right arrow over (m)}) by the CRC polynomial ({right arrow over (p)}) as given in Equation 3 below: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       CRC 
                        
                       
                         ( 
                         
                           m 
                           → 
                         
                         ) 
                       
                     
                     ≡ 
                     
                       CRC 
                       ( 
                       
                         
                           ∑ 
                           i 
                         
                          
                         
                           
                             
                               b 
                               → 
                             
                             i 
                           
                           ⊗ 
                           
                             
                               e 
                               → 
                             
                             i 
                           
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       i 
                     
                      
                     
                       
                         CRC 
                          
                         
                           ( 
                           
                             
                               
                                 b 
                                 → 
                               
                               i 
                             
                             ⊗ 
                             
                               ( 
                               
                                 
                                   e 
                                   → 
                                 
                                 i 
                               
                               ) 
                             
                           
                           ) 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   [ 
                   
                     Eqn 
                     . 
                     
                         
                     
                      
                     3 
                   
                   ] 
                 
               
             
           
         
       
     
         [0019]    Using the modulation properties of Equations 4 and 5 below and after assuming that x is smaller than p (i.e., mod(x) p =x), Equation 3 may be simplified to Equation 6 below, where {right arrow over (β)} i ≡CRC({right arrow over (e)} i ) and {right arrow over (β)} i  is a set of pre-computed coefficients: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         mod 
                          
                         
                           ( 
                           
                             x 
                             ⊕ 
                             y 
                           
                           ) 
                         
                       
                       p 
                     
                     = 
                     
                       
                         
                           mod 
                            
                           
                             ( 
                             x 
                             ) 
                           
                         
                         p 
                       
                       ⊕ 
                       
                           
                       
                        
                       
                         
                           mod 
                            
                           
                             ( 
                             y 
                             ) 
                           
                         
                         p 
                       
                     
                   
                   ; 
                 
               
               
                 
                   [ 
                   
                     Eqn 
                     . 
                     
                         
                     
                      
                     4 
                   
                   ] 
                 
               
             
             
               
                 
                   
                     
                       
                         mod 
                          
                         
                           ( 
                           
                             x 
                             ⊗ 
                             y 
                           
                           ) 
                         
                       
                       p 
                     
                     = 
                     
                       
                         mod 
                          
                         
                           ( 
                           
                             
                               
                                 mod 
                                  
                                 
                                   ( 
                                   x 
                                   ) 
                                 
                               
                               p 
                             
                             ⊗ 
                             
                               
                                 mod 
                                  
                                 
                                   ( 
                                   y 
                                   ) 
                                 
                               
                               p 
                             
                           
                           ) 
                         
                       
                       p 
                     
                   
                   ; 
                 
               
               
                 
                   [ 
                   
                     Eqn 
                     . 
                     
                         
                     
                      
                     5 
                   
                   ] 
                 
               
             
             
               
                 
                   
                     CRC 
                      
                     
                       ( 
                       
                         m 
                         → 
                       
                       ) 
                     
                   
                   ≡ 
                   
                     
                       ∑ 
                       i 
                     
                      
                     
                       
                         CRC 
                          
                         
                           ( 
                           
                             
                               
                                 b 
                                 → 
                               
                               i 
                             
                             ⊗ 
                             
                               
                                 β 
                                 → 
                               
                               i 
                             
                           
                           ) 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   [ 
                   
                     Eqn 
                     . 
                     
                         
                     
                      
                     6 
                   
                   ] 
                 
               
             
           
         
       
     
         [0020]    Finally, Equation 6 simplifies to Equation 7 below, where the CRC calculation essentially becomes a series of Galois multiply-accumulate operations: 
         [0000]    
       
         
           
             
               
                 
                   
                     CRC 
                      
                     
                       ( 
                       
                         m 
                         → 
                       
                       ) 
                     
                   
                   ≡ 
                   
                     
                       ∑ 
                       i 
                     
                      
                     
                       
                         gmpy 
                          
                         
                           ( 
                           
                             
                               
                                 b 
                                 → 
                               
                               i 
                             
                             , 
                             
                               
                                 β 
                                 → 
                               
                               i 
                             
                           
                           ) 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   [ 
                   
                     Eqn 
                     . 
                     
                         
                     
                      
                     7 
                   
                   ] 
                 
               
             
           
         
       
     
         [0021]    In Equation 7, the blocks ({right arrow over (b)} i ) are of a particular size (e.g., W bits or less). 
         [0022]      FIG. 1  a simplified block diagram of a system  100  for cyclic redundancy check calculations with modulo-2 multiplication in accordance with one embodiment of the present disclosure. System  100  includes a digital signal processing system  101  having an input  102  and an output  103 . By way of example, system  100  may include wire line or wireless communication devices (including cell phones, PCS handsets, personal digital assistant (PDA) handsets, portable computers, telemetry devices, etc.), computer systems, audio and video equipment, satellite communications, multimedia applications, home automation systems and any other systems requiring digital signal processing. Digital signal processing system  101  includes a controller  104  for performing cyclic redundancy check calculations according to one embodiment of the present disclosure. Digital signal processing system  101  may optionally include a lookup table  106 . It should be understood that embodiments of the present disclosure may implemented into existing equipment, such as multipliers. 
         [0023]    In accordance with one embodiment of the present disclosure, however, a series of modolu-2 multiply-accumulate operations is preferable. In alternate embodiments, modulo-2 multiplications may be used for at least some of the repetitive operations performed in the cyclic redundancy check (CRC) computations. As explained in greater detail below, a series of N-bit messages is parsed into blocks of size M for N/M parallel modulo-2 and multiply-accumulate operations. Finally, the accumulator is divided by the polynomial ({right arrow over (p)}). 
         [0024]    As a specific example, Equation 3 above may be expanded using Equation 8 to arrive at Equation 9 below. 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       mod 
                        
                       
                         ( 
                         
                           x 
                           ⊗ 
                           y 
                         
                         ) 
                       
                     
                     p 
                   
                   = 
                   
                     
                       mod 
                        
                       
                         ( 
                         
                           
                             
                               mod 
                                
                               
                                 ( 
                                 x 
                                 ) 
                               
                             
                             p 
                           
                           ⊗ 
                           
                             
                               mod 
                                
                               
                                 ( 
                                 y 
                                 ) 
                               
                             
                             p 
                           
                         
                         ) 
                       
                     
                     p 
                   
                 
               
               
                 
                   [ 
                   
                     Eqn 
                     . 
                     
                         
                     
                      
                     8 
                   
                   ] 
                 
               
             
             
               
                 
                   
                     
                       
                         
                           CRC 
                            
                           
                             ( 
                             
                               m 
                               → 
                             
                             ) 
                           
                         
                         = 
                         
                           
                             ∑ 
                             i 
                           
                            
                           
                             CRC 
                              
                             
                               ( 
                               
                                 
                                   
                                     b 
                                     → 
                                   
                                   i 
                                 
                                 ⊗ 
                                 
                                   ( 
                                   
                                     
                                       e 
                                       → 
                                     
                                     i 
                                   
                                   ) 
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                         
                           CRC 
                           ( 
                           
                             
                               ∑ 
                               i 
                             
                              
                             
                               CRC 
                               ( 
                               
                                 
                                   
                                     b 
                                     → 
                                   
                                   i 
                                 
                                  
                                 
                                   
                                     ) 
                                   
                                   ⊗ 
                                   
                                     
                                       β 
                                       → 
                                     
                                     i 
                                   
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   [ 
                   
                     Eqn 
                     . 
                     
                         
                     
                      
                     9 
                   
                   ] 
                 
               
             
           
         
       
     
         [0025]    Assuming that the block sizes ({right arrow over (b)} i ) are of size W bits or less, Equation 9 may be further simplified to a series of modolu-2 multiply-accumulate operations, as shown in Equation 10: 
         [0000]    
       
         
           
             
               
                 
                   
                     CRC 
                      
                     
                       ( 
                       
                         m 
                         → 
                       
                       ) 
                     
                   
                   ≡ 
                   
                     CRC 
                     ( 
                     
                       
                         ∑ 
                         i 
                       
                        
                       
                         
                           
                             b 
                             → 
                           
                           i 
                         
                         ⊗ 
                         
                           
                             β 
                             → 
                           
                           i 
                         
                       
                     
                     ) 
                   
                 
               
               
                 
                   [ 
                   
                     Eqn 
                     . 
                     
                         
                     
                      
                     10 
                   
                   ] 
                 
               
             
           
         
       
     
         [0026]    The division operation by the CRC polynomial is an epilog operation. Therefore, processing speed becomes less essential and reconfigurability becomes the main consideration. 
         [0027]      FIG. 2  is a simplified flowchart illustrating method  200 . Method  200  provides a method for cyclic redundancy check (CRC) operations in accordance with one embodiment of the present disclosure. Method  200  begins with receiving a message ({right arrow over (m)}) from, for example, input  102  of system  100  in step  201 . The message includes a plurality of blocks ({right arrow over (b)} i ) and a set of pre-computed coefficients ({right arrow over (β)} i ) In step  202 , controller  104  performs a modulo-2 multiply-accumulate operation on the message ({right arrow over (m)}) using the relationship given by Equation 10 above. Method  200  finally ends with step  203  by outputting a signal from digital signal processing system  101 . 
         [0028]    Embodiments of the present disclosure offer a number of advantages over previously known systems and methods. For example, the present disclosure is based on modulo-2 multiplications and therefore uses relatively few logical gates and consumes less power when compared to prior art Galois multiplication techniques. Moreover, because the modulo-2 multiplication is not followed by a division, the operation may be performed at higher clock speed than the prior art systems based on Galois multiplications. 
         [0029]    Conventional Galois multiplication methods depend upon the polynomials involved in the operation. As noted above, Galois multipliers have hardwired CRC polynomials and therefore are not reconfigurable to support other polynomials. Embodiments of the modulo-2 multiplication operation in accordance with the present disclosure, however, do not depend on a specific polynomial. Moreover, a lookup table approach may be implemented for full reconfigurability during polynomial division using, for example, lookup table  106 . Thus, the polynomial value may be customized to suit a particular application. 
         [0030]    Previous systems and methods require N/W CRC operations. According to one embodiment of the present disclosure, however, a series of GF(2) multiplications requires only one final CRC operation. Thus, one embodiment of the present disclosure saves at least (N/W)-1 unnecessary divisions. 
         [0031]    Existing systems may be modified by turning off the carry bit capability and using the modulo-2 multiplication in accordance with the present disclosure. As another example, in one embodiment according to the present disclosure, the system and method may include performing the division of the accumulator by the CRC polynomial by a nibble using lookup table  106 . Lookup table  106  is preferably made up of 16×W bits. 
         [0032]    Although certain aspects of the present disclosure have been described in relation to specific systems, standards and structures, it should be easily appreciated by one skilled in the art that embodiments of the system of the present disclosure provides and comprehends a wide array of variations and combinations easily adapted to a number of signal processing systems. As described herein, the relative arrangement and operation of necessary functions may be provided in any manner suitable for a particular application. All such variations and modifications are hereby comprehended. It should also be appreciated that the constituent members or components of this system may be produced or provided using any suitable hardware, firmware, software, or combination(s) thereof. 
         [0033]    The embodiments and examples set forth herein are therefore presented to best explain the present disclosure and its practical application, and to thereby enable those skilled in the art to make and utilize the system of the present disclosure. The description as set forth herein is therefore not intended to be exhaustive or to limit any invention to a precise form disclosed. As stated throughout, many modifications and variations are possible in light of the above teaching without departing from the spirit and scope of the following claims.