Beyond SECDED
November 15, 202647 min readbeginner
One particle strike can flip two neighboring cells, which SEC-DED can only flag. The chapter builds codes for two random errors, two adjacent errors, one failed 4-bit symbol and errors that all flip one way.
A neutron from a cosmic-ray shower can strike a silicon nucleus in a memory chip, and the charged fragments of that collision leave a short trail of charge. When the charge reaches a storage cell it flips the bit the cell holds. Such a soft error damages no hardware, and the next write repairs it. As cells have shrunk, one strike has come to reach more than one cell, so two neighbors in a memory row can flip together [1]. A word stored with the SEC-DED code of the chapter SECDED and Hsiao Codes then reads back with two wrong bits, and its decoder can only report the damage. The data is lost although the memory saw a single event.
This chapter asks what a memory designer can buy beyond SEC-DED, and at what price. Each answer starts from a fault model, a statement of which error patterns are likely, and ends with a code and a count of its check bits. Two random errors call for a double-error-correcting code built from a small finite field. Two adjacent errors call for a cheaper code that keeps Hsiao's eight check bits. A chip that fails whole calls for a code that corrects one multi-bit symbol, and bits that can fail only one way call for codes that count zeros. The chapter closes by setting all of them side by side for a 64-bit word.
Every code in the chapter is built, and every count, limit and syndrome it yields recomputed, by ch21_beyond_secded.py in the python/ folder of the companion repository ecc-book-lab, and the charts are drawn by ch21_charts.py in the same folder. The GNU Octave twin ch21_beyond_secded.m prints the same lines, as The Octave Route explains.
01.One Strike, Two Neighboring Bits
A memory row stores the 72 bits of a word in neighboring cells, so a strike whose charge spreads across two cells flips two neighboring bits of one word. Figure 1 draws a stretch of such a row. When the strike reaches one cell, the syndrome of Hsiao's code [2] has odd weight, and the decoder flips the matching bit back. When it reaches two, the syndrome is the XOR of two odd-weight columns, which has even weight, and the decoder can only raise its uncorrectable-error flag.
A count shows why the decoder has no better option. A 72-bit word can suffer a double error in ways, and eight check bits give only 256 syndromes, so most doubles must share a syndrome with other doubles. Only 71 of the 2556 pairs are neighbors, though. A fault model that names only adjacent doubles adds 71 patterns, which might fit inside the same eight check bits, while a model that names every double asks for far more. The chapter takes the expensive model first, because the field arithmetic it needs returns throughout the rest of the book.
02.Correcting Two Random Errors
Two flips anywhere in the word can come from two separate strikes between reads, or from one strike on a word that already holds a stuck cell.
How Many Check Bits Two Errors Need
A syndrome decoder corrects a set of error patterns exactly when no two share a syndrome, so that each can lead its own coset, as the chapter Syndrome Decoding and the Standard Array showed. An code has syndromes, and correcting every error of weight at most two means giving distinct syndromes to the error-free pattern, the singles and the doubles. That is the sphere-packing bound of the chapter Hamming Codes and Perfect Codes with radius two.
Proof. With check bits the length is . At the left side of Equation 1 is , which fits in . At it is , more than , and every smaller fails too, since gives .
For DEC-TED the distance must be at least six. Correction alone needs , so suppose , with codewords and at distance 5. A word that agrees with on two of the five positions where they differ, and with elsewhere, is two errors from , so the decoder must return . It is also three errors from , so if was sent the decoder must flag it. It cannot do both, so . Now delete one position from every codeword. Two codewords differ in at least 6 places, so they stay distinct, and the result is a linear code with 64 data bits, check bits and distance at least 5. It corrects two errors, so .
The theorem is a count. It rules out 12 or fewer check bits for DEC-TED and does not promise a code with 13. The code built below uses 15, and the gap is the price of a construction that can be written down and decoded quickly.
A Field of Sixteen Elements
The construction needs 4-bit words that can be multiplied and divided, not only XORed. The Part Finite Fields and Their Arithmetic builds such fields in general, and this chapter needs just one of them, written out as a table. Its 16 elements are the 4-bit words, and adding two of them means XORing their bits.
Multiplication comes from one rule. Take a symbol and require , which is the polynomial set to zero. Every power of then reduces to a sum of , , and , whose four coefficients are its bits. Multiplying by shifts the bits left, and a 1 that leaves the top place stands for , so the shifted word is XORed with . From the shifts give , , , then , , and . Table 1 lists all fifteen.
Table 1. The fifteen nonzero elements of the field of sixteen elements, as powers of alpha, as polynomials in alpha and as four bits
| Power | Polynomial in | Bits |
|---|---|---|
Source: reproduced by ch21_beyond_secded.py.
The fifteen powers are the fifteen nonzero words, each once, and the next shift returns . So two nonzero elements multiply by adding exponents modulo 15, as Equation 2 records.
For example , and the inverse of is . The rule gives a field because has no factor. A factor of degree 1 would make 0 or 1 a root, yet . The only irreducible quadratic over is , modulo which , so . The script also checks the table against shift-and-add multiplication on all 256 pairs, confirms that every nonzero element has an inverse and that no two nonzero elements multiply to zero, and checks associativity and distributivity on all 4,096 triples.
Three facts carry the proofs below, in every field built this way. Subtraction equals addition, since . Squaring distributes over a sum, , because the cross term is zero. And a product of nonzero elements is never zero.
Proof. Since and , expanding gives . Adding leaves .
Proof. Multiplying out, , and gives . If the product is zero, one factor is zero, since the field has no zero divisors.
Columns Built from Powers and Cubes
A Hamming check matrix uses each nonzero -bit word once as a column, and that is exactly why it cannot correct two errors. Two errors at positions whose columns are and give the syndrome , which is itself the column of some third position, so the decoder cannot tell the pair from a single error there, or from any other pair with the same sum. The cure is a second half under each column that hands the decoder a second equation about the same positions. The obvious candidate, the square , adds nothing, because squaring distributes over a sum and the bottom half of every syndrome would then be the square of its top half. The cube is the next power to try, and the theorem below shows that it is enough.
Double correction needs distance five, which means that no four or fewer columns of the check matrix sum to zero, by the column reading of distance in the chapter Linear Codes. The construction gives each position a distinct nonzero field element and stacks above its cube . With and , each column has eight bits and the matrix is Equation 3. A set of columns with elements sums to zero exactly when and both hold.
Figure 2 draws the same matrix bit by bit.
Proof. One column has top half . Two columns sum to zero only if . Three columns with have bottom half , by the lemma Three elements that sum to zero. For four, suppose and , and write , which is nonzero. Expanding as in that lemma gives and , so and . Then , so is a root of , and the lemma A quadratic has at most two roots makes equal to or , against distinctness.
The (15,7) Code
With all fifteen nonzero elements of the matrix is . Column 0 reads top to bottom, column 1 reads and column 14 reads . The bottom halves take only five values, because , yet the eight rows are independent. The script finds rank 8, so the code has data bits and 128 codewords, with weights , , , , , , and . The minimum distance is exactly five, and the 121 patterns of weight at most two, of them, have 121 distinct syndromes. This is the double-error-correcting BCH code of length 15, from the family Bose and Ray-Chaudhuri described [3], and a later Part develops BCH codes in general [4].
For an error set , the two syndrome halves are the sums in Equation 4.
If both are zero, the decoder assumes no error. One error at gives and , which the decoder recognizes. Two errors at elements and give and , so , and both are roots of the locator polynomial in Equation 5.
The decoder tries all fifteen nonzero elements as and finds either two distinct roots, which name the error positions, or none, which means at least three errors, and the word is flagged. So does with . Three errors are not always caught, though. Three errors inside the support of one of the 18 codewords of weight 5 leave the word two bits from that codeword, which the decoder returns. The code is DEC but not DEC-TED.
In hardware the division is the awkward step, and the decoder avoids it. When , multiplying Equation 5 through by gives the test , which holds at exactly the same values of and needs only products. Each bit position gets its own copy of the test with fixed, and a product with a fixed power of is a fixed pattern of XOR gates, so all fifteen tests run at once. Each drives the flip of its own bit only while , since an error-free word has and passes every test. For the errors at positions 3 and 10, with and , the script finds the test zero at and and nowhere else.
A DEC-TED Code for 64 Data Bits
In each column takes bits and the length is at most . With that is 63, too short for 64 data bits, so the word needs . The polynomial builds , and the script confirms that the powers of run through all 127 nonzero words before . The matrix has rank 14, a code. Keeping its first 78 columns leaves rank 14 and gives a code whose distance stays at least five by the lemma Shortening keeps the distance in SECDED and Hsiao Codes. Its 3082 patterns of weight at most two have 3082 distinct syndromes.
Triple detection needs one more bit. Add a row of all ones and a new column for an overall parity bit. Every column now ends in 1, so every codeword has even weight. A nonzero codeword has a nonzero first part, since a zero first part would force the parity bit to zero too, and that first part is a codeword of weight at least 5. An even weight of at least 5 is at least 6, so the code has , and the theorem Correcting and detecting together in the chapter Distance, Detection and Correction, with and , gives DEC-TED since . The script confirms 3161 distinct syndromes.
The price is 15 check bits, an overhead of 23.44%, two above the counting minimum of 13, against 21.88% for the DEC code. Either is nearly twice SEC-DED, and the decoder must solve a quadratic over whenever a read shows an error.
03.Correcting Two Adjacent Errors
If the fault model names only adjacent doubles, the code must correct 71 more patterns rather than 2556, and a careful choice of columns fits them into Hsiao's eight check bits.
Odd-weight columns, as in Hsiao's code, keep the analysis short. A single error at gives the odd syndrome . A double at and gives , which is even by the lemma Parity of an XOR in SECDED and Hsiao Codes and nonzero because the columns are distinct. An adjacent double at and has the neighbor sum as its syndrome.
Proof. Single syndromes are distinct odd words and neighbor sums are even, so the only possible collision is between two neighbor sums, and equal sums would leave two adjacent doubles indistinguishable. If the sums are distinct, the following decoder works. A zero syndrome means no error. An odd syndrome equal to a column names that single error, and any other odd syndrome is flagged. An even syndrome equal to a neighbor sum names that adjacent pair, and any other even syndrome is flagged. A double always gives an even syndrome, so it is never taken for a single.
The weak point is a nonadjacent double whose syndrome happens to equal a neighbor sum, because the decoder then flips the wrong pair. The wrong pair shares no position with the true one, since with equal to or would make the true pair adjacent. So a miscorrection leaves four wrong bits and reports the word as repaired.
Proof. The neighbor sums are distinct among the nonzero even words, so . Equality would use every nonzero even word once. Each bit position is 1 in even words, an even number when , so the XOR of all of them is zero. But the XOR of the neighbor sums telescopes to , which is not zero.
The limit sits one below the theorem The SEC-DED length bound in SECDED and Hsiao Codes, which allows , so adjacency costs one position. With four check bits there are eight odd columns but only seven nonzero even words, so no code of this kind exists, as the script's search confirms. Any linear SEC-DED-DAEC code must also give distinct syndromes to the error-free word, the singles and the adjacent doubles, which is Equation 6.
For 64 data bits, gives , while gives , so eight check bits is the least, the same as for SEC-DED.
The smallest case is a code with four check bits, as long as the lemma allows, drawn in Figure 3. Its columns in storage order are , , , , , and , and its six neighbor sums , , , , and are distinct. They leave one nonzero even word unused, , and the nonadjacent pairs with that syndrome are the only doubles the decoder flags. The matrix has rank 4. The decoder corrects all 7 singles and all 6 adjacent doubles, and of the 15 nonadjacent doubles it miscorrects 12 and flags 3.
Twelve of fifteen sounds poor, and a count shows it is the best four check bits can do.
Proof. Let be the set of columns and fix a neighbor sum . The sets and each hold of the odd words, so they share at least . Each shared word is a column whose partner is also a column, and each such pair is counted from both ends, so at least pairs of columns sum to . One is the adjacent pair, and the rest are nonadjacent, because the neighbor sums are distinct, so the decoder miscorrects each of them. No pair has two sums, so adding over the neighbor sums gives the bound.
The script searched for each code depth first, trying odd words in increasing order for each position and backing up whenever none kept the neighbor sums distinct. Table 2 sets the codes it found beside the floor.
Table 2. SEC-DED-DAEC codes found by the search, with the adjacent doubles they correct, what happens to their nonadjacent doubles, and the floor on miscorrection
| Code | Rank | Adjacent doubles corrected | Nonadjacent doubles | Miscorrected | Flagged | Floor |
|---|---|---|---|---|---|---|
| 4 | 6 | 15 | 12 | 3 | 12 | |
| 5 | 12 | 66 | 51 | 15 | 48 | |
| 7 | 38 | 703 | 490 | 213 | 228 | |
| 8 | 71 | 2485 | 1465 | 1020 | 497 |
Source: reproduced by ch21_beyond_secded.py.
The code meets the floor exactly. The code uses 8 unit columns, 47 of weight 3 and 17 of weight 5, and miscorrects 1465 of its 2485 nonadjacent doubles, 59.0%, against a floor of 497, or 20.0%. Four of that code's 71 neighbor sums carry the floor's count of 8 pairs, and the other 67 carry more. A search that weighs miscorrection can do better than one that stops at the first valid code. Dutta and Touba searched heuristically for SEC-DED-DAEC codes with the same number of check bits as SEC-DED, choosing the columns to reduce the miscorrection of nonadjacent doubles [5]. No choice of columns falls below the floor.
04.Interleaving Instead of Check Bits
Adjacent errors can also be handled without changing the code. Interleaving stores four 72-bit SEC-DED words in one row of 288 cells, with cell holding bit of word . Cell 13 holds bit 3 of word 1, and its neighbors belong to words 0 and 2. Figure 4 draws the arrangement with the words labeled A to D.
For bursts of 1 to 9 neighboring cells, the script counts the most errors in one word as 1, 1, 1, 1, 2, 2, 2, 2 and 3. Every burst of up to 4 cells is corrected, every burst of up to 8 is detected, and nine cells can put three errors into one word. Cells and leave the same remainder on division by 4, so they belong to the same word, and a burst of neighboring cells therefore puts errors into its busiest word. The interleave costs no check bits. Its cost is wiring, a row four times as wide and 72 four-to-one multiplexers that select one word on each read. An array that already selects among several words per row gets this protection cheaply, which is why the cell layout and the code are best chosen together.
05.Errors Confined to One Symbol
Some memories build each word from several chips, each supplying four bits. When one chip fails, any of its four bits may be wrong, and the fault model becomes one bad symbol. A code that corrects it treats the word as a string of elements of .
A symbol can go wrong in ways, so with symbols and check symbols the error-free word and the single-symbol errors need distinct syndromes, which is Equation 8.
Proof. An error of value in symbol has syndrome . Suppose errors in symbol and in symbol share a syndrome. If , a nonzero entry of gives . If , then , a multiple, which was ruled out. Conversely, if , the error in symbol and the error 1 in symbol collide, and a zero column makes its symbol's errors invisible.
The theorem caps the length. The nonzero columns fall into classes of multiples, and a code takes at most one from each, which gives Equation 9. The -ary Hamming code of the chapter Hamming Codes and Perfect Codes takes one from every class and meets it.
For 64 data bits in 16 symbols of 4 bits, two check symbols allow at most 17 symbols, room for 60 data bits, and 18 symbols would need syndromes. Three check symbols allow 273, and 19 symbols need only 286, so a code over needs three check symbols, or 12 check bits.
A code that meets this gives data symbols 0 to 14 the columns with , data symbol 15 the column , and the three check symbols the unit columns. The script confirms that no column is zero and that none of the 171 pairs has one column a multiple of the other, so the 285 single-symbol errors give 285 distinct nonzero syndromes. Expanding each element into 4 bits gives a binary matrix of rank 12, a code with an overhead of 18.75%, drawn in Figure 5.
The decoder reads the syndrome as , and . An error in data symbol gives , so all three are nonzero, the equal ratios name the symbol, and is the value to add back. An error in symbol 15 gives and , and an error in a check symbol makes exactly two of the three zero. Any other syndrome is flagged.
A binary code need not spend its check bits in whole symbols. Cut the bits into 4-bit symbols in order, the last one shorter if need be. With 8 check bits the 18 full symbols need syndromes, more than . With 9 the word gains a 1-bit symbol, and the 272 syndromes needed fit within . The count does not promise a code, but the script carries a searched check matrix of rank 9 whose 271 single-symbol errors give 271 distinct nonzero syndromes, a code with an overhead of 14.06%. Spreading the check bits over more, partly empty symbols lowers the count, but each extra symbol is another chip.
Designers still pay for whole symbols. In memory built from 4-bit chips, 9 check bits fill three chips, so the word takes the same 19 chips as the word, and the three extra bits buy detection. When two chips fail, the code miscorrects 17,553 of 34,695 double-symbol errors, 50.6%, and the code only 405 of 38,475, or 1.1%, flagging the rest.
Bytes work the same way with . Kaneda and Fujiwara built byte codes of this kind for memory that also detect two bad bytes [6], Chen and Hsiao reviewed such codes for semiconductor memory [7], and Fujiwara's book collects the symbol-level codes of dependable systems [8]. The Reed–Solomon codes of a later Part correct several bad symbols at once.
06.Errors in One Direction
Some faults push bits one way only. Charge leaking from a cell can turn a stored 1 into a 0 but not the reverse, and lines that a fault ties to ground can only read 0. Such errors can hit many bits at once, and a code built for them detects large errors cheaply.
Proof. A error turns into a word that covers, with weight , and every such is reached by exactly one such error, which goes undetected exactly when is a codeword. A error from is the same pair with the roles exchanged.
The lemma rules out linear codes, because every codeword covers the all-zero word, so codes that detect every unidirectional error are not linear.
The Berger Code
The count runs from 0 to , so it needs the check bits in Equation 10. Eight data bits need 4, and 64 need 7, an overhead of 10.94%. Berger introduced the code in 1961 for channels whose errors run one way [9].
Proof. Suppose covers . In the data, has the zeros of plus the positions where has a 1 and a 0, so . In the check, every 1 of is a 1 of , so . Then , so and , and the covering-pair criterion finishes the proof.
A error can only raise the zero count of the data and can only lower the stored number, so the two never meet again. Figure 6 draws a checker for 8 data bits, and the script finds 0 covering pairs among all codewords for .
Counting ones instead fails. The word has five ones and would carry , and has four and would carry , so the two flips that turn into land on a valid codeword. A error moves the zero count and the stored number in opposite directions, and the ones count in the same direction.
Proof. Let have ones in its first positions, so covers for . If two had the same check , then would cover . So the checks are distinct.
For the bound is 7, the Berger code's own count.
Counting Zeros Modulo a Power of Two
A fault model that also bounds the error weight allows fewer check bits. The simplest idea keeps only the zero count modulo .
Proof. Take a error from codeword to codeword with data flips and check flips. Every 1 of is a 1 of , so is the word of flipped check bits and , while gives . If , then . Otherwise , so the weight is at least . Adding 1 to a number raises its weight by at most 1, so never decreases and is at most , which leaves a weight of at least . A error is the same pair read backward.
With 64 data bits and from 2 to 6, the script finds the limit exactly each time. At nothing is reduced, and the code is the Berger code.
A small case shows why the limit cannot be raised. With , the data has three zeros and carries the check . Flipping its second bit and both check bits, all from 1 to 0, gives . The new data has four zeros, and matches the stored , so an error of weight passes unseen. Here the stored number fell by at the cost of check flips, and the single data flip made up the rest, so the weight from the proof is met exactly.
Bose-Lin Codes
Spending the check patterns more cleverly does better. Bose and Lin gave systematic codes that detect 6 errors with 4 check bits and errors with [10]. The two constructions below reach those figures, and the script checks every limit at over every pair of zero counts. The first is an offset zero count, which keeps the top two check bits as a flag holding exactly one 1, with the check in Equation 11. At it is Bose and Lin's code, and for larger a generalization made here.
Proof. The check lies between and , so its top two bits are or , and neither covers the other. Under a error between codewords and , the top bits therefore stay put, so , and . If , the weight is at least for . Otherwise it is at least .
At the check is , which detects up to 6, where counting zeros modulo 16 in the same four bits detects 4. The offset matters. With in its place at , the top bit is always 1, and the code detects only 4.
The second construction, for , reduces the count modulo . Its top four check bits name which of six blocks the reduced count falls in, using the six words of weight two, , , , , and , and its low bits give the place inside the block. The same argument gives a limit of , which is 11, 22 and 43 at , 6 and 7, against 11, 20 and 37 for the offset count. Figure 7 plots both beside the reduced count. For the script also checks all 65,536 pairs of codewords directly and finds limits of 2 and 3 for counting modulo 4 and 8, 6 for , and every weight for the Berger code.
07.Choosing a Code from a Fault Model
Table 3 sets the chapter's codes side by side for 64 data bits, each with the counting minimum for its fault model, and Figure 8 draws the same comparison.
Table 3. Codes for 64 data bits matched to fault models, with their check bits, their overhead and the counting minimum for each model
| Fault model | Code | Check bits | Overhead | Counting minimum |
|---|---|---|---|---|
| one random bit | Hamming SEC | 7 | 10.94% | 7 |
| one random bit, two detected | Hsiao SEC-DED | 8 | 12.5% | 8 |
| two random bits, three detected | DEC-TED | 15 | 23.44% | 13 |
| two adjacent bits | SEC-DED-DAEC | 8 | 12.5% | 8 |
| one 4-bit symbol | single-symbol code | 12 | 18.75% | 9, or 12 in whole symbols |
| unidirectional, any weight | Berger | 7 | 10.94% | 7 |
| unidirectional, at most 6 bits | Bose-Lin | 4 | 6.25% | not derived |
Source: reproduced by ch21_beyond_secded.py.
The table reads as a price list. A second random bit costs seven check bits more than SEC-DED, plus field arithmetic in the decoder, so it pays only where two independent errors in one word are likely. Adjacent pairs cost no extra check bits. A DAEC code adds decoder gates and miscorrects 59.0% of nonadjacent doubles in the code found here, while a four-way interleave adds multiplexers and leaves the code alone. A chip that can fail whole calls for symbol correction at 9 check bits, or 12 to flag most double-chip failures. Unidirectional faults are the cheapest, 7 bits for every weight and 4 for up to six, but those codes only detect, so the system must fetch a good copy or stop.
The Hamming, Hsiao, DAEC and Berger codes all meet their counting minimums, so none can be beaten. The code sits three bits above the binary minimum of 9, the price of whole check symbols. The DEC-TED code sits two bits above its minimum of 13, and the count alone cannot say whether a code with 13 exists.
08.Looking Ahead
The chapter matched codes to four fault models beyond one random bit. Powers and cubes in give a DEC-TED code with 15 check bits. Odd-weight columns with distinct neighbor sums correct adjacent doubles within Hsiao's 8, at the price of miscorrecting some nonadjacent ones, and interleaving does the same job with wiring. A code over corrects a 4-bit symbol with 12 check bits and a searched binary code with 9, and counting zeros detects unidirectional errors with 7 check bits for every weight or 4 for up to six.
All of these codes protect bits at rest. The next chapter, Arithmetic Codes and Checking Logic, protects bits in motion through an adder or a multiplier, where one faulty gate can corrupt many bits of a result. There AN and residue codes check the arithmetic, the Berger code returns as Berger check prediction, and two-rail and parity checkers expose their own faults.
09.Worked Examples
10.Exercises
References
- [1]Baumann, R. C. (2005). “Radiation-Induced Soft Errors in Advanced Semiconductor Technologies.” IEEE Transactions on Device and Materials Reliability, 5(3), pp. 305–316. doi:10.1109/TDMR.2005.853449
- [2]Hsiao, M. Y. (1970). “A Class of Optimal Minimum Odd-weight-column SEC-DED Codes.” IBM Journal of Research and Development, 14(4), pp. 395–401. doi:10.1147/rd.144.0395
- [3]Bose, R. C. and Ray-Chaudhuri, D. K. (1960). “On a Class of Error Correcting Binary Group Codes.” Information and Control, 3(1), pp. 68–79. doi:10.1016/S0019-9958(60)90287-4
- [4]Lin, Shu and Costello, Jr., Daniel J. (2004). “Error Control Coding: Fundamentals and Applications.” 2nd edition. Pearson Prentice Hall.
- [5]Dutta, Avijit and Touba, Nur A. (2007). “Multiple Bit Upset Tolerant Memory Using a Selective Cycle Avoidance Based SEC-DED-DAEC Code.” In 25th IEEE VLSI Test Symposium (VTS'07), pp. 349–354. doi:10.1109/VTS.2007.40
- [6]Kaneda, Shigeo and Fujiwara, Eiji (1982). “Single Byte Error Correcting-Double Byte Error Detecting Codes for Memory Systems.” IEEE Transactions on Computers, C-31(7), pp. 596–602. doi:10.1109/TC.1982.1676056
- [7]Chen, C. L. and Hsiao, M. Y. (1984). “Error-Correcting Codes for Semiconductor Memory Applications: A State-of-the-Art Review.” IBM Journal of Research and Development, 28(2), pp. 124–134. doi:10.1147/rd.282.0124
- [8]Fujiwara, Eiji (2006). “Code Design for Dependable Systems: Theory and Practical Applications.” Wiley. doi:10.1002/0471792748
- [9]Berger, J. M. (1961). “A Note on Error Detection Codes for Asymmetric Channels.” Information and Control, 4(1), pp. 68–73. doi:10.1016/S0019-9958(61)80037-5
- [10]Bose, Bella and Lin, Der Jei (1985). “Systematic Unidirectional Error-Detecting Codes.” IEEE Transactions on Computers, C-34(11), pp. 1026–1032. doi:10.1109/TC.1985.1676535
— Anirban
Hardware–software at the seam where compilers meet microcode.