CHAPTER 8 : VIRTUAL MEMORY. Introduction

Transcription

1 CHAPTER 8 : VIRTUAL MEMORY Introduction In simple paging and segmentation, we realised that we can : Load program pages or segments into frames that may not necessarily be contigous. Make memory address references in the loaded pages or segments to be dynamically calculated. Virtual memory is based on the above two things but we also realised that we do not need to load every part of the program into memory. Only a small portion of the whole program is first loaded into memory (this is called the resident portion), the rest of the program will be loaded when needed and swapped out to disk when other protion needs to be loaded but there are not enough space. Benefits of not loading all part of a program is : More processes can be in memory. A big program (bigger than available space) can be run by loading only a small portion of the program into available memory. The memory where programs are loaded is called real or physical memory. Programmer have a view of memory as big as in the hard disk. Programmers view of memory is called virtual memory. Principle of Locality What makes virtual memory possible is the fact that when a program is brought into memory to run, most of the time it confines to a certain area in the program and data. So, it is wasteful to load everything and use only a portion of it. Sometimes there are cases when portion of a program is loaded into memory to run and the loaded portion immediately need another module which is not in memory. So, it have to be loaded from disk. There will be a time when there are many processes loaded in memory that needs to do the swap in and the processor spends more time swapping in and out as compared to doing real processing. This is called thrashing. To avoid thrashing, OS will guess which part of a process is not needed in the near future and swap it out for new process to be loaded in. Only process that will be used in a short time will remain in memory. The selection is based on principle of locality (POL). Principle of locality states that program and data references tend to cluster which means that within a short period of time the same set of instructions and data will be repeatedly used. Abdul Rahim Ahmad page 1

2 For implementing virtual memory, 2 main things are needed : Hardware support for paging/segmentation OS software poprtion for managing movements of pages/segments from hard disk to memory. Virtual Memory using Paging Virtual memory can be implemented for system using paging or segmentation of combination of paging and segmentation. For virtual memory using paging, during initial loading of a proccess, some pages can be loaded into memory and a page table is created. The table contains the corresponding frame number in the memory. There will be a page table for each process. Each entry in the table contains : A present bit Used for protection Modified bit and sharing Control bits Frame number P M Control bits Frame Number Used to indicate whether corresponding page is in memory on not Used to indicate whether corresponding page have been modified since it was last loaded Address refered in the program (the logical address) will have two parts : Page number Offset Page Number Offset If a program refers to a memory location using logical address (or the virtual address), the logical address have to be translated to physical address using the following steps : For a running process, a register in CPU holds the starting address of the page table for the process. Page number in the virtual address is used to index into the page table and get the frame number. The frame number is combined with the offset portion of the logical address to form the physical address real address CPU register Frame # offset offset Page # offset Page table pointer program Logical address paging + P# Page table Frame # frame Main memory Abdul Rahim Ahmad page 2

3 Page table can itself reside in virtual memory for a system with large number of frames per processes and many processes can be running. There could be a two level page table scheme. At the first level, a logical address points to a page table directory of page table. From page table directory, there will be another pointer to the actual page table. Page # offset Level 1 Level 2 memory Page table directory Page table.. Page table Another method is to use an inverted page table where page number protion of virtual address is mapped into a hash table using a simple hashing funtion. The hash table contains a pointer to the inverted page table which contains the page table entries. So there is one antry in the hash table and in the inverted page tablefor each real memory page. Page # offset Virtual address Page# entry chain Frame# Hash table page table frame # physical address offset Every virtual memory reference actually require 2 memory access. One - to fetch appropriate page table entry for calculating physical memory. Two -to fetch the actual data/intruction. This will increase memory access time. To overcome this, we can cache (store temporarily) a group of page table entries that have been most recently used in a buffer called Translation Lookaside Buffer (TLB). TLB normally resides in main memory. Abdul Rahim Ahmad page 3

4 Using TLB, if a vitual address needs to be translated to physical addres, the following steps are done : TLB is first examined. If the page entry is present in the TLB then fine, go ahead as normal, calculate real address and execution jump to there. If page entry is not found in TLB, processor go to real page table and check if present bit is on. if yes, it means page is in memory. So we can calculate real address and execution jump to there. The TLB is also updated. If not, then page is in hard disk, so memory page fault interrupt is generated and OS will load the page in memory, and the page table entry is updated and the TLB is also updated. Real address is then calculate and execution jump to there. Diagram below, shows the use of TLB. Remember that there are many issues involved in using TLB plus the fact is that TLB is also use in conjunction with the cache memory in the processor itself. Abdul Rahim Ahmad page 4

