Memory Management Evolution: Fixed Partitions to 64‑Bit Virtual Memory

Name: You need to learn how operating systems handle memory (virtual memory, 32-bit vs 64-bit, addressing)
Uploaded: 2026-03-30T15:15:03.331024+00:00
Duration: 17 min 32 s
Channel: Programming w/ Professor Sluiter
Description: Summary and key takeaways on Memory Management Evolution: Fixed Partitions to 64‑Bit Virtual Memory, covering Historical Evolution of Memory Management Early

Programming w/ Professor Sluiter

Mar 30, 2026

•

17 min video

•

2 min read

YouTube video ID: ueV1gcYJSZg

Source: YouTube video by Programming w/ Professor Sluiter — Watch original video

PDF

Early single‑user systems in the 1950s‑1980s could run only one program at a time. The operating system had to evacuate the entire RAM before loading a new program, so any program larger than the total memory could not be executed. Fixed‑partition systems introduced multiple partitions, allowing several programs to reside simultaneously, but they quickly ran into fragmentation and “no vacancy” errors that often required a reboot. Dynamic contiguous‑block allocation improved matters by loading programs until memory filled, yet gaps left by terminated programs still prevented large applications from loading.

Virtual Memory and Paging

Virtual memory breaks a program into fixed‑size pages that map onto page frames in physical RAM. A page table records the location of each page, enabling the operating system to load only the pages needed for the current execution. This on‑demand paging lets programs exceed the size of physical RAM because unused pages remain on secondary storage until required. Memory mapping translates virtual addresses to physical addresses, making the virtual address space appear larger than the actual hardware capacity.

Processor Architecture and Addressing Capacity

A processor’s bit‑depth determines the maximum addressable memory. 32‑bit CPUs cap the address space at 4 GB, while 64‑bit CPUs expand it to a theoretical 16 exabytes. The larger address space not only permits more memory but also increases data throughput, much like adding extra lanes to a highway allows more traffic to flow simultaneously.

Page Replacement Policies

When RAM fills, the operating system must evict pages. Different policies decide which page to replace:

FIFO (First In, First Out) removes the oldest page in memory.
LRU (Least Recently Used) discards the page that has not been accessed for the longest time.
LFU (Least Frequently Used) targets the page with the lowest access count.
MRU (Most Recently Used) removes the most recently accessed page, which can be efficient for certain sequential workloads.

Performance Limitations and Thrashing

If paging activity becomes excessive, the system enters thrashing, spending more time swapping pages between RAM and storage than executing useful work. Thrashing dramatically degrades performance. Common remedies include closing unnecessary programs or adding more physical RAM. Features like ReadyBoost allow external storage (e.g., a USB stick) to act as an auxiliary swap area, though this extension remains slower than true RAM.

Mechanisms Explained

On‑demand paging loads only the pages required for the current execution path, keeping the rest on disk until needed.
Memory mapping provides a translation layer that treats virtual addresses as if they were contiguous, even when they span disparate physical locations.
ReadyBoost leverages fast flash storage to supplement virtual memory, offering a modest performance boost when RAM is scarce.

Takeaways

Early single‑user systems could only run one program at a time and required the entire RAM to be cleared before loading another, preventing execution of programs larger than the physical memory.
Fixed‑partition and dynamic contiguous‑block schemes introduced multitasking but suffered from fragmentation and “no vacancy” errors, often forcing reboots when memory gaps blocked new programs.
Virtual memory splits programs into fixed‑size pages that map to physical page frames, allowing the OS to run applications larger than RAM by loading only needed pages on demand.
Moving from 32‑bit (4 GB address limit) to 64‑bit processors expands the addressable space to 16 exabytes, dramatically increasing throughput similar to adding lanes on a highway.
Thrashing occurs when excessive paging overwhelms the system, and remedies include closing applications or adding more RAM, while policies like FIFO, LRU, LFU, and MRU determine which pages to replace.

Frequently Asked Questions

What is on-demand paging and how does it work?

On-demand paging loads only the pages a program needs for its current execution into RAM, leaving the rest on secondary storage. The operating system tracks page usage with a page table and fetches additional pages when the program accesses them, conserving memory and reducing load time.

Why does 64‑bit addressing provide an exponential increase over 32‑bit?

