BCS303 VTU OS Notes Module 4
BCS303 VTU OS Notes Module 4
1
Operating Systems BCS303
MODULE 4
MEMORY MANAGEMENT
Basic Hardware
Main memory, cache and CPU registers in the processors are the only storage spaces that
CPU can access directly.
The program and data must be bought into the memory from the disk, for the process to
run. Each process has a separate memory space and must access only this range of legal
addresses. Protection of memory is required to ensure correct operation. This prevention
is provided by hardware implementation.
Two registers are used - a base register and a limit register. The base register holds the
smallest legal physical memory address; the limit register specifies the size of the range.
For example, The base register holds the smallest legal physical memory address; the limit
register specifies the size of the range. For example, if the base register holds 300040 and
limit register is 120900, then the program can legally access all addresses from 300040
through 420940 (inclusive).
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 only the operating system can load the base and limit registers.
2
Operating Systems BCS303
Address Binding
User programs typically refer to memory addresses with symbolic names. These symbolic
names must be mapped or bound to physical memory addresses.
Address binding of instructions to memory-addresses can happen at 3 different stages.
1. Compile Time - If it is known at compile time where a program will reside in physical
memory, then absolute code can be generated by the compiler, containing actual physical
addresses. However, if the load address changes at some later time, then the program will
have to be recompiled.
2. Load Time - If the location at which a program will be loaded is not known at compile
time, then the compiler must generate relocatable code, which references addresses
relative to the start of the program. If that starting address changes, then the program must
be reloaded but not recompiled.
3. Execution Time - If a program can be moved around in memory during the course of its
execution, then binding must be delayed until execution time.
3
Operating Systems BCS303
The address generated by the CPU is a logical address, whereas the memory address
where programs are actually stored is a physical address.
The set of all logical addresses used by a program composes the logical address space,
and the set of all corresponding physical addresses composes the physical address space.
The run time mapping of logical to physical addresses is handled by the memory-
management unit (MMU).
One of the simplest is a modification of the base-register scheme.
The base register is termed a relocation register
The value in the relocation-register is added to every address generated by a
user-process at the time it is sent to memory.
The user-program deals with logical-addresses; it never sees the real physical-
addresses.
4
Operating Systems BCS303
Dynamic Loading
This can be used to obtain better memory-space utilization.
A routine is not loaded until it is called.
Advantages:
1. An unused routine is never loaded.
2. Useful when large amounts of code are needed to handle infrequently occurring cases.
3. Although the total program-size may be large, the portion that is used (and hence loaded)
may be much smaller.
4. Does not require special support from the OS.
With static linking library modules get fully included in executable modules, wasting
both disk space and main memory usage, because every program that included a certain
routine from the library would have to have their own copy of that routine linked into their
executable code.
With dynamic linking, however, only a stub is linked into the executable module,
containing references to the actual library module linked in at run time.
The stub is a small piece of code used to locate the appropriate memory-resident
library-routine.
This method saves disk space, because the library routines do not need to be fully
included in the executable modules, only the stubs.
An added benefit of dynamically linked libraries (DLLs, also known as shared
libraries or shared objects on UNIX systems) involves easy upgrades and updates.
Shared libraries
A library may be replaced by a new version, and all programs that reference the library
will automatically use the new one.
Version info. is included in both program & library so that programs won't accidentally
execute incompatible versions.
5
Operating Systems BCS303
Swapping
Major part of swap-time is transfer-time; i.e. total transfer-time is directly proportional to the
amount of memory swapped.
Disadvantages:
1. Context-switch time is fairly high.
2. If we want to swap a process, we must be sure that it is completely idle.
Two solutions:
i) Never swap a process with pending I/O.
ii) Execute I/O operations only into OS buffers.
6
Operating Systems BCS303
Example:
Assume that the user process is 10 MB in size and the backing store is a standard hard disk with
a transfer rate of 40 MB per second.
The actual transfer of the 10-MB process to or from main memory takes
10000 KB/40000 KB per second = 1/4 second
= 250 milliseconds.
Assuming that no head seeks are necessary, and assuming an average latency of 8 milliseconds,
the swap time is 258 milliseconds. Since we must both swap out and swap in, the total swap time
is about 516 milliseconds.
The main memory must accommodate both the operating system and the various user
processes. Therefore we need to allocate the parts of the main memory in the most efficient
way possible.
Memory is usually divided into 2 partitions: One for the resident OS. One for the user
processes.
Each process is contained in a single contiguous section of memory.
7
Operating Systems BCS303
2. Memory Allocation
1. Fixed-sized Partitioning
2. Variable-sized Partitioning
The OS keeps a table indicating which parts of memory are available and which parts are
occupied.
A hole is a block of available memory. Normally, memory contains a set of holes of
various sizes.
Initially, all memory is available for user-processes and considered one large hole.
When a process arrives, the process is allocated memory from a large hole.
If we find the hole, we allocate only as much memory as is needed and keep the
remaining memory available to satisfy future requests.
8
Operating Systems BCS303
Three strategies used to select a free hole from the set of available holes:
1. First Fit: Allocate the first hole that is big enough. Searching can start either at the
beginning of the set of holes or at the location where the previous first-fit search ended.
2. Best Fit: Allocate the smallest hole that is big enough. We must search the entire list,
unless the list is ordered by size. This strategy produces the smallest leftover hole.
3. Worst Fit: Allocate the largest hole. Again, we must search the entire list, unless it is
sorted by size. This strategy produces the largest leftover hole.
First-fit and best fit are better than worst fit in terms of decreasing time and storage utilization.
3. Fragmentation
1. Internal Fragmentation
The general approach is to break the physical-memory into fixed-sized blocks and
allocate memory in units based on block size.
The allocated-memory to a process may be slightly larger than the requested-memory.
The difference between requested-memory and allocated-memory is called internal
fragmentation i.e. Unused memory that is internal to a partition.
2. External Fragmentation
External fragmentation occurs when there is enough total memory-space to satisfy a
request but the available-spaces are not contiguous. (i.e. storage is fragmented into a
large number of small holes).
Both the first-fit and best-fit strategies for memory-allocation suffer from external
fragmentation.
Statistical analysis of first-fit reveals that given N allocated blocks, another 0.5 N blocks
will be lost to fragmentation. This property is known as the 50-percent rule.
9
Operating Systems BCS303
Paging
The basic method for implementing paging involves breaking physical memory into fixed-
sized blocks called frames and breaking logical memory into blocks of the same size called
pages.
When a process is to be executed, its pages are loaded into any available memory frames
from the backing store.
The backing store is divided into fixed-sized blocks that are of the same size as the memory
frames.
10
Operating Systems BCS303
The page size (like the frame size) is defined by the hardware.
The size of a page is typically a power of 2, varying between 512 bytes and 16 MB per
page, depending on the computer architecture.
The selection of a power of 2 as a page size makes the translation of a logical address into
a page number and page offset.
If the size of logical address space is 2m and a page size is 2n addressing units (bytes or
words), then the high-order m – n bits of a logical address designate the page number, and
the n low-order bits designate the page offset.
When a process requests memory (e.g. when its code is loaded in from disk), free frames
are allocated from a free-frame list, and inserted into that process's page table.
Processes are blocked from accessing anyone else's memory because all of their memory
requests are mapped through their page table. There is no way for them to generate an
address that maps into any other process's memory space.
The operating system must keep track of each individual process's page table, updating it
whenever the process's pages get moved in and out of memory, and applying the correct
page table when processing system calls for a particular process. This all increases the
overhead involved when swapping processes in and out of the CPU.
11
Operating Systems BCS303
Figure: Free frames (a) before allocation and (b) after allocation.
Hardware Support
A special, small, fast lookup hardware cache, called a translation look-aside buffer
(TLB).
Each entry in the TLB consists of two parts: a key (or tag) and a value.
When the associative memory is presented with an item, the item is compared with all
keys simultaneously. If the item is found, the corresponding value field is returned. The
search is fast; the hardware, however, is expensive. Typically, the number of entries in a
TLB is small, often numbering between 64 and 1,024.
The TLB contains only a few of the page-table entries.
Working:
When a logical-address is generated by the CPU, its page-number is presented to the
TLB.
If the page-number is found (TLB hit), its frame-number is immediately available and
used to access memory
If page-number is not in TLB (TLB miss), a memory-reference to page table must be
made. The obtained frame-number can be used to access memory (Figure 1)
12
Operating Systems BCS303
In addition, we add the page-number and frame-number to the TLB, so that they will be
found quickly on the next reference.
If the TLB is already full of entries, the OS must select one for replacement.
Percentage of times that a particular page-number is found in the TLB is called hit ratio.
Protection
13
Operating Systems BCS303
Shared Pages
Disadvantage:
Systems that use inverted page-tables have difficulty implementing shared-memory.
14
Operating Systems BCS303
1. Hierarchical Paging
Problem: Most computers support a large logical-address space (232 to 264). In these
systems, the page-table itself becomes excessively large.
Solution: Divide the page-table into smaller pieces.
15
Operating Systems BCS303
where p1 is an index into the outer page table, and p2 is the displacement within the
page of the inner page table
The address-translation method for this architecture is shown in below figure. Because address
translation works from the outer page table inward, this scheme is also known as a forward-
mapped page table.
16
Operating Systems BCS303
17
Operating Systems BCS303
Advantage:
1. Decreases memory needed to store each page-table
Disadvantages:
1. Increases amount of time needed to search table when a page reference occurs.
2. Difficulty implementing shared-memory
Segmentation
18
Operating Systems BCS303
VIRTUAL MEMORYMANAGEMENT
Virtual memory is a technique that allows for the execution of partially loaded process.
Advantages:
A program will not be limited by the amount of physical memory that is available
user can able to write in to large virtual space.
Since each program takes less amount of physical memory, more than one program
could be run at the same time which can increase the throughput and CPU
utilization.
Less i/o operation is needed to swap or load user program in to memory. So each
user program could run faster.
Virtual memory is the separation of users logical memory from physical memory. This
separation allows an extremely large virtual memory to be provided when these is less
physical memory.
Separating logical memory from physical memory also allows files and memory to be
shared by several different processes through page sharing.
20
Operating Systems BCS303
DEMAND PAGING
A demand paging is similar to paging system with swapping when we want to execute a
process we swap the process the in to memory otherwise it will not be loaded in to
memory.
A swapper manipulates the entire processes, where as a pager manipulates individual
pages of the process.
Bring a page into memory only when it is needed
Less I/O needed
Less memory needed
Faster response
21
Operating Systems BCS303
More users
Page is needed ⇒ reference to it
invalid reference ⇒abort
not-in-memory ⇒ bring to memory
Lazy swapper– never swaps a page into memory unless page will be needed
Swapper that deals with pages is a pager.
Basic concept: Instead of swapping the whole process the pager swaps only the necessary pages
in to memory. Thus it avoids reading unused pages and decreases the swap time and amount of
physical memory needed.
The valid-invalid bit scheme can be used to distinguish between the pages that are on the disk
and that are in memory.
With each page table entry a valid–invalid bit is associated
(v ⇒ in-memory, i⇒not-in-memory)
Initially valid–invalid bit is set to ion all entries
Example of a page table snapshot:
During address translation, if valid–invalid bit in page table entry is I ⇒ page fault.
If the bit is valid then the page is both legal and is in memory.
If the bit is invalid then either page is not valid or is valid but is currently on the disk. Marking
22
Operating Systems BCS303
a page as invalid will have no effect if the processes never access to that page. Suppose if it
access the page which is marked invalid, causes a page fault trap. This may result in failure of
OS to bring the desired page in to memory.
Fig: Page Table when some pages are not in main memory
Page Fault
If a page is needed that was not originally loaded up, then a page fault trap is generated.
Steps in Handling a Page Fault
1. The memory address requested is first checked, to make sure it was a valid memory
request.
2. If the reference is to an invalid page, the process is terminated. Otherwise, if the page is
not present in memory, it must be paged in.
3. A free frame is located, possibly from a free-frame list.
4. A disk operation is scheduled to bring in the necessary page from disk.
5. After the page is loaded to memory, the process's page table is updated with the new frame
number, and the invalid bit is changed to indicate that this is now a valid page reference.
6. The instruction that caused the page fault must now be restarted from the beginning.
23
Operating Systems BCS303
Pure Demand Paging: Never bring a page into main memory until it is required.
We can start executing a process without loading any of its pages into main memory.
Page fault occurs for the non memory resident pages.
After the page is brought into memory, process continues to execute.
Again page fault occurs for the next page.
Hardware support: For demand paging the same hardware is required as paging and swapping.
1. Page table:-Has the ability to mark an entry invalid through valid-invalid bit.
2. Secondary memory:-This holds the pages that are not present in main memory.
Performance of Demand Paging: Demand paging can have significant effect on the performance
of the computer system.
Let P be the probability of the page fault (0<=P<=1)
Effective access time = (1-P) * ma + P * page fault.
Where P = page fault and ma = memory access time.
Effective access time is directly proportional to page fault rate. It is important to keep page
fault rate low in demand paging.
24
Operating Systems BCS303
COPY-ON-WRITE
Technique initially allows the parent and the child to share the same pages. These pages
are marked as copy on- write pages i.e., if either process writes to a shared page,a copy
of shared page is created.
Eg:-If a child process try to modify a page containing portions of the stack; the OS
recognizes them as a copy-on-write page and create a copy of this page and maps it on
to the address space of the child process. So the child process will modify its copied page
and not the page belonging to parent. The new pages are obtained from the poolof free
pages.
The previous contents of pages are erased before getting them into main memory. This
is called Zero – on fill demand.
25
Operating Systems BCS303
PAGE REPLACEMENT
Page replacement policy deals with the solution of pages in memory to be replaced by a new
page that must be brought in. When a user process is executing a page fault occurs.
The hardware traps to the operating system, which checks the internal table to see that this
is a page fault and not an illegal memory access.
The operating system determines where the derived page is residing on the disk, and this finds
that there are no free frames on the list of free frames.
When all the frames are in main memory, it is necessary to bring a new page to satisfy the
page fault, replacement policy is concerned with selecting a page currently in memory to be
replaced.
The page i,e to be removed should be the page i,e least likely to be referenced in future.
Victim Page
The page that is supported out of physical memory is called victim page.
If no frames are free, the two page transforms come (out and one in) are read. This will see
the effective access time.
Each page or frame may have a dirty (modify) bit associated with the hardware. The
modify bit for a page is set by the hardware whenever any word or byte in the page is
26
Operating Systems BCS303
FIFO Algorithm:
This is the simplest page replacement algorithm. A FIFO replacement algorithm associates
each page the time when that page was brought into memory.
When a Page is to be replaced the oldest one is selected.
We replace the queue at the head of the queue. When a page is brought into memory, we
insert it at the tail of the queue.
In the following example, a reference string is given and there are 3 free frames. There are
20 page requests, which results in 15 page faults
27
Operating Systems BCS303
Belady’s Anomaly
For some page replacement algorithm, the page fault may increase as the number of
allocated frames increases. FIFO replacement algorithm may face this problem.
more frames ⇒ more page faults
Example: Consider the following references string with frames initially empty.
The first three references (7,0,1) cases page faults and are brought into the empty frames.
The next references 2 replaces page 7 because the page 7 was brought in first. x Since 0 is
the next references and 0 is already in memory e has no page faults.
The next references 3 results in page 0 being replaced so that the next references to 0
causer page fault. This will continue till the end of string. There are 15 faults all together.
28
Operating Systems BCS303
Optimal Algorithm
Optimal page replacement algorithm is mainly to solve the problem of Belady’s Anomaly.
Optimal page replacement algorithm has the lowest page fault rate of all algorithms.
An optimal page replacement algorithm exists and has been called OPT.
The working is simple “Replace the page that will not be used for the longest period of time”
Example: consider the following reference string
The first three references cause faults that fill the three empty frames.
The references to page 2 replaces page 7, because 7 will not be used until reference 18. x
The page 0 will be used at 5 and page 1 at 14.
With only 9 page faults, optimal replacement is much better than a FIFO, which had 15
faults. This algorithm is difficult t implement because it requires future knowledge of
reference strings.
Replace page that will not be used for longest period of time
The main problem to how to implement LRU is the LRU requires additional h/w assistance.
29
Operating Systems BCS303
Note: Neither optimal replacement nor LRU replacement suffers from Belady’s Anamoly. These are
called stack algorithms.
30
Operating Systems BCS303
If the reference bitvalueis‘1’, then the page is given a second chance and its reference bit
value is cleared (assigned as‘0’).
Thus, a page that is given a second chance will not be replaced until all other pages have
been replaced (or given second chances). In addition, if a page is used often, then it sets
its reference bit again.
This algorithm is also known as the clock algorithm.
31
Operating Systems BCS303
This algorithm suffers from the situation in which a page is used heavily during the initial
phase of a process but never used again. Since it was used heavily, it has a large count
and remains in memory even though it is no longer needed.
b)MFU Algorithm:
based on the argument that the page with the smallest count was probably just brought in
and has yet to be used
ALLOCATION OF FRAMES
The absolute minimum number of frames that a process must be allocated is dependent
on system architecture.
The maximum number is defined by the amount of available physical memory.
Allocation Algorithms
After loading of OS, there are two ways in which the allocation of frames can be done to
the processes.
Equal Allocation- If there are m frames available and n processes to share them, each
process gets m / n frames, and the left over’s are kept in a free-frame buffer pool.
Proportional Allocation - Allocate the frames proportionally depending on the size of
the process. If the size of process i is Si, and S is the sum of size of all processes in the
system, then the allocation for process Pi is ai= m * Si/ S. where m is the free frames
available in the system.
Consider a system with a 1KB frame size. If a small student process of 10 KB and an
interactive database of 127 KB are the only two processes running in a system with 62
free frames.
with proportional allocation, we would split 62 frames between two processes, asfollows
m=62, S = (10+127)=137
Allocation for process 1 = 62 X 10/137 ~ 4 Allocation for process 2 = 62 X
127/137 ~57
Thus allocates 4 frames and 57 frames to student process and database
respectively.
Variations on proportional allocation could consider priority of process rather than just
their size.
Global versus Local Allocation
Page replacement can occur both at local or global level.
With local replacement, the number of pages allocated to a process is fixed, and page
replacement occurs only amongst the pages allocated to this process.
With global replacement, any page may be a potential victim, whether it currently belongs
to the process seeking a free frame or not.
Local page replacement allows processes to better control their own page fault rates, and
leads to more consistent performance of a given process over different system load levels.
32
Operating Systems BCS303
Global page replacement is over all more efficient, and is the more commonly used
approach.
THRASHING
If the number of frames allocated to a low-priority process falls below the minimum
number required by the computer architecture then we suspend the process execution.
A process is thrashing if it is spending more time in paging than executing.
If the processes do not have enough number of frames, it will quickly page fault. During
this it must replace some page that is not currently in use. Consequently it quickly faults
again and again.
The process continues to fault, replacing pages for which it then faults and brings back.
This high paging activity is called thrashing. The phenomenon of excessively moving
pages back and forth b/w memory and secondary has been called thrashing.
Cause of Thrashing
Thrashing results in severe performance problem.
The operating system monitors the cpu utilization is low. We increase the degree of
multi programming by introducing new process to the system.
A global page replacement algorithm replaces pages with no regards to the process to
which they belong.
33
Operating Systems BCS303
reached. If the degree of multi programming is increased further thrashing sets in and
the cpu utilization drops sharply.
At this point, to increases CPU utilization and stop thrashing, we must increase degree
of multiprogramming.
we can limit the effect of thrashing by using a local replacement algorithm. To prevent
thrashing, we must provide a process as many frames as it needs.
Locality of Reference:
As the process executes it moves from locality to locality.
A locality is a set of pages that are actively used.
A program may consist of several different localities, which may overlap.
Locality is caused by loops in code that find to reference arrays and other data
structures by indices.
The ordered list of page number accessed by a program is called reference string.
Locality is of two types :
1. spatial locality 2. temporal locality
34
Operating Systems BCS303
Page-Fault Frequency
When page- fault rate is too high, the process needs more frames and when it is too low,
the process may have too many frames.
The upper and lower bounds can be established on the page-fault rate. If the actual
page- fault rate exceeds the upper limit, allocate the process another frame or suspend the
process.
If the page-fault rate falls below the lower limit, remove a frame from the process. Thus,
we can directly measure and control the page-fault rate to prevent thrashing.
35
Operating Systems BCS303
QUESTION BANK
2. For the following page reference string 1,2,3,4,1,2,5,1,2,3,4,5. Calculate the page faults
using FIFO, Optimal and LRU using 3. Which algorithm is most significant?
MEMORY MANAGEMENT
36