DETERMINING MESSAGE RESIDUE USING A SET OF POLYNOMIALS

BACKGROUND

[0001] Data transmitted over network connections or retrieved from a storage device, for example, may be corrupted for a variety of reasons. For instance, a noisy transmission line may change a "1" signal to a "0", or vice versa. To detect corruption, data is often accompanied by some value derived from the data such as a checksum. A receiver of the data can recompute the checksum and compare with the original checksum to confirm that the data was likely transmitted without error. [0002] A common technique to identify data corruption is known as a Cyclic Redundancy Check (CRC). Though not literally a checksum, a CRC value can be used much in the same way. That is, a comparison of an originally computed CRC and a recomputed CRC can identify data corruption with a very high likelihood. CRC computation is based on interpreting message bits as a polynomial, where each bit of the message represents a polynomial coefficient. For example, a message of " 1110" corresponds to a polynomial of x ³ + x ² + x + 0. The message is divided by another polynomial known as the key. For example, the other polynomial may be " 11 " or x + 1. A CRC is the remainder of a division of the message by the key. CRC polynomial division, however, is somewhat different than ordinary division in that it is computed over the finite field GF(2) (i.e., the set of integers modulo 2). More simply put: even number coefficients become zeroes and odd number coefficients become ones. [0003] A wide variety of techniques have been developed to perform CRC calculations. A first technique uses a dedicated CRC circuit to implement a specific polynomial key. This approach can produce very fast circuitry with a very small footprint. The speed and size, however, often come at the cost of inflexibility with respect to the polynomial key used. Additionally, supporting multiple keys may increase the circuitry footprint nearly linearly for each key supported. [0004] A second commonly used technique features a CRC lookup table where, for a given polynomial and set of data inputs and remainders, all possible CRC results are calculated and stored. Determining a CRC becomes a simple matter of performing table lookups. This approach, however, generally has a comparatively large circuit

footprint and may require an entire re -population of the lookup table to change the polynomial key being used.

[0005] A third technique is a programmable CRC circuit. This allows nearly any polynomial to be supported in a reasonably efficient amount of die area. Unfortunately, this method can suffer from much slower performance than the previously described methods.

BRIEF DESCRIPTION OF THE DRAWINGS

[0006] FIG. 1 is a diagram illustrating a set of stages that apply a set of pre-computed polynomials to determine a polynomial division residue.

[0007] FIG. 2 is a diagram of a set of pre-computed polynomials.

[0008] FIG. 3 is a diagram illustrating stages that perform parallel operations on a pre-computed polynomial and input data.

[0009] FIGs. 4A and 4B are diagrams of sample stages' digital logic gates.

[0010] FIG. 5 is a diagram of a system to compute a polynomial division residue.

DETAILED DESCRIPTION

[0011] FIG. 1 illustrates a sample implementation of a programmable Cyclic Redundancy Check (CRC) circuit 100. The circuit 100 can achieve, roughly, the same performance as a lookup table CRC implementation and may be only modestly slower than a dedicated CRC circuit implementation operating on a typical polynomial. From a die-area perspective, the circuit 100 can be orders of magnitude smaller than a lookup table approach and within an order of magnitude of a dedicated circuit implementation.

[0012] The circuit 100 uses a series of pre-computed polynomials 10Oa-IOOd derived from a polynomial key. Bits of the pre-computed polynomials 10Oa-IOOd are loaded into storage elements (e.g., registers or memory locations) and fed into a series of stages 106a-106d that successively reduce an initial message into smaller intermediate values en route to a final CRC result output by stage 106d. For example, as shown, the width of data, rb - ra, output by stages 106a-106d decreases with each successive stage. The pre-computed polynomials 10Oa-IOOd and stages 106d-106a are constructed such that the initial input, r _a , and the stage outputs, rb - ra, are congruent to

each other with respect to the final residue (i.e., r _a ≡ η, ≡ r _c ≡ rj). In addition, the pre- computed polynomials 10Oa-IOOd permit the stages 106a-106d to perform many of the calculations in parallel, reducing the number of gate delays needed to determine a CRC residue. Reprogramming the circuitry 110 for a different key can simply be a matter of loading the appropriate set of pre-computed polynomials into the storage elements 10Oa-IOOd.

[0013] FIG. 2 illustrates a sample set of pre-computed polynomials, gi(x), 10Oa-IOOd (e.g., g4, g2, gi, and go). By examination, these polynomials 10Oa-IOOd have the property that each successive polynomial 10Oa-IOOd in the set features a leading one bit (i + kth bit) followed by followed by i-zeroes 102 (shaded) and concluding with k- bits of data 104 of the order of the generating (CRC) polynomial (e.g., go). The form of these polynomials 10Oa-IOOd enables each stage 106a-106d to reduce input data to a smaller, but CRC equivalent, value. For example, after deriving a set of polynomials (g4(x), g ₂ (x), gi(x)} from some 9-bit polynomial go(x), a CRC could be determined for input data of 16-bits. During operation, applying g ₄ (x) would reduce the input data from 16-bits to 12-bits, g ₂ (x) would reduce the next the data from 12- bits to 10-bits, and so forth until an 8-bit residue was output by a final stage 106d. Additionally, as described in greater detail below, a given stage 106a-106d may use a polynomial 10Oa-IOOd to process mutually exclusive regions of the input data in parallel.

