Download File - ashish b. khare

UNIT- IV
1. Memory management
Memory management is the act of managing computer memory. The essential requirement of
memory management is to provide ways to dynamically allocate portions of memory to
programs at their request, and freeing it for reuse when no longer needed. This is critical to
the computer system.
Several methods have been devised that increase the effectiveness of memory management.
Virtual memory systems separate the memory addresses used by a process from actual
physical addresses, allowing separation of processes and increasing the effectively available
amount of RAM using paging or swapping to secondary storage. The quality of the virtual
memory manager can have a big impact on overall system performance.
1.1 Systems with virtual memory
Virtual memory is a method of decoupling the memory organisation from the actual physical
hardware. The applications operate memory via virtual addresses. Each time an attempt to
access the actual data is made; virtual memory subsystem translates the virtual address to a
physical address, which corresponds to the address of the data as seen by the hardware. The
address translation process itself is managed by the operating system. In this way addition of
virtual memory enables granular control over the main memory and ways to access it. This
can be used to increase the effectiveness of memory management.
Protection
In virtual memory systems the operating system controls the ways a process can access the
memory. This feature can be used to disallow a process to read or write to memory that is not
allocated to the said process, essentially prevents malicious or malfunctioning code in one
program from interfering with the operation of other running programs.
Sharing
Even though the memory for different processes is normally protected from each other,
different processes sometimes need to be able to share information. One way to provide this
is to allow the processes to access the same part of memory. Shared memory is one of the
fastest techniques for Inter-process communication.
Physical organization
Memory is usually divided into fast primary storage and slow secondary storage. Memory
management in the operating system handles moving information between these two levels of
memory.
2. Paging
In computer operating systems, paging is one of the memory-management schemes by which
a computer can store and retrieve data from secondary storage for use in main memory. In the
paging memory-management scheme, the operating system retrieves data from secondary
storage in same-size blocks called pages. The main advantage of paging over memory
segmentation is that it allows the physical address space of a process to be non-contiguous.
Before the time paging was used, systems had to fit whole programs into storage
contiguously, which caused various storage and fragmentation problems.
Paging is an important part of virtual memory implementation in most contemporary generalpurpose operating systems, allowing them to use disk storage for data that does not fit into
physical random-access memory (RAM).
2.1 Overview
The main functions of paging are performed when a program tries to access pages that are not
currently mapped to physical memory (RAM). This situation is known as a page fault. The
operating system must then take control and handle the page fault, in a manner invisible to
the program. Therefore, the operating system must:
1.
2.
3.
4.
5.
Determine the location of the data in auxiliary storage.
Obtain an empty page frame in RAM to use as a container for the data.
Load the requested data into the available page frame.
Update the page table to show the new data.
Return control to the program, transparently retrying the instruction that caused the
page fault.
Until there is not enough RAM to store all the data needed, the process of obtaining an empty
page frame does not involve removing another page from RAM. If all page frames are nonempty, obtaining an empty page frame requires choosing a page frame containing data to
empty. If the data in that page frame has been modified since it was read into RAM (i.e., if it
has become "dirty"), it must be written back to its location in secondary storage before being
freed; otherwise, the contents of the page's page frame in RAM are the same as the contents
of the page in secondary storage, so it does not need to be written back to secondary storage.
If a reference is then made to that page, a page fault will occur, and an empty page frame
must be obtained and the contents of the page in secondary storage again read into that page
frame.
Efficient paging systems must determine the page frame to empty by choosing one that is
least likely to be needed within a short time. There are various page replacement algorithms
that try to do this. Most operating systems use some approximation of the least recently used
(LRU) page replacement algorithm (the LRU itself cannot be implemented on the current
hardware) or a working set-based algorithm.
To further increase responsiveness, paging systems may employ various strategies to predict
which pages will be needed soon. Such systems will attempt to load pages into main memory
preemptively, before a program references them.
2.2 Demand paging
In computer operating systems, demand paging (as opposed to anticipatory paging) is an
application of virtual memory. In a system that uses demand paging, the operating system
copies a disk page into physical memory only if an attempt is made to access it (i.e., if a page
fault occurs). It follows that a process begins execution with none of its pages in physical
memory, and many page faults will occur until most of a process's working set of pages is
located in physical memory. This is an example of lazy loading techniques.
Advantages
Demand paging, as opposed to loading all pages immediately:



Only loads pages that are demanded by the executing process.
As there is more space in main memory, more processes can be loaded reducing
context switching time which utilizes large amounts of resources.
Less loading latency occurs at program startup, as less information is accessed from
secondary storage and less information is brought into main memory.
Disadvantages




