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.