Memory technologies include features to identify errors, correct issues, and improve performance. In this video, you’ll learn about parity memory, ECC memory, and multi-channel RAM.
The memory modules that we use inside of our computers can be different depending on what that system is used for. If it’s for a desktop computer at home, it might have standard memory inside of it. But if we’re using this inside of a server, we might need memory that has some additional capabilities. So if you’re running a web server, database server, or any other important service, you might want to use one of these memory types.
The first memory type you might want to consider is parity memory. This is memory that includes an extra parity bit with each byte that is stored in the memory. This will not always detect errors that may have occurred in that memory, and it’s not able to correct every error. But it can tell you that a memory error has occurred. This often requires the system halting and requires a full reboot, but at least you were informed where the problem was occurring.
Well, if you were able to recognize an error with the memory, then it might be possible to correct that error. If you are running ECC memory, you would be able to provide that correction. ECC is Error Correction Code. It not only determines that a memory error has occurred. It can correct that error and the system will continue to run normally. Physically, the memory modules that you would use for standard memory, parity memory, or ECC memory are all about the same size. They look very similar, and you’d have to look at the details of those memory specifications to even know there’s a difference between those different memory types.
So how are these memory types able to recognize that an error has occurred? It’s able to do it because it’s saving some extra information in that memory called a parity bit. It’s able to look at an entire terabyte of data, a byte being, of course, 8 bits in length, and it adds effectively a ninth bit to that particular byte.
In most systems, the parity bit that we use is referred to as even parity because the bit that we’re going to add will make all of these bits add up to an even number. Let’s give it a shot and see if we can calculate the parity bits for these three bytes.
We’ll start with the first byte across the top, which is 1, 1, 1, 0, 0, 1, 1, 1. If we were to add up all of the 1s in this particular byte, there would be 1, 2, 3, 4, 5, 6. This means that we already have an even number for this particular byte, which means our parity bit would not add any additional bits. We would instead add the parity bit as a 0.
Let’s try another one. We have 0, 0, 0, 0, 0, 0, 1, 0. If we count up the number of 1s, we have 1, which means it’s an odd number. So to make this even parity, we need to make our parity a 1. And now all of the 1s on that line add up to an even number.
And let’s do a third byte. This one is 1, 0, 0, 1, 1, 0, 0, 0. And if we count the number of 1s, there is 1, 2, 3 1s. So that is an odd number. To make this even parity, our parity bit then needs to be 1. And now we have parity that we’ve calculated for all three of these bytes on our system.
When we’re writing this information into memory, we would write it with not only the 8 bits of the byte, but we would include the parity bit in that storage as well. When we retrieve this information from memory, we evaluate this byte. We perform our own parity check. And then we compare that parity bit to the one that was stored in memory. If those parity bits are identical, then we can assume that that particular byte is intact, and there’s no errors. And if those parity bits are different, then we know some type of error has occurred, either with the process of writing that information to memory or reading that information from the memory module.
So let’s perform our own parity checks. Here’s information that has already been stored in memory. Let’s retrieve this from memory and see if it matches what we would expect. Let’s look at the first byte, which is 0, 0, 0, 0, 0, 1, 1, 1. We know that if we count those up, that is odd number, which means the parity bit should be a 1. And in this case, the parity bit that we’ve pulled from memory is a 1. So that particular memory is valid.
Let’s go with the next byte, which is 0, 0, 0, 0, 0, 0, 1, 0. We see that this is an odd number. So to make this even parity, our parity value would need to be a 1. But the parity value in this case is a 0, which means some type of error has occurred with that byte. And lastly, we have 0, 1, 1, 0, 0, 1, 0, 0. If we count the number of 1s, we have 3, which means we need to add one more to the parity bit. Indeed, that is already a 1, which means that particular byte does not have an error.
If you were to examine the amount of data that’s moving around your computer, you would find an enormous amount of data being transferred between the memory and the CPU. This is what we refer to as the memory bandwidth, and it is an important measurement to determine just how fast your computer is able to operate.
We often refer to this data transfer rate in Mega Transfers or MT per second. This refers to million transfers per second. If you were to look at a memory module, one that you were either purchasing online or at a store, it might say that it is a 32-gigabyte DDR5 memory module or a 1 by 32 gigabyte.
And it also might tell you that this module supports 5,600 million transfers per second. This is why the memory bandwidth that’s on a particular motherboard is such an important statistic. If we want to increase the speed of a system, we would generally need to increase that data rate between the CPU and the memory.
One of the challenges we have with constantly increasing these speeds is that eventually, we hit a maximum of what is humanly possible. So if you’re moving information from memory into a CPU and then back to memory again, you may find that you’re able to max out the total amount of throughput available over that particular pathway.
One of the challenges with this is that the CPU has quite a bit of idle time while it’s waiting for this transfer to occur from memory to CPU and then back again. While that’s going on, we could be performing other calculations, but the problem is that the bandwidth between these two is not enough to support the overall speed of the CPU.
In order to increase these throughputs, we might add an additional channel between the CPU and the memory. This allows the CPU to communicate to multiple memory modules simultaneously, thereby increasing the overall throughput of your system. If you were to look at your computer, it may support multichannel memory, which could potentially double the total throughput between your memory and your CPU.
If you check your motherboard documentation, you may see the motherboard supports dual-channel memory, triple-channel memory, or even quad-channel memory. This means that you could add two, three, or four separate memory modules inside of your computer and increase the total throughput of that memory bandwidth by that total amount.
If you are planning to implement multichannel memory, it’s very useful to have memory combinations that match each other. So the modules that you would install for dual-channel, triple-channel, or quad-channel should all be the same type of memory, ideally even the same make and model.
The motherboard manufacturers have tried to make this a little bit easier for us by coloring the different slots in the memory modules. So on your motherboard, there might be two different colors of slots. This particular motherboard supports dual-channel memory, and there are two separate dual-channel configurations, one that is colored with the black memory slots and one that is colored with the red memory slots.
So on this motherboard, if you wanted to install this into a dual-channel configuration, you would add memory modules into the slots that had the same color. This is one of the reasons you might often find your systems being shipped with two 16-gig memory modules rather than one single 32-gig memory module. Even though the total amount of memory is exactly the same in those two systems, having two separate memory modules provides additional throughput between your CPU and your memory.