Let's start our conversation about memory technologies
with what we do when we run out of memory.
There are ways to help when you run low
on random access memory.
And one of the things you can do is
take information you're not currently using in RAM
and swap it out to a hard drive or SSD.
We sometimes refer to this as virtual memory,
although we can also refer to it as virtual RAM or a swap file.
In Windows in the Performance Options,
there's an Advanced tab that allows you to configure
a virtual memory section.
This is an area of your hard drive or SSD
that Windows can use as if it was actual memory.
Obviously, a hard drive or SSD is
slower than actual random access memory
so this is really an area where we're temporarily
storing things until we find more
room within our normal random access memory.
Many operating systems will manage this process
automatically.
In Windows, there's a checkbox that
says "Automatically manage paging file
size for all drives."
But you can manage this yourself.
If you uncheck that option, you can
specify exactly how much virtual memory
you'd like to allocate on your storage drive.
Another memory technology that can greatly
increase the throughput in your system is multichannel memory.
Sometimes you'll see this as dual channel, triple channel,
or quad channel memory.
This takes the throughput that normally
would be sent to one single memory module
and spreads that load across multiple memory modules.
Ideally, you would have exactly the same memory module types
in each of these multichannel slots.
If your motherboard supports multichannel memory,
then you might want to look at the memory modules
and see if they have different colors.
This is often done so that you know exactly which slots to use
for the multichannel memory.
One thing you might have to consider
is what might happen to your system
if there happens to be an error with the memory
that you're using.
In some environments, you're able to have
memory check itself.
And if a memory does occur, then we
can choose to perform some other functions.
This is the type of memory that you
might have in a system that's running virtual machines.
It may be very large database servers or anything
where you want to maintain the uptime and availability
of those services.
One type of memory you might use is parity memory.
This adds an additional parity bit to the information
that you're storing in RAM.
This isn't a perfect way to identify problems
because parity memory can't always identify
when an error has occurred.
And parity memory has no method to be
able to correct any problems that it happens to find.
If you would like to use memory that can make corrections
to any problems, then you want to use
a motherboard that can support error correcting
code memory or ECC memory.
This will not only identify when an error has occurred
but it will make a change to the memory
to correct any of those problems.
It's this parity bit that allows us
to identify when an error may have occurred with the data.
Many memory modules use even parity,
which means adding the parity bit
means that there will be an even number of ones in that data.
Let's see how this parity bit is calculated and added
to the existing data.
Let's look at this first line of data.
And we want to count the number of ones.
So in this particular data that's 1, 1, 1, 0, 0, 1, 1, 1,
we have one, two, three, four, five,
six ones within that data.
That six is already an even number
so we don't need any additional ones to make this even.
Therefore, the parity bit will be zero.
Let's take the next bit of data.
This data is 0, 0, 0, 0, 0, 0, 1, 0.
If we count the number of ones, there
is a single one which means there
are an odd number of ones.
To be able to make this even parity,
we need to add one more one into this mix
so that we have an even number of ones in this data.
And lastly, we have 1, 0, 0, 1, 1, 0, 0, 0..
We count the number of ones.
There are one, two, three, ones.
That's an odd number.
So to get even parity, we're going to add a one.
And now we have an even number of ones in that data.
So with the existing parity bit, we
can run some tests of some data that
may already be existing to see if the data appears
to be correct.
So let's evaluate the parity bit, assuming
that we're using even parity.
We'll take this first bit of data
and count the number of ones.
We have 0, 0, 0, 0, 0, 1, 1, 1, 1 with a one as the parity bit.
And if we count the number of ones, we have four ones.
That is an even number.
Therefore that data has been validated.
Let's do the next bit of data, which is 0, 0,0 0, 0, 0, 0, 1,
0, with a 0 on the end.
We count the number of ones.
That one is an odd number, which means
something has gone wrong with that data
and it does not validate.
And then lastly, we have 0, 1, 1, 0, 0, 1, 0,
0 with a one parity bit.
If we count the number of ones, there's
one, two, three, four ones, which means it is even parity.
That validates and that data appears to be correct.