A 64‑bit address can represent 2^64 distinct locations, while a 32‑bit address covers only 2^32. This jump expands the addressable memory from 4 GB to 16 exabytes, an exponential growth that enables vastly larger address spaces and higher data throughput.

Who is Programming w/ Professor Sluiter on YouTube?

Programming w/ Professor Sluiter is a YouTube channel that publishes videos on a range of topics. Browse more summaries from this channel below.

Does this page include the full transcript of the video?

Yes, the full transcript for this video is available on this page. Click 'Show transcript' in the sidebar to read it.

Helpful resources related to this video

If you want to practice or explore the concepts discussed in the video, these commonly used tools may help.

Computer Architecture And Operating Systems Book Recommended

Provides deep technical context on memory management, paging, and processor architecture to supplement the lecture.

Amazon →

Desktop Computer Memory Ram Upgrade Kit

Adding physical RAM is the primary hardware solution mentioned to prevent thrashing and improve system performance.

Amazon →

Computer Organization And Design Textbook

Explains the hardware-level implementation of bit-depth, address spaces, and how processors interact with memory.

Amazon →

Links may be affiliate links. We only include resources that are genuinely relevant to the topic.

Summarize another video

Full Transcript YouTube

hi my name's shad and I'll be your
teacher and guide for this lesson on
operating systems most people know that
a fast processor in a computer makes the
computer fast but did you know that it's
just as important for the memory and how
it's managed in this video we're going
to look at the history and the
innovations that people have made and
making computers fast using just memory
techniques so this video is about memory
management with operating systems so in
ear computer you're going to find the
task manager shows you how much
resources is being utilized in your
computer and an important part of that
is the amount of memory and so you can
see in this computer 85 percent of the
memory is being consumed and one
computer program in particular is taking
the space you can see Visual Studio is
quite a memory hog now if you are in the
old days you would have had a system
that managed memory quite differently
than what happened in Windows does and
then in the most current version of
Windows which right now is Windows 11.
there's dramatic improvements from the
history of how computers especially
computers that are personal computers
have been designed so way back in the
old days there was this concept of a
single user memory system so I mean
really old like 1950s old and then the
first personal computers in the 1980s so
this is what it looked like when you
bought a computer with Microsoft DOS on
it there was no windows but just as
importantly it was a single user memory
process so what does that look like well
we have memory which is represented by
this chip here and suppose we had
multiple programs that we wanted to run
how did you do it with a single user
system well you would put a process into
memory and then when you wanted to use a
second program you had to evacuate the
memory so that another one can come in
and so you can see the pattern here that
three can go in after two is done and
four cannot go into the memory and do
any processing while three is action so
we need to have some kind of a dynamic
system where we can put more than one
computer program into memory because
this is kind of a slow process and also
when you get to a problem like here with
program number five we're going to see
that there is no way that we're going to
put five into memory even if we clear
out everything else the program is
physically bigger than the computer can
handle now we've solved that and we can
see that in later parts of this video of
techniques to make virtual memory but in
the old days a single user system has
severe limitations so a single user
systems are quite simple and they were
effective for what they needed to do
they do not require a large amount of
resources as a matter of fact the early
days of Dos you could put the entire
operating system on a floppy disk but
they were only for one program at a time
time which was severely limiting so we
had some slowness and people just put up
with it because that was a good system
for the time the next Innovation that
came along was called a fixed partition
size which allowed multiple programs to
fit into memory at the same time but it
too had some limitations so we would be
able to put one process in but while
that process was there we could also
load a second program if there was
sufficient space in the RAM and so we
could in this a case he can put three
and even four which appears to be a
small program but of course when you try
to put the next item in it just wouldn't
fit and there was no vacancy so if you
filled up your memory you were stuck and
you couldn't run any more programs you
had to reboot your computer and so
shutting down each time that you wanted
to free up the ram is a very inefficient
use of the program so I'd like to show
you a simulator of a memory management
system so this is the program that
student design to believe that shows you
how a memory manager worked in some of
the older versions of operating systems
so I can put in a number here for the
process size which represents the amount
of kilobytes required and then the
processing time is how long that process
will live so I'm going to use 90 and 90
for the two values and you can see each
time I add a new process the memory is
slowly consumed and you can see that
it's consumed in pieces of size 90
kilobytes each
and so then the problem eventually
arises that we're so fragmented that you
can't put in another large chunk of a
process and so we have to either refresh
the browser which is like rebooting the
computer or just continue to use smaller
and smaller fragments so this is an
older system design and it's a great
program to illustrate how memory
management looks but I wouldn't want to
have this for my modern operating system
on my computer today
so this system has the advantage of
letting multiple applications run but we
are not Dynamic which means we can't
readjust the size of the blocks after
they've been used and so it was somewhat
limited the next Innovation was called
Dynamic but with continuous blocks and
so what does that look like so once
again we have RAM and we have programs
we can load them in one at a time and we
can consume all of the memory up to the
very last byte and so in this case you
can see four programs are running so
when we try to put the fifth one in it
doesn't work but we're not going to put
up the No Vacancy sign here if we clear
out a program there's a possibility that
this next number five will fit it
doesn't fit so we have to wait till the
next process is finished and when those
two are out of the way then process five
is free to move in and occupy the space
however notice the Gap that Gap is still
there and so we can't put number six in
obviously because it's too big so six
cannot fit between five and three nor
can it fit at the end and so six is
pretty much out of luck until three or
five finish up their job now this here
can allow you to use multiple apps it is
dynamic which means that you can you
know free up the space that it's
contiguous but then there is a still
that problem of The Limited program size
if your program is bigger than the
amount of ram it still will not run so
we still need a better solution and
Along Comes the idea of virtual memory
so how does virtual memory work so
instead of using a program in its
entirety we split it up into slices and
so those slices we're going to call
pages so a page is a set amount of
memory so you can configure that in your
operating system and certain page sizes
work better than others your page frames
then are the segments in your memory so
think of taking a large parking lot and
painting lines on it and pretending that
every vehicle in the world is the exact
same size that would be kind of like
organ using your program and you split
it up into car sized pieces so that you
can park them and so you can put all of
your memory then in the same segments
now you don't have to put them in
sequence because if you decide that
you're going to put them in any and the
next available slots then you have a
much more efficient way to reutilize
those empty parking places to make that
happen we have to have what's called a
page table a page index and so the page
numbers are listed along with the memory
address where that place has been stored
and so that is a way to make your
virtual memory work
got to make that work you have to have a
memory map and the nice thing about the
memory map is that it allows you to
actually have more virtual memory than
physically is on your computer so your
computer memory has a address space so
zero would be the lowest address and
then some number the maximum amount of
memory that's in the computer would be
your maximum High memory value however
with virtual memory we can extend that
to a huge number and so you have to just
map the parts that are actually in use
with the pieces that actually can be put
into RAM and so there's this mapping
process that goes on and so virtual
memory allows you to have programs that
are actually larger than the RAM and
they can still operate correctly so this
brings up another concept of operating
systems and the idea of having a 32-bit
operating system versus a 64-bit
operating system is very important when
it comes to memory management so first
of all what is a 8-bit or 16-bit kind of
operating system so think of the chips
or the little integrated circuits that
you may have seen that have pins and
those pins are numbered so an 8-bit
integrated circuit would have eight pins
a 16 bit would have 16 pins and 32 pins
and 64 pins and so on and so when you
have a CPU that has more bits it means
you have higher throughput if you can
check on your computer with the system
information you can see what kind of an
operating system you have installed so
back in the days of Windows 7 there were
two different kind of operating systems
that were common there was a 32-bit
system and there was a 64-bit system now
they both looked identical the desktops
were indistinguishable but the
performance was much better with the
64-bit why is that well one of the
issues is that you can have more
throughput when you have more wires so
it's just like a highway with more Lanes
in it has a higher capacity to carry
more cars also you can use higher values
when it comes to memory and that's why
32-bit versus 64-bit is such a critical
concept when it comes to memory
management so let's talk about the
numbers that you can represent using
bits so if you have a one bit number you
have two combinations zero or One A
two-bit number allows you to count up to
four a three bit number allows you to
count to a maximum number of eight and
four bits allow you to count all the way
up to 16. so that is binary counting now
what if you have 32 bits how high can
you count with a 32-bit number well you
can count quite high at least it sounds
High the number actually is four
gigabytes when it comes to how high you
can count and so a 32-bit processor is
only able to have an address space of
four to gigabytes now at one time four
gigabytes seemed like a lot for a PC to
have for memory and of course nowadays
nobody has four so 64-bit processors
allow you to access a huge amount of
space as you can see in this chart it
says 16 exabytes which I think is
probably more data than you can find in
the world today on the internet so 64
bits is much larger than 32 bits not by
doubling but by an exponential amount
and so the amount of virtual memory that
a computer system can access is
important by the number of bits that an
operating system is measured by let's
take a look at the processors that Intel
has made so in 1971 they had a 4-bit
processor quickly they came out with an
8-bit processor which was the 88 which
was one of their most successful the
ad86 of course was one that is still
called the 86 architecture used today
and then we have the 386 which was the
first 32-bit processor and then in 2004
they introduced a 64-bit processor when
will they come out with a 128 processor
I don't know maybe it'll not even be in
your lifetime but we do have this growth
of capacity of how many bits a processor
can access by the way Intel is not the
only Processing Company in the world
1975 was the first 64-bit processor with
the cray one supercomputer another trick
that came out I think in Windows 7 or
Vista or sometime was this thing called
Ready boost if you were to plug in a USB
stick into your computer you would be
presented with this auto play option and
at the very bottom was the ability to
speed up your system now this is simply
virtual memory that was allowed to
expand the amount of memory that your
computer could access and so you could
swap out things to your USB stick and
that would essentially give you more RAM
even though the USB stick was likely
many many times slower than the original
RAM and so that would be somewhat
effective now this virtual memory system
allows you to run multiple apps and the
advantages is that it's Dynamic again
and you can have programs that are
actually far exceeding the amount of
memory that's on the computer so the way
that works is that you would have a
partial piece of them of the program in
memory at any one time so that process
of loading only a partial part of a
program is called on-demand paging so if
we were to have a computer system again
with a piece of program that is trying
to load into RAM we would split it up
into Pages now what happens if you don't
need all of those so the program
executes and we only need one one five
and six for our pages and so we can load
those three into memory and leave the
others on the hard drive so there's no
sense in loading them into RAM if we're
not going to need them and so we would
call that on-demand paging so there is
now a problem to say which Pages do we
want to put into memory and which piece
pieces do we want to keep there so
that's called your page replacement and
so we have a policy in place where you
can say first in first out or at least
recently used the least frequently used
or the most recently used so first of
all if we have pages in memory where the
first in first out rule occurs then the
one that came in first which is page
number one that has to be excluded first
and then everyone kind of moves over and
we put in the new piece so first in
first out the next item is the rule
called least recently used rules so if
we were to have some kind of a timer on
each page and we were to notice that
memory page number three has been in
memory a long time we need to put five
in so we're going to elect three then to
be booted so three gets excluded and
then we put five into its place so that
is the res least recently used Rule now
then there's also the free least
frequently used rules so we could look
at our memory and instead of putting a
timer on it now we count how many times
it's been accessed either read or
written to and so you can see that we
have number two here it stands out as
hardly they ever used it was only
accessed twice so if we need to put five
in now we're going to elect number two
to be booted and then we'll put five
into his place
now how about the most recently used
rule so this one seems a little
counter-intuitive but we would do the
opposite of the least recently used so
we look at the piece of memory that was
most recently used and we elect that one
to be kicked out and so we throw out
number four and then five gets into his
place now that would occur when you're
trying to read through a long list of
things and sometimes this actually is
more efficient than the other routines
finally there's one item called segments
so pages that we've assumed right now
are all the same link now we can also
split up a program by segments so what's
a segment so a segment is essentially
one of the methods that's in your class
you can think of it as a code chunk that
is a logical unit and so some segments
are bigger than others and we can split
the pages up into variable sizes so
obviously that's not as easy to work
with if you don't have a uniform size
but you can have more granularity as far
as security and things like that so in
the reality we get a combination of the
two now the last problem is you can only
get this benefit of swapping up until a
certain point where it becomes
inefficient so you've all had a computer
before that seems to just slow down
after you load so many programs into it
that's because your RAM is being swapped
out from the hard drive into memory and
then back out again and you get to a
certain point that it's called thrashing
and so the only solution for this is
either to purchase more memory and
expand your computer or to close
programs so thrashing is kind of the
limit that is practical for how much you
can do with multi-programming so there
are essentially five things that we've
done here with memory management if this
is interesting to you make sure that you
take a look at the next video which is
about what the jobs of an operating
system are if you like this please make
sure that you touch that subscribe
button and come back or you can join me
in class where I teach at Grand Canyon
University with software development
thanks for showing up and I'll see you
in the next video