Correcting memory device and memory channel failures in the presence of known memory device failures

[0001] This invention relates generally to computer memory and more particularly, to error detection and correction in a redundant memory system.

[0002] Memory device densities have continued to grow as computer systems have become more powerful. With the increase in density comes an increased probability of encountering a memory failure during normal system operations. Techniques to detect and correct bit errors have evolved into an elaborate science over the past several decades. Perhaps the most basic detection technique is the generation of odd or even parity where the number of 1's or 0's in a data word are “exclusive or-ed” (XOR-ed) together to produce a parity bit. If there is a single error present in the data word during a read operation, it can be detected by regenerating parity from the data and then checking to see that it matches the stored (originally generated) parity.

[0003] Richard Hamming recognized that the parity technique could be extended to not only detect errors, but to also correct errors by appending an XOR field, an error correction code (ECC) field, to each data, or code, word. The ECC field is a combination of different bits in the word XOR-ed together so that some number of errors can be detected, pinpointed, and corrected. The number of errors that can be detected, pinpointed, and corrected is related to the length of the ECC field appended to the data word. ECC techniques have been used to improve availability of storage systems by correcting memory device (e.g., dynamic random access memory or “DRAM”) failures so that customers do not experience data loss or data integrity issues due to failure of a memory device.

[0004] Redundant array of independent memory (RAIM) systems have been developed to improve performance and/or to increase the availability of storage systems. RAIM distributes data across several independent memory modules (each memory module contains one or more memory devices). There are many different RAIM schemes that have been developed each having different characteristics, and different pros and cons associated with them. Performance, availability, and utilization/efficiency (the percentage of the disks that actually hold customer data) are perhaps the most important. The tradeoffs associated with various schemes have to be carefully considered because improvements in one attribute can often result in reductions in another.

[0005] An embodiment is method for locating and correcting a memory channel failure, or alternately for correcting up to c chip failures and detecting up to d chip failures in the presence of up to u chips that are marked as suspect. The method includes computing syndromes of data retrieved from a memory in a memory system comprising M channels. A first stage of decoding is performed using a decoder capable of u-erasure, c error correction, and d error detection. Performing the first stage of decoding results in recovering an estimate of correctable errors affecting the data or in declaring an uncorrectable error state. An uncorrectable error state is declared in response to a syndrome of the recovered estimated errors not being the same as the computed syndromes of data retrieved from the memory. A second stage of decoding is performed in response to the uncorrectable error state being declared. The performing a second stage includes attempting to correct u erasures and a channel error in M iterations, while changing a channel location in each iteration. A correctable error is declared in response to exactly one of the M iterations being successful.

[0019] An embodiment provides an implementation efficient error control coding system that allows a memory to sustain a combination of known memory device failures, a channel failure, as well as additional corrections. An embodiment of an algorithm described herein is able to detect and correct a failing channel even in the presence of known chip failures without any external aid to locate the failing channel. An embodiment provides a general framework for the design of a new class of efficient coding algorithms that may be applied to a variety of memory system architectures. An embodiment described herein provides lower complexity of implementation, a more regular placement for redundant checks throughout a channel, and no loss of strength in error correction and detection coverage as compared to Reed-Solomon codes.

[0020] As in many redundant array of independent memory (RAIM) system designs, an embodiment assumes that one channel stores the simple parity of the other channels, thus enabling a simple way of correcting for many errors. Embodiments described herein are concerned with the check bits that are stored in the other channels and how to design these check bits. In an embodiment, these check bits are designed to solve the problem of “error mirroring” which is the phenomenon that errors outsides a failing channel get replicated into the failing channel when a simple “exclusive or” (XOR) operation is used to correct the failing channel, thus increasing the apparent number of errors in the pattern.

[0021] An embodiment described herein provides techniques for developing parity check matrices, as well as very efficient encoding and decoding algorithms for codes that have no loss of strength with respect to Reed-Solomon codes, yet preserve the simple parity across the channels and gracefully handle the problem of error mirroring.

[0022] As used herein, the term “memory channel” refers to a logical entity that is attached to a memory controller and which connects and communicates to registers, memory buffers and memory devices. Thus, for example, in a cascaded memory module configuration a memory channel would comprise the connection means from a memory controller to a first memory module, the connection means from the first memory module to a second memory module, and all intermediate memory buffers, etc. As used herein, the term “channel failure” refers to any event that can result in corrupted data appearing in the interface of a memory controller to the memory channel. This failure could be, for example, in a communication bus (e.g., electrical, and optical) or in a device that is used as an intermediate medium for buffering data to be conveyed from memory devices through a communication bus, such as a memory hub device.

[0023] FIG. 1 is a block diagram of a cascade interconnect memory system that may be implemented by an exemplary embodiment. The memory system depicted in FIG. 1 includes multiple independent cascade interconnected memory interface busses 106 that are logically aggregated together to operate in unison to support a single independent access request from a memory controller 110. The servicing of the single independent access request includes data and error detection/correction information distributed or “striped” across the parallel memory interface busses 106 and associated memory devices located on the memory modules 102.

[0024] As shown in the embodiment depicted in FIG. 1, the memory controller 110 attaches to five narrow/high speed point-to-point memory interface busses 106, with each memory interface bus 106 connecting one of five memory controller interface channels to a cascade interconnect memory module 102 (or memory subsystem). In an exemplary embodiment, each memory module 102 includes at least one hub device and one or more memory devices. As used herein, the terms “memory device” and “chip” are used interchangeably with a chip being a particular implementation of a memory device. As depicted in FIG. 1, the memory interface busses 106 operate in unison to support an access request from the memory controller 110. In an exemplary embodiment, there may exist a multiplicity of outstanding fetch and store requests to the multiple cascades in the memory subsystem.

[0025] Each memory interface bus 106 in the embodiment depicted in FIG. 1 includes an upstream bus 108 and a downstream bus 104. One of the functions provided by the memory modules 102 (e.g., a hub device located on the memory module 102) is a re-drive function to send signals on the upstream bus 108 to the memory controller 110 or on the downstream bus 104 to other memory modules 102. In an exemplary embodiment, up to two memory modules 102 are cascade connected to each memory interface bus 106. In an exemplary embodiment, the memory interface bus 106 is implemented using differential clock and data signals (i.e., each clock and data signal requires two wires). In an exemplary embodiment, the downstream bus 104 includes thirty-two wires to support: one clock signal, thirteen data/command signals (or bits), one spare clock lane, and one spare data/command lane. In this embodiment, each data packet is transferred over the downstream bus 104 in twelve beats. In an exemplary embodiment, the upstream bus 108 includes forty-six wires to support: one clock signal, twenty data/command signals, one spare clock lane, and one spare data/command lane. In this embodiment, each data packet is transferred over the upstream bus 108 in eight beats.

[0026] As used herein, the term “RAIM” refers to redundant arrays of independent memory modules (e.g., dual in-line memory modules or “DIMMs). In a RAIM system, if one of the memory channels fails (e.g, a memory module in the channel), the redundancy allows the memory system to use data from one or more of the other memory channels to reconstruct the data stored on the memory module(s) in the failing channel. The reconstruction is also referred to as error correction. As used herein, the terms “RAIM” and “redundant arrays of independent disk” or “RAID” are used interchangeably.

[0027] In an exemplary embodiment, the memory system depicted in FIG. 1 is a RAIM memory system and the five channels are lock step channels (i.e., the five memory interface busses 106 are accessed in unison with each other). In an exemplary embodiment, the RAIM system depicted in FIG. 1 is implemented using the RAIM ECC code described herein which has the property that one of the channel's data is the bitwise XOR of the other four channel's data with additional check bits included in order to correct for additional errors. In the embodiment depicted in FIG. 1, the decoder 112 is located on the memory controller 110. In embodiments, the decoder 112 is located on the memory modules 102, the memory controller and/or on other hardware/software locations in the memory system.

[0028] As used herein, the term “mark” refers to is an indication given to an ECC that a particular symbol or set of symbols of a read word are suspected to be faulty. The ECC can then use this information to enhance its error correction properties. As used herein, the term “correctable error” or “CE” refers to an error that can be corrected while the system is operational, and thus a CE does not cause a system outage. As used herein, the term “uncorrectable error” or “UE” refers to an error that cannot be corrected while the memory system is operational, and thus correction of a UE causes the memory system to be off-line for some period of time while the cause of the UE is being corrected (e.g., by replacing a memory device, by replacing a memory module, recalibrating and interface).

[0029] As used herein, the term “coincident” refers to the occurrence of two (or more) error patterns or error conditions that overlap each other in time. In one example, a CE occurs and then later in time, before the first CE can be repaired, a second failure occurs. The first and second failure are said to be coincident. Repair times are always greater than zero and the longer the repair time, the more likely it would be to have a second failure occur coincident with a the first. Some contemporary systems attempt to handle multiple failing devices by requiring sparing a first device or module. This may require substantially longer repair times than simply using marking, as provided by exemplary embodiments described herein. Before a second failure is identified, exemplary embodiments provide for immediate correction of a memory channel failure using marking, thus allowing an additional correction of a second failure. Once a memory channel failure is identified, an exemplary embodiment provides correction of the memory channel failure, up to two marked additional chips (e.g., memory devices) and a new single bit error. If the system has at most one marked memory device together with the marked channel, then an entire new chip error can be corrected.

[0030] The words “memory channel failure” utilized herein, includes failures of the communication medium that conveys the data from the memory modules 102 to the memory controller 110 (i.e., a memory interface bus 106), in addition to possible memory hub devices and registers.

[0031] The ECC code described herein supports incorporating a special uncorrectable error (SPUE) signature into an encoded data packet so that in the absence of new errors, and irrespective of the chip and channel marking state and the errors in the marked chips/channel, the SPUE is still detectable as a SPUE. Even if there are a large number of errors on top of the codeword, the data will still be flagged as a UE. This is necessary to protect against UE data that has to be stored to memory to keep soft errors from having that data appear good (i.e. Clean or CE).

[0032] FIG. 2 depicts a table that defines the marking states for a RAIM code according to the value of the chip marks (x and y) as well as the channel mark in accordance with an embodiment. A checkmark indicates that the associated mark has a non-default valid value (i.e., the mark is pointing to a chip/channel). The absence of a checkmark indicates that the corresponding mark is pointing to its default value.

[0033] FIG. 3 depicts a table that summarizes the capabilities of an embodiment of the RAIM code as a function of the marking state. A ‘(*)’ indicates that the channel error is correctable in all but about 1 e⁻⁹ of the cases. A ‘(**)’ indicates that the UE flag is raised with extremely high probability.

[0034] FIG. 4 depicts a table that summarizes the capabilities of an embodiment of the RAIM code in the presence of an injected SPUE. A ‘(*)’ indicates that the UE flag is raised with extremely high probability.

[0035] A description of a decoder implemented in accordance with an embodiment follows.

[0036] Regular Syndrome Generation Stage.

[0037] There two distinct kinds of syndromes that are associated with an embodiment of a code. One is called the Z syndrome which is obtained by doing a simple XOR of the contents of the five channels:
Z=D₀⊕D₁⊕D₂⊕D₃⊕D₄
The other syndrome is called S, and is associated with a parity check matrix:
H=[H₀H₁H₂H₃H₄]:
S=H₀D₀⊕H₁D₁⊕H₂D₂⊕H₃D₃⊕H₄D₄

[0038] This parity check matrix is highly structured and thus the computation of S admits efficient implementations, as described herein below. In an embodiment, the quantity S is a total of 64 bits, logically grouped in four 16-bit (2¹⁶) Galois Field (GF) elements.

[0039] Channel Adjusted Syndrome Generation Stage.

[0040] In an embodiment, the decoder initially computes five syndromes {S⁽⁻⁰⁾, S⁽⁻¹⁾, S⁽⁻²⁾, S⁽⁻³⁾, S⁽⁻⁴⁾} called the “channel adjusted syndromes”. Mathematically, S⁽⁻ⁱ⁾ are the syndromes that would be obtained if the contents of channel i were replaced with the XOR of the contents of the other four channels. The original syndrome S is 64 bits, and the same is true for S⁽⁻ⁱ⁾, iε{0, 1, 2, 3, 4}. Since the contents of the ith channel are D_i and Z=D₀⊕D₁⊕D₂⊕D₃⊕D₄, the adjusted content for D_i can be computed as D_i⊕Z.

[0041] Thus, mathematically, the definition of an embodiment of S⁽⁻ⁱ⁾ is as follows:

[0042] $\begin{array}{c}{S}^{\left(-i\right)}=H_0{D}_0\oplus H_1{D}_1\oplus H_2{D}_2\oplus H_3{D}_3\oplus H_4{D}_4\oplus H_{i}Z\\ =S\oplus H_{i}Z\end{array}\hspace{1em}$

[0043] It is important to note that channel adjusted syndromes are computed for all channels iε{0, 1, 2, 3, 4}. A primary reason behind the design of an embodiment is to be able to have a total latency for the decoder that is constant across all possible error pattern instances. In particular, in this manner the decoder is prepared to correct any possible unknown channel failure.

[0044] Chip and Channel Adjusted Syndrome Generation Stage.

[0045] In an embodiment, this stage is responsible for removing from each of the syndromes computed in the earlier stage the contribution of any possible error that is residing in chip pointed to by x or y. The input signals to the RAIM block x and y (henceforth called the “chip marks”) are each in one of two valid generic states: a chip mark can be set to a default location (different for x and y), or can point to a valid chip location. It is allowed for one chip mark to point to its default location and the other one to be pointing to a valid chip location. The default locations are logically thought to be in a sixth (physically non-existing) channel and in chip positions 9 and 10 of the sixth channel, again these locations physically non-existing depicts since in an embodiment a channel has exactly 9 chips associated with it.

[0046] FIG. 5 illustrates an embodiment of the logical placement of symbols of an error control code in a memory system that includes five channels 504 (e.g., each channel corresponding to a memory module 102) and nine chips 502 (e.g., memory devices). As shown in FIG. 5, four of the channels 504 include stored check bits (e.g., nine sixteen bit symbols) and the fifth channel is the RAIM channel that contains a simple XOR of the other four channels. Also shown in FIG. 5 are the two chip marks 506 which are logically assigned to a sixth (non-existing) channel on non-existing chips nine and ten.

[0047] In an embodiment, the decoder is completely symmetric in x and y; that is, it is not necessary to use specifically x or y when there is only one chip being marked. The chip marks may also be thought of as “soft” (unlike the case of chip sparing) since there is no actual data movement/changes when a chip mark is placed, these marks may be removed or changed to another chip with a simple mark store table update (in an embodiment the mark store table is not a component that belongs to the RAIM block). In an embodiment, the decoder always removes any contribution of errors in chips pointed to by x and y even if x and/or y are pointing to a default “parked” location.

[0048] The notation used herein is as follows: Ŝ⁽⁻ⁱ⁾ denotes the chip and channel adjusted syndromes for the case in which channel i is thought to contain the channel error, and these syndromes are derived from the syndromes S⁽⁻ⁱ⁾. For each iε{0, 1, 2, 3, 4}, S⁽⁻ⁱ⁾ contains exactly four 16-bit GF(2¹⁶) quantities (same number of bits as in S), whereas the chip and channel adjusted syndromes {Ŝ⁽⁻ⁱ⁾} are each only two 16-bit quantities. This is explained by the fact that an embodiment always removes potential errors for exactly two chip locations, even if one or two of these locations are pointing to their default value.

[0049] An important special case happens when x or y or both happen to point at chip(s) that reside on the same channel that is being adjusted for. The design is such that it is necessary to avoid “double marking” chip locations. Thus, in an embodiment, the following procedure is performed by the decoder: while preparing the chip and channel adjusted syndromes for channel i, it is checked whether x, y or both reside on channel i. Any chip mark pointing to a chip in channel i is “moved” to its default location for the purposes of making computations that assume that channel i is marked. It is important to note that the “movement” of chip marks is independent for each channel; all five possible chip mark movements are calculated and performed in parallel.

[0050] One embodiment of this design is that the corrected content of chips that are marked may in fact be corrected through the RAIM channel correction mechanism.

[0051] Channel Adjusted Mark Generation.

[0052] In an embodiment, the externally supplied chip marks x, y need to be suitably modified for each possible choice for channel mark. One reason has been mentioned previously: when a chip mark points to a chip that is contained in a channel that is being marked, this chip mark needs to be moved to its default position. This is not the only reason the chip marks need to be adjusted in a per channel marked basis. The structure of an embodiment of the this RAIM code, which stores a simple parity in the fifth channel of the other four channels, gives rise to a phenomenon that is termed “error mirroring”.

[0053] This is most easily understood by example. Suppose that the following is received from the five channels:

[0054] $\left(D_0,D_1\left[\begin{array}{c}0\\ 0\\ 0\\ 0\\ e\\ 0\\ 0\\ 0\\ 0\end{array}\right],D_2,D_3\oplus \left[\begin{array}{c}{\epsilon }_1\\ {\epsilon }_2\\ {\epsilon }_3\\ {\epsilon }_4\\ {\epsilon }_5\\ {\epsilon }_6\\ {\epsilon }_7\\ {\epsilon }_8\\ {\epsilon }_9\end{array}\right],D_4\right)$

[0055] In the above, D_i stands for the original nine 16-bit symbols stored in channel i for iε{0, 1, 2, 3, 4} (so that D₄=D₀⊕D₁⊕D₂⊕D₃), there is a single chip error in channel one in the fifth chip with an error magnitude e and there is a channel failure in channel three. If channel three is marked accordingly, consider what would be obtained if XOR of channels 0, 1, 2 and 4 is calculated and the result is substituted in channel three:

[0056] $\left(D_0,D_1\left[\begin{array}{c}0\\ 0\\ 0\\ 0\\ e\\ 0\\ 0\\ 0\\ 0\end{array}\right],D_2,D_3\oplus \left[\begin{array}{c}0\\ 0\\ 0\\ 0\\ e\\ 0\\ 0\\ 0\\ 0\end{array}\right],D_4\right)$

[0057] Note that the chip error with magnitude e has been “mirrored” into channel three, in exactly the same row (chip index within a channel) as the original row (row five in this case). An exemplary embodiment of the decoder Due to reasons that are beyond the scope of this initial high level description of the decoder operation it turns out that the correct method for decoding the remaining error calls for thinking of “channel adjusted chip positions” instead of regular chip positions, and thus chip marks need to be channel adjusted for each channel. Suppose that X_k,j is the 16-bit Galois Field pattern that is associated with the chip in channel k, chip j. Then the channel adjusted chip position of X_k,j when channel i* is marked is given by X_k,j⊕X_i*,j.

[0058] Syndrome and Mark Selector.

[0059] The architecture of an embodiment of the decoder is such that internally, a channel is always chosen to be marked. The index of this channel that is marked is called i*, which is a number in {0, 1, 2, 3, 4}. This is true even in the case there are no new errors to be solved for or in the case there is no external channel marked. When there is no obvious choice for what channel mark to use, the decoder chooses the fifth channel (i*=4) as the channel mark.

[0060] An embodiment of a process followed to do syndrome selection is described next. When an external channel mark is given, the decoder will always multiplex the chip and channel adjusted syndromes corresponding to that channel (it will also multiplex the channel adjusted syndromes for that channel as well, as they are needed for the next stage).

[0061] When there is no external channel mark placed, the decoder checks whether there is a unique chip and channel adjusted syndrome that is exactly equal to zero, since such “signature” implies that applying that channel mark in conjunction with potential existing chip marks, would fully resolve the error. If a unique choice exists, the syndrome selection circuitry chooses to select such syndrome, which of course by definition is equal to zero. It also selects the corresponding channel adjusted syndrome, which is general nonzero.

[0062] If all the chip and channel adjusted syndromes are equal to zero:
Ŝ⁽⁻⁰⁾=Ŝ⁽⁻¹⁾=Ŝ⁽⁻²⁾=Ŝ⁽⁻³⁾=Ŝ⁽⁻⁴⁾=0
then, the decoder at this moment has learned that no new error has taken place, beyond any error potentially present in chips that are marked. In this case, the syndromes corresponding to the fifth channel (both channel adjusted and chip and channel adjusted) are selected as a default action.

[0063] The final case is when there are at least two distinct channels i, j with
Ŝ⁽⁻ⁱ⁾=Ŝ^(−j)=0
In this case, the decoder does not have enough information to decide which is the failing channel and declares an uncorrectable error.

[0064] Syndrome Decoder.

[0065] In an embodiment, once a choice for what chip and channel adjusted syndromes to employ has been made, the decoder proceeds to decode the resulting syndromes. Throughout this discussion the terminology “error magnitude” will refer to the bit flip masks that need to be applied to a chip in order to correct its error.

[0066] It is important to note that this stage of the decoder processes both the channel adjusted syndromes as well as the chip and channel adjusted syndromes. The latter are analyzed first when attempting to find the location and magnitude of a potential new chip error, and the former are then employed when computing the error magnitudes of the chips that are marked.

[0067] If the chip and channel adjusted syndrome is zero, no further errors have been detected and hence all that remains is to compute the error magnitudes associated with the channel marked and the chips marked.

[0068] If the chip and channel adjusted syndrome is nonzero, this implies that there is an error that must be analyzed to see whether is correctable, and if so, to correct it. In an embodiment this includes two steps. The first step is the computation of the error magnitude e and location r of a potential new chip error. A salient feature of this step is that the location computation procedure entails solving a quartic that due to its special structure, admits a simplified implementation. The quartic does result in four possible solutions for r, but the mathematical properties of the code are such that when there is a new single chip error, it is guaranteed that only one of the four possible solutions will correspond to a valid chip location. The decoder compares the roots of the quartic against the possible valid chip locations and eliminates from the list those roots that are not valid. The second step is the computation of the error magnitudes e_x and e_y of the chips pointed to by x and y. The outcome of this step is self explanatory. It is important to note though that both e_x and e_y are computed even if x, or y or both are pointing to their default location. If x is pointing to its default location, then e_x=0 in the absence of uncorrectable errors; similarly for y.

[0069] Bit Flip Mask Generation and Flags Generation.

[0070] In an embodiment, this is the last stage of decoding. This stage requires access to e_x, e_y, e and r, as well as the syndrome Z, among other findings of the decoder. In principle, the following prescription results in the desired correction: the bit flip masks e_x, e_y and e are applied to the chips pointed to x, y and r, respectively, unless the chip pointed to is not a valid chip location (for example, a default value for x is not a valid chip location for x). Then the contents of the channel i* are replaced with the XOR of the chip corrected contents of the other 4 channels. It is important to note that in an embodiment, the values of x and y must correspond.

[0071] An actual implementation of an embodiment in the decoder may achieve the above in a different manner, because the decoder needs to generate an overall bit flip mask for the data in all five channels that is then applied to the data as a single last step. In an embodiment, the bit flip mask is generated as follows. As in the description above, the values of e_x, e_y, e and x, y, and r are used to generate the bit flip mask corresponding to “chip corrections”; note that this is one mask for each of the 4 channels that are not marked (equivalently, that are not assigned the index i*). Then, each of the masks for the 4 channels is applied to the Z syndrome that is forwarded to this stage from the initial syndrome generation stage. The result of this operation becomes the bit flip mask of the channel that is marked (i*).

[0072] Also in this section the decoder computes the uncorrectable error flag. There are various invalid conditions that the decoder checks for in order to form an overall uncorrectable error flag; it is important to note that it is important to capture all possible invalid states for the decoder in order to obtain the maximum amount of protection against potential mis-corrections.

[0073] A particular UE condition that is worth singling out due to its special significance relates to the claim in the last two columns of the table in FIG. 3 for state F. Note that the table indicates that single bit errors are correctable whereas double bit errors are fully detectable. Disallowing corrections of new errors in state F that have 2 or more bits in error in one 16-bit symbol, results in any double bit error always be detected. This property is obtained by a very careful choice of the “chip indexing” function that is described in a later section of this document, and has been proved to be true by an exhaustive computer manipulation of the parity check matrix of the code.

[0074] No External Channel Mark.

[0075] In this case, an embodiment of the decoder is responsible for correcting up to two chip marks, and an unknown chip error or channel error. An important consideration is the decoder, in this mode, internally treats unknown chip errors as channel errors, and corrects them accordingly. In this setting, the syndromes obtained in the “syndrome selection” stage described above are equal to zero, and therefore the circuits under “syndrome decoder” that look for new errors do not find any. This design stems from the fact that the decoder does not make a distinction on the number of errors present in a channel when it detects a channel error.

[0076] External Channel Mark Specified.

[0077] In contrast to the no external channel mark situation, in this mode new chip errors result in a nonzero chip and channel adjusted syndrome selected in the “syndrome and mark selector”. Thus, new errors are resolved using the “syndrome decoder” stage. This remark together with the previous one implies that the mechanisms for correcting new single chip errors differ according to whether there is an external channel mark or not.

[0078] FIG. 6 depicts a summary of the process flow described above and implemented by an embodiment of the decoder. In an embodiment that utilizes a double data rate three (DDR3) device, a sixteen bit symbol is received over two transfers. In an embodiment, the RAIM code is applied four times across the burst of 8 in each DRAM, each processing 64 bytes (B) worth of data for a total of 256B. Input to the process includes data from the 5 channels, the chip marks and the channel mark. At block 602, channel adjusted syndrome generation is performed and at block 620 channel adjust marks are generated. At block 604, chip mark and channel adjust syndrome generation is performed, and at block 606, syndrome and mark selection are performed. At block 608, syndrome decoding is performed and at block 610, bit flip masks and flags are generated and output.

[0079] The following section describes Galois field arithmetic that is implemented by an embodiment. In an embodiment: GF(16) elements are polynomials of degree less than 4 in the variable u, where operations are done modulo 1+u+u⁴; GF(256) elements are polynomials of degree less than 2 in the variable v, with operations done modulo 1+u³+v+v²; and GF(65536) elements are polynomials of degree less than 2 in the variable z, with operations done modulo (u²+u³)v+z+z². As described herein, the convention followed is that the bit pattern b₀b₁ . . . b₁₄b₁₅, which is ordered in agreement with the manner in which VHDL (“very high speed integrated circuit hardware description language”) orders bits denotes the GF(65536) element:
[(b₀+b₁u+b₂u²+b₃u³)+(b₄+b₅u+b₆u²+b₇u³)v]+[(b₈+b₉u+b₁₀u²+b₁₁u³)+(b₁₂+b₁₃u+b₁₄u²+b₁₅u³)v]z

[0080] The construction of the GF(65536) field is such that it is natural to think of one such element as four elements of GF(16) concatenated. With this in mind, introduced is the convention that the GF(65536) symbol (a₀+a₁v)+(a₂+a₃v)z where a₀, a₁, a₂, a₃ are GF(16) elements may also be written as the vector:

[0081] $\left[\begin{array}{c}{a}_0\\ a_1\\ a_2\\ a_3\end{array}\right]\hspace{1em}$

[0082] Thus for example within this convention:

[0083] $\left[\begin{array}{c}\gamma \\ 0\\ 0\\ 0\end{array}\right]\left[\begin{array}{c}{a}_0\\ a_1\\ a_2\\ a_3\end{array}\right]=\left[\begin{array}{c}\gamma a_0\\ \gamma a_1\\ \gamma a_2\\ \gamma a_3\end{array}\right]$
where γ is a GF(16) element.

[0084] Following is a description of the symbols associated with each chip location in an embodiment. The GF(2¹⁶) symbol associated with channel kε{0, 1, 2, 3, 4}, chip index jε{1, 2, 3, 4, 5, 6, 7, 8} is given by:

[0085] $X_{k,j}={\beta }_k\left[\begin{array}{c}1\\ u^{I\left(j\right)}\\ u^{2I\left(j\right)}\\ u^{3I\left(j\right)}\end{array}\right]$

[0086] where I(j) is the indexing function that sets I(1, 2, . . . , 8, 9, 10)={2, 4, 6, 7, 8, 9, 10, 11, 12, 13}, and the β_i are GF(16) elements given by:

• • [0087] β₀=1
  • [0088] β₁=u
  • [0089] β₂=u²
  • [0090] β₃=u³
  • [0091] β₄=1+u+u²+u³
  • [0092] β₅=1+u

[0093] In an embodiment, the checks are stored in locations X_0,0, . . . X_4,0 which in turn is defined as

[0094] $X_{k,0}=\left[\begin{array}{c}{\beta }_k\\ 0\\ 0\\ 0\end{array}\right]$
for kε{0, 1, 2, 3, 4}. The two default symbols for the x and y marks are given by:

[0095] $X_{\mathrm{def}}={\beta }_5·\left[\begin{array}{c}1\\ u^{I\left(9\right)}\\ u^{2I\left(9\right)}\\ u^{3I\left(9\right)}\end{array}\right]$ $Y_{\mathrm{def}}={\beta }_5\left[\begin{array}{c}1\\ u^{I\left(10\right)}\\ u^{2I\left(10\right)}\\ u^{3I\left(10\right)}\end{array}\right]$

[0096] The role of the indexing function I(•) is to enable the single bit correct/double bit detect feature when a channel is marked and two chips are marked.

[0097] Following is a description of an embodiment of the parity check matrix along with key properties. The parity check matrix is H=[H₀ H₁ H₂ H₃ H₄] where H_i for iε{0, 1, 2, 3, 4} is given by:

[0098] $H_i\left[\begin{array}{cccc}{X}_{i,0}& X_{i,1}& \dots & X_{i,8}\\ X_{i,0}^2& X_{i,1}^2& \dots & X_{i,8}^2\\ X_{i,0}^4& X_{i,1}^4& \dots & X_{i,8}^4\\ X_{i,0}^8& X_{i,1}^8& \dots & X_{i,8}^8\end{array}\right]$

[0099] The following auxiliary matrices are defined:
H⁽⁻⁰⁾=[H₁⊕H₀H₂⊕H₀H₃⊕H₀H₄⊕H₀]
H⁽⁻¹⁾=[H₀⊕H₁H₂⊕H₁H₃⊕H₁H₄⊕H₁]
H⁽⁻²⁾=[H₀⊕H₂H₁⊕H₂H₃⊕H₂H₄⊕H₂]
H⁽⁻³⁾=[H₀⊕H₃H₁⊕H₃H₂⊕H₃H₄⊕H₃]
H⁽⁻⁴⁾=[H₀⊕H₄H₁⊕H₄H₂⊕H₄H₃⊕H₄]

[0100] The following is the basic result for this code, which essentially ensures that the “error mirroring” effect caused by correcting a failed channel does not result on a reduced error correction and correction degradation with respect to having used a fully maximum-distance separable (MDS) code.

[0101] Theorem 1. Each of the matrices H⁽⁻ⁱ⁾ for iε{0, 1, 2, 3, 4} is MDS over GF(2¹⁶), this is, the 4×4 matrix with entries from GF(2¹⁶) formed by selecting any four columns is invertible.

[0102] As a matter of fact, a stronger and useful result holds. Let

[0103] $A=\left[\begin{array}{ccc}{X}_{\mathrm{SPUE}}& X_{\mathrm{def},\left(-i^{*}\right)}& Y_{\mathrm{def},\left(-i^{*}\right)}\\ X_{\mathrm{SPUE}}^2& {\left(X_{\mathrm{def},\left(-i^{*}\right)}\right)}^2& {\left(Y_{\mathrm{def},\left(-i^{*}\right)}\right)}^2\\ X_{\mathrm{SPUE}}^4& {\left(X_{\mathrm{def},\left(-i^{*}\right)}\right)}^4& {\left(Y_{\mathrm{def},\left(-i^{*}\right)}\right)}^4\\ X_{\mathrm{SPUE}}^8& {\left(X_{\mathrm{def},\left(-i^{*}\right)}\right)}^8& {\left(Y_{\mathrm{def},\left(-i^{*}\right)}\right)}^8\end{array}\right]$
Then the following holds:

[0104] Result 1. Each of the matrices [H⁽⁻ⁱ⁾ A] for iε{0, 1, 2, 3, 4} is MDS over GF(2¹⁶), that is, the 4×4 matrix with entries from GF(2¹⁶) formed by selecting any four columns is invertible. This result is of importance to obtain various desired properties for the error control code when default marks and SPUE are involved. The proof of Theorem 1 is based on purely algebraic arguments. The proof of Result 1, is via an exhaustive computer checking.

[0105] Following is a description of an embodiment of the decoder.

[0106] The following computes the regular syndromes of the code:
Z=D₀⊕D₁⊕D₂⊕D₃⊕D₄
S=H₀D₀⊕H₁D₁⊕H₂D₂⊕H₃D₃⊕H₄D₄

[0107] Due to the manner in which the parity check matrix is defined, the indexing of the vector S follows the following convention:

[0108] $S=\left[\begin{array}{c}{S}_1\\ S_2\\ S_4\\ S_8\end{array}\right]$

[0109] The following computes the syndromes for each possible channel mark:
S⁽⁻ⁱ⁾=S⊕H_iZ iε{0,1,2,3,4}

[0110] The two chip marks are x,y. Adjusted for channel mark i, the chip marks are x_(−i) and y_(−i); see below for an example embodiment of how to compute the adjusted marks.

[0111] The following computes the syndromes that incorporate the 2 chip marks for each possible channel mark:
Ŝ₁⁽⁻ⁱ⁾=(x_(−i)y_(−i)²⊕x_(−i)²y_(−i))S₁⁽⁻ⁱ⁾⊕(x_(−i)y_(−i)⊕x_(−i)²⊕y_(−i)²)S₂⁽⁻ⁱ⁾⊕S₄⁽⁻ⁱ⁾ iε{0, 1, 2, 3, 4}
Ŝ₂⁽⁻ⁱ⁾=(x_(−i)²y_(−i)⁴⊕x_(−i)⁴y_(−i)²)S₂⁽⁻ⁱ⁾⊕(x_(−i)²y_(−i)²⊕x_(−i)⁴⊕y_(−i)⁴)S₄⁽⁻ⁱ⁾⊕S₈⁽⁻ⁱ⁾ iε{0,1,2,3,4}  (1)

[0112] The following computes the flag that determines whether a given channel mark solves the error equations:
F_i=(Ŝ₁⁽⁻ⁱ⁾==0)&&(Ŝ₂⁽⁻ⁱ⁾==0) iε{0,1,2,3,4}

[0113] The value of i* is then determined as follows:

[0114] If an external channel mark has been passed to the decoder, then set i* to be the value of that external channel mark.

[0115] If no external channel mark has been passed then, if exactly one of the F_i flags is true, i* is assigned to the corresponding index. If no external channel mark has been passed and none of the F_i flags are true (or two or more are true), then set i*=4 (a default value).

[0116] The error magnitude for a possible new error is computed with:

[0117] $e=\frac{{\left({\hat{S}}_1^{\left(-i^{*}\right)}\right)}^2}{{\hat{S}}_2^{\left(-i^{*}\right)}}$

[0118] The error location is found as follows. First compute:

[0119] $\alpha =\frac{{\hat{S}}_2^{\left(-i^{*}\right)}}{{\hat{S}}_1^{\left(-i^{*}\right)}}$

[0120] Conceptually, first it is required to find a value of r that satisfies the quartic equation:
r⁴⊕r²(x_(−i*)y_(−i*)⊕x_(−i*)²⊕y_(−i*)²)⊕r(x_(−i*)y_(−i*)²⊕x_(−i*)²y_(−i*))⊕α=0

[0121] It is possible that there is no such solution, in which case an uncorrectable error condition has been identified. The error magnitudes for the erased locations can be found from:

[0122] $e_x=\frac{y_{\left(-i^{*}\right)}\left(S_2^{\left(-i^{*}\right)}\oplus r^{2}e\right)\oplus y_{\left(-i^{*}\right)}^2\left(S_1^{\left(-i^{*}\right)}\oplus \mathrm{re}\right)}{x_{\left(-i^{*}\right)}{y}_{\left(-i^{*}\right)}^2\oplus x_{\left(-i^{*}\right)}^2{y}_{\left(-i^{*}\right)}}$ $e_y=\frac{x_{\left(-i^{*}\right)}\left(S_2^{\left(-i^{*}\right)}\oplus r^{2}e\right)\oplus x_{\left(-i^{*}\right)}^2\left(S_1^{\left(-i^{*}\right)}\oplus \mathrm{re}\right)}{x_{\left(-i^{*}\right)}{y}_{\left(-i^{*}\right)}^2\oplus x_{\left(-i^{*}\right)}^2{y}_{\left(-i^{*}\right)}}$

[0123] In an embodiment, an algebraic method is utilized for solving the quartic. This method also allows a computation of the associated error magnitudes e_x, e_y in a manner synergistic to the solution of the quartic. First compute:

[0124] $d_x=\frac{1}{x_{\left(-i^{*}\right)}\left(y_{\left(-i^{*}\right)}\oplus x_{\left(-i^{*}\right)}\right)}$ $d_y=\frac{1}{y_{\left(-i^{*}\right)}\left(y_{\left(-i^{*}\right)}\oplus x_{\left(-i^{*}\right)}\right)}$

[0125] Next, obtain w_x, w_y as solutions for the quadratics
w_x²+w_x+αd_x²=0
w_y²+w_y+αd_y²=0
through the module w_x=quadroot(αd_x²), w_y=quadroot(αd_y²). Then use w_x, w_y to compute r, e_x and e_y with the following equations:
e_x=d_x(S₂^(−i*)⊕y_(−i*)S₁^(−i*))⊕ew_x
e_y=d_y(S₂^(−i*)⊕x_(−i*)S₁^(−i*))⊕ew_y
r=x_(−i*)w_x⊕y_(−i*)w_y

[0126] Next there are two broad cases:

[0127] d(r=0). This happens if and only if α=0. In this case, both e_x and e_y have the correct error magnitude for the marked chip position (the marks possibly being default). Also it will be true that e=0.

[0128] d(r≠0). This happens if and only if α≠0 and therefore e≠0. In this case we need to test which of the following expressions is a valid location:
r,r⊕x_(−i*),r⊕y_(−i*),r⊕x_(−i*)⊕y_(−i*)

[0129] The valid locations are given by the chip locations adjusted for channel i* AND the X_SPUE location (without any adjustment whatsoever), for a total of N(M−1)+1 locations. The code is constructed so that when a new chip error is present, or when X_SPUE is injected in the absence of a new error, exactly one of the expressions above will be valid.

[0130] If it is determined that exactly one of the expressions is valid, then r is added the appropriate term (either x_(−i*), or y_(−i*), or x_(−i*)⊕y_(−i*)). If it is needed to add x_(−i*) to r, then set e_x←e_x⊕e. If it is needed to add y_(−i*) to r, then set e_y←e_y⊕e. These actions are summarized below in a chart that summarizes the updates to r, e_x and e_y that need to be performed according to which solution to the quartic is found to be a valid solution:

[0131]

Valid location	New value for ex	New value for ey
r←r	ex ← ex	ey←ey
r←r⊕x(−i*)	ex←ex⊕x(−i*)	ey←ey
r←r⊕y(−i*)	ex←ex	ey←ey⊕y(−i*)
r←r⊕x(−i*)⊕y(−i*)	ex←ex⊕x(−i*)	ey←ey⊕y(−i*)

[0132] Finally, it is needed to trap some uncorrectable error situations. These are summarized as follows: the quartic has no solutions whatsoever; the quartic does not have exactly one valid solution; and the valid solution to the quartic is equal to X_SPUE. If any of the situations above hold, then the uncorrectable error flag is raised. One embodiment for doing this, which is described herein, is to set, r←0 if any of the above holds. Because in this case e≠0, the UE₃ condition described below will ensure that these will be caught as uncorrectable errors.

[0133] After the processing of these two broad cases, the process continues with the computation of the UE flag, as well as the potential bit flipping correction stage. Recall that if it is the case that β_x=i* then the x was moved to X_def for the purposes of computing x_(−i*). When computing the UE flag it is required to use “moved” x mark as well. An identical statement holds true for the y mark. To this end, let

[0134] $\begin{array}{cc}\hat{x}=\{\begin{array}{cc}x& {\beta }_x\ne {\beta }_{i^{*}}\left(2\right)\\ X_{\mathrm{def}}& {\beta }_x={\beta }_{i^{*}}\left(3\right)\end{array}\hat{y}=\{\begin{array}{cc}y& {\beta }_y\ne {\beta }_{i^{*}}\left(5\right)\\ Y_{\mathrm{def}}& {\beta }_y={\beta }_{i^{*}}\left(6\right)\end{array}& \left(2\right)\end{array}$

[0135] The global UE flag is computed by joining together several partial UE flags. In an embodiment, these conditions include:

• • [0136] 0. The syndromes adjusted for channel i* and the chip marks must either be both zero or both nonzero. UE₀=(Ŝ₁^(−i*)==0)⊕(Ŝ₂^(i*)==0)
  • [0137] 1. If there is no external channel mark, then the {F_i}_i flags must report either that exactly one channel can resolve the problem or that all channels can resolve the problem. Thus, letting count denote the number of flags F_i that are true,
  • [0138]  UE₁=(passed_external_channel_mark==FALSE)&&(count≠1)&&(count≠5)
  • [0139] 2. This computes the UE's flag contribution coming from correcting the erasures. Note the use of {circumflex over (x)} and ŷ instead of x, y, respectively. UE₂=(({circumflex over (x)}==X_def)&&(e_x!=0))∥((ŷ==Y_def)&& (e_y!=0)) This flag is used also in the computation of the SPUE flag.
  • [0140] 3. This computes the UE's flag contribution coming the various exception cases when processing the solution to the quartic.
  • [0141]  UE₃=((r==0)&&(e≠0));
  • [0142] 4. This computes the UE flag that ensures the single bit correct/double bit detect with a channel mark. Let weight(e) denote the number of bits set to one (out of the 16 bits).
  • [0143]  UE₄=((weight(e)>1)&&({circumflex over (x)}≠X_def)&&(ŷ≠Y_def))
  • [0144] 5. This flag is important to ensure that a channel failure when there is no channel marked never mis-corrects. The reason this condition is needed is because some channel failures have the property that all of the 5 F_i flags turn out to be true. oxUE₅ is set to be true if all the following hold: there is no external channel mark; all of the 5 F_i flags are true; and there are corrections outside of non-default chip marks.

[0145] The complete UE flag can then be computed using:
UE=UE₀∥UE₁∥UE₂∥UE₃∥UE₄∥UE₅

[0146] In an embodiment, the correction is performed by letting D_i*←D_i*⊕Z and then applying the corrections (e_x, e_y, e) to both locations mirroring the errors.

[0147] Following is a description of an embodiment of a method for adjusting the marks to reflect a channel mark. It is assumed that the channel being marked is denoted by the index iε{0, 1, 2, 3, 4} The method for adjusting the marks for x and y is described by

[0148] $x_{\left(-i\right)}=\{\begin{array}{cc}\left(\frac{{\beta }_x+{\beta }_i}{{\beta }_x}\right)x& {\beta }_x\ne {\beta }_i\\ \left(\frac{{\beta }_5+{\beta }_i}{{\beta }_5}\right)X_{\mathrm{def}}& {\beta }_x={\beta }_i\end{array}{y}_{\left(-i\right)}=\{\begin{array}{cc}\left(\frac{{\beta }_y+{\beta }_i}{{\beta }_y}\right)y& {\beta }_y\ne {\beta }_i\\ \left(\frac{{\beta }_5+{\beta }_i}{{\beta }_5}\right)Y_{\mathrm{def}}& {\beta }_y={\beta }_i\end{array}$

[0149] Following is an analysis of uncorrectable channel failures in an embodiment. With a small probability, this code is unable to correct for an unmarked channel failure. This section analyzes the precise conditions in which this happens. An unmarked channel failure is uncorrectable when it is the case that there is a subset At{0, 1, 2, 3, 4}, such the number of elements in A is two or greater and furthermore we have that for iεA,
(Ŝ_i⁽⁻ⁱ⁾==0)&&(Ŝ₂⁽⁻ⁱ⁾==0)
Pick any two distinct i, jεA

[0150] A. The case of no chips marked. In the case there are no chips marked, and by letting E to be the channel failure error vector, and gε{0, 1, 2, 3, 4} the index of the failing channel, results in Z=E and S=H_gE so that for every iε{0, 1, 2, 3, 4},
S⁽⁻ⁱ⁾=(H_g⊕H_i)E

[0151] The code construction is such that for every iε{0, 1, 2, 3, 4}, H_i=B_iH₀, where B_i the diagonal matrix given by

[0152] $B_i=\left[\begin{array}{cccc}{\beta }_i& 0& 0& 0\\ 0& {\beta }_i^2& 0& 0\\ 0& 0& {\beta }_i^4& 0\\ 0& 0& 0& {\beta }_i^8\end{array}\right]$

[0153] From this, it can easily identify a class of errors that are uncorrectable. Write S⁽⁻ⁱ⁾=(H_g−H_i)E=(B_g⊕B_i)H₀E and consider the class of errors U={E:H₀E=0}. Clearly, it can be shown that for EεU, for every iε{0, 1, 2, 3, 4}, S⁽⁻ⁱ⁾=0 and therefore Ŝ₁⁽⁻¹⁾=Ŝ₂⁽⁻ⁱ⁾=0, showing that this class of errors is uncorrectable.

[0154] More generally it can be seen that Ŝ_i⁽⁻ⁱ⁾=Ŝ₂⁽⁻ⁱ⁾=0 if and only if there exists ψ₁, ψ₂ such that equation (4) below holds:

[0155] $\left[\begin{array}{cc}{X}_{\mathrm{def}}& Y_{\mathrm{def}}\\ X_{\mathrm{def}}^2& Y_{\mathrm{def}}^2\\ X_{\mathrm{def}}^4& Y_{\mathrm{def}}^4\\ X_{\mathrm{def}}^8& Y_{\mathrm{def}}^8\end{array}\right]\left[\begin{array}{c}{\psi }_1\\ {\psi }_2\end{array}\right]=\left(B_g\oplus B_i\right)H_{0}E$

[0156] Note that for all distinct i,jε{0, 1, 2, 3, 4}, β_i≠β_j and therefore B_i⊕B_j is an invertible matrix. Thus (B_g⊕B_i)H₀ has full rank, and for fixed ψ₁, ψ₂ there are multiple choices for E that will solve this equation. By then varying ψ₁, ψ₂, the set of all possible errors E that are uncorrectable can be obtained.

[0157] The special case described earlier corresponds to the class of uncorrectable errors that can be found by setting ψ₁=ψ₂=0.

[0158] The following text described special uncorrectable errors (SPUEs).

[0159] Analysis: Adding an SPUE at encoding time.

[0160] The overall parity check of the RAIM code is given by the (N+r)×(MN) matrix:

[0161] $\begin{array}{cc}H=\left[\begin{array}{ccccc}{I}_N& I_N& I_N& I_N& I_N\\ H_0& H_1& H_2& H_3& H_4\end{array}\right]& \left(3\right)\end{array}$

[0162] where N=9, r=4, I_N represents the N×N identity matrix, and H_i* represents the r×N section of the parity check matrix that contributions to the formation of the bottom r syndromes for the data and checks in the ith channel.

[0163] The general method for incorporating an SPUE is based on an augmented version of (3), given by:

[0164] $H_{\mathrm{aug}}=\left[\begin{array}{cccccc}{I}_N& I_N& I_N& I_N& I_N& 0\\ & & & & & X_{\mathrm{SPUE}}\\ H_0& H_1& H_2& H_3& H_4& X_{\mathrm{SPUE}}^2\\ & & & & & X_{\mathrm{SPUE}}^4\\ & & & & & X_{\mathrm{SPUE}}^8\end{array}\right]$
where the precise definition of X_SPUE will be given in the subsequent discussion. Given the channel data vectors {D_i}_i=0^M−2 each of which has N−1=8 entries in GF(2¹⁶) when the encoder wishes to store this data with an SPUE mark, it chooses the checks c₀, c₁, c₂, c₃ (each of which is a single entry in GF(2¹⁶) so as to satisfy the equation

[0165] $\begin{array}{cc}{H}_{\mathrm{aug}}\left[\begin{array}{c}{c}_0\\ D_0\\ c_1\\ D_1\\ c_2\\ D_2\\ c_3\\ D_3\\ c_0\oplus c_1\oplus c_2\oplus c_3\\ D_0\oplus D_1\oplus D_2\oplus D_3\\ 1\end{array}\right]=0& \left(4\right)\end{array}$

[0166] This can be done as follows. Let ĉ₀, ĉ₁, ĉ₂, ĉ₃ and {tilde over (c)}₀, {tilde over (c)}₁, {tilde over (c)}₂, {tilde over (c)}₃ satisfy the following equations:

[0167] $H_{\mathrm{aug}}\left[\begin{array}{c}{\hat{c}}_0\\ 0\\ {\hat{c}}_1\\ 0\\ {\hat{c}}_2\\ 0\\ {\hat{c}}_3\\ 0\\ {\hat{c}}_0\oplus {\hat{c}}_1\oplus {\hat{c}}_2\oplus \widehat{c_3}\\ 0\\ 1\end{array}\right]=0,H_{\mathrm{aug}}\left[\begin{array}{c}{\hat{c}}_0\\ D_0\\ {\hat{c}}_1\\ D_1\\ {\hat{c}}_2\\ D_2\\ {\hat{c}}_3\\ D_3\\ {\hat{c}}_0\oplus {\hat{c}}_1\oplus {\hat{c}}_2\oplus \widehat{c_3}\\ D_0\oplus D_1\oplus D_2\oplus D_3\\ 0\end{array}\right]=0$

[0168] By defining c_i=ĉ_i⊕{tilde over (c)}_i for iε{0, 1, 2, 3} and summing the two equations above (sum=⊕), equation (4) is obtained, as desired. Now recall that the first column of H_i (which is associated with the check symbol for channel i) is equal to

[0169] $\hspace{1em}\left[\begin{array}{c}{\beta }_i\\ {\beta }_i^2\\ {\beta }_i^4\\ {\beta }_i^8\end{array}\right]$

[0170] Therefore, in an embodiment, to compute ĉ₀, ĉ₁, ĉ₂, ĉ₃ the following equation needs to be solved:

[0171] $\begin{array}{cc}\left[\begin{array}{cccc}{\beta }_0\oplus {\beta }_4& {\beta }_1\oplus {\beta }_4& {\beta }_2\oplus {\beta }_4& {\beta }_3\oplus {\beta }_4\\ {\beta }_0^2\oplus {\beta }_4^2& {\beta }_1^2\oplus {\beta }_4^2& {\beta }_2^2\oplus {\beta }_4^2& {\beta }_3^2\oplus {\beta }_4^2\\ {\beta }_0^4\oplus {\beta }_4^4& {\beta }_1^4\oplus {\beta }_4^4& {\beta }_2^4\oplus {\beta }_4^4& {\beta }_3^4\oplus {\beta }_4^4\\ {\beta }_0^8\oplus {\beta }_4^8& {\beta }_1^8\oplus {\beta }_4^8& {\beta }_2^8\oplus {\beta }_4^8& {\beta }_3^4\oplus {\beta }_4^4\end{array}\right]\left[\begin{array}{c}{\hat{c}}_0\\ {\hat{c}}_1\\ {\hat{c}}_2\\ {\hat{c}}_3\end{array}\right]=\left[\begin{array}{c}{X}_{\mathrm{SPUE}}\\ X_{\mathrm{SPUE}}^2\\ X_{\mathrm{SPUE}}^4\\ X_{\mathrm{SPUE}}^8\end{array}\right]& \left(5\right)\end{array}$

[0172] In summary, in order to incorporate an SPUE into the codeword in an embodiment, take the checks {tilde over (c)}₀, {tilde over (c)}₁, {tilde over (c)}₂, {tilde over (c)}₃ from the standard output of the encoder and then XOR these with the checks ĉ₀, ĉ₁, ĉ₂, ĉ₃ computed from solving equation (5).

[0173] Specific values used for SPUE encoding and detection in an embodiment. The following choice for X_SPUE passes all the relevant tests for an SPUE described above and it additionally has the property that when a channel is marked and two chips are marked, a single bit error injected and an SPUE is present, the decoder will not mis-correct. Using the bit ordering b₀b₁ . . . b₁₅, this design chooses

• • [0174] X_SPUE=1000110111010101
  • [0175] ĉ₀=1011010110110000
    • [0176] ĉ₁=1001001011101000
    • [0177] ĉ₂=1111100001100000
    • [0178] ĉ₃=1000100011111000
    • [0179] ĉ₄=0101011111000000

[0180] Decoder processing of an SPUE with no unmarked errors in an embodiment. The methodology for this section is to follow the decoder processing in order to understand how a 90B chunk of data that has an SPUE is processed. Using the notation from the previous subsection, what the decoder receives is

[0181] $A_{\mathrm{recvd}}=\left[\begin{array}{c}{c}_0\\ D_0\\ c_1\\ D_1\\ c_2\\ D_2\\ c_3\\ D_3\\ c_0\oplus c_1\oplus c_2\oplus c_3\\ D_0\oplus D_1\oplus D_2\oplus D_3\end{array}\right]\oplus \Delta$
where Δ is a vector with NM entries in GF(2¹⁶) that represents all of the errors affecting the data received. For this part of the analysis it is not assumed that these errors are necessarily marked or even correctable. Recall also from the previous subsection that c_i={tilde over (c)}_i⊕ĉ_i.

[0182] The first stage of the decoder is to compute Z and S; these quantities are independent of the values of the marks passed to the decoder x and y as well as the value of the external channel mark. These values are given by

[0183] $\left[\begin{array}{c}Z\\ S\end{array}\right]={\mathrm{HA}}_{\mathrm{recvd}}=H\Delta \oplus \left[\begin{array}{c}0\\ ⋮\\ 0\\ X_{\mathrm{SPUE}}\\ X_{\mathrm{SPUE}}^2\\ X_{\mathrm{SPUE}}^4\\ X_{\mathrm{SPUE}}^8\end{array}\right]$
where there are N₀ entries in the rightmost vector above. Let S_{not SPUE} be the syndromes obtained when exactly the same data is encoded without an SPUE, and when exactly the same errors are present in the data when it is retrieved. Thus
S_{not SPUE}=[H₀H₁H₂H₃H₄]Δ

[0184] Note that the Z syndrome is unaffected by the application of the SPUE mark, and therefore Z_{not SPUE}=Z The decoder then computes the channel adjusted syndromes S⁽⁻ⁱ⁾ for iε{0, 1, 2, 3, 4}, using the formula S⁽⁻ⁱ⁾=S⊕H_iZ, obtaining:

[0185] $\begin{array}{c}{S}^{\left(-i\right)}=\left(S_{\mathrm{not}\mathrm{SPUE}}\oplus H_{i}Z\right)\oplus \left[\begin{array}{c}{X}_{\mathrm{SPUE}}\\ X_{\mathrm{SPUE}}^2\\ X_{\mathrm{SPUE}}^4\\ X_{\mathrm{SPUE}}^8\end{array}\right]\\ =S_{\mathrm{not}\mathrm{SPUE}}^{\left(-i\right)}\oplus \left[\begin{array}{c}{X}_{\mathrm{SPUE}}\\ X_{\mathrm{SPUE}}^2\\ X_{\mathrm{SPUE}}^4\\ X_{\mathrm{SPUE}}^8\end{array}\right]\end{array}$
where S_{not SPUE}⁽⁻ⁱ⁾ denotes syndromes adjusted for channel i that would have been received if exactly the same data was encoded without an SPUE and exactly the same errors are present in the data when it is retrieved. The decoder next computes the chip and channel adjusted syndromes according to Equation (1). Note that in order to compute the chip and channel adjusted syndromes for every possible channel marked iε{0, 1, 2, 3, 4}, the decoder internally moves any marks that are in a given channel to their default values. The label x_(−i) and y_(−i) is used to denote the channel adjusted marks that are obtained after the possible movement to their default location. Using the same methodology as before, it can be deduced that
Ŝ₁⁽⁻ⁱ⁾=Ŝ_{1,not SPUE}⁽⁻ⁱ⁾⊕(x_(−i)y_(−i)²⊕x_(−i)²y_(−i))X_SPUE⊕(x_(−i)y_(−i)⊕x_(−i)²⊕y_(−i)²)X_SPUE²+X_SPUE⁴
Ŝ₂⁽⁻ⁱ⁾=Ŝ_{2,not SPUE}⁽⁻ⁱ⁾⊕(x_(−i)y_(−i)²⊕x_(−i)²y_(−i))²X_SPUE²⊕(x_(−i)y_(−i)⊕x_(−i)²⊕y_(−i)²)²X_SPUE⁴+X_SPUE⁸

[0186] Suppose now that there are no unmarked errors in the data received. It is known that if there was no SPUE encoded in the data the following would hold true
Ŝ_{1,not SPUE}⁽⁻ⁱ⁾=0
Ŝ_{2,not SPUE}⁽⁻ⁱ⁾=0
and therefore the syndromes Ŝ₁⁽⁻ⁱ⁾, Ŝ₂⁽⁻ⁱ⁾ satisfy
Ŝ₁⁽⁻ⁱ⁾=(x_(−i)y_(−i)²⊕x_(−i)²y_(−i))X_SPUE⊕(x_(−i)y_(−i)⊕x_(−i)²⊕y_(−i)²)X_SPUE²+X_SPUE⁴
Ŝ₂⁽⁻ⁱ⁾=(x_(−i)y_(−i)²⊕x_(−i)²y_(−i))²X_SPUE²⊕(x_(−i)y_(−i)⊕x_(−i)²⊕y_(−i)²)²X_SPUE⁴+X_SPUE⁸

[0187] In an embodiment, the design must ensure that for any iε{0, 1, 2, 3, 4}, Ŝ₁⁽⁻ⁱ⁾≠0, Ŝ₂⁽⁻ⁱ⁾≠0, so that the decoder is not “tricked” into thinking that there is a correctable error that can be resolved using a channel mark. This leads to a first requirement for how to choose X_SPUE:

[0188] For all iε{0, 1, 2, 3, 4}, x,yε{X_def, Y_def}∪{X_i,j}_{iε{0, . . . , 4}, jε{0, . . . , 8}}
0≠(x_(−i)y_(−i)²⊕x_−i)²y_(−i))X_SPUE⊕(x_(−i)y_(−i)⊕x_(−i)²⊕y_(−i)²)X_SPUE²+X_SPUE⁴

[0189] Assuming this requirement is met (this will be shown later), the decoder then chooses i*=4 if no external channel mark was passed, or it sets i* equal to the external channel mark if one is given. The next step of the decoder is to compute α and e, which the decoder obtains as:
α=Ŝ₁⁽⁻ⁱ⁾
e=1

[0190] The decoder then proceeds to solve the quartic
r⁴+r²(x_(−i)y_(−i)+x_(−i)²+y_(−i)²)+r(x_(−i)y_(−i)²+x_(−i)²y_(−i))+α=0

[0191] This quartic has the four solutions

• • [0192] X_SPUE
  • [0193] X_SPUE⊕x_(−i*)
  • [0194] X_SPUE⊕y_(−i*)
  • [0195] X_SPUE⊕x_(−i*)⊕y_(−i*)

[0196] Finally, recall from the decoder operation description that {circumflex over (x)} and ŷ are the actually employed channel marks (standard, not channel adjusted, see Equation (2). If {circumflex over (x)}=X_def, then even in the presence of an SPUE, we should never see e_x≠0. Similarly, if ŷ=Y_def, we should never see e_y≠0.

[0197] Summarizing the findings of an embodiment, a SPUE is determined by checking whether i) one of the solutions to the quartic is equal to X_SPUE; ii) e=1; iii) if {circumflex over (x)}=X_def, then e_x=0; iv) If ŷ=Y_def, then e_y=0. If these four conditions are true, then an SPUE is declared.

[0198] Note: conditions iii) and iv) above may be implemented ensuring that the SPUE flag is not set whenever UE₂ is on.

