SECDED and Hsiao Codes
November 15, 202647 min readbeginner
Main memory stores each 64-bit word with eight check bits. The chapter proves why eight is the least, builds SEC-DED codes from the extended Hamming code and from Hsiao's odd-weight columns, and counts their gates.
A server's main memory stores every 64-bit word with eight extra bits beside it, and the memory controller checks all 72 bits each time the word is read. If one bit has flipped since the word was written, the controller puts it back. If two bits have flipped, the controller cannot tell which two, but it reports that the word is damaged, so the system can stop before a wrong value spreads. A code with both powers is called SEC-DED, also written SECDED, for single-error-correcting and double-error-detecting, and codes of this kind are the usual protection for semiconductor main memory, as the review of [1] surveys.
The chapter Hamming Codes and Perfect Codes already built one such code, the extended Hamming code, by adding an overall parity bit to a Hamming code. This chapter asks what every SEC-DED code needs, proves that eight check bits are the least a linear code can add to a 64-bit word, and then follows M. Y. Hsiao's 1970 observation that a different choice of check-matrix columns gives the same protection with fewer gates and a shallower decoder [2]. The last section asks what each code does when three bits flip, a case neither code is designed for, and finds that the choice of columns matters there as well.
Every number in the chapter is recomputed by ch20_secded_and_hsiao_codes.py in the python/ folder of the companion repository ecc-book-lab, and the charts are drawn by ch20_charts.py in the same folder. The GNU Octave twin ch20_secded_and_hsiao_codes.m prints the same lines, as The Octave Route explains.
01.A 64-Bit Word and Its Check Bits
Hardware numbers bits from 0, and this chapter does the same. A 64-bit data word has bits to , and its eight check bits are to . Grouped into bytes of eight, the data fills bytes 0 to 7 and the check bits fill byte 8, so the stored word is nine bytes, 72 bits in all. Figure 1 draws the word three times. In the first strip nothing has gone wrong, in the second has flipped and a SEC-DED decoder puts it back, and in the third and have flipped and the decoder reports the word as damaged without touching any bit.
Why eight check bits, and not seven or nine? The chapter Hamming Codes and Perfect Codes answered the first half of the question. With check bits the syndrome can take values. A decoder that corrects every single error needs one value to mean "no error" and one distinct value for each of the positions where the error could be, so
For data bits, gives against , which fails, and gives against , which holds. So correction alone needs seven check bits. The next section proves that detecting double errors as well needs the stronger condition . For , gives against , which fails, and gives against , which holds. Eight check bits are therefore the least, the codeword has bits, and the check bits cost percent of the data.
Table 1. The least number of check bits for single-error correction and for SEC-DED at six data widths, with the SEC-DED codeword length and the check bits as a percentage of the data bits
| Data bits | Check bits for SEC | Check bits for SEC-DED | Length | Overhead |
|---|---|---|---|---|
| 4 | 3 | 4 | 8 | 100.0% |
| 8 | 4 | 5 | 13 | 62.5% |
| 16 | 5 | 6 | 22 | 37.5% |
| 32 | 6 | 7 | 39 | 21.9% |
| 64 | 7 | 8 | 72 | 12.5% |
| 128 | 8 | 9 | 137 | 7.0% |
Source: reproduced by ch20_secded_and_hsiao_codes.py.
Table 1 shows two patterns. SEC-DED always costs exactly one check bit more than correction alone, because writing for in the condition gives back Equation 1. And the overhead falls as the word widens, since the check bits grow only with the logarithm of the width. A 128-bit word needs nine check bits, 7.0 percent, but its 137 bits do not fill a whole number of bytes, while the 72-bit word fills exactly nine.
02.When One Correction and Two Detections Are Possible
The promise of a SEC-DED code concerns two kinds of error.
The chapter Distance, Detection and Correction proved that a bounded-distance decoder with radius corrects every error of weight up to and flags every error of weight to whenever . With and that condition reads . The theorem below adds the converse, so distance four is not merely enough for SEC-DED but required.
Proof. If , then and satisfy , and the theorem Correcting and detecting together from Distance, Detection and Correction gives a decoder that corrects every single error and flags every double error. For the converse, suppose and pick two codewords at distance . If , let be with one of the three positions where and differ set to its value in . Then differs from in one position and from in two. A single error on produces , so a decoder that corrects every single error must return on . A double error on also produces , and the decoder returns instead of flagging it, so the code is not SEC-DED. If , change one of the two differing positions of in the same way. The result is one bit from and one bit from , so single errors on two different codewords produce the same word, and the decoder can return only one of them. If , then is with one bit flipped, and on input the decoder must return for the error-free case and for the single error on , which is impossible. In every case the code fails, so is necessary.
For a linear code the condition turns into a statement about columns. The chapter Linear Codes showed that the minimum distance of a linear code is the least number of columns of its check matrix that sum to zero. Over one column sums to zero only if it is the zero column, and two columns sum to zero only if they are equal. So holds exactly when the columns of are nonzero, distinct, and no three of them sum to zero.
Each condition has a meaning for the decoder. An error in position alone gives the syndrome , and errors in positions and give . Distinct columns make every double-error syndrome nonzero, and the rule against three columns summing to zero says that never equals a third column . So a double error can never look like no error or like a single error, and a decoder can follow three questions in turn. If , nothing is wrong. If equals a column , bit is flipped back. Anything else is flagged.
How long can such a code be? The answer is the bound promised above.
Proof. Let be the set of the columns of , all distinct and nonzero words of length , and fix one column . Form the set of all words with in . The map undoes itself, so it is one-to-one and also has members. Suppose some word lay in both sets, so that with and in . If , then , but no column is zero. If , then because , and because , so is a sum of three distinct columns equal to zero, which the code forbids. So the two sets share no word, and together they hold distinct words of length . There are only such words, so and .
The bound is the reason for eight check bits. With the length can reach 128, leaving room for up to 120 data bits, while allows a length of at most 64 and so at most 57 data bits, too few for a 64-bit word. A SEC-DED code with check bits may reach length , one bit longer than a Hamming code with , so the extra check bit buys detection and one more position.
03.SEC-DED from the Extended Hamming Code
Hamming's 1950 paper already added an overall parity check to detect double errors [3], and the extended Hamming code with eight check bits meets the bound exactly. It has length and 120 data bits, and its check matrix has a simple rule. Number the positions 0 to 127. The column for position holds the binary form of in rows 0 to 6, with the least significant bit in row 0, and a 1 in row 7, the overall parity row that covers every bit. Position 0 has the column with zeros in rows 0 to 6 and a 1 in row 7, so it is the overall parity bit, and positions 1, 2, 4, 8, 16, 32 and 64 are the Hamming check bits. Throughout the chapter a column or syndrome is written as a string of bits with row 0 first, so the column of position 5 is .
A memory word needs 64 data bits, not 120, and the way to get a shorter code from a longer one is to shorten it [4].
Proof. Take a nonzero codeword of the shortened code and put zeros back in the deleted positions. The result is a codeword of the original code, because it satisfies every original parity check, which reads only the kept positions where the word is unchanged and the deleted positions where it is zero. It has the same weight as the shortened word. So every nonzero weight in the shortened code is also a nonzero weight in the original, and the least of them cannot be smaller.
Keeping positions 0 to 71 and deleting positions 72 to 127 removes 56 positions. None of the deleted positions is a power of 2, so all of them are data positions. The shortened code keeps the eight check positions 0, 1, 2, 4, 8, 16, 32 and 64 and the 64 data positions among 1 to 71, so it is a code with .
Decoding uses the two-part syndrome from Hamming Codes and Perfect Codes. Rows 0 to 6 give a 7-bit word , the Hamming syndrome, and row 7 gives a single bit , the parity of the whole received word. A single error at position sets and makes the binary form of . A double error sets , because two flips leave the parity unchanged, and makes the XOR of two different positions, which is nonzero. An error at position 37, whose binary form is , gives with row 0 first and , so the decoder flips position 37. Table 2 collects the four cases.
Table 2. The decision an extended Hamming decoder makes from the two parts of its syndrome, the Hamming syndrome s' and the overall parity p
| What happened | What the decoder does | ||
|---|---|---|---|
| zero | 0 | no error | passes the word unchanged |
| nonzero | 1 | one error at position | flips that position |
| zero | 1 | one error in the parity bit | flips position 0 |
| nonzero | 0 | two errors | flags the word |
Source: reproduced by ch20_secded_and_hsiao_codes.py.
Figure 2 draws the same decision as a flow that applies to every SEC-DED code in this chapter. The extended Hamming code answers its odd-weight question with the parity bit .
The code works, and its cost is visible in the check matrix. Rows 0, 1 and 2 hold 36 ones each, rows 3, 4 and 5 hold 32 each, row 6 holds only 8, because only positions 64 to 71 have bit 6 set, and the parity row holds 72, one for every position. That is 284 ones. Each syndrome bit is computed by an XOR tree over the bits its row selects, and a row with ones needs two-input XOR gates, so the syndrome takes gates. The parity row is the problem. Its tree has 72 inputs, the widest in the decoder, and every bit of the word passes through it.
04.Hsiao's Odd-Weight Columns
Hsiao's idea replaces the parity row by a property of the columns. The smallest example has four data bits and four check bits. Its eight columns are
four data columns of weight 3 and four check columns of weight 1. These are all eight words of length 4 with odd weight, and no row of the matrix holds a 1 in every column. Each row holds four ones, sixteen in all.
Encoding works as in any systematic code. Check bit is the XOR of the data bits whose columns have a 1 in row . Row 0 selects , and , row 1 selects , and , row 2 selects , and , and row 3 selects , and . For the data , meaning , , and , the checks are , , and , so the check bits are .
Now decode. An error in gives the syndrome , the column of , which has weight 3. Errors in and give , which has weight 2. The single error left an odd syndrome and the double error an even one, and Table 3 shows that this is no accident. All 28 double errors give even syndromes, and they fall into seven classes of four.
Table 3. Every syndrome of the Hsiao (8,4) code and the errors that cause it
| Syndrome | Weight | Errors that produce it |
|---|---|---|
| 0000 | 0 | none |
| 1110, 1101, 1011, 0111 | 3 | one error in , , or |
| 1000, 0100, 0010, 0001 | 1 | one error in , , or |
| 1111 | 4 | , , , |
| 1100 | 2 | , , , |
| 1010 | 2 | , , , |
| 1001 | 2 | , , , |
| 0110 | 2 | , , , |
| 0101 | 2 | , , , |
| 0011 | 2 | , , , |
Source: reproduced by ch20_secded_and_hsiao_codes.py.
The 16 syndromes split as one zero word, eight odd words for the eight single errors and seven even nonzero words for the double errors, . The reason is a fact about weights. The lemma The weight of an XOR in Distance, Detection and Correction proved the identity , where is the word with ones where both and have ones. Its last term is even, which leads to the following.
Proof. For both sides are . Suppose the claim holds for words, and write . The weight identity gives , and the last term is even, so . Replacing by , which the assumption allows modulo 2, gives the claim for words.
So the XOR of an odd number of odd-weight words has odd weight, and the XOR of an even number of them has even weight. That is all a SEC-DED code needs.
Hsiao's own class also asks for the fewest ones and the most even rows, so the name is used loosely here.
Proof. The zero word has weight 0, which is even, so no column is zero. The columns are distinct, so no two of them sum to zero. Three columns have, by the parity lemma, a weight with the parity of three odd numbers, which is odd, so their sum is not zero. No one, two or three columns sum to zero, so by the column test of Linear Codes. A single error at gives , of odd weight. A double error at and gives , of even weight by the parity lemma, and nonzero because .
The decoder therefore learns whether one or two bits failed from the parity of its own syndrome, an XOR over bits, instead of from a parity row over all bits. The price might seem to be length, since only odd words may serve as columns. The next lemma shows that nothing is lost.
Proof. Flipping bit 0 maps the set of words of length to itself, and doing it twice returns every word, so the map is one-to-one. It changes the weight by exactly one, so it sends every odd-weight word to an even-weight word and every even-weight word to an odd-weight word. The odd and even words are therefore equal in number, and each set holds half of , which is .
For the counts are 8, 16, 32, 64 and 128. A Hsiao code can use every odd word as a column, which gives length , exactly the SEC-DED bound.
A slightly larger code shows how the columns are chosen when there are more odd words than positions. With there are 16 odd words, namely five of weight 1, ten of weight 3 and one of weight 5. The five weight-1 words become the check columns. Eight data bits need eight more columns, and the cheapest are eight of the ten weight-3 words. The code in Figure 3 leaves out and , which gives the data columns
for to .
Reading the matrix by rows gives the five check equations.
For the data , with , , and and the rest zero, these give , , , and , so the check bits are and the codeword has weight 6. The rows hold 5, 6, 6, 6 and 6 ones, 29 in all.
Every one of the 32 possible syndromes now has a meaning. The zero word means no error. The 13 columns name the 13 single errors. The 15 nonzero even words are the double-error syndromes, and all 15 occur among the 78 pairs of positions. The three odd words that are not columns, , and , cannot come from one or two errors at all, so they can only mean three or more. That accounts for syndromes.
05.Choosing the Columns
A 64-bit word with eight check bits has 128 odd words of length 8 to choose from and needs only 72 of them. The choice decides how many gates the circuit needs and how deep it is. A first limit applies to every systematic SEC-DED code, odd columns or not.
Proof. A column of weight 0 is the zero column, which is forbidden. A column of weight 1 equals one of the columns of , and two equal columns are forbidden. A column of weight 2 has ones in some rows and , so it equals , the sum of two columns of , and these three columns sum to zero, which is forbidden. So every data column has weight at least 3. The data columns then hold at least ones and holds more.
For and the lemma gives at least 200 ones. A Hsiao code cannot reach that, because there are only words of length 8 and weight 3, and the next odd weight is 5.
Proof. Let of the 64 data columns have weight 3. They are distinct, so . The remaining data columns have odd weight other than 1, which the columns of hold, and other than 3, so weight at least 5. The data columns therefore hold at least ones, and adds 8, for at least 216. Taking all 56 weight-3 words and any 8 weight-5 words as data columns gives exactly , and the result is an odd-weight-column code.
The extended Hamming matrix held 284 ones, so the Hsiao matrix saves 68, and with them 68 XOR gates in the syndrome. Hsiao asked for one more property [2]. The ones should be spread as evenly over the rows as possible, because the slowest syndrome bit sets the speed of the whole decoder. With 216 ones over 8 rows, some row holds at least , and a perfectly even spread puts 27 in every row.
A short count shows how to reach it. A weight-3 column with a 1 in a given row needs two more rows out of the remaining seven, so each row lies in of the 56 weight-3 columns. For the eight weight-5 columns, take the eight runs of five consecutive rows, wrapping around from row 7 to row 0.
A row lies in the run that starts at row exactly when is one of 0, 1, 2, 3 and 4, so every row lies in exactly five runs. Each row then holds ones, the last from , and the matrix is balanced.
Any other eight weight-5 words also give 216 ones, but not necessarily an even spread. The first eight in dictionary order, the row sets , and so on up to , all contain rows 0, 1 and 2, and they leave the rows with 30, 30, 30, 26, 26, 25, 25 and 24 ones. Figure 4 compares the three matrices row by row.
With two-input XOR gates the balancing buys less than it might seem. A tree over inputs has levels, because each level of gates at most halves the number of signals, and both 27 and 30 lie between and , so both trees take 5 levels. The difference appears with three-input XOR gates, where a tree takes levels. Since , the balanced rows take 3 levels and a 30-input row takes 4.
The same reasoning sizes a 32-bit word with seven check bits. There are weight-3 words of length 7, more than the 32 data columns need, so every data column can have weight 3 and the matrix meets the lower bound exactly. Each row lies in weight-3 columns. Leaving out the three words with row sets , and takes two ones from rows 0 and 1 and one from each other row, so the rows hold 14, 14, 15, 15, 15, 15 and 15 ones. The largest row of any such matrix holds at least , so this is as even as the count allows. The extended Hamming code, by comparison, holds 135 ones with rows of 19, 19, 19, 16, 16, 7 and 39. Table 4 collects the five matrices.
Table 4. Ones, largest row, two-input XOR levels and syndrome XOR gates for five SEC-DED check matrices
| Code | Ones in | Largest row | Levels | Syndrome XOR gates |
|---|---|---|---|---|
| Extended Hamming (72,64) | 284 | 72 | 7 | 276 |
| Hsiao (72,64), dictionary order | 216 | 30 | 5 | 208 |
| Hsiao (72,64), balanced | 216 | 27 | 5 | 208 |
| Extended Hamming (39,32) | 135 | 39 | 6 | 128 |
| Hsiao (39,32) | 103 | 15 | 4 | 96 |
Source: reproduced by ch20_secded_and_hsiao_codes.py.
06.The Decoder in Gates
Figure 5 lays out the decoder for the balanced Hsiao code. Its parts follow the flow of Figure 2.
The syndrome block is eight XOR trees, one per row, each over the received bits its row selects, and with 27 inputs per row it takes gates and 5 levels. The zero detector is an OR over the eight syndrome bits, 7 gates, and its output says that something is wrong. The parity detector is an XOR over the same eight bits, 7 more gates, and its output says the syndrome has odd weight. The double-error flag is an AND of "nonzero" with the inverse of "odd", one gate and one inverter.
Correction needs a match signal for every data bit. The match for bit is an AND of eight inputs that is 1 exactly when . It takes directly where has a 1 and through an inverter where has a 0, so for bit 0, whose column is , bits to enter directly and to enter inverted. Eight inverters, one per syndrome bit, serve all the match gates. An eight-input AND is a tree of 7 two-input gates and 3 levels, so the 64 match signals take gates. Each match then drives an XOR with its received bit, 64 more gates. Since the columns are distinct, at most one match fires, and since every column is odd, none fires on an even syndrome, so a double error leaves the data unchanged.
The no-match flag covers the last branch of the flow. Eight more match gates, gates, compare with the check columns. They flip no data bit, but without them a single check-bit error would look unmatched. An OR over all 72 match signals, 71 gates, gives a signal that is 1 when some column matched, and the flag is an AND of "odd" with the inverse of .
Correction and the double-error flag take two-input gates, and the no-match flag adds , for 863 gates and 10 inverters. The path to a corrected data bit runs through 5 levels of syndrome, 3 of match and 1 of correction, 9 levels in all. The double-error flag also sits 9 levels deep, 5 for the syndrome, 3 for the OR or the XOR, and 1 for the final AND. The no-match flag is the slowest output, since arrives after levels and the AND adds one, for 16. The encoder is the syndrome block without the check bits, so each check bit is an XOR over 26 data bits, gates.
The extended Hamming decoder has the same parts, sized differently. Its syndrome takes 276 gates and 7 levels. Its parity bit is already a syndrome bit, so it needs no parity detector, and its zero detector covers only the seven bits of , 6 gates. The total is 923 gates, the corrected data appears after levels, and the no-match flag after 18. Its double-error flag waits for the slower of , at 7 levels, and the zero detector on , whose widest tree of 36 inputs takes 6 levels and whose 7-input OR takes 3 more, so it sits levels deep. Table 5 sets the four decoders side by side.
Table 5. Two-input gates in each part of four SEC-DED decoders, with the logic depth to a corrected data bit and to each flag
| Part | Hsiao (72,64) | Ext. Hamming (72,64) | Hsiao (39,32) | Ext. Hamming (39,32) |
|---|---|---|---|---|
| Syndrome XOR gates | 208 | 276 | 96 | 128 |
| Zero detector | 7 | 6 | 6 | 5 |
| Parity detector | 7 | 0 | 6 | 0 |
| Data match AND gates | 448 | 448 | 192 | 192 |
| Correcting XOR gates | 64 | 64 | 32 | 32 |
| Double-error AND | 1 | 1 | 1 | 1 |
| Check match AND gates | 56 | 56 | 42 | 42 |
| Any-match OR | 71 | 71 | 38 | 38 |
| No-match AND | 1 | 1 | 1 | 1 |
| Total | 863 | 923 | 414 | 439 |
| Levels to corrected data | 9 | 11 | 8 | 10 |
| Levels to the double-error flag | 9 | 10 | 8 | 9 |
| Levels to the no-match flag | 16 | 18 | 14 | 16 |
Source: reproduced by ch20_secded_and_hsiao_codes.py.
The Hsiao decoder saves 68 syndrome gates and spends 8 of them back on its parity detector and wider zero detector, a net saving of 60 gates, and it delivers corrected data two levels sooner. The data match logic, at 448 gates, is the largest part of both decoders and, like the no-match logic, the same in each. The saving is therefore modest in gates and real in depth, and depth is what limits how fast a memory read can finish.
07.Three Errors
A SEC-DED code promises nothing about three errors, but its decoder still acts on them, and the parity lemma says how.
Proof. The syndrome is , the XOR of three odd-weight words, so it has odd weight by Equation 3. Odd weight rules out the zero word and every double-error syndrome, which are even. Suppose for some position . If were , then and , which distinct columns forbid, and the same holds for and , so is a fourth position. The decoder flips bit , leaving the error pattern with ones at , , and . Its syndrome is , so the returned word is a codeword, and it differs from the sent codeword in exactly four positions.
The first outcome is a miscorrection, the worst thing a decoder can do, because the word leaves the decoder with no flag, as a wrong codeword four bits from the one sent. The second outcome raises the no-match flag. For the Hsiao code there are three-bit errors, and running the decoder of Figure 5 on all of them finds 33,568 miscorrected, 56.3 percent, and the other 26,072 flagged.
A rough estimate explains the figure. The syndrome of a triple is an odd word of length 8, and 72 of the 128 such words are columns. If the syndromes were spread evenly over the odd words, percent would match a column. Table 6 shows the exact split by the weight of the syndrome. Every weight-1 word is a check column and every weight-3 word is a data column, so those triples always miscorrect. Only 8 of the 56 weight-5 words are columns, and none of the 8 weight-7 words is, so most of those triples are flagged.
Table 6. Three-bit errors of the balanced Hsiao (72,64) code, grouped by the weight of their syndrome
| Syndrome weight | Triples | Miscorrected | Flagged |
|---|---|---|---|
| 1 | 3,952 | 3,952 | 0 |
| 3 | 26,112 | 26,112 | 0 |
| 5 | 26,040 | 3,504 | 22,536 |
| 7 | 3,536 | 0 | 3,536 |
Source: reproduced by ch20_secded_and_hsiao_codes.py.
The extended Hamming code fares much worse, and the reason is the structure of its column numbers. A triple at positions , and sets , which looks like a single error, and makes the binary XOR of the three position numbers. The decoder miscorrects whenever that XOR is a position the shortened code still has.
Proof. A number below 64 has its ones only in bits 0 to 5, and so does the XOR of such numbers, so the XOR of three distinct positions , and below 64 is again below 64 and is a position of the code. The three flips give and , exactly the syndrome of a single error at . If were , then and , which is false, and the same holds for and , so is a fourth position and the decoder flips it.
That alone is miscorrected triples, and triples that touch positions 64 to 71 add 3,640 more, for 45,304 in all, 76.0 percent. Figure 6 compares six codes, and Table 7 adds the dictionary-order matrix as a seventh.
Table 7. Three-bit errors miscorrected and flagged by the full decoder for seven SEC-DED codes, counted over every triple of positions
| Code | Triples | Miscorrected | Flagged | Share miscorrected |
|---|---|---|---|---|
| Hsiao (8,4) | 56 | 56 | 0 | 100.0% |
| Hsiao (13,8) | 286 | 220 | 66 | 76.9% |
| Hsiao (39,32) | 9,139 | 5,452 | 3,687 | 59.7% |
| Extended Hamming (39,32) | 9,139 | 6,332 | 2,807 | 69.3% |
| Hsiao (72,64), balanced | 59,640 | 33,568 | 26,072 | 56.3% |
| Hsiao (72,64), dictionary order | 59,640 | 34,032 | 25,608 | 57.1% |
| Extended Hamming (72,64) | 59,640 | 45,304 | 14,336 | 76.0% |
Source: reproduced by ch20_secded_and_hsiao_codes.py.
The small codes are the extreme case. The Hsiao code uses all eight odd words as columns, so every odd syndrome matches one and every triple is miscorrected. The choice of the eight weight-5 columns in the code matters too, though less, since the dictionary-order matrix miscorrects 464 more triples than the balanced one.
Those 26,072 flagged triples are what the 128 gates of the no-match flag buy, since a decoder without them would pass every one through uncorrected and unflagged.
08.Looking Ahead
A SEC-DED code corrects one bit and detects two, and the chapter found that eight check bits are the least a linear code can add to a 64-bit word, that odd-weight columns deliver the same promise with a shallower decoder, and that the choice of columns also decides how often three errors slip through as a silent miscorrection. Each of these results treats every bit as failing on its own.
Real memories do not always fail one bit at a time. The next chapter, Beyond SECDED, asks what to build when errors arrive in pairs, in neighboring bits, or in whole bytes, and how to choose a code from what is known about the faults.
09.Worked Examples
10.Exercises
References
- [1]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
- [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]Hamming, Richard W. (1950). “Error Detecting and Error Correcting Codes.” Bell System Technical Journal, 29(2), pp. 147–160. doi:10.1002/j.1538-7305.1950.tb00463.x
- [4]Lin, Shu and Costello, Jr., Daniel J. (2004). “Error Control Coding: Fundamentals and Applications.” 2nd edition. Pearson Prentice Hall.
— Anirban
Hardware–software at the seam where compilers meet microcode.