Virtual memory

Virtual Memory is a storage mechanism which offers user an illusion of

having a very big main memory. It is done by treating a part of secondary
memory as the main memory. In Virtual memory, the user can store
processes with a bigger size than the available main memory.

Therefore, instead of loading one long process in the main memory, the OS
loads the various parts of more than one process in the main memory. Virtual
memory is mostly implemented with demand paging and demand
segmentation.

Why Need Virtual Memory?

Here, are reasons for using virtual memory:

 Whenever your computer doesn’t have space in the physical memory it

writes what it needs to remember to the hard disk in a swap file as virtual
memory.
 If a computer running Windows needs more memory/RAM, then
installed in the system, it uses a small portion of the hard drive for this
purpose.

How Virtual Memory Works?

In the modern world, virtual memory has become quite common these days.
It is used whenever some pages require to be loaded in the main memory for
the execution, and the memory is not available for those many pages.So, in
that case, instead of preventing pages from entering in the main memory, the
OS searches for the RAM space that are minimum used in the recent times or
that are not referenced into the secondary memory to make the space for the
new pages in the main memory.

Let’s understand virtual memory management with the help of one example.
 For example:
Let’s assume that an OS requires 300 MB of memory to store all the running
programs. However, there’s currently only 50 MB of available physical
memory stored on the RAM.

 The OS will then set up 250 MB of virtual memory and use a program
called the Virtual Memory Manager(VMM) to manage that 250 MB.
 So, in this case, the VMM will create a file on the hard disk that is 250
MB in size to store extra memory that is required.
 The OS will now proceed to address memory as it considers 300 MB of
real memory stored in the RAM, even if only 50 MB space is available.
 It is the job of the VMM to manage 300 MB memory even if just 50
MB of real memory space is available.

Demand Paging
A demand paging system is quite similar to a paging system with swapping
where processes reside in secondary memory and pages are loaded only on
demand, not in advance. When a context switch occurs, the operating system
does not copy any of the old program’s pages out to the disk or any of the
new program’s pages into the main memory Instead, it just begins executing
the new program after loading the first page and fetches that program’s pages
 as they are referenced.

While executing a program, if the program references a page which is not

available in the main memory because it was swapped out a little ago, the
processor treats this invalid memory reference as a page fault and transfers
control from the program to the operating system to demand the page back
into the memory.

Advantages
Following are the advantages of Demand Paging −

 Large virtual memory.

 More efficient use of memory.
 There is no limit on degree of multiprogramming.

Disadvantages
 Number of tables and the amount of processor overhead for handling
page interrupts are greater than in the case of the simple paged management
techniques.
 Page Replacement Algorithm
Page replacement algorithms are the techniques using which an Operating
System decides which memory pages to swap out, write to disk when a page
of memory needs to be allocated. Paging happens whenever a page fault
occurs and a free page cannot be used for allocation purpose accounting to
reason that pages are not available or the number of free pages is lower than
required pages.

When the page that was selected for replacement and was paged out, is
referenced again, it has to read in from disk, and this requires for I/O
completion. This process determines the quality of the page replacement
algorithm: the lesser the time waiting for page-ins, the better is the algorithm.

A page replacement algorithm looks at the limited information about

accessing the pages provided by hardware, and tries to select which pages
should be replaced to minimize the total number of page misses, while
balancing it with the costs of primary storage and processor time of the
algorithm itself. There are many different page replacement algorithms. We
evaluate an algorithm by running it on a particular string of memory
reference and computing the number of page faults,

Reference String
The string of memory references is called reference string. Reference strings
are generated artificially or by tracing a given system and recording the
address of each memory reference. The latter choice produces a large number
of data, where we note two things.

 For a given page size, we need to consider only the page number, not
the entire address.
 If we have a reference to a page p, then any immediately following
references to page p will never cause a page fault. Page p will be in memory
after the first reference; the immediately following references will not fault.
 For example, consider the following sequence of addresses −