[0199] Analysis showing that correctable errors cannot be converted into SPUE's. It is of significant importance to demonstrate that no correctable error, on whatever combination of chip and channel marks and failures, can possibly be declared an SPUE. This may be in principle possible because when the decoder finds the 4 solutions to the quartic, it may be that one of the solutions is X_SPUE. It is shown below that this cannot happen by proper choice of X_SPUE. If a correctable error is such that S₁^(−i*)=S₂^(−i*)=0 (this happens when all errors are marked or when a new error is solved by the RAIM correction machinery), then e=0 and therefore in this case there is never an SPUE declared. So suppose that there is an external channel mark and suppose that a new error has occurred in location l with an error magnitude of 1. Then
S₁^(−i*)=(x_(−i)y_(−i)²⊕x_(−i)²y_(−i))l_(−i)⊕(x_(−i)y_(−i)⊕x_(−i)²⊕y_(−i)²)l_(−i)²+l_(−i)⁴
S₂^(−i*)=(x_(−i)y_(−i)²⊕x_(−i)²y_(−i))²l_(−i)²⊕(x_(−i)y_(−i)⊕x_(−i)²⊕y_(−i)²)²l_(−i)⁴+l_(−i)⁸

[0200] The decoder, as designed, computes e=1 and α=Ŝ₁^(−i*). It then finds as solutions to the quartic the following quantities:

• • [0201] l_(−i)
  • [0202] l_(−i)⊕x_(−i*)
  • [0203] l_(−i)⊕y_(−i*)
  • [0204] l_(−i)⊕x_(−i*)⊕y_(−i*)

[0205] Now, choose X_SPUE so that regardless of the value of i*ε{0, 1, 2, 3, 4}, and regardless of the value of x, y, l all of which can take on a maximum of N×M+2 values (the l symbol can only take on up to N×M values), none of the four quantities above can be equal to X_SPUE, then a correctable error will never become an SPUE.

[0206] A computer program has been written that tests whether a particular candidate for X_SPUE is viable in the sense of the reasoning above. The value of X_SPUE given in the this document has been shown to be viable in this manner. Note that this implies that whenever the SPUE flag is raised, the UE flag is raised as well.

[0207] Analysis of the probability of raising the SPUE flag when an uncorrectable error is present in an embodiment. Assume that Ŝ₁^(−i*) and Ŝ₂^(−i*) are independent random variables each uniformly distributed over GF(2¹⁶), {0}. The vast majority of the values that these variables can take correspond to uncorrectable errors. The question is asked, what is the probability that with such uniformly chosen syndromes one can call the result an SPUE? With this model, the values of e and α that the decoder computes are itself independent random variables each distributed over GF(2¹⁶), {0}. With chance approximately ½¹⁶ the value that the decoder calculates for e is equal to one, which implies that the probability of converting an uncorrectable error into an SPUE is smaller than ½¹⁶. To complete this assessment one needs to compute the probability that when α is chosen at random, one of the solutions of the quartic is equal to X_SPUE.

[0208] Implementation Notes for embodiments described herein.

[0209] Computation of the regular syndromes (S) according to an embodiment. The computation of the syndrome S can be simplified by noting that:

[0210] $H_i=B_i{H}_0$ $B_i=\left[\begin{array}{cccc}{\beta }_i& 0& 0& 0\\ 0& {\beta }_i^2& 0& 0\\ 0& 0& {\beta }_i^4& 0\\ 0& 0& 0& {\beta }_i^8\end{array}\right]$
and therefore S_i=[H₀]_i(D₀⊕β₁ⁱD₁⊕β₂ⁱD₂⊕β₃ⁱD₃⊕β₄ⁱD₄), where [H₀]_i is the ith row of H₀, and where iε{1, 2, 4, 8}. The nature of the simplification relies on the fact that each of the factors β_i are elements of GF(16). If the computation of the syndromes S can be done in two cycles, then the hardware can be reduced by half as follows.

[0211] The matrix H₀ can be split in 4 sections, each of which has the same number of columns but ¼ of the number of rows:

[0212] $H_0=\left[\begin{array}{c}{\left[H_0\right]}_1\\ {\left[H_0\right]}_2\\ {\left[H_0\right]}_4\\ {\left[H_0\right]}_8\end{array}\right]$

[0213] The data from the channels D₀, D₁, D₂, D₃, D₄ is received from the DRAM interface in two cycles, which allows the S₁, S₂, S₄, S₈ syndromes to be computed using approximately half the circuitry than it would be required in a single cycle computation. Let D_k,i for iε{0, 1, . . . , 8} denote the symbol received in channel k for the i th chip, and let [D_k,i]_j for jε{0, 1, . . . , 15} denote the jth bit in symbol D_k,i. It is assumed that in the first transfer from the DRAM interface, the kth channel presents the bits

• • [0214] [D_k,0]₀[D_k,0]₁ . . . [D_k,0]₇, [D_k,1]₀[D_k,1]₁ . . . [D_k,1]₇, . . . , [D_k,8]₀[D_k,8]₁ . . . [D_k,8]₇
  • [0215] and in the [D_k,0]₈[D_k,0]₉ . . . [D_k,0]₁₅, [D_k,1]₈[D_k,1]₉ . . . [D_k,1]₁₅, . . . , [D_k,8]₈[D_k,8]₁ . . . [D_k,8]₁₅

[0216] This is accomplished as follows:
F_Dk=[D_k,0,D_k,1, . . . ,D_k,7, 0,0,0,0,0,0,0,0]
S_Dk=[D_k,8,D_k,9, . . . ,D_k,15, 0,0,0,0,0,0,0,0]
where F_Dk stands for the FIRST bits coming from channel k and S_Dk stands for the SECOND bits coming from channel k. Interpreting F_Dk and S_Dk as elements of GF(2¹⁶), the method for computing the syndromes is then to compute
S_i←[H₀]_i(F_D0⊕β₁ⁱF_D1⊕β₂ⁱF_D2⊕β₃ⁱF_D3⊕β₄ⁱF_D4)  (6)
and then when the second beat of data is received,
S_i←(1/z)S_i⊕[H₀]_i(S_D0⊕β₁ⁱF_D1⊕β₂ⁱF_D2⊕β₃ⁱF_D3⊕β₄ⁱF_D4)  (7)
where in the above, (1/z) denotes the inverse of the GF(2¹⁶) element z (see Galois Field construction notes at the beginning of this document). The key point to notice is that each 16-bit symbol in the vector (F_D0⊕β₁ⁱF_D1rβ₂ⁱF_D2⊕β₃ⁱF_D3⊕β₄ⁱF_D4) is of the form:
[?,?,?,?,?,?,?,?,0,0,0,0,0,0,0,0]
where ? is either 0 or 1. Multiplication of [H₀]_i times a vector with symbols having this structure in fact only requires half of the binary columns of [H₀]_i (more precisely, the first half of each symbol column). A similar remark applies to the computation in (7), which requires the same binary columns of [H₀]_i as the computation (6).

[0217] An embodiment of computation of the channel adjusted syndromes. To compute the S⁽⁻ⁱ⁾ syndromes, use S⁽⁻ⁱ⁾=S⊕B_i(H₀Z)

[0218] An embodiment of a mathematical derivation of solution to the quartic. Given locations x₁, . . . , x_eεGF(2^q) for some q, let eqnarray
Λ(x₁, . . . ,x_e)={a:a=Σ_xεXx_i0.lin for some 0.lin A⊂{x₁, . . . ,x_e}}

[0219] An embodiment of how to solve the quartic follows. For the e_x,e_y computations, 4 coefficients needed to be calculated, the coefficient of S₂ in e_x was 1/(x²+xy), while the coefficients of S₂ in e_x was 1/(y²+xy). In this embodiment, instead of solving 2 quadratics serially, 2 quadratics are solved in parallel.
dr⁴+r²(xy+x²+y²)+r(xy²+x²y)+α=0
is equivalent to either or both of the following 2 systems of equations:
r²+yr=z_x
z_x²+(xy+x²)z_x=α
r²+xr=z_y
z_y²+(xy+y²)z_y=α

[0220] The second equation in each set can be normalized using z_x=(xy+x²)w_x and z_y=(xy+y²)w_y to produce:

[0221] $w_x^2+w_x=\frac{\alpha }{{\left(\mathrm{xy}+x^2\right)}^2}$ $w_y^2+w_y=\frac{\alpha }{{\left(\mathrm{xy}+y^2\right)}^2}$
whose solutions are connected to the first equations via:

[0222] $\frac{r^2+yr}{\mathrm{xy}+x^2}=w_x$ $\frac{r^2+xr}{\mathrm{xy}+y^2}=w_y$

[0223] Using these identities the error value equations can be rewritten as:

[0224] $e_x=\frac{S_2+y{S}_1}{x^2+\mathrm{xy}}+{\mathrm{ew}}_x$ $e_y=\frac{S_2+x{S}_1}{y^2+\mathrm{xy}}+{\mathrm{ew}}_y$

[0225] Now consider xw_x+yw_y, using the equations above:

[0226] ${\mathrm{xw}}_x+{\mathrm{yw}}_y=\frac{r^2+yr}{x+y}+\frac{r^2+xr}{x+y}=r$

[0227] Note that no additional pre-computation is required since this embodiment is just using the square of the coefficients of S₂ for e_i. Now this embodiment can directly compute r=xw_x+yw_y where it may be required to add 1 to either or both of w_x and w_y since each equation has 2 solutions. If 1 is added to w_x then we add e to e_x, if 1 is added to w_y then e is added to e_x.

[0228] When both x and y are zero, an embodiment computes r as the unique root of:
r⁴=α
since taking fourth roots is a linear map on GF(2^k).

[0229] If y=0 but x is nonzero, an embodiment can solve for w_x as above, and since:

[0230] $w_x=\frac{r^2}{x^2}$
an embodiment can recover r with:
r=x√{square root over (w_x)}

[0231] Since the denominator for e_x is well defined, the same formula remains valid when y=0. In this case set e_x=0.

[0232] FIG. 7 depicts a table that summaries updates that need to be performed to r, e_x and e_y that need to be performed according to which solution to the quartic is found to be a valid solution.

[0233] FIG. 8 depicts a table that includes a binary pattern corresponding to each symbol (equivalently chip or memory device) in an embodiment of the RAIM code. In an embodiment, this is the pattern that x and/or y need to be set to when the corresponding chip is to be marked as suspect.

[0234] FIG. 9 depicts an error control code symbol definition (DDR3 device) according to an embodiment. The 16 bit symbol depicted in FIG. 9 is received over two DDR3 transfers. The RAIM code is applied four times across the burst of 8 in the DRAM, each processing 64 bytes worth of data for a total of 256 bytes.

[0235] Generalization to Arbitrary Number of Chips, Channels, and Redundancy.

[0236] Generalization: Preliminaries.

[0237] Given locations x₁, . . . , x_eεGF(2^q) for some q,

[0238] $\Lambda \left(x_1,\dots ,x_e\right)=\left\{a:a=\sum _{x\in \chi }{x}_i\mathrm{for}\mathrm{some}A⋐\left\{x_1,\dots ,x_{\varepsilon }\right\}\right\}$
where the set A can be the null set (and thus 0εΛ(x₁, . . . , x_e), and let the associated polynomial be:
p(r,x₁, . . . ,x_e)=Π_{αεΛ(x1, . . . ,xe)}(r⊕α)
It is known that p(r, x₁, . . . , x_e) is a linearized polynomial: the only powers of r that are present in this polynomial are an integer power of 2 (the zeroth power inclusive). Because of this, the following equality holds for any r₁, r₂εGF(2^q):
p(r₁⊕r₂,x₁, . . . ,x_e)=p(r₁,x₁, . . . ,x_e)⊕p(r₂,x₁, . . . ,x_e)
Note that
Λ(x₁, . . . ,x_e)=Λ(x₁, . . . ,x_e−1)∪{x_e⊕Λ(x₁, . . . ,x_e−1)}
where a⊕B for an element aεGF(2^p) and a set B with elements from GF(2^p) denotes the set formed by adding every element of B to a. As a consequence,

[0239] $\begin{array}{cc}\begin{array}{c}p\left(\right)=\left[{\prod }_{\alpha \mathrm{\epsilon \Lambda }\left(x_1,...,x_{e-1}\right)}\left(r\oplus a\right)\right]\left[{\prod }_{\alpha \mathrm{\epsilon \Lambda }\left(x_1,...,x_{e-1}\right)}\left(r\oplus x_e\oplus a\right)\right]\\ =p\left(r,x_1,...,x_{e-1}\right)p\left(r\oplus x_e,x_1,...,x_{e-1}\right)\\ =p\left(r,x_1,...,x_{e-1}\right)\left[p\left(r,x_1,...,x_{e-1}\right)\oplus p\left(\right)\right]\end{array}& \left(8\right)\end{array}$

[0240] Generalization: Construction of Parity Check Matrix.

[0241] As before, let N be the number of symbols in a channel, and let M denote the number of channels, and let r be the number of checks that need to be designed. This section is devoted to presenting a method for constructing check matrices of the form H=[H₀ H₁ . . . H_M−1]

where

[0242] $\begin{array}{cc}{H}_i=\left[\begin{array}{cccc}{X}_{i,0}& X_{i,1}& \dots & X_{i,N-1}\\ X_{i,0}^2& X_{i,1}^2& \dots & X_{i,N-1}^2\\ X_{i,0}^4& X_{i,1}^4& \dots & X_{i,N-1}^4\\ ⋮& ⋮& \ddots & ⋮\\ X_{i,0}^{2^r}& X_{i,1}^{2^r}& \dots & X_{i,N-1}^{2^r}\end{array}\right]& \left(9\right)\end{array}$
so that for every iε{0, . . . , M−1} the matrix
H⁽⁻ⁱ⁾=[H₀⊕H_i . . . H_i−1⊕H_iH_i+1⊕H_i . . . H_M−1⊕H_i]
is maximum distance separable (MDS), that is, any choice of r columns of H⁽⁻ⁱ⁾ results in a r×r matrix that that is invertible. This is a highly desirable property as it results in codes for this application with maximal strength.

[0243] It is assumed that the elements X_i,jεGF(2^q), where q is a design parameter. The code construction is based on the following blocks:

[0244] 1) A binary code for codewords with a total of M bits that can detect up to r bit errors for r even or r+1 bit errors for r odd. Let r_b be the (binary) redundancy of this code. Let the columns of a parity check matrix for this code be β₀, β₁, . . . , β_M−1. Thus, β_i is regarded as an element of GF(2 raised to the r_b power).

[0245] 2) A code for r_b-bit symbols (that is, a code defined over GF(2 raised to the r_b power)) and codewords with a total of N symbols, capable of detecting up to r symbol errors. Let r_s denote the redundancy (in symbols) of this code. Let the columns of a parity check matrix for this code be γ₀, . . . , γ_N−1. Note that. The code construction then sets γ_iεGF(2^rb)^rs.

[0246] The code construction then sets X_i,j=β_iγ_j. Note that this results in a field size parameter of q=r_b×r_s. In general terms, good binary codes for item (1) above and good symbol codes for item (2) above are desired. Candidates for the former include the binary repetition code (where the codewords are 00 . . . 0, 11 . . . 1), Hamming codes, BCH codes, etc. Candidates for the latter include Reed-Solomon codes and non-binary BCH codes in general.

[0247] In an embodiment of the main code described herein, r=4, M=5, N=9. For the binary (item 1) the following is used:

[0248] $\left[\begin{array}{ccccc}{\beta }_0& {\beta }_1& {\beta }_2& \mathrm{\beta 3}& {\beta }_4\end{array}\right]=\left[\begin{array}{ccccc}1& 0& 0& 0& 1\\ 0& 1& 0& 0& 1\\ 0& 0& 1& 0& 1\\ 0& 0& 0& 1& 1\end{array}\right]$
which is the parity check matrix of a binary repetition code with total length 5. It can be easily seen that this code can detect any 4 bit errors, as required by the construction. For the code (item 2), an embodiment employs a Reed-Solomon code defined over symbols in GF(2⁴) that has a total codeword length of 9 and has exactly 4 checks of redundancy.

[0249] Generalization: General Method for Finding Modified Syndromes.

[0250] Following a general method is described for finding modified syndromes which do not contain information about errors in known position, and where the original syndromes come from a parity check matrix of the form (10,11).

[0251] To apply the technique described below to the class of codes that have been considered herein, it is important to note that the parity check matrix (9) above could be that associated with the channel adjusted syndromes. Indeed, due to the 1, 2, 4, . . . structure of the original check matrix employed in the class of codes described herein, the channel adjusted syndromes are known to be also associated with a parity check matrix of the form (9). This observation is the key underlying insight that enables the class of error correction codes with simple channel parity in embodiments described herein.

[0252] Suppose that x is a vector that includes e nonzero values with magnitudes e₁, . . . e_e at locations x₁, . . . , x_e, respectively. Additionally, x includes t more nonzero values (with t=0 a possibility) with magnitudes w₁, . . . , w_t and locations y₁, . . . , y_t. Thus x is thought of as an error vector with corresponding syndrome:

[0253] $S_1=\sum _{i=1}^{\varepsilon }{x}_i{e}_i\oplus \sum _{i=1}^t{y}_i{w}_i$ $S_2=\sum _{i=1}^{\varepsilon }{x}_i^2{e}_i\oplus \sum _{i=1}^t{y}_i^2{w}_i$ $S_4=\sum _{i=1}^{\varepsilon }{x}_i^4{e}_i\oplus \sum _{i=1}^t{y}_i^4{w}_i$ $⋮$ $S_{2^r}=\sum _{i=1}^{\varepsilon }{x}_i^{2^r}{\varepsilon }_i\oplus \sum _{i=1}^t{y}_i^{2^r}{w}_i$

[0254] Now consider the following calculation:

[0255] $S_{1,1}=x_1{S}_1\oplus S_2$ $S_{2,1}=x_1^2{S}_2\oplus S_4$ $S_{4,1}=x_1^4{S}_4\oplus S_8$ $⋮$ $S_{2^{r-1},1}=S_{2^{r-1}}\oplus S_{2^r}$
where S subscript 2ⁱ,j stands for the i^th syndrome after j errors have been removed from the syndrome. Note that

[0256] $S_{1,1}=\sum _{i=2}^e\left(x_i^2\oplus x_1{x}_i\right)e_i\oplus \sum _{i=1}^t\left(y_i^2\oplus x_1{y}_i\right)w_i$ $S_{2,1}=\sum _{i=2}^e{\left(x_i^2\oplus x_1{x}_i\right)}^2{e}_i\oplus \sum _{i=1}^t{\left(y_i^2\oplus x_1{y}_i\right)}^2{w}_i$ $S_{4,1}=\sum _{i=2}^e{\left(x_i^2\oplus x_1{x}_i\right)}^4{e}_i\oplus \sum _{i=1}^t{\left(y_i^2\oplus x_1{y}_i\right)}^4{w}_i$ $⋮$ $S_{2^{r-1},1}=\sum _{i=2}^e{\left(x_i^2\oplus x_1{x}_i\right)}^{2^{r-1}}{e}_i\oplus \sum _{i=1}^t{\left(y_i^2\oplus x_1{y}_i\right)}^{2^{r-1}}{w}_i$
so that the equations above may be interpreted as r−1 syndromes for an error vector with errors {e₂, . . . , e_e} and {w₁, . . . , w_t} with locations:
{x_i²⊕x₁x_i}_i=2^e and {y_i²⊕x₁y_i}_i=1^t

[0257] To remove the contribution of error e₂, the same technique described above may be applied but with the new locations. This will lead to a set of r−2 syndromes {T_2i,2}_i=1^r−2 and to a new set of e−2 and t error locations to which the procedure can be applied again.

[0258] The discussion above is now generalized. Let x_i,j denote the location assigned to error i (from the errors with known locations) after the first j errors e₁, . . . , e_j

• • [0259] have been removed from the syndromes. Thus:
    x_i,0=x_i and x_i,1=x_i²⊕x₁x_i.
    Then, for:
    iε[j+1, . . . ,e],jε[1, . . . ,e],
    x_i,j=x_i,j−1²⊕x_i,j−1x_j,j−1  (10)

[0260] Similarly, if y_i,j denotes the location assigned to error i (from the errors with unknown locations) after j errors have been removed, for iε[1, . . . , t] and jε[1, . . . , e], then:
y_i,j=y_i,j−1²⊕y_i,j−1x_j,j−1

[0261] Note that the expression in the right hand side of (10) is a polynomial on x_i,0 in which the coefficients are a function of x_1,0, x_2,0, . . . , x_j,0. By denoting this polynomial as u_i,j(ξ) (where x_i,0 has been substituted for r), the following relation is obtained: u_i,j(r)=u_i,j−1(r)²⊕u_i,j−1(r)u_j,j−1(x_j,0), where the fact that the expression x_j,j−1 that appears in (10) is a function of x_1,0, . . . , x_j,0 but NOT a function of x_i,0, since i≧j+1. From this it is clear that x_i,j=p(x_i, x₁, . . . , x_j−1). From a similar reasoning, it can be deduced that y_i,j=p(yj, x₁, . . . , x_j). The relations will be used below. From the syndrome perspective, for jε[1, . . . , e]

[0262] $S_{1,j}=S_{1,j-1}{x}_{j,j-1}\oplus S_{2,j-1}$ $S_{2,j}=S_{2,j-1}{x}_{j,j-1}^2\oplus S_{4,j-1}$ $S_{4,j}=S_{4,j-1}{x}_{j,j-1}^4\oplus S_{8,j-1}$ $⋮$ $S_{2^{r-j},j}=S_{2^{r-j},j-1}{x}_{j,j-1}^{2^{r-1}}\oplus$

[0263] The above already gives a sequential algorithm for computing modified syndromes from which the contribution of possible errors at known locations has been removed. In the case of the main code described herein, e=2 and instead of using a sequential algorithm, the expressions for the modified syndromes have been written in terms of S_1,0, S_2,0, S_4,0, S_8,0 directly, using the notation above (in the main code, the process of removing contributions of known chip errors is applied to each of the channel adjusted syndromes in parallel to meet minimal latency design guidelines).

[0264] After e erasures have been removed, r−e syndromes describing t errors at unknown locations are left:

[0265] $S_{1,e}=\sum _{i=1}^t{y}_{i,e}{w}_i$ $S_{2,e}=\sum _{i=1}^t{y}_{i,e}^2{w}_i$ $S_{4,e}=\sum _{i=1}^t{y}_{i,e}^4{w}_i$ $⋮$ $S_{2^{r-e},e}=\sum _{i=1}^t{y}_{i,e}^{2^{r-e}}{w}_i$

[0266] If there is exactly one error (t=1), then to find the new error location α=S_2,e/S_1,e=y_1,e can be computed. The variable y_1,e is a function of x₁, . . . , x_e, the order in which these known locations were presented to the syndrome modification removal algorithm described above, as well as y₁. It is desired to find y₁ from α=y_1,e.

[0267] Generalization: General Method for Solving for a New Error Location.

[0268] From the earlier description above, it is known that y_1,e=p(y₁, x₁, . . . , x_e). Now suppose that equation p(r, x₁, . . . , x_e)⊕α=0 is being solved for r. Because the degree of this polynomial is 2^e, this equation can have up to 2^e solutions in GF(2^p). Nonetheless, these solutions form a linear space, and particular, since p(x_i, x₁, . . . , x_e)=0 for iε{1, . . . , e}, if one solution ξεGF(2^p) exists then every other solution can be found in the set ξ⊕Λ(x₁, . . . , x_e). One way of solving this equation is by using the relation (8). Suppose a value of z₁ is found that solves:
z₁²⊕z₁p(x_e,x₁, . . . ,x_e−1)⊕α=0
Then, once in possession of this value z₁, then the next equation to solve is:
p(r,x₁, . . . ,x_e−1)⊕z₁=0
This, in turn, can be solved by first solving the quadratic
z₂²⊕z₂p(x_e−1,x₁, . . . ,x_e−2)⊕z₁=0
By continuing this line of thinking, the algorithm includes solving the equation
z_i²⊕z_ip(x_e−i⊕1,x₁, . . . ,x_e−i)⊕z_i−1=0
for z_i, where z_i−1 comes from an earlier iteration of the algorithm. This clearly results in a method for solving the general problem p(r, x₁, . . . , x_e)⊕α for r using a sequence of e quadratic solvers.

[0269] Note that in the description of algorithm that is used in the specific code described herein, a method for solving the degree 4 polynomial p(r, x, y) is given which improves upon the description above in that it solves the quartic with two quadratics in parallel, instead of in series as described in here.

[0270] Diff-MDS Embodiment.

[0271] The following text describes an embodiment where a class error control codes which are termed “diff-MDS” codes that are custom designed for highly resilient computer memory storage. The error scenarios of concern range from simple single bit errors, to memory chip failures and catastrophic memory module failures. A general code construction and analysis framework will be presented, together with efficient encoding and decoding algorithms. A discussion of the potential advantages and disadvantages of this class of algorithms when compared to Reed-Solomon codes will also be given.

[0272] Diff-MDS Embodiment: Introduction.

[0273] The main memory of the majority of modern computer servers is structured so that any given read or write request from a processor is serviced through a parallel access to multiple dynamic random access memory (DRAM) chips. Error control codes whose codewords span these chips are used routinely to correct single bit errors caused, for example, by cosmic rays and alpha particles. Failures affecting multiple bits have also been observed, ranging from a small section of a chip to entire chip failures. For this type of occurrence, servers employ symbol (as opposed to bit) oriented codes capable of correcting bursts of bit errors.

[0274] A goal of an embodiment is to present coding techniques that further protect a server against another type of failure that arises from the manner in which chips are organized within a memory system. In systems architecture, a memory channel is an independent physical construct that a processor uses to communicate to a group of memory chips; typically a processor will have multiple memory channels and in some instances distribute an ECC word over multiple channels. Sometimes it is the case that the design of a memory channel has single points of failure. For example, the chips in a memory channel may share a memory buffer in common which may fail, and/or may share a common clock signal that can also result in correlated errors. The goal is then to design a memory system that can survive entire memory channel errors, in addition to the kinds of errors described earlier.

[0275] Embodiments described herein overcome technical challenges related to the requirement of obtaining a reliability and redundancy optimum design while keeping the complexity of the design to a point in which very aggressive latency, bandwidth and chip circuit area requirements set by a main memory application are met.

[0276] An embodiment utilized to attain these goals includes a new class of error control codes, referred to herein as diff-MDS codes. Described herein, is a systematic development of the foundations for how these codes are designed and analyzed, and the characteristics of the particular instance of this class of codes for use with RAIM memory systems is described.

[0277] Diff-MDS Embodiment: Preliminaries.

[0278] The error control codes that are discussed herein are defined over an N×M array of symbols, each of them comprised of p bits. Each symbol is regarded to be an element of the Galois Field with 2^p elements and is denoted as GF(2^p). FIG. 10 illustrates how these symbols are labeled and organized. In the embodiment described herein, a column is a memory channel, and any element of a column is a memory chip. The upper index in parenthesis in d_i^(j) denotes the channel index. The subscript indicates the chip within the channel. From these N×M symbols, k will be devoted to storing data and r=N×M−k will be used as redundant symbols.

[0279] Typically, a machine runs error free with occasional temporary errors affecting one symbol from FIG. 10, which depicts an array of symbols in the ECC, with M columns and N rows. Nonetheless, a hard error—whether single bit or multibit—may take place, and from that point onwards there is a significantly higher likelihood of an error being perceived at the associated symbol. Information about persistent faults is stored in the marking state of the memory; see FIG. 11, which depicts allowed transitions for array mark states. In addition to the state information of FIG. 11, the overall mark state includes a pointer to which chips and/or channel have been marked as bad. It is assumed that regardless of the present state, the code needs to correct t_c and detect t_d symbol errors in addition to those symbols that are marked as bad.

[0280] Whenever something is marked (as potentially with errors) the decoder treats the associated symbol or symbols as erasures, in the standard sense of information and coding theory. Doing so is expected to allow the decoder to correct all marked symbols and potentially new additional errors as well. It is assumed that a maximum of e chip marks may be stored for use in the decoding of a codeword of the error control code. In the most common use, these marks are applied sequentially as the system discovers hard chip errors, each time causing the marking state in FIG. 11 to transition to an adjacent state on the right until no more chip marks are available.

[0281] In addition to single symbol errors, a memory channel may fail, resulting in a new multisymbol error that is contained in a column in FIG. 10. The decoder is expected to deduce entirely on its own the memory channel containing the multisymbol error, even in the presence of chip marks in any place of the memory array, although in some instances there may be independent indications that a channel is failing. Using variants of well known arguments it is possible to deduce that it is mathematically impossible to design any code that accomplishes the task of locating (autonomously) the failing channel with 100% certainty unless the following relation is satisfied:
2N+e≦r

[0282] In an embodiment, e=2, N=9, M=5, k=32, implying that r=13. Therefore, it is provably impossible to locate a failing channel with 100% certainty. Nonetheless, it is still feasible to find a failing channel with overwhelmingly high probability. Furthermore, once the bad channel is located (by any available means, this is either by the decoder or by another agent), then a system that achieves 100% correction of this channel need only satisfy the relation:
N+e≦r

[0283] which holds in the specific instance of the present embodiment. This leads to the notion of a channel mark, which is similar to the idea of a chip mark, although in this case applied to an entire channel. Whenever a channel mark is in place, the decoder no longer is required to find the location of a bad channel and may assume instead that the bad channel is the one pointed to by the channel mark. The judicious use of channel marks by a memory system results in the elimination of the problem of the finite probability of not being able to correct failing channel for all practical purposes. As one uses chip or channel marks, the amount of redundancy that is effectively available for the correction and detection of any additional errors on symbols that are not marked decreases, since the symbols that are marked also need to be corrected. For the purposes of the development of a foundation to study error control codes for this embodiment, it is assumed that regardless of the marking state (as given in FIG. 11) t_c additional errors will need to be corrected in addition to any symbol errors that are marked (chip or channel), and td additional errors will need to be detected.

[0284] One skilled in the theory of Reed-Solomon (RS) error correcting codes will notice that as long as NM≦2^p−1, RS codes appear to be a candidate for this problem, since they are maximum-distance-separable (MDS) and hence have strong optimality properties for settings with erasures and/or unknown symbol errors. It can be indeed shown that this is the case from the standpoint of the degree of reliability that these codes offer. Nonetheless, the large burst of length N symbols that needs to be detected and corrected in potential combination with other errors can introduce implementation complexity problems, particularly in the high performance setting of the embodiment.

[0285] Note that if the embodiment only had to correct a memory channel in error, and which channel was in error was always known, then one of the M channels could always be a simple parity of the other M−1 channels as it is done in RAID systems, with decoding being a straightforward operation. For this simple abstract problem, clearly Reed-Solomon codes are unnecessary. The methodology in the embodiment described herein starts by assuming that one of the memory channels will be a simple parity of the other channels. Starting from this restriction, a theory of how to construct optimal codes for this application is developed. The codes described herein present favorable implementation characteristics when N is relatively large with respect to t_c and t_d, in an asymptotic sense. Nonetheless, in any given application, the case for one kind of code versus another (Reed-Solomon, diff-MDS, etc) may not be immediately clear and a more detailed analysis is required.

[0286] Diff-MDS Embodiment: Mathematical Problem Definition.

[0287] For any positive integer n, let GF(2^p)ⁿ denote the space of vectors of length n with elements in GF(2^p). Let dεGF(2^p)^NM denote a vector that is stored in any given memory location. The memory has M channels and thus:
d=((d⁽⁰⁾)^T(d⁽¹⁾)^T . . . (d^(M−1))^T)^T
where the upperscript T denotes vector/matrix transpose, and where

[0288] $d^{\left(i\right)}=\left(\begin{array}{c}{d}_0^{\left(i\right)}\\ d_1^{\left(i\right)}\\ ⋮\\ d_{N-1}^{\left(i\right)}\end{array}\right)$
for iε{0, . . . , M−1}.
Thus for each jε{0, . . . , M−1},
d^(j)εGF(q)^N and for iε{0, . . . , N−1}, d_i^(j)=d_jN+i.

[0289] It is assumed that d is a codeword of the code defined by a parity check matrix H that has dimensions (n+Δ)×(NM) and entries in GF(2^p). The parameter Δ>0 controls the excess redundancy one possesses to provide protection against individual symbol errors, for locating channel errors and for ensuring that any corrections that are applied are sound. Any codeword of the code by definition must satisfy Hd=0. The check matrices of interest can be written as:

[0290] $\begin{array}{cc}H=\left(\begin{array}{cccc}{I}_N& I_N& \dots & I_N\\ {\hat{H}}^{\left(0\right)}& {\hat{H}}^{\left(1\right)}& \dots & {\hat{H}}^{\left(M-1\right)}\end{array}\right)& \left(11\right)\end{array}$
where I_N denotes the N×N identity matrix and
ĤΔ(Ĥ⁽⁰⁾Ĥ⁽¹⁾. . . Ĥ^(M−1))  (12)
where Ĥ is a Δ×MN matrix. The essential constraint in (11), is that Σ_j=0^M−1d^(j)=0.

[0291] A code with check matrix:
I_NI_N . . . I_N)
is referred to herein as a simple parity check code. Because the codes (11) are obtained by expurgating codewords from a simple parity check code, any code whose parity check matrix can be written as (11) is referred to as an expurgated simple parity check code, and Ĥ is referred to as the expurgating matrix.

[0292] The marking state of the memory describes:

[0293] 1. Whether a channel is marked and the location of the possible channel mark if applicable.

[0294] 2. How many chips are marked (up to e chips), including the information of which chips are marked.

[0295] If there is no channel mark and i chip marks, this is referred to as being in the marking state (0, i). If there is a channel mark and i chip marks, this is referred to as being in the marking state (1, i). This notation is in reference to FIG. 11, where the first index refers to a row and the second index refers to a column. Note that to be accurate, the marking state also includes the identity of the entities to which marks point to; this shorthand will be often useful though and should cause no confusion. In order to compare the strength of various choices of H (not necessarily expurgated simple parity check codes), requires settling on a precise set of metrics for evaluating codes. A description of these metrics follows.

[0296] For all marking states of the form (0, i), it is assumed that in every marked chip, if any, there can be any kind of error, or no error at all. In addition to an assumption that any errors on marked chips can be corrected, the code's strength is characterized by: the number t_c^(0,i) of simultaneous chip errors it can correct, the number t_d^(0,i) of simultaneous chip errors it can detect (or correct); and the probability p_c^(0,i) of correcting a channel error, under the random channel error model (see below).

[0297] A random channel error is a channel error which can be modeled as: 1) choosing the channel in error from the set {0, 1, . . . M−1} uniformly at random; and 2) choosing for the error in the chosen channel a vector uniformly from GF(2^p)^N. Note that this includes the possibility that no error at all is added, nonetheless this is of no consequence to the analysis for sufficiently large (but still practical) p and N. Note also that this error model allows for channel errors on channels where there may be chip marks.

[0298] For all marking states of the form (1, i) assume that in the marked channel and any marked chip there can be any kind of error or no error at all. All marked errors are assumed to be correctable. In addition, the code's strength is characterized by: the number t_c^(1,i) of simultaneous chip errors it can correct; and the number t_d^(1,i) of simultaneous chip errors it can detect or correct.

[0299] Recall that all the codes in this embodiment are assumed to be capable of encoding k symbols from GF(2^p) worth of “user data” using a redundancy r=NM−k. Given (N, M, k) and e, the number of marked chips one can have, the first problem is to characterize, without the restriction on H given by (11) (but still assuming a linear code), what are the allowable values for {t_c^(0,i), t_d^(0,i), p_c^(0,i), t_c^(1,i), t_d^(1,i)}_i=0^c−1.

[0300] The second problem is to find a class of error control codes whose parity check matrix satisfies the restriction (11) that are optimal in the sense that a code can be found that meets or alternately improves on any point of the set of allowable values.

[0301] The third problem is to develop practical techniques for encoding and decoding these codes. Described herein are partial solutions for all three problems. For the second problem, focus is on the case where 2^p<NM and code construction methodologies are presented that are optimal for sufficiently large values of p. Fortunately, for the particular application parameters in this embodiment it will turn out that the theory is applicable in a real practical sense.

[0302] Diff-MDS Embodiment: Codes.

[0303] For j*ε{0, . . . , M−1}, define the matrix Ĥ^(−j*) by deleting the j*th component matrix from Ĥ and subtracting it from each of the remaining matrices. For example, the case when j* is neither 0 nor M−1 is as follows:
Ĥ^(−j*)=(Ĥ⁽⁰⁾−Ĥ^(j*). . . Ĥ^(j*−1)−Ĥ^(j*)Ĥ^(j*+1)−Ĥ^(j*) . . . Ĥ^(M−1)−Ĥ^(j*))

[0304] The definition of Ĥ⁽⁻⁰⁾ and Ĥ^(−(M−1)) follow directly from the explanation and example above. Note that in GF(2^p), subtraction is identical to addition, so the use of the − assign is somewhat superfluous in this case. Nonetheless, all of the results in this embodiment can be extended to finite fields with Characteristic other than 2, and thus the choice to use the − sign. For jε{0, . . . , M−1} and for an arbitrary vector vεGF(2^p)^NM, let v^(−j) the vector obtained by deleting from v the jth subcomponent. This is illustrated with an example when i* is neither 0 nor M−1:
v^(−j)=(v⁽⁰⁾, . . . ,v^(j−1),v^(j+1), . . . v^(M−1))

[0305] Note that Ĥ^(−j*) is a Δ×N(M−1) matrix with elements in GF(2^p). Let A be any matrix with entries in GF(2^p). Let d(A) denote the minimum symbol distance of the code defined by parity check matrix A. This is, d(A) is the largest integer such that any choice of d(A)−1 columns of A are linearly independent. A code with parity check matrix is said to be maximum-distance-separable (MDS) if d(A) is equal to the number of rows of A plus 1.

[0306] It is said that Ĥ is Diff-MDS if Ĥ^(−j*) is MDS for every j*ε{0, 1, . . . , M−1}. The definition of diff-MDS codes is motivated with an example of how to decode a code whose parity check matrix has the form (11). In this example, channel 0 is affected with a “serious” error δ⁽⁰⁾εGF(2P)^N which is any nonzero vector. Channels 1 through M−1 are affected with errors ξ⁽¹⁾ through ξ^(M−1), which collectively, have exactly t nonzero entries (and hence t errors). Thus an encoded vector d is corrupted so that:

[0307] $v=\left(\begin{array}{c}{d}^{\left(0\right)}+{\delta }^{\left(0\right)}\\ d^{\left(1\right)}+{\xi }^{\left(1\right)}\\ ⋮\\ d^{\left(M-1\right)}+{\xi }^{\left(M-1\right)}\end{array}\right)$
is what is retrieved from the memory. Note that:

[0308] $\begin{array}{c}\sum _{j=0}^{M-1}{v}^{\left(i\right)}={\delta }^{\left(0\right)}+\sum _{j=1}^{M-1}{\xi }^{\left(j\right)}+\sum _{j=0}^{M-1}{d}^{\left(i\right)}\\ ={\delta }^{\left(0\right)}+\sum _{i=1}^{M-1}{\xi }^{\left(j\right)}\end{array}$

[0309] Suppose that it is known that the “serious” channel error δ⁽⁰⁾ was in channel 0. Subtracting Σ_i=0^M−1v⁽ⁱ⁾ from channel 0 in v results in:

[0310] $w=\left(\begin{array}{c}{d}^{\left(0\right)}-\sum _{j=1}^{M-1}{\xi }^{\left(j\right)}\\ d^{\left(1\right)}+{\xi }^{\left(1\right)}\\ ⋮\\ d^{\left(M-1\right)}+{\xi }^{\left(M-1\right)}\end{array}\right)$

[0311] Note that the large error δ⁽⁰⁾ has been removed but the smaller errors have now “propagated” from channels 1 through M−1 to channel 0. Now compute the Ĥ-syndrome of w:

[0312] $\begin{array}{c}\hat{H}w=-{\hat{H}}^{\left(0\right)}\left(\sum _{j=1}^{M-1}{\xi }^{\left(j\right)}\right)+\sum _{j=1}^{M-1}{\hat{H}}^{\left(j\right)}{\xi }^{\left(j\right)}\\ =\sum _{j=1}^{M-1}\left({\hat{H}}^{\left(j\right)}-{\hat{H}}^{\left(0\right)}\right){\xi }^{\left(j\right)}\\ ={\hat{H}}^{\left(-0\right)}{w}^{\left(-0\right)}\end{array}$
where the latter follow from the definitions made at the beginning of this section.