Chapter 4. Physical and Virtual Memory

49

needed all the memory at once. But there is an important distinction; the word "virtual" means that

this is the total number of uniquely addressable memory locations required by the application, and

not the amount of physical memory that must be dedicated to the application at any given time.

In the case of our example application, its virtual address space is 15000 bytes.

In order to implement virtual memory, it is necessary for the computer system to have special mem 

ory management hardware. This hardware is often known as an MMU (Memory Management Unit).

Without an MMU, when the CPU accesses RAM, the actual RAM locations never change   memory

address 123 is always the same physical location within RAM.

However, with an MMU, memory addresses go through a translation step prior to each memory access.

This means that memory address 123 might be directed to physical address 82043 at one time, and

physical address 20468 another time. As it turns out, the overhead of individually tracking the virtual

to physical translations for billions of bytes of memory would be too great. Instead, the MMU divides

RAM into pages   contiguous sections of memory of a set size that are handled by the MMU as

single entities.

Keeping track of these pages and their address translations might sound like an unnecessary and

confusing additional step, but it is, in fact, crucial to implementing virtual memory. For the reason

why, consider the following point.

Taking our hypothetical application with the 15000 byte virtual address space, assume that the applica 

tion's first instruction accesses data stored at address 12374. However, also assume that our computer

only has 12288 bytes of physical RAM. What happens when the CPU attempts to access address

12374?

What happens is known as a page fault. Next, let us see what happens during a page fault.

4.4.1. Page Faults

First, the CPU presents the desired address (12374) to the MMU. However, the MMU has no transla 

tion for this address. So, it interrupts the CPU and causes software, known as a page fault handler, to

be executed. The page fault handler then determines what must be done to resolve this page fault. It

can:

Find where the desired page resides on disk and read it in (this is normally the case if the page fault

is for a page of code)

Determine that the desired page is already in RAM (but not allocated to the current process) and

direct the MMU to point to it

Point to a special page containing nothing but zeros and later allocate a page only if the page is ever

written to (this is called a copy on write page, and is often used for pages containing zero initialized

data)

Get it from somewhere else (which is discussed in more detail later)

While the first three actions are relatively straightforward, the last one is not. For that, we need to

cover some additional topics.

4.4.2. The Working Set

The group of physical memory pages currently dedicated to a specific process is known as the working

set for that process. The number of pages in the working set can grow and shrink, depending on the

overall availability of pages on a system wide basis.

The working set grows as a process page faults. The working set shrinks as fewer and fewer free

pages exist. In order to keep from running out of memory completely, pages must be removed from

process's working sets and turned into free pages, available for later use. The operating system shrinks

processes' working sets by: