As there is much less physical memory than virtual memory the operating system must be careful that it does not use the physical memory inefficiently. One way to save physical memory is to only load virtual pages that are currently being used by the executing program. For example, a database program may be run to query a database. In this case not all of the database needs to be loaded into memory, just those data records that are being examined. Also, if the database query is a search query then the it does not make sense to load the code from the database program that deals with adding new records. This technique of only loading virtual pages into memory as they are accessed is known as demand paging.
When a process attempts to access a virtual address that is not currently
in memory the CPU cannot find a page table entry for the virtual
page referenced.
For example, in Figure 
there is
no entry in Process X's page table for virtual PFN 2 and
so if Process X attempts to read from an address within
virtual PFN 2 the CPU cannot translate the address into a physical one.
At this point the CPU cannot cope and needs the operating system to
fix things up.
It notifies the operating system that a page fault has occurred
and
the operating system makes the process wait whilst it fixes things up.
The CPU must bring the appropriate page into memory from the image on disk.
Disk access takes a long time, relatively speaking, and so the process must
wait quite a while until the page has been fetched.
If there are other processes that could run then the operating
system will select one of them to run.
The fetched page is written into a free physical page frame and an entry
for the virtual PFN is added to the processes page table.
The process is then restarted at the point where the memory fault
occurred.
This time the virtual memory access is made, the CPU can make the
address translation and so the process continues to run.
This is known as demand paging and occurs when the system is busy but also
when an image is first loaded into memory.
This mechanism means that a process can execute an image that only partially
resides in physical memory at any one time.