|Publication number||US8140945 B2|
|Application number||US 12/126,325|
|Publication date||Mar 20, 2012|
|Filing date||May 23, 2008|
|Priority date||May 23, 2008|
|Also published as||US20090292968|
|Publication number||12126325, 126325, US 8140945 B2, US 8140945B2, US-B2-8140945, US8140945 B2, US8140945B2|
|Inventors||Robert E. Cypher|
|Original Assignee||Oracle America, Inc.|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (19), Non-Patent Citations (1), Referenced by (2), Classifications (5), Legal Events (3)|
|External Links: USPTO, USPTO Assignment, Espacenet|
1. Field of the Invention
This invention is related to error correction code (ECC) systems.
2. Description of the Related Art
Error codes are commonly used in electronic systems to detect and correct data errors, such as transmission errors or storage errors. For example, error codes may be used to detect and correct errors in data transmitted via any transmission medium (e.g. conductors and/or transmitting devices between chips in an electronic system, a network connect, a telephone line, a radio transmitter, etc.). Error codes may additionally be used to detect and correct errors associated with data stored in the memory of computer systems. One common use of error codes is to detect and correct errors of data transmitted on a data bus of a computer system. In such systems, error correction bits, or check bits, may be generated for the data prior to its transfer or storage. When the data is received or retrieved, the check bits may be used to detect and correct errors within the data.
Component failures are a common source of error in electrical systems. Faulty components may include faulty memory chips or faulty data paths provided between devices of a system. Faulty data paths can result from, for example, faulty pins, faulty data traces, or faulty wires. Additionally, memory modules, which may contain multiple memory chips, may fail. Circuitry which drives the data paths may also fail. Component failures are referred to as “hard” failures.
Another source of error in electrical systems may be so-called “soft” or “transient errors”. Transient memory errors may be errors caused by the occurrence of an event, rather than a defect in the memory circuitry itself. Transient memory errors may occur due to, for example, random alpha particles striking the memory circuit. Transient communication errors may occur due to noise on the data paths, inaccurate sampling of the data due to clock drift, etc.
Generally, various error detection code (EDC) and error correction code (ECC) schemes are used to detect and correct memory and/or communication errors. For example, parity may be used. With parity, a single parity bit is stored/transmitted for a given set of data bits, representing whether the number of binary ones in the data bits is even or odd. The parity is generated when the set of data bits is stored/transmitted and is checked when the set of data bits is accessed/received. If the parity doesn't match the accessed set of data bits, then an error is detected.
Other EDC/ECC schemes assign several check bits per set of data bits. The check bits are encoded from various overlapping combinations of the corresponding data bits. The encodings are selected such that a bit error or errors may be detected, and in some cases the encodings may be selected such that the bit or bits in error may be identifiable so that the error can be corrected (depending on the number of bits in error and the ECC scheme being used). Typically, as the number of bit errors that can be detected and/or corrected increases, the number of check bits used in the scheme increases as well.
In one embodiment, a memory controller comprises a check bit encoder circuit coupled to receive a data block to be written to memory, a check/correct circuit coupled to receive an encoded data block read from the memory, and a hard failure detection circuit coupled to the check/correct circuit. The check bit encoder circuit is configured to generate a corresponding encoded data block comprising the data block, a first plurality of check bits, and a second plurality of check bits. The check/correct circuit is configured to detect an error in the encoded data block responsive to the first plurality of check bits, the second plurality of check bits, and the data block within the encoded data block. The encoded data block is logically arranged as an array of R rows and N columns, wherein R and N are positive integers. Each of the first plurality of check bits covers a respective row of the array, and the check/correct circuit is configured to generate a first syndrome corresponding to the first plurality of check bits. A presence of more than one binary one in the first syndrome indicates a multi-bit error. Responsive to detecting the multi-bit error, the hard failure detection circuit is configured to perform a plurality of memory read/write operations to the memory locations in which the encoded data block is stored to identify a hard error failure in the memory. A corresponding method is also contemplated.
In another embodiment, an apparatus comprises a check bit encoder circuit coupled to receive a data block and a check/correct circuit coupled to receive an encoded data block. The check bit encoder circuit is configured to generate a corresponding encoded data block comprising the data block, a first plurality of check bits, and a second plurality of check bits. The check/correct circuit is configured to detect an error in data from one of a plurality of components and correct the error using the first plurality of check bits, the second plurality of check bits, and the data block within the encoded data block. The encoded data block is logically arranged as an array of R rows and N columns, wherein R and N are positive integers. The first plurality of check bits form a first column of the array, and each of the first plurality of check bits covers a row of the array. The second plurality of check bits are stored in a second column of the array and are defined to cover bits in the array according to a plurality of check vectors. Each of the plurality of check vectors corresponds to a different bit in the array and is an element of a Galois Field (GF(2X)), where X is a positive integer equal to a number of the second plurality of bits. The plurality of check vectors are derived from a plurality of unique elements of GF(2X), each of the plurality of unique elements corresponding to a different column of the array, and each of the plurality of unique elements includes at least one non-zero bit, including the element corresponding to the first column of the array. The check vector in row Z of the column is the product, in GF(2X) of the unique element for that column and alphaZ, wherein alpha is a primitive element of GF(2X).
The following detailed description makes reference to the accompanying drawings, which are now briefly described.
While the invention is susceptible to various modifications and alternative forms, specific embodiments thereof are shown by way of example in the drawings and will herein be described in detail. It should be understood, however, that the drawings and detailed description thereto are not intended to limit the invention to the particular form disclosed, but on the contrary, the intention is to cover all modifications, equivalents and alternatives falling within the spirit and scope of the present invention as defined by the appended claims.
Turning now to
The apparatus may operate on data blocks, and may encode the data blocks with check bits to provide for error detection and correction of the data blocks. More particularly, the check bit encoder circuit 16 may receive a data block and may generate a corresponding encoded data block including the check bits that cover the data block. The check bit encoder circuit 16 may then transmit the encoded data block to the components 5A-5N. The components 5A-5N may transmit an encoded data block to the error check/correct circuit 18, which may decode the encoded data block, detect (and in some cases correct) errors in the data block, and transmit the output data block. Errors that may be introduced in the components 5A-5N (and/or the interconnect between the components 5A-5N, the check bit encoder circuit 16, and the error check/correct circuit 18) may be detected and possibly corrected.
As used herein, the term “component” includes one or more of: interconnect, circuitry, and/or storage. For example, in some embodiments described below, the check bit encoder circuit 16 and the error check/correct circuit 18 may be implemented in a memory controller. The components 5A-5N may comprise memory devices in the memory system to which the memory controller is coupled. In other embodiments described below, the check bit encoder circuit 16 may be implemented in a source that transmits data on a communication medium, and the error check/correct circuit 18 may be implemented in a destination that receives the data from the communication medium. In such embodiments, the components 5A-5N may comprise communication paths in a communication medium between the source and the destination. The components 5A-5N may further comprise circuitry in the communication medium (e.g. switches).
Generally, the encoded data block (also referred to herein as a “code word”) may be logically arranged as an array of rows and columns, where the data in each column corresponds to one component 5A-5N. For example, if the components 5A-5N include storage, the data in a given component's column may be data from the code word that is stored in that component. If the components 5A-5N include interconnect, the data in a given component's column may be data from the code word that is transmitted on that component. If the components 5A-5N include circuitry that operate on the data, the data in a given component's column may be data from the code word that is operated on by that component.
In one embodiment, the check bits in the code word include a first set of check bits stored in a first column of the array (and thus corresponding to a first component) and a second set of check bits stored in a second column of the array (and thus corresponding to a second component). Each check bit in the first set of check bits (referred to herein as “row check bits”) may cover the bits in the same row as that check bit. For example, the check bit encoder circuit 16 may generate each check bit as an exclusive OR (XOR) of the other bits in the same row. Thus, if the bits in each row of the code word are XOR'd by the error check/correct circuit 18, a resulting bit vector may represent a pattern of errors in one of the columns (corresponding to one of the components). That is, if the resulting bit vector is non-zero, the set bits in the resulting bit vector identify which rows in one column have an error. The resulting bit vector is also referred to herein as the “row syndrome”. The second set of check bits (referred to herein as “inner check bits”) may cover various overlapping subsets of the remaining bits. In one embodiment, the inner check bits may be any number of check bits (X), wherein X is a positive integer that is greater than or equal to the (base 2) logarithm of the number of columns in the logical array. In one embodiment, the only requirement on the definition of which inner check bits cover which bits in the logical array is that each of the bits in a given row is covered by a unique set of inner check bits (to allow identification of a component failure when the row syndrome is non-zero). Various embodiments may obtain additional error detection and/or correction properties based on how the inner check bits are selected.
For example, in one embodiment, the inner check bits may be defined using a Galois field (GF). Each column in the array may be assigned a key, which is a unique element of GF(2X), where X is the number of inner check bits (as mentioned above). The key may be used as a check vector for the bit in row 0 of the corresponding column. A check vector may have a bit for each of the inner check bits (corresponding to the row in the second column that stores that inner check bit) and may define which of the second set of check bits covers that bit. That is, each set bit in the check vector may indicate that the check bit in the corresponding position of the second column covers that bit. Check vectors for bits in the column may be generated by multiplying, in GF(2X), the key by alphaZ, where Z is the row number storing the bit for which the check vector is being generated and alpha is a primitive element of GF(2X). A code defined in this fashion may permit detection and probabilistic correction of a single component failure using R+X check bits. The probability of correcting the failure is approximately one minus a factor that is inversely proportional to 2X. Those component failures that cannot be corrected are detected. In one embodiment, the key for the column containing the row check bits includes at least one binary one bit (i.e. the key is non-zero), and the check vectors as a whole are strictly non-zero, but the key for the column containing the row check bits is selected so that the definition of the check bits is non-circular. For example, it can be shown that a key of all binary zeros except the least significant two bits (which are binary one) for the column containing the row check bits provides a non-circular definition. However, other key selections are also possible.
In various embodiments, if the row syndrome indicates a multi-bit error (i.e. there is more than one binary one in the row syndrome), a memory controller may perform a set of two or more memory read/write operations to determine hard failures in the memory locations storing the encoded data block. In some cases, e.g. if the failing bits are all in the same component, the hard failure may be correctable. In other cases, the hard failure may only be detected. However, in some embodiments, the mechanism may guarantee that the hard failure is detected, which may prevent data corruption that would otherwise occur if the erroneous data were provided in response to a read.
Additional details of one embodiment of the check bit definition are described below. The example of a memory controller is used for much of the description, but the check bit definition and other properties of the defined code may apply to any apparatus having any set of components 5A-5N, in some embodiments.
As used herein, a data block is the unit of data over which check bits are generated. The error detection/correction capabilities may be measured in terms of the errors detected and corrected in a single data block. An encoded data block includes the data block and the corresponding check bits generated by the check bit encoder circuit 16 (and decoded by the error check/correct circuit 18 to detect errors and correct errors, where applicable).
Memory Controller Overview
Turning now to
The memory controller 10 is coupled to receive read and write requests from various sources (e.g. processors and/or peripheral devices in a computer system including the memory controller 10, such as the computer system shown in
The memory controller 10 is configured to encode data to be written to the memory with a plurality of check bits, thus generating the encoded data to be stored in the memory. The encoded data may comprise the data supplied to the memory controller and the check bits, arranged in a predetermined fashion for storage in the various memory devices of the memory 12. Additionally, when encoded data is read from the memory 12, the error check/correct circuit 18 is configured to decode the encoded data to detect certain errors in the data and, in some cases, to correct the errors. The corrected data is supplied as an output of the memory controller 10.
The data written to the memory 12 by the memory controller 10 may comprise data from a write request received by the memory controller 10 (“Data In” in
The memory controller 10 may be configured to detect (and in some cases to correct) various errors through the encodings of the check bits. For example, as mentioned above, in one embodiment, the check bits may provide for detection and probabilistic correction of the failure of a memory device. The correction may include reconstructing the data that was stored in the failed memory device using the check bits and the data from the other memory devices. The correction may also include “mapping out” the failed memory device such that the failed memory device is no longer used to store bits of encoded data blocks.
The persistent state storage 20 is configured to record state information regarding the persistent failures which have been detected by the memory controller 10. In the illustrated embodiment, the persistent state may include an indication of a failed memory device (Failed_MD in
A write request may supply up to a predetermined amount of data to be written to the memory, and similarly a read request may transfer up to a predetermined amount of data from the memory. For example, in one embodiment, a read or write request may supply a cache line of data. The cache line may be of any size (e.g. 32 bytes, 64 bytes, 128 bytes, etc.). In one particular implementation, a cache line may comprise 64 bytes of data (512 bits). The data supplied via a write request may further include metadata bits in some embodiments. Generally, metadata bits may be used to describe various properties of the corresponding cache line (e.g. type of data, coherency information, etc.). Any metadata used by the producers and consumers of the data (e.g. processors) may be encoded in the metadata.
The cache line may be divided into one or more data blocks. Check bits are generated for each data block independent of the other data blocks corresponding to a given cache line. The encoded data block (comprising the data bits, metadata bits if applicable, and the check bits arranged in a predetermined fashion) corresponding to each data block is referred to as a code word herein. A portion of the code word may be stored in each memory device MD_0 to MD_N−1.
As used herein, a memory device includes any memory packaged into a single device package having pins for accessing the memory device for writing and reading data stored therein. For example, a memory device may include a dynamic random access memory (DRAM) of any type (e.g. asynchronous DRAM, synchronous DRAM (SDRAM), RAMBUS DRAM (RDRAM), double data rate SDRAM (DDR SDRAM), etc.). A memory device may also include static RAM (SRAM), flash memory, etc. A memory device may include any memory which is subject to transient or persistent errors. In some embodiments, a memory device may be a single chip. In some cases, two or more memory devices may be included on a memory module. A memory module is a circuit board to which two or more memory devices have been attached. For example, memory modules may include dual inline memory modules (DIMMs), single inline memory modules (SIMMs), and any other type of memory modules.
As used herein, a check bit refers to a bit which is generated from two or more data bits and/or other check bits for providing error detection in the data bits/check bits (and optionally, depending on the definition of the check bits as a whole, error correction). A first check bit is referred to as “covering” a given data bit or given check bit if: (i) the given data bit/check bit is used in the generation of the first check bit (and thus the first check bit aids in the error detection/correction of that data bit/check bit); or (ii) the given check bit is the first check bit (that is, the first check bit may cover itself). For example, a check bit may be generated from two or more data bits/check bits by exclusive OR (XOR) or exclusive NOR (XNOR) of the two or more data bits/check bits.
It is noted that various buffers and/or queues (not shown) may be included in the memory controller 10 as desired for buffering data. Furthermore, read and write requests to the memory 12 generally include an address to select the memory locations within each memory device that are read or written, control lines to control the access to the memory, etc., which have not been illustrated in
The memory 12 may have any desired arrangement. For example, the memory 12 may be arranged into a plurality of banks. The memory devices MD_0 to MD_N−1 may be part of one bank, and other memory devices (not shown) may be part of other banks. As mentioned above, the memory devices may be configured onto memory modules, which may be part of one or more memory banks, as desired.
Error Code Definition
One embodiment of a definition of the check bit encodings to provide various error detection/correction properties based on the code word shown in
Each row check bit covers the bits that are in each other column of the code word and in the same row as that row check bit. For example, the row check bit in row r0 covers the bits that are in each other column and in row r0.
Decoding the code word to detect an error may include XORing the bits in each row (including the row check bit) to generate a corresponding bit of a row syndrome. If the row syndrome is not zero, then an error has occurred. The decoding may further include other manipulations of the data and the row syndrome (and an inner syndrome over the inner check bits) to determine what the failure is and, in some cases, the correction to be performed. The assignment of inner check bits to cover various data bits causes an error in a given position in the logical array to generate the inner syndrome, and by appropriate assignment of check bits to data bits, various error detection and correction properties may be realized.
Generally, the row check bits may be used to identify the failure of a memory device, and to reconstruct the data bits which were stored in the failed memory device. For example, row check bits may be the XOR of each other bit in the same row, and thus may detect that a given bit in the row has changed (e.g. due to the failure of the memory device which stores that bit). By XORing the other bits in the row and the row check bit, the changed bit may be reconstructed. Alternatively, once the failed column is identified, the bits in the row syndrome that are non-zero identify bits in the failed column that are to be inverted to reconstruct the data from the failed column.
The failure of a memory device causes at least one row to indicate a failure. That is, the row check bits identify which rows of the logical array contain an error, but not which column the errors are in. The inner check bits may be assigned to cover various data bits to identify which particular memory device (which column of the code word array) has failed (thus permitting the reconstruction of the data from the failed memory device and the remapping of the code word to exclude the failed memory device, if desired). For the remainder of this discussion, “failed memory device” or “failed DRAM” and “failed column” may be used. The failed column may be the column of the array which corresponds to the failed memory device or failed DRAM.
In one embodiment, the memory controller 10 (and more particularly the error check/correct circuit 18 and/or the hard failure detection circuit 22, in one embodiment) may implement a mechanism to identify hard failures when multi-bit errors are detected. Specifically, the flowchart illustrated in
The error check/correct circuit 18 may calculate the row syndrome and the inner syndrome for the encoded data block (block 70). If the row syndrome includes a single binary one (decision block 72, “yes” leg), it is possible that a single bit error has been detected. If the inner syndrome identifies a single bit error in one of the columns (decision block 74, “yes” leg), the error check/correct circuit 18 may correct the single bit error (block 76). If the inner syndrome does not indicate a single bit error (decision block 74, “no” leg), then the error is uncorrectable (block 78). The determination of whether or not the inner syndrome indicates a single bit error depends on the particular definition of the inner check bits. As previously noted, considerable flexibility may be permitted in the definition of the inner check bits. For example, in one embodiment described below, a check vector is assigned to each bit in the array that indicates which check bits cover the bit. If the inner syndrome matches a check vector in the row identified by the row syndrome, then a single bit error may be detected.
If the row syndrome is zero (decision block 80, “yes” leg) and the inner syndrome is zero (decision block 82, “yes” leg), there is no error. On the other hand, if the row syndrome is zero (decision block 80, “yes” leg) and the inner syndrome is non-zero (decision block 82, “no” leg), an uncorrectable error is detected (block 78).
If the row syndrome includes at least two binary ones (decision blocks 72 and 80, “no” legs), the error check/correct circuit 18 may provide the row syndrome to the hard failure detection circuit 22. The hard failure detection circuit 22 may perform a plurality of memory operations to search for a hard failure in the memory locations storing the data block for which the error is detected (block 84).
One embodiment of the hard failure detection circuit 22 implementing the search for a hard error is illustrated in the flowchart of
In the illustrated embodiment, the hard failure detection circuit 22 may capture the encoded data read from the memory. In response to the multiple-one-bit row syndrome, the hard failure detection circuit 22 may complement the encoded data that was read (block 90) and write the complemented data back to the memory 12 (block 92). The memory controller 10 may use the same address provided when the erroneous data was read from the memory 12, so the complemented data is written to the same memory locations from which the erroneous read data was read. Since each bit in the data has been inverted by the complement operation, each bit should have been changed to the opposite state. If a bit storage location in memory has experienced a hard error (or “stuck at” error, since the bit is stuck at a zero or a one), the bit will be the same as the previous read. Accordingly, the hard failure detection circuit 22 may read the complemented data from memory (block 94) and may determine the hard error syndrome (block 96). For example, the hard error syndrome may comprise the bitwise exclusive NOR (XNOR) of the originally read data and the complemented data. Any bits that did not change state will have an XNOR result of one, and bits that did (correctly) change state will have an XNOR result of zero. Accordingly, the hard error syndrome may comprise set bits in the hard error locations. Alternatively, a bitwise exclusive OR (XOR) may be performed and the bits that are clear may indicate the hard error locations.
Generally, if any hard error is detected, the hard failure detection circuit 22 may attempt to identify the failing component and correct the data based on the failing component. For example, in one embodiment, the hard failure detection circuit 22 may determine if the bits detected as hard failures are in the same column of the logical array shown in
It is noted that any set of memory operations may be used to detect the hard failures. For example, the hard failure detection circuit 22 may write all zeros to the memory locations, read the data back, write all ones, and read the data back. The two data reads may then be used to compute the hard error syndrome as discussed above. Any data and its complement may be read and written, in various embodiments.
The above description has referred to the hard failure detection circuit 22 performing read and write operations to the memory 10. The operations may be performed by the hard failure detection circuit 22 directly, or they may be transmitted through the paths in the check bit encoder circuit 16 and error check/correct circuit 18 (without performing the encode/decode). Thus, the hard failure detection circuit 22 performing the memory operations may include both directly and indirectly causing the memory operations.
The above embodiments have permitted significant variation in the definition of the inner check bits. Choosing the inner check bits in specific fashions may provide additional error detection and/or correction properties.
For example, in one embodiment, a check vector is assigned to each bit in the array. The check vector corresponding to a given bit defines which of the inner check bits cover the given bit. Given a set of check vectors assigned to the array, a given inner check bit may be generated (e.g. by the check bit encoder circuit 16) by combining each of the bits in the array covered by the given inner check bit (as indicated by the corresponding check vectors). For example, the check vector may be a vector of X bits, each location of which corresponds to a row in the inner check bit column. If the bit in the check vector is set, the corresponding inner check bit covers the bit to which the check vector is assigned.
The check vectors may be defined as follows, in one embodiment. For each column, a “key” is selected from the elements of GF(2X). The key for each column is unique. That is, the keys are different elements of GF(2X). The check vectors for the rows in a given column may be generated by multiplying, in GF(2X), the key by alphaY, where Y is the row number and alpha is a primitive element of GF(2X). The check vector for row 0 (r0) of a given column may be equal to the key assigned to the given column (since multiplying an element by alpha0 results in that element). This equation is shown in
Additionally, in one embodiment, the keys may be strictly non-zero. See
Given the above definition of the check vectors, the equation at reference numeral 32 may be used to detect a failure of one column (where the arithmetic is performed in GF(2X)). In the equation 32, row_syn is the row syndrome (viewed as an element of GF(2X)), key_i is the key for column i, and inner_syn is the inner syndrome. Assuming X is less than R, the row syndrome can be viewed as an element of GF(2X) by viewing the R bits of the row syndrome as the coefficients of a degree-(R−1) polynomial and converting this polynomial to a degree-(X−1) polynomial by performing a modulus operation relative to the primitive polynomial used in defining the GF(2X). In this way, any polynomial (with Boolean coefficients) can be viewed as an element of GF(2X).
The inner syndrome is a bit vector, viewed as an element of GF(2X), where each bit is calculated by XORing the bits covered by the corresponding inner check bit with the inner check bit. Thus, if the row syndrome is non-zero, the inner syndrome divided by the row syndrome (in GF(2X)) is equal to key_i. By comparing result of the division to each of the keys, the failed column may be identified (and the row syndrome may be used to reconstruct the data from the failed column) with a probability of approximately 1-2−X. It is noted that, in some embodiments, rather than performing division as mentioned above, the error check/correct circuit 18 may guess that the error occurs in each column (in parallel) and may calculate the inner syndrome that would occur if the bits indicated by the row syndrome were in error in that column, and compare the calculated inner syndrome to the actual inner syndrome. Additionally, in one embodiment, if the row syndrome viewed as an element of GF(2X) is non-zero, the check for hard failures (block 84 in
As described above, Galois field arithmetic is used in the error code. Generally, a Galois Field is a finite field of numbers having the property that arithmetic operations on field elements (numbers in the field) have a result in the field (i.e. another element of the field). Addition may be defined in a Galois Field of size 2X to be bitwise exclusive OR (XOR) of the elements. A primitive element (alpha) of a Galois Field is an element used to generate the other elements of the Galois Field. Each of the elements of the Galois Field may be written as the sum of powers of alpha. There is at least one primitive element for a Galois field, but there may be more than one in some instances. In one embodiment, alpha is defined to satisfy the equation:
although alpha may be defined differently in other embodiments. In another view, any element of the Galois Field may be the linear combination of powers of alpha up to X−1, where the powers used in the linear combination correspond to bit positions in the element that have set (binary one) bits.
In one embodiment, the key for the column storing the inner check bits (e.g. column c1 in
Other definitions of the inner check bits are possible for other embodiments. For example, Hamming-like codes may be used. In one embodiment, the inner check bits may be defined as a Hamming code per row of the array shown in
Some of the above embodiments provide probabilistic detection of errors. Assuming that the data is randomly distributed, the probability of the undetectable cases occurring may be low. However, data is not always randomly distributed. To improve the randomness of the data, the data may be “whitened” by logically combining the data with a predictable pseudo-random pattern. For example, the pattern may be based on the address of the memory operations.
Turning now to
The check bit encoder circuit 16 may implement the operation of the write flowchart on the left side of
The error check/correct circuit 18 may implement the operation of the read flowchart on the right side of
Turning now to
The syndrome generator circuit 50 may generate the row syndrome and inner syndrome for the received code word, as described above. The component failure correction circuit 52 is configured to reconstruct the data from the failed component (e.g. memory device, in this embodiment) given the row syndrome, the inner syndrome, and the code word.
In one embodiment, the component failure correction circuit 52 may comprise circuitry to use the failed_MD to locate the failed column and correct the failure.
The syndrome generator circuit 54 receives the corrected encoded data from the component failure correction circuit 54, and generates a new inner syndrome over the corrected encoded data. If the inner syndrome generated by the syndrome generator circuit 54 is non-zero, additional data correction may be possible. The data correct circuit 56 performs these error detections/corrections, and signals uncorrectable error where appropriate.
Turning now to
In the illustrated embodiment, the transmission media 184 includes conductors coupled between the source device 180 and a set of switches 186 and conductors coupled between the switches 186 and the destination device 182. For example,
In the embodiment of
Generally, the various embodiments of check bits in accordance with the above described memory controller may be used in the communication system of
If the error check/correct circuit 18 transmits a path_failure indication to the source device 180 in response to detecting a path failure, the failing path may be “mapped out” by ceasing use of the failing path for subsequent packets, and by using one of the other paths to transmit the bits previously transmitted on the failing path (e.g. unused paths, similar to the above described memory device embodiments). In other embodiments, instead of transmitting the path_failure indication to the source device 180, the destination device 182 may inform a service processor of the failure. The service processor may inform the source device 180 (and any other source devices which may use the failing path) to cease using the failing path. Alternatively, the failing path may continue to be used, and the error check/correct circuit 18 may correct for the failing path.
It is noted that, while a single switch is shown for each set of conductors in
Turning next to
Numerous variations and modifications will become apparent to those skilled in the art once the above disclosure is fully appreciated. It is intended that the following claims be interpreted to embrace all such variations and modifications.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US3868632||Aug 20, 1973||Feb 25, 1975||Ibm||Plural channel error correcting apparatus and methods|
|US4646312||Dec 13, 1984||Feb 24, 1987||Ncr Corporation||Error detection and correction system|
|US5081626||Dec 8, 1989||Jan 14, 1992||Hughes Aircraft Company||System for detection and location of events|
|US5745508||Nov 13, 1995||Apr 28, 1998||Tricord Systems, Inc.||Error-detection code|
|US5872798||Feb 14, 1995||Feb 16, 1999||U.S. Philips Corporation||Error correctable data transmission method and device based on semi-cyclic codes|
|US6018817 *||Dec 3, 1997||Jan 25, 2000||International Business Machines Corporation||Error correcting code retrofit method and apparatus for multiple memory configurations|
|US6519736 *||Nov 30, 1999||Feb 11, 2003||International Business Machines Corporation||Generating special uncorrectable error codes for failure isolation|
|US6973613 *||Jun 28, 2002||Dec 6, 2005||Sun Microsystems, Inc.||Error detection/correction code which detects and corrects component failure and which provides single bit error correction subsequent to component failure|
|US7051264 *||Nov 14, 2001||May 23, 2006||Monolithic System Technology, Inc.||Error correcting memory and method of operating same|
|US7103824||Jul 22, 2003||Sep 5, 2006||Robert Halford||Multi-dimensional data protection and mirroring method for micro level data|
|US7171591 *||Dec 23, 2003||Jan 30, 2007||International Business Machines Corporation||Method and apparatus for encoding special uncorrectable errors in an error correction code|
|US7188296 *||Oct 30, 2003||Mar 6, 2007||Sun Microsystems, Inc.||ECC for component failures using Galois fields|
|US7243293 *||Dec 23, 2003||Jul 10, 2007||International Business Machines Corporation||(18, 9) Error correction code for double error correction and triple error detection|
|US7496826 *||Oct 20, 2006||Feb 24, 2009||Intel Corporation||Method, system, and apparatus for adjacent-symbol error correction and detection code|
|US7509560 *||Dec 29, 2003||Mar 24, 2009||Intel Corporation||Mechanism for adjacent-symbol error correction and detection|
|US7530008||Aug 8, 2003||May 5, 2009||Sun Microsystems, Inc.||Scalable-chip-correct ECC scheme|
|US7761771 *||Apr 20, 2006||Jul 20, 2010||International Business Machines Corporation||High reliability memory module with a fault tolerant address and command bus|
|US20020157044||Oct 29, 2001||Oct 24, 2002||Byrd James M.||System and method for verifying error detection/correction logic|
|US20050034050||Aug 8, 2003||Feb 10, 2005||Sun Microsystems, Inc.||Scalable-chip-correct ECC scheme|
|1||PCI Express, "PCI Express(TM) Base Specification," Revision 1.0a, Apr. 15, 2003, 3 pages.|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US9250990 *||Sep 24, 2013||Feb 2, 2016||Intel Corporation||Use of error correction pointers to handle errors in memory|
|US20150089310 *||Sep 24, 2013||Mar 26, 2015||Ravi H. Motwani||Use of error correction pointers to handle errors in memory|
|U.S. Classification||714/785, 714/758|
|May 23, 2008||AS||Assignment|
Owner name: SUN MICROSYSTEMS, INC., CALIFORNIA
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:CYPHER, ROBERT E.;REEL/FRAME:020992/0913
Effective date: 20080520
|Sep 2, 2015||FPAY||Fee payment|
Year of fee payment: 4
|Dec 16, 2015||AS||Assignment|
Owner name: ORACLE AMERICA, INC., CALIFORNIA
Free format text: MERGER AND CHANGE OF NAME;ASSIGNORS:ORACLE USA, INC.;SUN MICROSYSTEMS, INC.;ORACLE AMERICA, INC.;REEL/FRAME:037311/0150
Effective date: 20100212