[0014] More rigorously, let g(x) be a k^-degree CRC polynomial of k+1 bits, where the leading bit is always set in order that the residue may span k bits. The polynomial g(x) is defined as k-l g( ^χ ) = [ ^χk + ∑ _gι ^χ '] _gj e GF(2)

[0015] The polynomial gj(x) is then defined as: _gl (x) = x ^k+ ' + [x ^k+ ' mod g(x)]

[0016] In accordance with this definition of gi(x), a sequence of polynomials can be computed as a function of selected values of i and the original polynomial g(x).

[0017] The CRC polynomial, g(x) , divides g _t (x) : g( ^χ ) \ g,( ^χ ) proof _gl (x) = x ^k+ ' +[x ^k+ ' modg(x)] = x ^k+ ' +[x ^k+ ' -a _l (x)g(x)]

- for some a _t (x) = a _t (x)g(x)

From this, a recurrence can be defined, where at each stage a message, m(x), is partially reduced by one of the pre-computed polynomials. [0018] Let m(x) be a 2 ^L bit message and r(x) be the k-bit result:

V ₁ , m _j e GF(2) r{x) = [m(x) ^■ x mod g(x)]

where m(x) is shifted by x , creating room to append the resulting CRC residue to the message, m(x). Thus: r _o (x) = m(x) -x ^k

φ) = [r ₁ -ι(x)modg _2L , (x)]

for i > 1. Thus, η (x) ≡ r ₀ (x) mod g(x) , which is proved by induction on i: proof r ₁ (x) = r ₀ (x)modg _{2£ 1} (x)

= r ₀ (x)mod[α _{2£ 1} (x)g(x)]

proof

= r _! _ ₁ (x)mod[α _L , (x)g(x)]

[0019] Finally, r _L {x) = r(x) , which follows from the observations made above:

r _L (x) = [r _L ^(x)∞odg ₀ (xy\

= [m(x) ^■ x ^k - b(x) ^■ g(x)] mod g ₀ (x)

- for some b(x) = m(x) ^■ x ^k mod g(x)

[0020] These equations provide an approach to CRC computation that can be implemented in a wide variety of circuitry. For example, FIG. 3 illustrates a high- level architecture of a circuit implementing the approach described above. As shown, a given stage 106a-106d can reduce input data, r, by subtracting a multiple of the k- least significant bits 104 of the pre-computed polynomial gj(x) from the stage input. Again, the resulting stage output is congruent to the stage input with respect to a CRC calculation though of a smaller width.

[0021] The sample implementation shown features stages 106a-106d that AND 110a- HOd (e.g., multiply) the k-least significant bits 104 of gj(x) by respective bits of input data. The i-zeroes 102 and initial "1" of gj(x) are not needed by the stage since they do not affect the results of stage computation. Thus, only the k-least significant bits of gi(x) need to be stored by the circuitry.

[0022] To illustrate operation, assuming ro had a value starting "1010..." and the k- least significant bits of g ₄ (x) had a value of "001010010", the first 110a and third 110c AND gates would output "001010010" while the second 110b and fourth HOd AND gates would output zeros. As indicated by the shaded nodes in FIG. 3, the output of the AND 1 lOa-11Od gates can be aligned to shift (i.e., multiply) the gate 1 lOa-11Od output in accordance with the respective bit-positions of the input data. That is, the output of the gate 110a operating on the most significant bit of input data is shifted by i-1 bits, and each succeeding gate 11 Ob-11Od decrements this shift by 1. For example, the output of gate 110a, corresponding to the most significant bit of r ₀ , is shifted by 3- bits with respect to the input data, the output of gate 110b corresponding to the next most significant bit of r ₀ is shifted by 2-bits, etc. The input data can then be subtracted (e.g., XOR-ed) by the shifted-alignment of the output of gates 11 Oa-11Od. The subtraction result reduces the input data by a number of bits equal to the number

of zeroes 102 in the polynomial for i > 0. In essence, the i-most significant bits of input data, r _Oj act as selectors, either causing subtraction of the input data by some multiple of the k-least significant bits of g^x) or outputting zeroes that do not alter the input data.

[0023] As shown, the AND gates 11 Oa-11Od of a stage 106a may operate in parallel since they work on mutually-exclusive portions of the input data. That is, AND gates 11 Oa-11Od can each simultaneously process a different bit of ro in parallel. This parallel processing can significantly speed CRC calculation. Additionally, different stages may also process data in parallel. For example, gate HOe of stage 106b can perform its selection near the very outset of operation since the most significant bit of r ₀ passes through unaltered to stage 106b.

[0024] FIG. 4A depicts digital logic gates of a sample stage 106a implementation conforming to the architecture shown in FIG. 3. In this example, the stage 106a receives a 16-bit input value (e.g., ro = input data [15:0]) and the k-least significant bits of g ₄ (x). The stage 106a processes the i-th most significant bits of the input value with i-sets of AND gates 11 Oa-11Od where each input data bit is ANDed 11 Oa-11Od with each of the k-least significant bits of g ₄ (x). Each set of k-AND gates 1 lOa-11Od in FIG. 4A corresponds to the conceptual depiction of a single AND gate in FIG. 3. The output of the AND gate arrays 11 Oa-11Od is aligned based on the input data bit position and fed into a tree of XOR gates 112a-l 12d that subtract the shifted AND gate 1 lOa-11Od output from the remaining bits of input data (i.e., the input data less the i-th most significant bits).

[0025] FIG. 4B depicts digital logic gates of a succeeding stage 106b that receives output 1 data [11 :0] and generates output_2 data [9:0]. The stage 106b receives the 12-bit value output by stage 106a and uses g ₂ (x) to reduce the 12-bit value to a CRC congruent 10-bit value. Stages 106a, 106b share the same basic architecture of i- arrays of AND gates that operate on the k-least significant bits of gi(x) and an XOR tree that subtracts the shifted AND gate output from the stage input to generate the stage output value. Other stages for different values of i can be similarly constructed. [0026] The architecture shown in FIGs. 3, 4A, and 4B are merely examples and a wide variety of other implementations may be used. For example, in the sample FIGs, each stage 106a-106d processed the i-th most significant bits of input data in

parallel. In other implementations, a number of bits greater or less than i could be used in parallel, however, this may not succeed in reducing the size of the output data for a given stage.

[0027] The architecture shown above may be used in deriving the pre-computed polynomials. For example, derivation can be performed by zeroing the storage elements associated with gj(x) and loading go with the k-least significant bits of the polynomial key. The bits associated with successive g _r s can be determined by applying x ^k+1 as the data input to the circuit and storing the resulting k-least significant bits output by the go stage as the value associated with g,. For example, to derive the polynomial for g ₂ , x ^k+2 can be applied as the circuit, the resulting k-bit output of the go stage can be loaded as the value of the g ₂ polynomial.

[0028] FIG. 5 depicts a sample CRC implementation using techniques described above. The implementation works on successive portions of a larger message in 32- bit segments 120. As shown, the sample implementation shifts 124, 126 and XORs 128 a given portion 120 of a message by any pre-existing residue 122 and computes the CRC residue using stages 106a-106f and the k-bits of the respective pre-computed polynomials gi(x). Again, successive stages 106a-106e reduce input data by i-bits until a residue value is output by stage 106f. The circuit then feeds the residue back 122 for use in processing the next message portion 124. The residue remaining after the final message portion 120 is applied is the CRC value determined for the message as a whole. This can either be appended to the message or compared with a received CRC value to determine whether data corruption likely occurred. [0029] The system shown in FIG. 5 featured (L+ 1) stages 106a- 106f where the polynomials were of the form i = {0, 2 ^{n l} for n = 1 to L}. However, this strict geometric progression of i is not necessary and other values of i may be used in reducing a message. Additionally, at the lower polynomial levels (e.g., i < 4) it may be more efficient to abandon the stage architecture depicted in FIGs. 3, 4 A, and 4B and process an input value using g ₀ in a traditional bit-serial or other fashion. [0030] Techniques described above can be used to improve CRC calculation speed, power efficiency, and circuit footprint. As such, techniques described above may be used in a variety of environments such as network processors, security processors, chipsets, ASICs (Application Specific Integrated Circuits), and as a functional unit

within a processor or processor core where the ability to handle high clock speeds, while supporting arbitrary polynomials, is of particular value. As an example, CRC circuitry as described above may be integrated into a device having one or more media access controllers (e.g., Ethernet MACs) coupled to one or more processors/processor cores. Such circuitry may be integrated into the processor itself, in a network interface card (NIC), chipset, as a co-processor, and so forth. The CRC circuitry may operate on data included within a network packet (e.g., the packet header and/or payload). Additionally, while described in conjunction with a CRC calculation, this technique may be applied in a variety of calculations such as other residue calculations over GF(2) (e.g., Elliptic Curve Cryptography). [0031] The term circuitry as used herein includes implementations of hardwired circuitry, digital circuitry, analog circuitry, programmable circuitry, and so forth. The programmable circuitry may operate on computer instructions disposed on a storage medium

[0032] Other embodiments are within the scope of the following claims. [0033] What is claimed is: