Operating System - 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 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 −

S.N 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 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.

Address Binding

Address binding is the process of mapping the program's logical or virtual

addresses to corresponding physical or main memory addresses. In other
words, a given logical address is mapped by the MMU (Memory Management
Unit) to a physical address.

 CPU generates the logical or virtual address for an

instruction/data to be fetched from RAM.
 The logical address undergoes translation by the MMU or address
translation unit in particular.
  The output of this process is the appropriate physical address or
the location of code/data in RAM.

The above described three-step process is also known as execution or run-

time address binding where each physical memory reference is resolved
only when the reference is made at run-time. Until a reference is made,
address resolution or binding does not happen. This type of binding requires
the compiler to generate relocatable or offset based addresses from
the source code. The exact manner of carrying out the address mapping is
dependent on the memory management scheme employed by the operating
system. I will now briefly describe address binding in the context of various
memory management schemes. The description of the schemes themselves
is brief as the focus is on address binding.

Let's take the case of contiguous memory allocation. In this method, a

process will occupy a contiguous main-memory area starting at some
location "L" and extending to "L+X" where X is a byte offset relative to L. In
this scheme, address binding happens through a set of 2
registers -- relocation/base register and limit register. In our example,
relocation/base register will have address "L" as its value, and limit register
will have offset "X" as its value. The purpose of these registers is two-fold:

 Memory protection - References made are checked if they lie

within the process's address space or the contiguous memory area
occupied by the process.
 Address conversion - Once the logical address reference is
verified, it is simply added to the value in base or relocation register.
The added value is the real physical address.

Next is paging. Contiguous memory allocation suffers from the problem of

external fragmentation. Paging allows the process to be allocated physical
memory wherever it is available. In short, with paging, the physical
address space of a process can be non-contiguous. The main memory
is divided into fixed size chunks or frames, and the logical memory is
partitioned into fixed size blocks or pages (usually 4K in size).

In a paging based system, address binding/mapping happens

through page tables. Page table maps a virtual page number to a physical
frame number in main-memory. When the process is loaded into memory,
the allocation is done in the form of frames or physical pages wherever they
are available. Along with this, the page table is also populated with correct
frame number.

Now coming back to address binding, the logical address generated by CPU
is divided into two parts:

 Page Number (aka virtual page number)

 Offset or displacement within the page.

Page number is used to index into the page table, to get the corresponding
physical frame/page number. The physical page number is them combined
with the offset to get the complete physical address.

Next is segmentation. In this scheme, the process is allocated memory in

the form of segments:

Code/Text Segment - containing instructions to be executed

Data Segment - containing the program's global and static data.
Heap - space used to service dynamic memory allocation requests for the
process.
Stack - space to be used during function calls.

All these segments together form the physical address space of the
process. Logical to physical address mapping is done through a segment
table. Each segment in memory has a segment number assigned by the
loader. A segment table is used to keep the following information about
each segment.

 Segment Limit - The offset range within the segment.

 Segment Base - The starting address of each segment in
memory.
Logical address generated by the CPU is divided into two parts:

 Segment number.
 Offset or displacement within the segment.
Segment number is used to index into the segment table to get the values of
segment limit and base. First, we check that offset is within the range
[0, limit]. If so, value of segment base is added to the offset to get the real
physical memory address within the segment.

I hope the above explains the execution-time address binding in the context
of different memory management schemes.

Apart from execution-time, address binding can be further classified into two
different types:

Load-time: logical to physical address resolution happens at the time

executable/program is loaded into main memory. Subsequently, all the
logical addresses generated by the CPU are identical to physical
addresses. In both load and execution time binding, the executable
has relocatable addresses for code/data. The difference is that in this
type of binding, loader translates these relocatable addresses to actual
physical addresses whereas this translation happens at run-time or
dynamically in execution-time binding.

Compile-time: Usually at compile time we don't know where exactly the

program is going to reside in the physical memory. But in case it is known,
the real physical addresses can be generated at the compile time. Again, the
logical addresses are same as physical memory addresses. Compile-time
binding makes it virtually impossible to have two different programs (with
binding done at compile-time) resident in the memory at the same time.

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 must 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 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 & 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 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.

References:

https://www.tutorialspoint.com/operating_system/os_memory_management.htm

https://www.quora.com/What-is-address-binding-in-memory-management