MEMORY MANAGEMENT

Memory management is the functionality of an operating system, which

handles or manages primary memory and moves processes back and
forth between main memory and disk during execution. Memory
management keeps track of each and every memory location, regardless
of either it is allocated to some process or it is free. It checks how much
memory is to be allocated to processes. It decides which process will get
memory at what time. It tracks whenever some memory gets freed or
unallocated and correspondingly it updates the status.

Process Address Space

The process address space is the set of logical addresses that a process
references in its code. For example, when 32-bit addressing is in use,
addresses can range from 0 to 0x7fffffff; that is, 2^31 possible numbers,
for a total theoretical size of 2 gigabytes.

The operating system takes care of mapping the logical addresses to

physical addresses at the time of memory allocation to the program.
There are three types of addresses used in a program before and after
memory is allocated −

Memory Addresses & Description

1 Symbolic addresses
The addresses used in a source code. The variable names, constants, and
instruction labels are the basic elements of the symbolic address space.

2 Relative addresses
At the time of compilation, a compiler converts symbolic addresses into
relative addresses.
3 Physical addresses
The loader generates these addresses at the time when a program is loaded
into main memory.

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 registers 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 re-locatable form and are loaded into memory only
when the program needs them.

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.
Difference Between Contiguous and Noncontiguous Memory
Allocation

Memory is a large array of bytes, where each byte has its own address.
The memory allocation can be classified into two methods contiguous
memory allocation and non-contiguous memory allocation. The major
difference between Contiguous and Noncontiguous memory allocation is
that the contiguous memory allocation assigns the consecutive blocks of
memory to a process requesting for memory whereas, the noncontiguous
memory allocation assigns the separate memory blocks at the different
location in memory space in a nonconsecutive manner to a process
requesting for memory. We will discuss some more differences between
contiguous and non-contiguous memory allocation with the help of
comparison chart shown below.

BASIS THE CONTIGUOUS MEMORY NONCONTIGUOUS

COMPARISON ALLOCATION ALLOCATION

Basic Allocates consecutive blocks of Allocates separate blo

memory to a process. process.

Overheads Contiguous memory allocation does Noncontiguous mem

not have the overhead of address overhead of addres
translation while execution of a execution of a process.
process.

Execution rate A process executes fatser in A process execu

contiguous memory allocation comparatively in non
allocation.

Solution The memory space must be divided Divide the process int
into the fixed-sized partition and each place them in different
partition is allocated to a single according to the ava
 process only. space available.

Table A table is maintained by operating A table has to be maint

system which maintains the list of that carries the base ad
available and occupied partition in the which has been acqu
memory space memory.
Content: Contiguous Vs Noncontiguous Memory Allocation
1 Comparison Chart
2 Definition
3 Key Differences
4 Conclusion

Comparison Chart

Allocation
The operating system and the user’s processes both must be
accommodated in the main memory. Hence the main memory is divided
into two partitions: at one partition the operating system resides and at
other the user processes reside. In usual conditions, the several user
processes must reside in the memory at the same time, and therefore, it is
important to consider the allocation of memory to the processes.
The Contiguous memory allocation is one of the methods of memory
allocation. In contiguous memory allocation, when a process requests for
the memory, a single contiguous section of memory blocks is assigned to
the process according to its requirement.
The contiguous memory allocation can be achieved by dividing the
memory into the fixed-sized partition and allocate each partition to a
single process only. But this will cause the degree of multiprogramming,
bounding to the number of fixed partition done in the memory. The
contiguous memory allocation also leads to the internal fragmentation.
Like, if a fixed sized memory block allocated to a process is slightly
larger than its requirement then the left over memory space in the block is
called internal fragmentation. When the process residing in the partition
terminates the partition becomes available for the another process.
In the variable partitioning scheme, the operating system maintains a
table which indicates, which partition of the memory is free and which
occupied by the processes. The contiguous memory allocation fastens the
execution of a process by reducing the overheads of address translation.
Definition Non-Contiguous Memory Allocation
The Non-contiguous memory allocation allows a process to acquire the
several memory blocks at the different location in the memory according
to its requirement. The noncontiguous memory allocation also reduces the
memory wastage caused due to internal and external fragmentation. As it
utilizes the memory holes, created during internal and external
fragmentation.
Paging and segmentation are the two ways which allow a process’s
physical address space to be non-contiguous. In non-contiguous memory
allocation, the process is divided into blocks (pages or segments) which
are placed into the different area of memory space according to the
availability of the memory.
The noncontiguous memory allocation has an advantage of reducing
memory wastage but, but it increases the overheads of address translation.
As the parts of the process are placed in a different location in memory, it
slows the execution of the memory because time is consumed in address
translation.
Here, the operating system needs to maintain the table for each process
which contains the base address of the each block which is acquired by
the process in memory space.

Key Differences Between Contiguous and Noncontiguous Memory

Allocation
1 The basic difference between contiguous and noncontiguous memory
allocation is that contiguous allocation allocates one single
contiguous block of memory to the process whereas, the
noncontiguous allocation divides the process into several blocks
and place them in the different address space of the memory i.e. in
a noncontiguous manner.
2 In contiguous memory allocation, the process is stored in contiguous
memory space; so there is no overhead of address translation
 during execution. But in noncontiguous memory allocation, there is
an overhead of address translation while the process execution, as
the process blocks are spread in the memory space.
3 Process stored in contiguous memory executes faster in comparison to
process stored in noncontiguous memory space.
4 The solution for contiguous memory allocation is to divide the memory
space into the fixed-sized partition and allocate a partition to a
single process only. On the other hands, in noncontigous memory
allocation, a process is divided into several blocks and each block
is placed at different places in memory according to the availability
of the memory.
5 In contiguous memory allocation, operating system has to maintain a
table which indicates which partition is available for the process
and which is occupied by the process. In noncontiguous memory
allocation, a table is maintained for each process which indicates
the base address of each block of the process placed in the memory
space.

Conclusion:
Contiguous memory allocation does not create any overheads and
fastens the execution speed of the process but increases memory
wastage. In turn noncontiguous memory allocation creates overheads of
address translation, reduces execution speed of a process but, increases
memory utilization. So there are pros and cons of both allocation
methods.

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 & Description

1 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 & Description

1 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.