Error-detection code

Abstract

Method and apparatus for improved detection of multiple-bit errors which occur within a single memory circuits. In one embodiment, a computer system is described which includes a main computer and a memory system. The memory system includes a plurality of memory circuits, at least one of the plurality of memory circuits having a data interface more than two bits wide. Also included is a multiple-bit-error-detect (MBED) circuit, wherein bits from the plurality of memory circuits are coupled to the MBED circuit in an order which causes the MBED circuit to preferentially detect multiple-bit errors which occur on the data interface of any single one of the plurality of memory circuits. In another embodiment, the method comprises the steps of: a) providing an initial bit-connection order between the plurality of memory circuits and the error-detection circuit; b) testing each of the predetermined set of possible multi-bit error conditions; c) determining whether the error-detection circuit provides (1) an erroneous no-error/single-bit-error indication or (2) a non-erroneous multiple-bit-error indication for each one of the predetermined set of possible multi-bit error conditions; and d) based on a number of erroneous indications or non-erroneous indications determined in step c), either: re-ordering the bit-connection order and reexecuting step b), or providing the bit-connection order as an output. In one such embodiment this method is used wherein the step of re-ordering comprises the step of shifting at least one bit connection from the first memory circuit to the second memory circuit.

Description

FIELD OF THE INVENTION

The present invention relates to methods and apparatus for detecting and correcting errors in computer memories and more specifically to an improved error-detection code and apparatus, and a method for determining same, which are used for detecting single-chip failures in multiple-bit-wide memory circuits.

BACKGROUND OF THE INVENTION

Very fast access to data stored in computer memories along with error detection and correction is desired to enhance the speed of the computer systems which use those memories, while improving reliability and serviceability of the computer systems. Such computer systems include single-processor systems, as well as multiple-processor systems.

The memory subsystems in a computer system can include static random access memories (SRAMs), dynamic random access memories (DRAMs), or dual-ported static random-access memories (DPSRAMs). The memory subsystems commonly include error correction and detection code (ECC) circuits in order to detect and/or potentially correct errors in the data stored in the memory subsystems. Such errors can include errors which may occur, perhaps due to a charged particle or cosmic ray, which causes the data a single cell to change from a logic state zero (hereinafter "zero") to a logic state one (hereinafter "one") or vice versa; errors due to a wire or bit line becoming "stuck" to a one or a zero (such as a short to a high or low data state), regardless of the data which is driven onto that line, or even an entire microcircuit chip failing, with all of its bits, for example, becoming stuck to ones or zeros. Commonly known ECCs have been designed to (1) correct any single-bit error and (2) detect any combination of two bits in error within a group (or "word") of N data bits by adding as few as log.sub.2 N redundant bits to each word. Such codes are called single-bit-error-correct/double-bit-error-detect (SBEC/DBED)codes. Codes which can detect any three bits in error or any four bits in error do exist, but generally require more redundant bits and/or more complex circuits, methods, or mechanisms, and are generally implemented in more complex circuits.

The prior art includes chips which have been designed to incorporate an entire SBEC/DBED code circuit onto a single integrated circuit chip. Such chips are adequate to handle memory subsystems which include only one-bit- and two-bit-wide memory chips, since even if an entire chip fails, the SBEC/DBED chip will correct (in the case of one-bit-wide memory chips) or at least detect (in the case of two-bit-wide memory chips) any single chip failure.

However, when three-bit-wide or four-bit-wide memory chips are used, a single-chip failure can cause as many as three or four bits at a time to be in error. Prior-art SBEC/DBED chips have not shown how to detect such errors.

SUMMARY OF THE INVENTION

The present invention teaches a method and apparatus for improved detection of multiple-bit errors which occur within a single memory circuits. In one embodiment, a computer system is described which includes a main computer and a memory system. The memory system includes a plurality of memory circuits, at least one of the plurality of memory circuits having a data interface more than two bits wide. Also included is a multiple-bit-error-detect (MBED) circuit, wherein bits from the plurality of memory circuits are coupled to the MBED circuit in an order which causes the MBED circuit to preferentially detect multiple-bit errors which occur on the data interface of any single one of the plurality of memory circuits.

In one such embodiment, the order that the bits from the plurality of memory circuits are coupled to the MBED circuit is determined by running a test program on a test computer to successively test various orders of coupling bits to the MBED circuit. In one such embodiment, the test program comprises a data structure indicative of error syndromes and related error indications. In another such embodiment, the test program comprises a data structure indicative of which error code (EC) bits are affected by each memory bit of the memory circuits.

In one such embodiment, the MBED circuit is a single-bit-error-correct, two-bit-error-detect (SBEC/DBED) circuit, each of a plurality of the memory circuits have a data interface which is four-bits wide, and bits from the memory interface are coupled to the MBED circuit in an order which causes the MBED circuit to also detect all three-bit and four-bit errors which occur at one time within any single one of the plurality of four-bit-wide memory circuits.

In another embodiment, a method for designing a memory system for a computer system is described. The memory system is capable of detecting multiple-bit errors within each of a plurality of single memory circuits, the computer system having an error-detection circuit capable of detecting multiple-bit errors and generating a plurality of error syndromes, and a memory, the memory having a plurality of memory circuits including a first and a second memory circuit each having a data interface which is more than two bits wide and each connected to the error detection circuit. The method comprises the steps of: a) providing a syndrome data structure distinguishing whether the error-detection circuit provides (1) no-error/single-bit-error indication from (2) a multiple-bit-error indication, as a result of each of the error syndromes; b) providing an error code (EC) data structure indicative of which EC bits are affected by each memory bit of the memory circuits; c) providing an initial bit-connection order between the plurality of memory circuits and the error-detection circuit; d) using a computer program which uses the bit connection order, the syndrome data structure, and the EC data structure, determining whether a first error, having more than two bits wrong within the first memory circuit, would be detected with a multiple-bit-error indication and whether a second error, having more than two bits wrong within the second memory circuit, would be detected with a multiple-bit-error indication; and e) if either the first error or the second error or both are not detected with a multiple-bit-error indication, then re-ordering the bit-connection order and reexecuting step d), otherwise outputing the bit-connection order.

In another embodiment, the method comprises the steps of: a) providing an initial bit-connection order between the plurality of memory circuits and the error-detection circuit; b) testing each of the predetermined set of possible multi-bit error conditions; c) determining whether the error-detection circuit provides (1) an erroneous no-error/single-bit-error indication or (2) a non-erroneous multiple-bit-error indication for each one of the predetermined set of possible multi-bit error conditions; and d) based on a number of erroneous indications or non-erroneous indications determined in step c), either: re-ordering the bit-connection order and reexecuting step b), or providing the bit-connection order as an output. In one such embodiment this method is used wherein the step of re-ordering comprises the step of shifting at least one bit connection from the first memory circuit to the second memory circuit.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram illustrating an computer system 100 including a memory subsystem 200 according to the present invention.

FIG. 2 is a block diagram illustrating an exemplary memory subsystem 200 including an MBED circuit 300 according to the present invention.

FIG. 3 is a block diagram illustrating details of one embodiment of the data path between MBED circuit 300 and system bus 210 according to the present invention.

FIG. 4 is a block diagram illustrating details of one embodiment of the address path within system bus 210.

FIG. 5 is an address decoding diagram illustrating details of address decoding used in one embodiment memory subsystem 200.

FIG. 6 is an addressing map for of one embodiment of memory subsystem 200 used in an IBM-compatible-type computer system 100.

FIG. 7 shows the scheme used to scrub memory in one embodiment of memory subsystem 200.

FIG. 8 is a bit map showing which data bits are involved in the eight respective checkbits CB0 through CB7, and the even/odd parity used.

FIG. 9 is a bit map showing which bit or bits are in error for each of the possible 256 syndrome codes for one embodiment of MBED circuit 300.

FIGS. 10A, 10B & 10C show various data patterns which can be used to test generation of each syndrome data pattern.

FIGS. 11A, 11B, & 11C show various checkbit data patterns which can be used to test various error log syndromes.

FIG. 12 shows various checkbit data patterns which can be used to test various error log syndromes.

FIG. 13 shows various data patterns which can be used to test various error log syndromes.

FIG. 14 shows one bit-connection pattern according to the present invention for one SBEC/DBED chip as used in MBED circuit 300.

FIG. 15 shows a flowchart of one embodiment of the method 500 for determining an optimal bit-connection order between MBED circuit 300 and the plurality of individual memory circuits.

FIG. 16 shows a diagram of one embodiment of the structures used in method 500 for determining an optimal bit-connection order between MBED circuit 300 and the plurality of individual memory circuits comprising memory array 270.

FIG. 17 shows a more detailed flow chart of program 510.

DESCRIPTION OF THE PREFERRED EMBODIMENT

In the following detailed description of the preferred embodiments, reference is made to the accompanying drawings which form a part hereof, and in which are shown by way of illustration specific exemplary embodiments in which the invention may be practiced. It is to be understood that other embodiments may be utilized and structural changes may be made without departing from the scope of the present invention.

FIG. 1 is a block diagram illustrating an overall computer system 100 according to the present invention, including main computer 102 and memory system 200 (used as a subsystem in computer system 100 to provide system memory for main computer 102), which in one embodiment, are connected by high-performance external bus 198. Memory system 200 is shown in more detail in FIG. 2.

Main computer 102 also includes disk subsystem 104. A cache 106 and one or more disk-connection busses 139 are provided, each disk-connection bus 139 connected to one or more disk devices 140. In one embodiment, disk-connection busses 139 are standard 16-bit-wide/fast differential-drive SCSI (Small Computer System Interface) busses with differential SCSI terminators, and disk devices 140 are SCSI disk devices. In other embodiments, disk-connection busses 139 are standard 8-bit-wide/fast differential-drive SCSI busses, 8-bit-wide/slow differential-drive SCSI busses, 8-bit-wide/fast single-ended-drive SCSI busses, or 8-bit-wide/slow single-ended-drive SCSI busses, depending on the interface chips used in to drive disk-connection busses 139.

In one embodiment, up to six disk subsystems 104 can be connected to one main computer 102, providing scalability to the needs of the user. In one such embodiment, portions of disk-processing tasks are offloaded from main computer 102 into each disk subsystems 104, allowing scalable system performance improvements by adding disk subsystems 104 subsystems. In another embodiment, multiple main computers 102 are also connected to high-performance external bus 198, providing additional system performance or redundancy (for additional reliability) or both.

FIG. 2 is a block diagram illustrating memory system 200 including a multiple-bit-error detection ("MBED") circuit 300 according to the present invention. Prior-art SBEC/DBED chips, such as the IDT49C466 type 64-bit flow-through error detection and correction unit chip made by Integrated Device Technology Inc., are available and are designed to correct all single-bit errors and detect all double-bit errors and many multiple-bit errors within a 64-bit-wide data word and a 8-bit-wide ECC check-byte; however there has heretofore been nothing to teach how such SBEC/DBED chips might be used to detect all three-bit and four-bit errors which occur within a single four-bit-wide memory chip used as one of a plurality of memory chips. As memory densities (i.e., the number of bits per chip) have increased, it has become desirable in many cases to use memory configurations which utilize prior-art SBEC/DBED algorithms and circuits along with memory chips which present data interfaces that are more than one bit wide, and in particular, to use memory chips that have data interfaces that are four-bits wide (i.e., presenting four data bits in parallel), such as 4-by-1 megabit, 4-by-4 megabit, or 4-by-16 megabit chips.

