OPERATING

SYSTEM
TUESDAY AND THURSDAY
5:30-7:00 PM
 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 decides which process will get memory at what time.
• It tracks whenever some memory gets freed or unallocated and correspondingly it
updates the status.
Memory

• Memory is central to the operation of a modern computer system.

• Memory consists of a large array of bytes, each with its own address.
• The CPU fetches instructions from memory according to the value of the
program counter.
Basic Hardware
• Main memory and the registers built into each 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.
Each process has a separate memory space.
Separate per-process memory space protects the
processes from each other and is fundamental to
having multiple processes loaded in memory for
concurrent execution.
To separate memory spaces, we need the ability to
determine the range of legal addresses that the
process may access and to ensure that the process
can access only these legal addresses.
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 with 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 instructions can be executed only in kernel mode, and since only
the operating system executes in kernel mode, only the operating system can load
the base and limit registers.
• This scheme allows the operating system to change the value of the registers but
prevents user programs 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
modify parameters of system calls, to perform I/O to and from user
memory, and to provide many other services.
Addresses may be represented in different
ways during these steps.
Addresses in the source program are
generally symbolic (such as the variable
count).
A compiler typically binds these symbolic
addresses to relocatable addresses.
The linker or loader in turn binds the
relocatable addresses to absolute addresses
(such as 74014). Each binding is a mapping
from one address space to another.
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.
 Process Address Space
• 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
• 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
• At the time of compilation, a compiler converts symbolic addresses into relative addresses.
• 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.
 Logical Versus 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 interchangeably in this text.
• The set of all logical addresses generated by a program is a logical address space.
• 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 run-time mapping from virtual to physical
addresses is done by a hardware device called
the Memory-Management Unit (MMU).

The value in the relocation register (base

register) is added to every address generated by
a user process at the time the address is sent to
memory.
• 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.
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 is the responsibility of the users to design their programs to
take advantage of such a method. Operating systems may help the programmer, however, by
providing library routines to implement dynamic loading.
 Static vs Dynamic Linking
• 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
• 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.
• 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.
• 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 −
• 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.
• 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.
 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.
 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.
• Modern microprocessors
intended for general-purpose
use, a memory management
unit, or MMU, is built into the
hardware. The MMU's job is to
translate virtual addresses into
physical addresses. A basic
example is given.
• Virtual memory is commonly
implemented by demand paging.
It can also be implemented in a
segmentation system. Demand
segmentation can also be used
to provide virtual memory.
 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.
 PAGE FAULT RATE

0 0 0 0 4 4 4 4 4 4 2 2
2 2 2 2 0 0 0 0 0 0 0
1 1 1 1 1 1 3 3 3 3
6 6 6 6 6 6 1 1 1
X X X X X X H H X X X H
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.
0 2 1 6 4 0 1 0 3 1 2 1
0 0 0 0 0 0 0 0 3 3 3 3
2 2 2 2 2 2 2 2 2 2 2
1 1 1 1 1 1 1 1 1 1
6 4 4 4 4 4 4 4 4
X X X X X H H H X H H H
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.
0 2 1 6 4 0 1 0 3 1 2 1
0 0 0 0 4 4 4 4 4 4 2 2
2 2 2 2 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 1
6 6 6 6 6 3 3 3 3
X X X X X X H H X H X H
 Page Buffering algorithm
• To get a process start quickly, keep a pool of free frames.
• On page fault, select a page to be replaced.
• Write the new page in the frame of free pool, mark the page table and restart
the process.
• Now write the dirty page out of disk and place the frame holding replaced
page in free pool.
• Least frequently Used(LFU) algorithm
• The page with the smallest count is the one which will be selected for replacement.
• This algorithm suffers from the situation in which a page is used heavily during the
initial phase of a process, but then is never used again.
• Most frequently Used(MFU) algorithm
• This algorithm is based on the argument that the page with the smallest count was
probably just brought in and has yet to be used.