5 Earlier we talked about cache memory where we said "the most recently used instruction that is possibly the next ones to be executed by CPU is stored in the cache. After calculating the real address, the virtual memory will first consult the cache if the referenced address content is in it. If not, it will seek in main memory, othger wise it will have to load from hard dik. In short the following issues are important : To calculate a real address, the TLB, the main memory and the hard disk might be involved as described above. To jump to the specific memory location indicated by the physical address calculated, the cache, the main memory and the hard disk might be involved. Another important issue is how big should the pages be? The size is influences by the following factors : Desire to reduce internal fragmentation require the pages to be small. Hard disk data transfer require block of transfer (pages) to be big. Page fault occur quite often if the size is of certain size according to the following graph: Page fault rate Page size As page size increase, page fault rate increase. Page fault rate drop as the page size reach certain limit Size of main memory determine the page size (and of course the frame size). Smaller main memory require small page size. Otherwise only a small number of process can be loaded into main memory. Wht about TLB size? TLB size is influenced by : Large TLB size means more page table entries and better hit rate for page table entries. Using larger page size also means that the TLB entry is referring to a large area of memory and reduce page fault. Some system support many different page sizes. This means pages of different sizes can accommodate different data structures. Program area of processes can be using lager page size while stack areas can use smaller page size. Abdul Rahim Ahmad page 5

6 Virtual Memory using Segmentation As stated earlier, segmentation is under the control of programmer. Programmer can segment their programs into segments of different sizes. Memory references in the segments will be logical addresses which have segment number and the offset. In using segmentation, each process have its own segment table, created when the program is loaded into memory. Segment table entry contains starting address of the corresponding segments in main memory, the length of the segment as well as the present, modify and control bits. A present bit Modified bit Control bits length. Frame number Used for protection and sharing P M Control bits length Segment base address Used to indicate whether corresponding segment is in memory on not Used to indicate whether corresponding segment have been modified since it was last loaded Address refered in the segments (the logical address) will have two parts : Page number Offset Segment Number Offset To calculate real address, the steps are almost the same as in paging except that the the length field in the segment table entry can be used to calculate the bound. real address Logical address CPU register Base + offset seg # offset Segment table ptr S# segment table d segment + base addr. program segmentation Main memory Abdul Rahim Ahmad page 6

7 Virtual Memory using combined paging and Segmentation Some processor hardware combined with OS capability can support both paging and segmentation. Here a user's address space is broken into a number of segments of unequal size at the descretion of the programmer. Each segment can be broken into a number of pages of equal size. From programmers's point of view, logical addres is still consisting of segment number and segment offset. In system point of view, segment offset is viewed as page number and page offset for a page within a segment. The segment table entry, page table entry and the logical address format are as follows : Control bits length Segment base address segment table entry P M Control bits Frame Number page table entry Segment Number Page Number Offset Logical address format To calculate real addres : processor uses the segment number portion of to index into process segment table to find the the page table for that segment. Page number portion of logical address is used to index into the page table of the segment to find the corresponding frame. The frame number is combined with the offset portion of the virtual addres to form the real address. Abdul Rahim Ahmad page 7

8 Abdul Rahim Ahmad page 8

9 OS Support for Virtual Memory Virtual memory using Paging and segmentation require hardware support. OS software support the various algorithm involved in managing the policies for : page fetching page placement page replacement after swap out. Management of resident set of pages. Cleaning of pages Load control. All the above policies rely on : Main memory size Relative speed of main and secondary memory Size of processes Number of processes Execution behaviour of individual program The nature of the application. The programming language it is written in. The compiler used. The style of the programmerwho wrote it. The behaviour of the user (in the case of interactive program). The OS designer must therefore choose a set of policies depending on the target users of the OS, based on the current knowledge. Most modern OS allow system administrators to configure the system or to tune the OS for the maximum performance. Fetch Policy Determines when a page should be brought into the main memory. Two common choices are : Demand paging - where a page is brought in only when a reference is made to the location on the page. Prepaging - where some pages are brought in even though it is not referenced. Placement Policy Determines where in real memory a piece of the process is to reside. Relacement Policy Determines which pages pages should be swap out to disk when a new page need to be place in memory or to be swap in from disk. The main objective is that a page to be removed should be the most unlikely to be replaced in the near future. The policy will predicyt future behaviour based on the past. Abdul Rahim Ahmad page 9

10 Frames in memory can be locked and they cannot be replaced. Those frames reserved for OS, I/O buffers and time critical areas are locked. Locking is done by associating a lock bit with each frame (in frame table and current page table). The followings are 4 algorithms used for selection of which page to replace : Optimal - select the page for which the time to the next reference is the longest. This can result in fewer page fault. This algorithm is not implemented but just merely used as a comparison. Least recently used (LRU) - select the page that has not been referenced for the longest time. Very difficult to implement and involve big overhead in the form of stack usage for keeping the page references.. First in first Out (FIFO) - remove pages in roud-robin cycle from the list of pages treated as a circular buffer. Very simple to implement but perform poorly. Clock - use an additional bit in the frame referred as use bit. List of pages that can be replaced is treated like a circular buffer with a pointer pointing to the page to be replaced. The diagram for this algorithm looks like a clock thus it is called clock algorithm. When a page is first loaded in main memory, its use bit is set to 0. When it is referenced again the use bit is set to 1. When a page needs to be replaced, the OS scans to find a frame that have use bit as 0. Along the way if it finds a frame with use bit as 1, it resets the use bit to 0. If all frames have use bit as 1, the system will scan all frames and set use bit to o and replace the one it first set to 1. The following graph shows a comparison of all the four policies using page size of 256 words, 250,000 references in a FORTRAN program with different number of frames allocated for the program : Page fault per 100 references FIFO Clock LRU 20 optimal Number of frames allocated. Another variation of clock algorithm by adding another bit called m (modify bit) is in Stallings page Abdul Rahim Ahmad page 10

11 A strategy that can improve paging performance is by using a simple replacement policy but on top of that employ page buffering. In page buffering, a replaced page is put into either one of the two lists : Free page list - page that have not been modified. Modified page list - page that have been modified. This page have to be written back to hard disk. When a page is to be read in, the page frame ahead in the free page list is overwritten. If the page is to be replaced is an unmodified page, the page frame is moved to the tail of the free page list. If the page is to be replaced is a modified page, the page frame is moved to the tail of the modified page list. The important fact here is that the replaced pages still remains in memory. The modified pages can later be written back to disk. Resident Set Management Resident set management deals with the followings issues : How many page frames are to be allocated to each active process Whether to limit the pages to replace to just the pages that cause the page fault or the whole pages that belong to the process. The following factors comes into play : Less amount of memory allocated to process means more process can be loaded, thus more ready process available. Rate of page fault is high if less memory frames allocated to process. Beyond certain size, even though more memory is allocated to process, the will be no noticable impact. Two different policies can be employed in resident set management : Fixed-allocation - fixing number of pages to allocate for a process at load time. Variable-allocation - let the number of pages allocated to be varied over the lifetime of the process. OS will have to assess the behaviour of each process. This require software overhead. The scope of replacement strategy can be Global - choose pages to replace among all unlocked pages in main memory from any processes at all. Local - choose pages to replace only among the resident pages of the process that generate page fault. The relationship between resident set size allocation and the scope can be one of the followings : Fixed allocation, local scope Variable allocation, local scope Variable allocation, global scope Abdul Rahim Ahmad page 11

12 Table below describe the relationship in more detail : Policy Fixed allocation Scope Local replacement Global replacement Number of frames allocated to Not possible process is fixed Pages to be replaced is chosen among frames allocated to that process Variable allocation Number of frames allocated to process may be changed from time to time. Pages to be replaced is chosen among frames allocated to that process More complex. Need to implement working set strategy. Pages to be replaced is chosen among available frames in main memory. Size of resident set will vary. Easiest to implement. Difficulty in replacement choice. Need also to implement page buffering. Working set is a concept introduced by Denning A working set W(t,Δ) at a virtual time t is the set of pages referenced in the last Δ virtual time units (virtual time can be taken as instruction cycles). Δ is the window of time over which process is observed. The larger Δ is, the larger is W. For any process, ther will time where W is stable and there will be times where it is changing rapidly. Algorithm that makes use of working set strategy are : page-fault frequency algorithm - require a use bit to be associated with each page in memory. Bit is set to 1 if page is accessed. When page fault occurs, OS will note the value of Δ and since last page fault for that process. A threshold F is defined, if Δ <F a page is added to the resident set. Otherwise discard all pages with use bit =0 and shrink resident set accordingly. At the same time reset the use bit of the remaining pages of the process to 0. Problem - during interlocality transition rapid page faults may occur causing undesirable switching and swappings. Variable-interval sampled working set (VSWS) algorithm. - The policy evaluates working set at sampling instancesbased on elapsed Δ. At the beginning of a sampling interval, the use bit of all resident pages for the process are reset to 0. At the end, only pages that have been referenced during the interval Δ have their use bit set to 1. These pages are retained in the resident setof the process throughout the next interval. Others are discarded. During each interval, any faulted pages are added to the resident set. Abdul Rahim Ahmad page 12

13 Cleaning Policy Cleaning policy determines when a modified page should be written to disk. 22 main alternatives are : Demand cleaning - a page is written out to disk only when selected for replacement. Precleaning - modified pages are written to disk in batches even before their page frames are needed. Using page buffering Load control Load control is concerned with determining the number of processes that will be resident in main memory. Also refered to as multiprogramming level. The objective is to avoid thrashing. If multiprogramming level is to be reduced, one or more of the currently resident process needs to be suspended (swapped out). There are 6 possibilities : Lowest-priority process. Faulting processlast process activated. Process with the smallest resident size Largest process Process with the largest remaining execution window. Abdul Rahim Ahmad page 13