What would be desirable, and what the present invention provides is a method for converting a SBEC/DBED code into a code which, in addition to correcting any single-bit error and detecting all double-bit-errors, will also detect all three-bit and four-bit errors which occur within a single memory chip which has a four-bit-wide data interface ("four-bit-wide chips," in which four data bits are read or written in parallel from one address location). What needs to be done, and what the present invention does is to arrange the order of bits presented to the SBEC/DBED chip in an order such that multiple-bit errors which are detected by the SBEC/DBED code are within single four-bit-wide chips, and thus the prior-art SBEC/DBED circuits handle the detection of three-bit and four-bit errors caused by the failure of single chips. (All one- and two-bit errors are detected--by definition--by a SBEC/DBED code. Three-bit errors must be detected since a total failure of a four-bit-wide memory chip may result in only three bits in error, such as if a 1011 binary pattern were changed to a 0000 pattern by the chip failing and driving all bits to zero. Four-bit errors must, of course, also be detected.) Such single-chip failures comprise one major mode or cause of system errors. Such single chip failures may or may not result in all bits of the chip being driven to the same state, e.g., to 0000 or 1111 binary, so it is desirable to detect bits which have flipped to the opposite state from what they should be.

Another benefit which the present invention provides is the capability to find a bit-connection order which maximizes certain error-detection capabilities in other memory-system configurations. In some embodiments, it is desirable to detect as many multiple-bit errors which occur within a single chip as possible, or to detect certain types or patterns of multi-bit errors which represent common failure modes of the memory chips or other components, even though perhaps not all multiple-bit errors can be detected. For example, memory cirsuits having an eight-bit-wide data interface are available. The present invention provides a method, described more fully below, which can be used to determine which connection-order provides the system with the highest number of detected errors among some pre-determined subset of all possible multi-bit errors, the least number of undetected or mis-corrected errors, or the "best" detection (by some criteria determined by the memory-system designer or user) of common failure modes. Thus, if certain failures which affect the system are more likely (such as a complete failure of a single chip or module, or some pre-determined pattern of erroneous bits), the method of the present invention can be tailored to detect preferentially as many of such failures as desired or possible. The designer can also choose which errors or failure modes should be selected for, thus tailoring the protection achieved for certain environments or parts, for example, choosing one bit-connection order which optimizes for detecting errors in a first part used in the system when failures in that part are thought more likely, and alternatively choosing a second, different connection order which optimizes for detecting errors in a second part in circumstances when those errors are thought more likely.

In one embodiment, an off-the-shelf SBEC/DBED chip, such as the IDT49C466 type 64-bit flow-through error detection and correction unit chip made by Integrated Device Technology Inc., is used as the basis for MBED circuit 300, and thus is the starting point used in order to derive a connection order for bits between a plurality of 3-bit and/or 4-bit memory chips and the MBED circuit 300. In one such embodiment, two IDT49C466 type 64-bit flow-through error detection and correction unit chips are used in parallel to provide SBEC/DBED functions on each or two 64-bit data words read or written together as part of a 128-bit memory operation to a memory array 270. In another embodiment, a SBEC/DBED code, such as can be commonly obtained or derived from a textbook or publication on memory circuits or error correction/detection, is used as the starting point, in order to derive a connection order for bits between a plurality of multiple-bit-wide memory circuits (such as 4-bit-wide memory chips) and the MBED circuit 300 based on the SBEC/DBED code.

It is possible for many, if not all, circuits which provide a SBEC/DBED function to be connected to the respective multiple-bit memory chips in such a bit-order as to detect all three-bit and four-bit errors which appear on the data interface of any single memory chip. Unfortunately, such a connection order is not apparent from the data sheet nor the ECC formula which corresponds to a given SBEC/DBED chip or circuit, e.g., a 72-bit SBEC/DBED code circuit designed to be used with a 64-data-bit memory bus. A brute-force attempt to test every combinatorial of 72 memory data/ECC bits to 72 ECC chip pins would generally take an unacceptably long time. It is thus desirable in one embodiment of the present invention to have a method to discern the most likely starting order and refine and verify the connection order in order to derive an improved connection order which detects all 3-bit and 4-bit errors within one memory chip.

While one embodiment described herein includes a SBEC/DBED circuit or other error-correcting circuit, the present invention is also used advantageously with any error-detection circuit capable of detecting errors occurring in two or more bits of a data word. Such circuits can be generalized as "multi-bit error detection" ("MBED") circuits.

FIG. 2 is a block diagram illustrating an exemplary memory subsystem 200 including an MBED circuit 300 according to the present invention. In one embodiment, system bus 210 is also used as high-performance external bus 198 of FIG. 1. In another embodiment, separate busses are provided for high-performance external bus 198 and system bus 210. In one embodiment, system bus 210 can be used to access single memory locations, the address of which is latched in address latch 212, and can also be used to access a consecutive string of locations, the addresses of which are tracked by burst address counter 214 used in conjunction with address latch 212. Memory requests are fed through address decode 216 and thereafter to access arbiter 218. Memory refresh requests are tracked by refresh address counter 220 which also feeds access arbiter 218, which determines the relative priorities of memory requests versus refresh requests. Configuration RAM 222 and configuration RAM page register 224 are loaded via internal bus 240, and control the mapping of system bus addresses to memory subsystem addresses and memory chip addresses by generating multiplex control signals which drive row/column address multiplexor ("mux") 226. In one embodiment, row/column address mux 226 drives address buffer/latch 228; which in one embodiment latches the multiplexed address signals, and in another embodiment, buffers (amplifies) the multiplexed address signals. The multiplexed address signals then drive memory array 270. In one embodiment, memory array 270 comprises a plurality of DRAM banks 271, each DRAM bank 271 comprising data bits 273 having M words of N data bits each and checkbits 272 having M words of K checkbits each. In one such embodiment, M is up to 64 megawords, N is 128 data bits (i.e., a data word up to 128 data bits wide is read or written as a single operation) comprised of two 64-bit data parts, and K is 16 checkbits comprised of two 8-bit checksum parts. In one embodiment, 128 bits of data and 16 bits of checksum are read or written in parallel to/from data buffer 260. RAS/CAS/WE control 262 and memory cycle control circuit 264 work cooperatively in order to control the function and timing signals needed to control memory array 270 in a manner well known in the art.

Data from and to data buffer 260 is passed through MBED circuit 300 and either to read data latch/mux 248 or from write data latch 246 which operate on 128-bit words. Error syndromes for errors detected by MBED circuit 300 are passed to error log circuit 250 (as are addressing errors detected by configuration RAM 222). The 128-bit words of read data latch 248 are multiplexed into a series of 64-bit words by data multiplexor (mux) 242 and coupled to internal bus 240. Likewise, 64-bit words from internal bus 240 are demultiplexed by data demultiplexor (demux) 244 and coupled to write data latch 246. 64-bit data words from internal bus 240 have parity generated by data & parity latch 236, one parity bit for every 8 bits of data, in order to generate 72-bit data/parity words which are driven onto system bus 210, and conversely, 72-bit data/parity words from system bus 210 are checked for proper parity, stripped to 64-data-bit words, and driven to internal bus 240. In an alternative embodiment, parity is not used on system bus 210, and data is passed without generating or detecting parity in data & parity latch 236. Control register 232, which controls the overall state of memory system 200, Status-and-ID register 234, which reports the identity and status of memory subsystem 200 to computer system 100, and SIMM-ID register 238, which stores the identification numbers of the single-in-line-memory-modules (SIMMs) comprising memory array 270, are each connected to and controlled from internal bus 240. Bus/snoop state tracker 230 monitors the state of system bus 210 in order to optimize the performance of memory subsystem 200.

FIG. 3 is a block diagram illustrating details of one embodiment of the data path between MBED circuit 300 and system bus 210 according to the present invention. In the embodiment shown, 64 bits can be read or written in parallel from system bus 210 from or to both the system bus data latches 237 within data & parity latch 236; alternatively, 32 bits can be written or read from one or the other system bus data latches 237 within data&parity latch 236 to effect 32-bit transfers (the parity generation/detection/stripping circuitry is not shown in this embodiment). In the embodiment shown, the data demux function of data demux 244 is performed within the write buffers of write data latch 246. In the embodiment shown, the data mux function of data mux 242 is performed within the read data latches/2:1 mux of read data latch 248. In the embodiment shown, MBED circuit 300 is implemented by using two 64-bit error detection and correction (EDAC) circuits as shown, on for the upper 64 bits and one for the lower 64 bits. In one embodiment, two IDT49C466 type 64-bit flow-through error detection and correction unit chips made by Integrated Device Technology Inc., are used in parallel in MBED circuit 300, each having a pipelined latch to facilitate data flow through memory subsystem 200. Such a configuration provides SBEC/DBED protection on each 64-bit half of each 128-bit data word, thus allowing certain double-bit errors (such as any single-bit error in the lower 64 bits and any single-bit error in the corresponding upper 64 bits of that data word) to be corrected and also allowing any of certain four-bit errors in a 128-bit data word (such as any double-bit error in the lower 64 bits and any double-bit error in the corresponding upper 64 bits of the same data word) to be detected. With the improved error detection provided by the present invention, any single chip failure (even with three or four bits in error) in the lower 64 bits and any single chip failure (even with three or four bits in error) in the upper 64 bits at the same time will be detected, thus providing improved detection of up to eight bits in error in any single 128-bit data word.

FIG. 4 is a block diagram illustrating details of one embodiment of the address path within system bus 210. In the embodiment shown, RAM access state machine 221 is used to control the flow of addresses by providing output enable (OE) signals for configuration RAM 222, configuration RAM page register 224, error log circuit 250, and address latch 212. Latch 223 is used to latch the data from configuration RAM 222. In this embodiment, a data tranceiver is used to implement error log circuit 250.

FIG. 5 is an address-decoding diagram illustrating details of address decoding used in one embodiment memory subsystem 200. In the embodiment shown, the lowest 4 bits are use to select 8-bit bytes within 128-bit words. The next ten bits (bit numbers 4 through 13) are used for column address bits. Row address bits are derived from the next 10, 11, 12, or 13 bits (bit numbers 14 through 23, 24, 25, or 26 respectively for 1M, 4M, 16M or 64M banks respectively), as shown. The bits above the row bits are used to obtain high-order column bits needed, if necessary (bits 25 for the 4M-bank case; bits 26 & 27 for the 16M-bank case; and bits 27, 28 & 29 for the 64M bank case).

FIG. 6 is an addressing map for of one embodiment of memory subsystem 200 used in an IBM-compatible-type computer system 100. The left-most column shows address ranges provided by the banks as shown.

FIG. 7 shows the scheme used to test the memory scrub in one embodiment of memory subsystem 200. This verifies that only words having single-bit errors will be modified, and that zero-error and multi-bit errors are not.

FIG. 8 is a bit map showing which data bits are involved in the generation of each of the eight respective checkbits CB0 through CB7, and the even/odd parity used. The FIG. 8 bit map shows that, for this exemplary error-correction code, data bits 1, 2, 3, 5, 8, 9, 11, 14, 17, 18, 19, 21, 24, 25, 27, 30, 32, 36, 38, 39, 42, 44, 45, 47, 48, 52, 54, 55, 58, 60, 61, and 63 are exclusive-ORed together in order to generate checkbit CB0. Similarly, other rows show how the data bits are exclusive-ORed together (in the case of checkbits CB2 and CB3, an exclusive-NOR is used for odd parity) in order to generate each of the other checkbits for this embodiment. The FIG. 8 bit map also shows, for example, that data bit 0 affects checkbits CB7, CB6, CB3, CB2, and CB1; thus if only data bit 0 is wrong (i.e., the bit is inverted from what it should be), the checkbits will mismatch on bits 7, 6, 3, 2, and 1; equivalent to a binary pattern of `11001110`b, or hexadecimal 0xCE (herein the notation for hexadecimal numbers are preceded by "0x"). The pattern of checkbit mismatch is called the "syndrome" of the error, where bits mismatching are one (1) and bits which match are zero. Thus the syndrome for date bit 0 being wrong is 0xCE (`11001110`b ), and the syndrome for bit 1 being wrong is 0xCB (`11001011`b). Note that if both data bit 0 and data bit 1 are wrong, then the resultant syndrome is equivalent to the exclusive-OR ("XOR") of the individual syndromes, here for example:

0xCE<XOR>0xCB=0x05. Also note that 0x05 is also the syndrome for other two-bit errors (such as data bits 16 and 17 both wrong, or data bits 32 and 33 both wrong), as well as for many multiple-bit errors. For the purposes of one embodiment of the method for determined the connection order of memory bits to the error-detection circuit, the fact that even parity (versus odd parity) is generated for any particular checkbit is not important, since when any one particular data bit is wrong, it will affect (invert) the checkbits in the same manner.

FIG. 9 is a bit map showing which bit or bits are in error for each of the possible 256 syndrome codes for one embodiment of MBED circuit 300. Note that a syndrome of all zero (0x00) is indicative of no errors, and corresponds to the table entry of "*". (Syndrome bits S0 through S7 correspond to checkbits CB0 through CB7, respectively.) The columns of the FIG. 9 table are used for the first hexadecimal digit of the syndrome code, and the rows for the second hexadecimal digit of the syndrome code. Thus, for example, syndrome 0xCE is indicated in the table in column "C" and row "E", and the table shows a single-bit error in data bit 0; syndrome 0xCB is indicated in the table in column "C" and row "B", and the table shows a single-bit error in data bit 1; syndrome 0x05 is indicated in the table in column "0" and row "5", and the table shows a "T" indicating a two-bit error (the corresponding data bits for which cannot be determined accurately from the syndrome). For the table in FIG. 9, "*" indicates no errors detected; a one or two-digit decimal number indicates the bit position of the data bit in which a single-bit error was detected; "T" indicates a two-bit error detected; "M" indicates a multi-bit error detected; and "C" followed by a single digit indicates the bit position of the checkbit in which a single-bit error was detected (i.e., C0 through C7 correspond to single-bit errors in checkbits CB0 through CB7, respectively).

FIGS. 10A & 10B can be placed next to one another, and show various data patterns (shown in hexadecimal digits) which can be used to test generation of each syndrome data pattern by computer system 100. 256 different data patterns are shown, each corresponding to a different one of the 256 possible checkbit patterns. This table is used to generate a test program which writes each data pattern into memory subsystem 200, in order to test the parity generation tree in MBED circuit 300.

FIGS. 11A, 11B, & 11C show various checkbit data patterns which can be used to test various error log syndromes. Each respective data word shown in FIGS. 11A, 11B, and 11C is written to data bits 273 in memory array 270 using MBED circuit 300 to generate the corresponding checkbits 272 (for example, a data word of 0x0000000000000000 generates checkbits 0x0C, since checkbits CB3 and CB2 are generated with "odd parity" which is equivalent to exclusive-NOR). The original checkbits are the modified by overwriting just the checkbits with the data in the "modified" column. (One embodiment of computer system 100 allows writing of just the checkbits 272 without modification of data bits 273, in order to facilitate testing. Another embodiment of computer system 100 allows writing of just the data bits 273 without modification of checkbits 272, in order to facilitate testing. Yet another embodiment of computer system 100 allows writing of both data bits 273 and checkbits 272 with arbitrary patterns, in order to facilitate testing.) The syndrome is generated by exclusive-ORing the pattern which should be generated by the data with the checkbits, thus the syndrome is obtained by exclusive-ORing the pattern in the "original" column with the pattern in the "modified" column to generate an 8-bit syndrome in the "error log syndrome" column (for example in the first row of FIG. 11A, the original checkbits are 0x0C, the modified checkbits are 0xC2, thus the syndrome is the XOR of these which is equal to 0xCE and which corresponds to a single-bit error in data bit 0 as shown in the "bit in error" column).

FIG. 12 shows a table of various 32-bit data words and their corresponding checkbit data patterns, which can be used to test various error log syndromes.

FIG. 13 shows various data patterns, and the corresponding checkbit pattern which should be generated, which can be used to test various error log syndromes. The patterns shown in FIG. 13 each have only a single data bit "on," except for the first data pattern which is all zeros.

FIG. 14 shows one bit-connection pattern according to the present invention between four-bit-wide memory circuits in memory array 270 and one SBEC/DBED chip, the IDT49C466 type 64-bit flow-through error detection and correction unit chip made by Integrated Device Technology Inc., as used in this embodiment of MBED circuit 300. FIGS. 8 and 9 correspond to the MBED code used for this embodiment. For this embodiment, MBED circuit 300 detects and corrects all single-bit errors, detects all two-bit errors (but does not correct them) and detects some, but not all, multiple-bit errors. Using the bit-connection order shown in FIG. 14 however, MBED circuit 300 detects all one-bit, two-bit, three-bit and four-bit errors which occur within a single one of the four-bit-wide memory circuits in memory array 270. In this embodiment, single-bit errors are corrected, and program execution continues. In one such embodiment, the occurrence of single-bit corrected errors is logged by error log 250 in order that maintenance can later be performed if too many such single-bit errors occur, especially if concentrated in one component of the system. In one embodiment, two-bit error indications and multi-bit error indications are both treated as uncorrectable multi-bit errors. In one such embodiment, such uncorrectable errors are surfaced to the system as exigent errors and cause program execution to stop, in order that the error gets noticed by a human user, and maintenance can be immediately performed. In another embodiment, an attempt is made to continue execution, with the memory area detected as having the error being marked as unreliable.

FIG. 15 shows a flowchart of one embodiment of the method 500 for determining an optimal bit-connection order between MBED circuit 300 and the plurality of individual memory circuits comprising memory array 270. In this embodiment, the method starts at block 501 and goes to block 502. At block 502, the data bits and checkbits are divided (or selected) into a first portion and a second portion. In one such embodiment, a human user performs this step, and chooses the upper-order (most significant) 32 data bits and four of the checkbits for the first portion, and the lower-order (least-significant) 32 data bits and the other four checkbits for the second portion; the user then customizes test-and-re-ordering program 510 (see FIG. 16) with the first portion of the bits and runs program 510 at step 503 which outputs a first set of results. The user then customizes test-and-re-ordering program 510 (see FIG. 16) with the second portion of the bits and runs program 510 at step 504 which outputs a second set of results. The process then ends at block 505.

In one embodiment, the method 500 is iteratively performed, wherein the outputted first results indicate to the user a connection order which is partially successful, and the user uses the outputted first results to help in selecting bits, and thus selects a smaller subset of the previous first portion of bits including those bits connections which previously yielded erroneous results (i.e., results which indicate either no error or single-bit error for multiple-bit errors). That is, the user keeps most of the memory-chip connections which successfully detected multi-bit errors, but selects a smaller subset of memory-chip connections to re-process through step 503. This can result in substantially faster processing time, since fewer bits are being tested and rearranged. Similarly, the output of second results after the initial second portion of bits can be used to select a smaller subset of those bits for subsequent processing.

FIG. 16 shows a diagram of one embodiment of the structures used in method 500 for determining an optimal bit-connection order between MBED circuit 300 and the plurality of individual memory circuits comprising memory array 270. In this embodiment, the method uses error-code ("EC") data structure 506 and syndrome data structure 507 to control test-and-re-ordering program 510. In one such embodiment, program 510 initializes bit-connection-order matrix 508 using a pseudo-random seed to help determine the initial bit-connection order. In one embodiment, as program 510 runs, it outputs results to output file 509 each time a bit-connection order yields results which meet some criterion, such as having the same-number-or-fewer erroneous results than previous attempts. In one such embodiment, output file 509 is printed to paper.

FIG. 17 shows a more detailed flow chart of program 510. Program 510 begins at start block 511. At block 512, the EC data structure 506 is initialized. In one embodiment, an 8-row, 64-column integer matrix is used to hold the data from FIG. 8, wherein a 1 is used in EC data structure 506 for each "X" in FIG. 8 and 0 is used otherwise. At block 513, the syndrome data structure 507 is initialized. In one embodiment, a 16-row, 16-column character matrix is used to hold the data from FIG. 9, wherein a "0" is used in syndrome data structure 507 for the "*" in FIG. 9, a "c" is used in syndrome data structure 507 for each "C0" through "C7" (indicating the single-bit checkbit errors) in FIG. 9, a "b" is used in syndrome data structure 507 for each "0" through "63" (indicating the single-bit data bit errors) in FIG. 9, a "t" is used in syndrome data structure 507 for each "T" (indicating the two-bit errors) in FIG. 9, and an "m" is used in syndrome data structure 507 for each "M" (indicating the multiple-bit errors) in FIG. 9. For the purposes of this embodiment, a "t" or "m" result is considered non-erroneous, since either of these indicates to computer system 100 that a multiple-bit non-correctable error has been detected. Although a "t" result (meaning a two-bit detected error) may be technically wrong if in fact more than two bits are actually inverted from what they should be, the computer system 100 treats all such uncorrectable errors as multiple-bit failures requiring exigent service. For the purposes of this embodiment, a "0," "b," or "c" result is considered erroneous, since the errors being tested for each have more than two bits inverted, and such results will cause the error to go undetected and/or will cause the error to be mis-corrected.

At block 514, bit-connection-order data structure 508 is initialized. In one embodiment, an 4-row, 9-column integer matrix is used as bit-connection-order data structure 508 to hold the bit-connection order, wherein each entry contains a bit number of the connection to MBED circuit 300, and wherein half (i.e., thirty-six) of the possible bits (i.e., seventy-two) of the MBED circuit are rearranged in each running of program 510 (i.e., per pass through step 503 of FIG. 15). In one such embodiment, the data-bit numbers are designated with the positive integers 0 through 63 and the checkbit numbers are designated with the negative integers -8 through -1. In one embodiment, checkbits are all assigned to one row of bit-connection-order data structure 508, in order that no more than one checkbit is assigned to any one memory chip (and, since the rearrangement process for this embodiment involves only shifting of the bits, this condition will remain in effect throughout the execution of program 510).

At block 515, each specified multi-bit error is tested, using the bit-connection-order data structure 508 and the EC data structure 506 to generate a separate test syndrome for each respective error. In one such embodiment, each column of bit-connection-order data structure 508 specifies four bits which are connected to a single memory chip in memory array 270. For such a four-bit chip, there are five possible multiple-bit errors having more than two bits wrong, i.e., XXXX, XXX0, XX0X, X0XX, and 0XXX, where each "X" represents a single-bit error; thus there are one 4-bit error and four 3-bit errors to test. Thus, the 4-bit column contains four indexes. For each "X" of the particular error being tested, the corresponding index is used to access an 8-bit column of EC data structure 506, and for each "1" found in EC data structure 506, the corresponding bit in the test syndrome is toggled.; this process is repeated until all error bits have been incorporated into the test syndrome. Thus five test syndromes are generated, one for each of the five specified multi-bit errors.

At block 516, each test syndrome is used to access the corresponding entry in syndrome data structure 507. As described above, one embodiment considers each "0", "b", or "c" as an erroneous result, since a multi-bit error is erroneously detected with a single-bit or no-error indication; and "t" and "m" entries are considered non-erroneous, since the multi-bit error was detected as a non-correctable error. In another embodiment, syndrome data structure 507 contains only one of two possible values for each entry: either an erroneous indication value or a non-erroneous indication value.