Individual programs face extra latency when they access a page for the first time. So
demand paging may have lower performance than anticipatory paging algorithms.
Programs running on low-cost, low-power embedded systems may not have a
memory management unit that supports page replacement.
Memory management with page replacement algorithms becomes slightly more
complex.
Possible security risks, including vulnerability to timing attacks;
Basic concept
Demand paging follows that pages should only be brought into memory if the executing
process demands them. This is often referred to as lazy evaluation as only those pages
demanded by the process are swapped from secondary storage to main memory. Contrast this
to pure swapping, where all memory for a process is swapped from secondary storage to main
memory during the process startup.
When a process is to be swapped into main memory for processing, the pager guesses which
pages will be used prior to the process being swapped out again. The pager will only load
these pages into memory. This process avoids loading pages that are unlikely to be used and
focuses on pages needed during the current process execution period. Therefore, not only is
unnecessary page load during swapping avoided but we also try to preempt which pages will
be needed and avoid loading pages during execution.
Commonly, to achieve this process a page table implementation is used. The page table maps
logical memory to physical memory. The page table uses a bitwise operator to mark if a page
is valid or invalid. A valid page is one that currently resides in main memory. An invalid
page is one that currently resides in secondary memory. When a process tries to access a
page, the following steps are generally followed:




Attempt to access page.
If page is valid (in memory) then continue processing instruction as normal.
If page is invalid then a page-fault trap occurs.
Check if the memory reference is a valid reference to a location on secondary
memory. If not, the process is terminated (illegal memory access). Otherwise, we
have to page in the required page.


Schedule disk operation to read the desired page into main memory.
Restart the instruction that was interrupted by the operating system trap.
3. Page fault
A page fault is a trap to the software raised by the hardware when a program accesses a page
that is mapped in the virtual address space, but not loaded in physical memory. In the typical
case the operating system tries to handle the page fault by making the required page
accessible at a location in physical memory or kills the program in the case of an illegal
access. The hardware that detects a page fault is the memory management unit in a processor.
The exception handling software that handles the page fault is generally part of the operating
system.
Contrary to what the name 'page fault' might suggest, page faults are not errors and are
common and necessary to increase the amount of memory available to programs in any
operating system that utilizes virtual memory, including Microsoft Windows, Unix-like
systems (including Mac OS X, Linux, *BSD, Solaris, AIX, and HP-UX), and z/OS.
Microsoft uses the term hard fault in more recent versions of the Resource Monitor (e.g.,
Windows Vista) to mean 'page fault'.
3.1 Page replacement algorithm
The most important aspect of paging is that pages can still be accessed even though they are
physically in secondary storage (the disk). Suppose a page fault occurs and there are no free
frames into which the relevant data can be loaded. Then the OS must select a victim: it must
choose a frame and free it so that the new faulted page can be read in. This is called
(obviously) page replacement. The success or failure of virtual memory rest on its ability to
make page replacement decisions. Certain facts might influence these algorithms. For
instance, if a process is receiving I/O from a device, it would be foolish to page it out - so it
would probably I/O locked into RAM. Here are some viable alternatives for page
replacement.
FIFO: first in first out
The simplest way of replacing frames is to keep track of their age (by storing their age in the
frame table). This could either be the date, as recorded by the system clock, or a sequential
counter. When a new page fault occurs, we can load in pages until the physical memory is
full - thereafter, we have to move out pages. The page which has been in memory longest is
then selected as the first to go.
This algorithm has the advantage of being very straightforward, but its performance can
suffer if a page is in heavy use for a long period of time. Such a page would be selected even
though it was still in heavy use.
LRU: Least recently used
The best possible solution to paging would be to replace the page that will not be used for the
longest period of time - but unfortunately, the system has no way of knowing what that is. A
kind of compromise solution is to replace the page which has not been used for the longest
period. This does not require a crystal ball, but it does require some appropriate hardware
support to make it worthwhile. As with all good ideas, it costs the system quite a lot to
implement it.
4. THRASHING
Swapping and paging can lead to quite a large system overhead. Compared to memory
speeds, disk access is quite slow - and, in spite of optimized disk access for the swap area,
these operations delay the system markedly. Consider the sequence of events which takes
place when a page fault occurs:
1.
2.
3.
4.
5.
6.
Interrupt / trap and pass control to the system interrupt handler.
Save the process control block.
Determine cause of interrupt - a page fault.
Consult MMU - is the logical address given inside the process' segment i.e. legal?
Look for a free frame in the frame table. If none is found, free one.
Schedule the disk operation to copy the required page and put the process into the
waiting state.
7. Interrupt from disk signals end of waiting.
8. Update the page table and schedule the process for running.
9. (On scheduling) restore the process control block and resume executing the
instruction that was interrupted.
Such a sequence of operations could take of the order or milliseconds under favourable
conditions (although technology is rapidly reducing the timescale for everything). It is
possible for the system to get into a state where there are so many processes competing for
limited resources that it spends more time servicing page faults and swapping in and out
processes than it does executing the processes. This sorry state is called thrashing.
Thrashing can occur when there are too many active processes for the available memory. It
can be alleviated in certain cases by making the system page at an earlier threshold of
memory usage than normal. In most cases, the best way to recover from thrashing is to
suspend processes and forbid new ones, to try to clear some of the others by allowing them to
execute. The interplay between swapping and paging is important here too, since swapping
effectively suspends jobs.