The memory in our computers can be configured to provide faster throughput and error correction. In this video, you’ll learn about multi-channel memory and the differences between parity and error correcting code memory.
If you look at the memory modules that are installed onto your motherboard, you may find that there is a single memory module installed into an available slot or there may be a pair of memory modules or even three or four separate memory modules installed on the motherboard. You may not have multiple modules installed because of convenience or even because of cost, but it may be because you have a performance increase by installing multiple modules in certain types of motherboards. This use of multiple modules to increase the performance is called multi-channel memory. And if your motherboard supports this, you’ll find you have much more throughput by having multiple memory modules rather than having a single larger memory module.
If you have a motherboard that supports dual channel memory, then you want to use pairs of memory modules. If your motherboard supports triple channel memory, then you want to have trios of modules. And a motherboard that supports quad channel memory expects you to have four separate memory modules for the best performance. When you’re deciding the types of memory modules to use in a dual channel, triple channel, or quad channel system, you want to be sure all of those memory modules are identical. You don’t want to use different sizes or different performance specifications. They should all match perfectly.
In the case of this particular motherboard, we even have color cues that tell us where we should install the memory modules. This motherboard supports dull channel memory, so we would put two memory modules in the black slots. And if we wanted to increase the amount of memory in our system, we would put to memory modules in the red slots. And by using these pairs of memory modules, we now have maximized the throughput two and from our system ram.
Most of the memory that we’re using on our desktop computers doesn’t provide any type of error checking or error correction. But if you have a file server or system that’s use for virtualization, you may want to type in memory that can recognize when errors occur. One of these memory types is parity memory. Parity memory adds an additional parity bit along with the memory that’s normally being transferred across those memory modules. It will determine when an error has occurred but it won’t provide any way to correct that error.
If you need memory that takes this a step further, that provides not only a way to detect the error but also to correct the error, then you may want to be using ECC memory, and that stands for Error Correcting Code memory. ECC memory, parity memory, and non-parity memory all look very similar to each other. You have to check the specifications of the memory to know exactly what kind you’re using. And you want to be sure to use the right type of memory in the right motherboard. If the motherboard requires ECC memory, you want to be sure that you’re using ECC memory modules and not parity modules or non-parity modules.
Let’s see how this parity process works. Most memory will use a parity process called even parity. That means it will add up all of the bits that were in an 8-bit byte, and it will determine if that is an odd or an even number. And it will add a parity bit on the end that will make sure that all of the byte and the additional parity bit are all an even number.
Let’s take an example. We’ll look at this first byte that we have at the top, where it’s 1, 1, 1, 0, 0, 1, 1, 1. If we count up the number of ones, we have 1, 2, 3, 4, 5, 6, ones in this byte. 6 is an even number, which means we don’t have to add any additional ones to make that number / so the parity bit in this case will be zero.
Let’s look at the next byte, which is 0, 0, 0, 0, 0, 0, 1, 0. We know that there’s only a single one inside of this byte, which is an odd number. In order to make this even parity, we need to add a 1 as the parity bit so that the number of ones is an even number. And the last byte 1, 0, 0, 1, 1, 0, 0, 0. If we add up the number of ones, we have 1 2, 3, ones, an odd number. To be able to make this even, we need to add a one as our parity bit.
Now that these parity bits have been added to this memory and the transactions have occurred inside of RAM, we’re now ready to write this information back to our storage drive. But before we do that, we want to check to be sure that the parity matches. So let’s look at the first byte that we have, which is 0, 0, 0, 0, 0, 1, 1, 1, and then we have a parity bit of 1. And if we count up the number of ones, we have four ones, which means that the total number of ones is an even number. We know that even parity is the correct type of parody, so this particular byte is correct.
Let’s look at the next byte, which is 0, 0, 0, 0, 0, 1, 0, 0, and it has a parity bit of 0. If we count up the number of ones, that is an odd number, which means that something must have gone wrong and that particular byte was corrupted. And our parity memory would recognize that byte as being invalid. Let’s look at the last byte that we have, 0, 1, 1, 0, 0, 1, 0, 0 and a parity bit of 1. If we count up the number of ones, we have 1, 2, 3, 4 ones, which is an even number, which means that that byte is a correct value.