At block 517, the number of erroneous indications (or equivalently, the converse number of non-erroneous indications) is checked to see if the bit-connection order currently being tested is better than previously test bit-connection orders; and if so, control passes to block 518 and the bit-connection order is output to a file or to a printer or other output device. If at block 517, the bit-connection order is not better than previous orders, control is passed to block 521. At block 519, a test is done to determine whether the last output bit-connection order was good enough (for example, whether no erroneous indications are found in the bits tested, or whether the number is below some threshold), and if so, the program ends at block 522, else control passes to block 521.

At block 521, the bit-connection order is re-assigned. In one embodiment, one row of bit connections is shifted one column, thus moving one of the four single-bit connections from one module to the next across all 9 modules, while leaving the other three bits connected as they were. After each bit connection of the first row has been tested in every column position, the next row is shifted one column position, and again the first row is tested in each of 9 positions. This process is iterated until each row has been tested with every other row in every position, and then the program is exited to block 522.

The best result from one such pass through program 510 is sometimes a bit-connection order which results in one, two, or three erroneous results. The user then (at block 502 of FIG. 15) selects the bit-connections in all columns containing the erroneous results, plus zero, one or two other columns to re-process. Such a subset of the bits is then processed at step 503 in a much faster time than if all bits in all columns are tested. The remaining columns (those not selected at the second pass through step 502) contain bit-connections each of which has multi-bit errors giving non-erroneous (i.e., "m" or "t") results.

Thus, in one embodiment, the user splits 64 data bits and 8 checkbits into two portions, each of which is to be connected to nine 4-bit-wide modules and processed by program 510 to determine the best bit-connection order. In one such embodiment, program 510 initially outputs results in which many modules have all multi-bit errors detected as such, and a few modules having multi-bit errors erroneously detected with single-bit or no-error indications. The user then selects the pin connections of a few memory circuits, including the erroneous-indicating ones for reprocessing as a smaller subset, and modifies program 510 to test and rearrange just those few pins until a bit-connection order is found having with no erroneous indications. In another embodiment, the entire process is programmed as one single all-encompassing program.

In another embodiment, a similar process is used to find a "best" (by some criteria) bit-connection order for 8-bit (or other width chips) memory chips, by testing 5-bit, 6-bit, or n-bit errors across such n-bit-wide chips to determine a bit-connection order which minimizes the number of undetected certain of such errors.

In one embodiment, a C-language program, such as is shown in Table 1 below, is used for program 510 when used for the upper-order portion of bits (i.e., for step 503 to process 32 upper-order data bits and four checkbits). (Note that this program is modified in function RANDFILL which has five lines which are changed by commenting-out five functional lines setting up the bit-connection matrix and replacing those with five corresponding lines from the comments, as shown below in the RANDFILL routine.) ##SPC1##

In one embodiment, computer system 100 causes memory array 270 to be sequentially read, corrected, and rewritten during otherwise unused cycles, in order that single-bit errors (which may "spontaneously" appear from time-to-time from various causes) are detected and corrected. In one such embodiment, a pointer is maintained, and sequenced through each successive location of memory array 270 under control of access arbiter 218, in order to correct all single-bit soft errors (a soft error is one which can be corrected by overwriting the location with the correct data). This can help prevent the accumulation of two errors in one data word which is uncorrectable. Once all (or substantially all) locations have been checked and corrected, the process starts over again. This repeated operation, called `scrubbing`, allows the correction of certain single-bit errors in a data word before a second error in the same data word makes correction impossible (in the embodiment shown, SBEC/DBED chip circuit 300 detects and corrects all single-bit errors, but double-bit errors are only detectable, not correctable).

It is to be understood that the above description is intended to be illustrative, and not restrictive. Many other embodiments will be apparent to those of skill in the art upon reviewing the above description, including the use of corresponding methods on n-bit-wide memory chips, where n is any number greater than two. The scope of the invention should, therefore, be determined with reference to the appended claims, along with the full scope of equivalents to which such claims are entitled.

Claims

1. A computer system for improved detection of multiple-bit errors which occur within a single memory circuit, the computer system comprising:

a main computer;

a memory, the memory comprising a plurality of memory circuits, at least one of the plurality of memory circuits having a data interface more than two bits wide; and

a multiple-bit-error-detect (MBED) circuit, wherein bits from the plurality of memory circuits are coupled to the MBED circuit in an order which causes the MBED circuit to preferentially detect multiple-bit errors which occur on the data interface of any single one of the plurality of memory circuits.

2. The computer system according to claim 1, wherein the MBED circuit is a single-bit-error-correct, two-bit-error-detect (SBEC/DBED) circuit, wherein each of a plurality of the memory circuits have a data interface which is four-bits wide, and wherein bits from the memory interface are coupled to the MBED circuit in an order which causes the MBED circuit to also detect all three-bit and four-bit errors which occur at one time within any single one of the plurality of four-bit-wide memory circuits.

3. The computer system according to claim 1, wherein the order that the bits from the plurality of memory circuits are coupled to the MBED circuit is determined by running a test program on a test computer to successively test various orders of coupling bits to the MBED circuit.

4. The computer system according to claim 3, wherein the test program comprises a data structure indicative of which error code (EC) bits are affected by each memory bit of the memory circuits.

5. The computer system according to claim 2, wherein the test program comprises a data structure indicative of error syndromes and related error indications.

6. The computer system according to claim 5, wherein the test program comprises a data structure indicative of which error code (EC) bits are affected by each memory bit of the memory circuits.

7. A memory error-detection subsystem for improved detection of multiple-bit errors in a computer system, the computer system having a memory, the memory having a plurality of memory circuits, at least one of the plurality of memory circuits having a three-bit wide or a four-bit-wide data interface, the memory subsystem capable of detecting one-, two-, three-, and four-bit errors within a single memory circuit, the memory subsystem comprising:

a memory interface to the memory circuits; and