123,215,600,1234,76,96
 If page size is 100, then the reference string is 1,2,6,12,0,0

First In First Out (FIFO) algorithm

 Oldest page in main memory is the one which will be selected for
replacement.
 Easy to implement, keep a list, replace pages from the tail and add new
pages at the head.

Optimal Page algorithm

 An optimal page-replacement algorithm has the lowest page-fault rate
of all algorithms. An optimal page-replacement algorithm exists, and has
been called OPT or MIN.
 Replace the page that will not be used for the longest period of time.
Use the time when a page is to be used.
 Least Recently Used (LRU) algorithm
 Page which has not been used for the longest time in main memory is
the one which will be selected for replacement.
 Easy to implement, keep a list, replace pages by looking back into time.
 Virtual and physical addresses are the same in compile-time and load-time
address-binding schemes. Virtual and physical addresses differ in execution-
time address-binding scheme.

The set of all logical addresses generated by a program is referred to as

a logical address space. The set of all physical addresses corresponding to
these logical addresses is referred to as a physical address space.

The runtime mapping from virtual to physical address is done by the memory
management unit (MMU) which is a hardware device. MMU uses following
mechanism to convert virtual address to physical address.

 The value in the base register is added to every address generated by a

user process, which is treated as offset at the time it is sent to memory. For
example, if the base register value is 10000, then an attempt by the user to
use address location 100 will be dynamically reallocated to location 10100.
 The user program deals with virtual addresses; it never sees the real
physical addresses.

Static vs Dynamic Loading

The choice between Static or Dynamic Loading is to be made at the time of
computer program being developed. If you have to load your program
statically, then at the time of compilation, the complete programs will be
compiled and linked without leaving any external program or module
dependency. The linker combines the object program with other necessary
object modules into an absolute program, which also includes logical
addresses.

If you are writing a Dynamically loaded program, then your compiler will
compile the program and for all the modules which you want to include
dynamically, only references will be provided and rest of the work will be
done at the time of execution.
At the time of loading, with static loading, the absolute program (and data) is
loaded into memory in order for execution to start.

If you are using dynamic loading, dynamic routines of the library are stored
on a disk in relocatable form and are loaded into memory only when they are
needed by the program.

Static vs Dynamic Linking

As explained above, when static linking is used, the linker combines all other
modules needed by a program into a single executable program to avoid any
runtime dependency.

When dynamic linking is used, it is not required to link the actual module or
library with the program, rather a reference to the dynamic module is
provided at the time of compilation and linking. Dynamic Link Libraries
(DLL) in Windows and Shared Objects in Unix are good examples of
dynamic libraries.

Swapping
Swapping is a mechanism in which a process can be swapped temporarily out
of main memory (or move) to secondary storage (disk) and make that
memory available to other processes. At some later time, the system swaps
back the process from the secondary storage to main memory.

Though performance is usually affected by swapping process but it helps in

running multiple and big processes in parallel and that’s the
reason Swapping is also known as a technique for memory compaction.
The total time taken by swapping process includes the time it takes to move
the entire process to a secondary disk and then to copy the process back to
memory, as well as the time the process takes to regain main memory.

Let us assume that the user process is of size 2048KB and on a standard hard
disk where swapping will take place has a data transfer rate around 1 MB per
second. The actual transfer of the 1000K process to or from memory will take

2048KB / 1024KB per second

= 2 seconds
= 2000 milliseconds
Now considering in and out time, it will take complete 4000 milliseconds
plus other overhead where the process competes to regain main memory.

Memory Allocation
 Main memory usually has two partitions −

 Low Memory − Operating system resides in this memory.

 High Memory − User processes are held in high memory.

Operating system uses the following memory allocation

mechanism.S.N.Memory Allocation & Description1

Single-partition allocation

In this type of allocation, relocation-register scheme is used to protect user

