Operating System Memory Management
Operating System Memory Management
Memory Management
The memory management algorithms vary from a primitive bare-machine approach to a strategy that uses paging. Each
approach has its own advantages and disadvantages.
• 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 tracks whenever some memory gets freed or unallocated and correspondingly it updates the status.
Memory
Basic Hardware
• Main memory and the registers built into processing core are the only general-purpose storage that the CPU can
access directly.
• Registers that are built into each CPU core are generally accessible within one cycle of the CPU clock.
• Not only are we concerned with the relative speed of accessing physical memory, but we also must ensure
correct operation. For proper system operation, we must protect the operating system from access by user
processes, as well as protect user processes from one another. This protection must be provided by the
hardware, because the operating system doesn’t usually intervene between the CPU and its memory accesses
(because of the resulting performance penalty). Hardware implements this production in several different ways.
The base register holds the smallest legal physical memory address;
the limit register specifies the size of the range.
• Protection of memory space is accomplished by having the CPU hardware compare every address generated in
user mode the registers. Any attempt by a program executing in user mode to access operating-system memory
or other users’ memory results in a trap to the operating system, which treats the attempt as a fatal error.
• This scheme prevents a user program from (accidentally or deliberately) modifying the code or data structures of
either the operating system or other users.
• The base and limit registers can be loaded only by the operating system, which uses a special privileged
instruction.
• Since privileged instruction can be executed only in kernel mode, and since the operating system executes in
kernel mode, only the operating system can load the mase and limit registers.
• This scheme allows the operating system to change the value of the registers but prevents user program from
changing the registers’ contents.
• The operating system, executing in kernel mode, is given unrestricted access to both operating-system memory
and users’ memory.
• This provision allows the operating system to load users’ programs into users’ memory, to dump out those
programs in case of errors, to access and modify parameters of system calls, to perform I/O to and from user
memory, and to provide many other services.
Address Binding
• The operating system, executing in kernel mode, is given unrestricted access to both operating-system
memory and users’ memory.
• This provision allows the operating system to load users’ programs into users’ memory, to dump out those
programs in case of errors, to access and memory, and to provide many other services.
Classically, the binding of instructions and data to memory addresses can be done at any step along the way:
• Compile time. If you know at compile time where the process will reside in memory, then absolute code can be
generated. For example, if you know that a user process will reside starting at location R, then the generated
compiler code will start at that location and extend up from there. If, at some later time, the starting location
changes, then it will be necessary to recompile this code.
• Load time. If it is not known at compile time where the process will reside in memory, then the compiler must
generate relocatable code. In this case, final binding is delayed until load time. If the starting address changes,
we need only reload the user code to incorporate this changed value.
• Execution time. If the process can be moved during its execution from one memory segment to another, then
binding must be delayed until run time. Special hardware must be available for this scheme to work. Most
operating systems use this method.
• The process address space is the set of logical addresses that a process references in its code.
• 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:
• Symbolic addresses
o The addresses used in a source code. The variable names, constants, and instruction labels are the basic
elements of the symbolic address space.
• Relative addresses
o At the time of compilation, a compiler converts symbolic addresses into relative addresses.
• Physical addresses
o 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.
• An address generated by the CPU is commonly referred to as a logical address, whereas an address seen by the
memory unit- that is, the one loaded into the memory-address register of the memory-is commonly referred to
as a physical address.
• Binding addresses at either compile or load time generates identical logical and physical addresses.
• The execution-time address-binding scheme results in differing logical and physical addresses. In this case, we
usually refer to the logical address as a virtual address. We use logical address and virtual address
interchangeable in this text.
o The set of all logical addresses generated by a program is a logical address space.
o The set of all physical addresses corresponding to these logical addresses is a physical address space.
Thus, in the execution-time address-binding scheme, the logical and physical address spaces differ.
• 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.
o The value in the base register is added to every address generated by a use 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.
o The user program deals with virtual addresses; it never sees the real physical addresses.
• 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 program 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.
Dynamic Loading
• With dynamic loading, a routine is not loaded until it is called. All routines are kept on disk in a relocatable load
format.
• The main program is loaded into memory and is executed. When a routine needs to call another routine, the
calling routine first checks to see whether the other routine has been loaded. If it has not, the relocatable linking
loader is called to load the desired routine into memory and to update the program’s address tables to reflect
this change. Then control is passed to the newly loaded routine.
• The advantage of dynamic loading is that a routine is loaded only when it is needed. This method is particularly
useful when large amounts of code are needed to handle infrequently occurring cases, such as error routines. In
such a situation, although the total program size may be large, the portion that is used (and hence loaded) may
be much smaller. Dynamic loading does not require special support from the operating system. It us the
responsibility of the users to design their programs to providing library routines implement dynamic loading.
• As explained, 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.
Memory Allocation
Fragmentation
• as process are loaded and removed from memory, the free memory space is broken into little pieces. It happens
after sometimes that process cannot be allocated to memory blocks considering their small size and memory
blocks remains unused. This problem is known as fragmentation.
• External fragmentation
o 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.
• Internal fragmentation
o Memory block assigned to process is bigger. Some portion of memory is left unused, as it cannot be used
by another process.
• 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.
Address translation
• Page address is called logical address and represented by page number and the offset.
• Frame address is called physical address and represented by a frame number and the offset.
• 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.
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.
VIRTUAL MEMORY
• 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 disk that's set up to emulate the computer's RAM.
• The main visible advantage of this scheme is that programs can be larger than physical memory. Virtual memory
serves two purposes. First, it allows us to extend the use of physical memory by using disk. Second, it allows us
to have memory protection, because each virtual address is translated to a physical address.
Following are the situations, when entire program is not required to be loaded fully in main memory.
• User written error handling routines are used only when an error occurred in the data or computation.
• Certain options and features of a program may be used rarely.
• Many tables are assigned a fixed amount of address space even though only a small amount of the table is
actually used.
• The ability to execute a program that is only partially in memory would counter many benefits.
• Less number of I/O would be needed to load or swap each user program into memory.
• A program would no longer be constrained by the amount of physical memory that is available.
• Each user program could take less physical memory, more programs could be run the same time, with a
corresponding increase in CPU utilization and throughput.
• 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.
Advantages
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 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 of number 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
• 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.