a multiple-bit-error-detect (MBED) circuit coupled to the main computer and the memory interface, wherein bits from the plurality of memory circuits are coupled to the MBED circuit in an order which causes the MBED circuit to preferentially detect multiple-bit errors which occur on the data interface of any single one of the plurality of memory circuits.

8. The memory subsystem according to claim 7, wherein the MBED circuit is a single-bit-error-correct, two-bit-error-detect (SBEC/DBED) circuit, wherein each of a plurality of the memory circuits have a data interface which is four-bits wide, and wherein bits from the memory interface are coupled to the MBED circuit in an order which causes the MBED circuit to also detect all three-bit and four-bit errors which occur at one time within any single one of the plurality of four-bit-wide memory circuits.

9. The memory subsystem according to claim 8, wherein bits from the memory interface are coupled to the MBED circuit in the following order:

a 1st memory circuit coupled to MBED bits MD0, MD15, MD19, and CB7;

a 2nd memory circuit coupled to MBED bits MD32, MD44, MD56, and MD59;

a 3rd memory circuit coupled to MBED bits MD1, MD4, MD22, and MD24;

a 4th memory circuit coupled to MBED bits MD33, MD51, MD55, and CB6;

a 5th memory circuit coupled to MBED bits MD2, MD17, MD26, and CB5;

a 6th memory circuit coupled to MBED bits MD34, MD53, MD57, and CB1;

a 7th memory circuit coupled to MBED bits MD3, MD11, MD16, and MD23;

an 8th memory circuit coupled to MBED bits MD35, MD37, MD46, and MD61;

a 9th memory circuit coupled to MBED bits MD5, MD9, MD18, and MD30;

a 10th memory circuit coupled to MBED bits MD36, MD38, MD62, and CB3;

a 11th memory circuit coupled to MBED bits MD6, MD13, MD20, and CB0;

a 12th memory circuit coupled to MBED bits MD39, MD48, MD52, and MD54;

a 13th memory circuit coupled to MBED bits MD7, MD25, MD27, and MD31;

a 14th memory circuit coupled to MBED bits MD40, MD41, MD43, and MD63;

a 15th memory circuit coupled to MBED bits MD8, MD21, MD28, and CB2;

a 16th memory circuit coupled to MBED bits MD42, MD45, MD47, and MD60;

a 17th memory circuit coupled to MBED bits MD10, MD12, MD14, and MD29; and

an 18th memory circuit coupled to MBED bits MD49, MD50, MD58, and CB4.

10. The memory subsystem according to claim 7, wherein the order that the bits from the plurality of memory circuits are coupled to the MBED circuit is determined by running a test program on a test computer to successively test various orders of coupling bits to the MBED circuit.

11. The memory subsystem according to claim 10, wherein the test program comprises a data structure indicative of which error code (EC) bits are affected by each memory bit of the memory circuits.

12. The memory subsystem according to claim 10, wherein the test program comprises a data structure indicative of error syndromes and related error indications.

13. The memory subsystem according to claim 12, wherein the test program comprises a data structure indicative of which error code (EC) bits are affected by each memory bit of the memory circuits.

14. A method for designing a memory system for a computer system, the memory system for improved detection of a predetermined set of multiple-bit errors, the memory system having an error-detection circuit capable of detecting multiple-bit errors, and a memory array, the memory array having a plurality of memory circuits including a first and a second memory circuit each having a data interface which is more than two bits wide and each connected to the error-detection circuit, the method comprising the steps of:

a) providing an initial bit-connection order between the plurality of memory circuits and the error-detection circuit;

b) testing each of the predetermined set of possible multi-bit error conditions;

c) determining whether the error-detection circuit provides (1) an erroneous no-error/single-bit-error indication or (2) a non-erroneous multiple-bit-error indication for each one of the predetermined set of possible multi-bit error conditions; and

d) based on a number of erroneous indications or non-erroneous indications determined in step c), either:

re-ordering the bit-connection order and reexecuting step b), or

providing the bit-connection order as an output.

15. The method according to claim 14, wherein the step of providing an initial bit-connection order comprises the step of assigning at least one bit connection based in a pseudo-random number.

16. The method according to claim 14, wherein the step of testing comprises the step of exclusive-ORing a first data pattern from an error-code data structure with a second data pattern from the error-code data structure and generating a test syndrome.

17. The method according to claim 14, wherein the step of determining whether the error-detection circuit provides (1) an erroneous no-error/single-bit-error indication or (2) a non-erroneous multiple-bit-error indication comprises the step of performing a table lookup in a syndrome data structure.

18. The method according to claim 14, wherein the step of re-ordering comprises the step of shifting at least one bit connection from the first memory circuit to the second memory circuit.

19. A method for designing a memory system for a computer system capable of detecting multiple-bit errors within each of a plurality of single memory circuits, the computer system having an error-detection circuit capable of detecting multiple-bit errors and generating a plurality of error syndromes, and a memory, the memory having a plurality of memory circuits including a first and a second memory circuit each having a data interface which is more than two bits wide and each connected to the error detection circuit, the method comprising the steps of:

a) providing a syndrome data structure distinguishing whether the error-detection circuit provides (1) no-error/single-bit-error indication from (2) a multiple-bit-error indication, as a result of each of the error syndromes;

b) providing an error code (EC) data structure indicative of which EC bits are affected by each memory bit of the memory circuits;

c) providing an initial bit-connection order between the plurality of memory circuits and the error-detection circuit;

d) using a computer program which uses the bit connection order, the syndrome data structure, and the EC data structure, determining whether a first error, having more than two bits wrong within the first memory circuit, would be detected with a multiple-bit-error indication and whether a second error, having more than two bits wrong within the second memory circuit, would be detected with a multiple-bit-error indication; and

e) if either the first error or the second error or both are not detected with a multiple-bit-error indication, then re-ordering the bit-connection order and reexecuting step d), otherwise outputing the bit-connection order.