processes from each other, and from changing operating-system code and
data. Relocation register contains value of smallest physical address whereas
limit register contains range of logical addresses. Each logical address must
be less than the limit register.2

Multiple-partition allocation

In this type of allocation, main memory is divided into a number of fixed-

sized partitions where each partition should contain only one process. When a
partition is free, a process is selected from the input queue and is loaded into
the free partition. When the process terminates, the partition becomes
available for another process.

Fragmentation
As processes are loaded and removed from memory, the free memory space
is broken into little pieces. It happens after sometimes that processes cannot
be allocated to memory blocks considering their small size and memory
blocks remains unused. This problem is known as Fragmentation.

Fragmentation is of two types −S.N.Fragmentation & Description1

External fragmentation
Total memory space is enough to satisfy a request or to reside a process in it,
but it is not contiguous, so it cannot be used.2

Internal fragmentation

Memory block assigned to process is bigger. Some portion of memory is left

unused, as it cannot be used by another process.

The following diagram shows how fragmentation can cause waste of memory
and a compaction technique can be used to create more free memory out of
fragmented memory −

External fragmentation can be reduced by compaction or shuffle memory

contents to place all free memory together in one large block. To make
compaction feasible, relocation should be dynamic.

The internal fragmentation can be reduced by effectively assigning the

smallest partition but large enough for the process.

Paging
A computer can address more memory than the amount physically installed
on the system. This extra memory is actually called virtual memory and it is a
section of a hard that’s set up to emulate the computer’s RAM. Paging
technique plays an important role in implementing virtual memory.

Paging is a memory management technique in which process address space is

broken into blocks of the same size called pages (size is power of 2, between
512 bytes and 8192 bytes). The size of the process is measured in the number
of pages.

Similarly, main memory is divided into small fixed-sized blocks of (physical)

memory called frames and the size of a frame is kept the same as that of a
page to have optimum utilization of the main memory and to avoid external
fragmentation.
Address Translation
Page address is called logical address and represented by page number and
the offset.

Logical Address = Page number + page offset

Frame address is called physical address and represented by a frame
number and the offset.

Physical Address = Frame number + page offset

A data structure called page map table is used to keep track of the relation
between a page of a process to a frame in physical memory.

When the system allocates a frame to any page, it translates this logical
address into a physical address and create entry into the page table to be used
throughout execution of the program.

When a process is to be executed, its corresponding pages are loaded into any
available memory frames. Suppose you have a program of 8Kb but your
 memory can accommodate only 5Kb at a given point in time, then the paging
concept will come into picture. When a computer runs out of RAM, the
operating system (OS) will move idle or unwanted pages of memory to
secondary memory to free up RAM for other processes and brings them back
when needed by the program.

This process continues during the whole execution of the program where the
OS keeps removing idle pages from the main memory and write them onto
the secondary memory and bring them back when required by the program.

Advantages and Disadvantages of Paging

Here is a list of advantages and disadvantages of paging −

 Paging reduces external fragmentation, but still suffer from internal

fragmentation.
 Paging is simple to implement and assumed as an efficient memory
management technique.
 Due to equal size of the pages and frames, swapping becomes very
easy.
 Page table requires extra memory space, so may not be good for a
system having small RAM.

Segmentation
Segmentation is a memory management technique in which each job is
divided into several segments of different sizes, one for each module that
contains pieces that perform related functions. Each segment is actually a
different logical address space of the program.

When a process is to be executed, its corresponding segmentation are loaded

into non-contiguous memory though every segment is loaded into a
contiguous block of available memory.
Segmentation memory management works very similar to paging but here
segments are of variable-length where as in paging pages are of fixed size.

A program segment contains the program’s main function, utility functions,

data structures, and so on. The operating system maintains a segment map
table for every process and a list of free memory blocks along with segment
numbers, their size and corresponding memory locations in main memory.
For each segment, the table stores the starting address of the segment and the
length of the segment. A reference to a memory location includes a value that
identifies a segment and an offset.