Whats 32x64 and 32x72 ram differences?
- Thread starter Passions
- Start date
It's still the same idea- an extra bit giving you information on how the other 8 should be.
I wasn't really paying attention- all I know is that if the second number is a multiple of 9 it's parity, multiple of 8 is non-parity
I didn't bother to figure out if he was talking about SDRAM or old SIMMs
I wasn't really paying attention- all I know is that if the second number is a multiple of 9 it's parity, multiple of 8 is non-parity
I didn't bother to figure out if he was talking about SDRAM or old SIMMs
Sorry, the idea IS different. Parity was 8+1, ECC is 64+8. Might sound the same, but mathematically it makes a dramatic difference.
8+1 just allows detection of all single-bit errors, no correction, no safe detection of higher grade errors - whereas the drastically larger codespace of 64+8 moves the valid datawords far enough apart to allow a much better error detection, and in case of all single-bit errors even correction.
regards, Peter
8+1 just allows detection of all single-bit errors, no correction, no safe detection of higher grade errors - whereas the drastically larger codespace of 64+8 moves the valid datawords far enough apart to allow a much better error detection, and in case of all single-bit errors even correction.
regards, Peter
Oh, neat! I wondered why everyone always said ECC was a lot nicer than regular parity. That does make a lot of sense. So it just writes a checksum for the 64 bits into the 8 ECC bits?
No, that's not how it works ... warning, math ahead.
What is being done is map the 2^64 valid datawords into a space of 2^72 possible datawords, and spread them out in a way such that the valid datawords have the widest possible distance between each other. This distance, the so-called Hamming Distance, is a measure of how good the redundancy in your code is - the redundancy signifying the quality of error detection and performance.
Simple example with less ridiculous code spaces ... imagine a 16x16 matrix of fields. This gives you 256 fields - like on a really old 8-bit SIMM. All those positions are occupied by valid data words. Now regard your read data result as a position in this matrix. If these read data are disturbed, you'll nonetheless get a valid dataword (because your overall space does not have any invalid positions) - so you'll never know your access was off.
Now for what Parity did - double the matrix size (17x16 in our example), keep the number of valid data words, arrange them in a checkerboard pattern. Now when the disturbance in your read data is just one position, you're on an invalid field, thus you know that your read data are off. But you can't correct the mistake, since you can't see which of the nearby valid data words would have been the right one - the difference to each of them is the same. Worse, if you're off by two (or any other even number) you won't even notice because there's the next valid field already.
Fast forward to ECC. By making the matrix MUCH larger, still keeping the number of valid data words in it the same, you can arrange the few valid datawords in that large matrix such that there's much more "invalid" space around each one. So if your read data is off by a little amount, you notice that it's off, and (that's the progress) as long as you're not too far off, you can safely replace it with the nearest valid dataword to correct the error.
On ECC DIMMs, the matrix size is 256 times larger than the number of valid datawords in it, allowing for pretty neat correction capabilities - on Parity RAM, the matrix size was just twice as large, just allowing for single bit error detection.
For the real headache read this:
http://www.cs.colostate.edu/~cs530/d_info.pdf
(Hey, I had to pass an exam on this to get my CS Master)
regards, Peter
What is being done is map the 2^64 valid datawords into a space of 2^72 possible datawords, and spread them out in a way such that the valid datawords have the widest possible distance between each other. This distance, the so-called Hamming Distance, is a measure of how good the redundancy in your code is - the redundancy signifying the quality of error detection and performance.
Simple example with less ridiculous code spaces ... imagine a 16x16 matrix of fields. This gives you 256 fields - like on a really old 8-bit SIMM. All those positions are occupied by valid data words. Now regard your read data result as a position in this matrix. If these read data are disturbed, you'll nonetheless get a valid dataword (because your overall space does not have any invalid positions) - so you'll never know your access was off.
Now for what Parity did - double the matrix size (17x16 in our example), keep the number of valid data words, arrange them in a checkerboard pattern. Now when the disturbance in your read data is just one position, you're on an invalid field, thus you know that your read data are off. But you can't correct the mistake, since you can't see which of the nearby valid data words would have been the right one - the difference to each of them is the same. Worse, if you're off by two (or any other even number) you won't even notice because there's the next valid field already.
Fast forward to ECC. By making the matrix MUCH larger, still keeping the number of valid data words in it the same, you can arrange the few valid datawords in that large matrix such that there's much more "invalid" space around each one. So if your read data is off by a little amount, you notice that it's off, and (that's the progress) as long as you're not too far off, you can safely replace it with the nearest valid dataword to correct the error.
On ECC DIMMs, the matrix size is 256 times larger than the number of valid datawords in it, allowing for pretty neat correction capabilities - on Parity RAM, the matrix size was just twice as large, just allowing for single bit error detection.
For the real headache read this:
http://www.cs.colostate.edu/~cs530/d_info.pdf
(Hey, I had to pass an exam on this to get my CS Master
)regards, Peter
Wow, you got a master's degree in CS and you think 17*16 = 2*16*16? Amazing (I think you meant it expanded it to 32*16=512, since IIRC that's how odd/even parity works- typically I just thought of it is that the parity bit = 1 the 8 bits has to be odd or if parity = 0 the 8 bit number has to be even, something to that effect. Maybe it's vice versa.)
I'm a senior in undergrad engineering/CS currently- only 20 years old
Very interesting. Makes sense though, trying to make the data sparsely distributed. So what you're ending up saying is that ECC really *is* the same idea as parity, just that the "matrix" can be made much larger.
(I think you meant it expanded it to 32*16=512, since IIRC that's how odd/even parity works- typically I just thought of it is that the parity bit = 1 the 8 bits has to be odd or if parity = 0 the 8 bit number has to be even, something to that effect. Maybe it's vice versa.)I'm a senior in undergrad engineering/CS currently- only 20 years old
Very interesting. Makes sense though, trying to make the data sparsely distributed. So what you're ending up saying is that ECC really *is* the same idea as parity, just that the "matrix" can be made much larger.
What the ... yes of course. 32x16. 'twas late evening when I posted that
The big difference between parity and ECC is that the math behind parity is just a bit-wise addition, while ECC involves some nasty looking vector and matrix math (which then turns out to be a really neat idea once you figured it out) ... and a severe headache when defining a good mapping of valid datawords into that large codespace. Luckily that's all up to the chipset designers After you passed that bloody exam, that is
regards, Peter
The big difference between parity and ECC is that the math behind parity is just a bit-wise addition, while ECC involves some nasty looking vector and matrix math (which then turns out to be a really neat idea once you figured it out) ... and a severe headache when defining a good mapping of valid datawords into that large codespace. Luckily that's all up to the chipset designers
After you passed that bloody exam, that is regards, Peter
TRENDING THREADS
-
Discussion Zen 5 Speculation (EPYC Turin and Strix Point/Granite Ridge - Ryzen 9000)- Started by DisEnchantment
- Replies: 25K
-
Discussion Intel Meteor, Arrow, Lunar & Panther Lakes Discussion Threads
- Started by Tigerick
- Replies: 21K
-
Discussion Intel current and future Lakes & Rapids thread- Started by TheF34RChannel
- Replies: 23K
-
-
Facebook
Twitter