Tutorial 8 March 9, 2012 TA: Europa Shang CSC369: Operating System Tutorial 8 March 9, 2012 TA: Europa Shang

Assignment 3 Implement paging by writing the following functions: lpage_fault: handles a page fault lpage_evit: evicts an logical page from physical memory page_replace: implements the page replacement policy Sequential Replacement: FIFO Second Chance Replacement: Clock No code reading questions

Virtual Memory Processes need more logical address space than physically available Need to manage what is in memory Swap pages on request When a page is requested but not in memory? Page fault When there is no more space in main memory to bring in pages? Replace and evict

MIPS TLB TLB keeps track of mapping from virtual to physical pages On memory read/write, check the entries in the TLB in parallel (associative lookup): Entry is found: TLB hit Entry not found: TLB miss Causes EX_TLBL for loads: reads Causes EX_TLBS for stores: writes Protection fault: trying to write to read-only memory causes EX_MOD (modify) TLB Exceptions mips_trap calls vm_fault for any TLB exception Different types of VM_FAULT_* are passed on Eventually gets to lpage_fault

LPAGE The lpage entry maps the virtual address to the address in physical memory and in swap space On creation, Request a block of swap space Set physical address to INVALID Update swap pointer The lpage structure keeps track of where the page stores In physical memory : lp_paddr On disk: lp_swapaddr Low bits of lp_addr used to hold flags, e.g. DIRTY, PINNED Read comments in src/kern/include/vmprivate.h

LPAGE Operations lpage_create: creates an logical page object lpage_destroy: deallocates a logical page, releases any RAM or swap pages involved lpage_lock: acquires the lock on an lpage lpage_unlock: releases the lock on an lpage lpage_lock_and_pin: locks the lpage page and pins the underlying physical page in the coremap. lpage_copy: creates a new lpage and copy data from another lpage lpage_zerofill: creates a new lpage and arrange for it to be cleared to all zeros lpage_fault: handles a fault on a specific lpage lpage_evict: evicts an lpage from physical memory

VM_OBJECT A vm_object is a data structure that defines a a valid block of process virtual memory Defiend in src/kern/include/vmprivate.h Created by as_define_region Each vm_object contains a base virtual address and an array of logical pages The address space is a collection of vm_objects Redzone: a possible guard band against other vm_objects Simple operations: create, destroy, copy, etc. lpage and vm_object From virtual address, can the corresponding vm_object In the vm_object, can find the index of the corresponding lpage structure

Coremap Logical pages are nice, but we ultimately need to work with physical memory Need to keep track of physical pages Coremap maps pages in memory to their virtual address. Reverse page table One entry per page frame Indexed by physical page number Contain the virtual page number of address space that is occupying the page frame.

Coremap TLB management and handling Page replacement policy Keep track of the number of Maximum number of physical pages Number of kernel pages Number of user pages Number of pages that are free Maintain information whether a page has been pinned for manipulation

COREMAP_ENTRY struct coremap_entry { struct lpage *cm_lpage; volatile int cm_tlbix:7; unsigned cm_cpunum:5; unsigned cm_kernel:1, cm_notlast:1, cm_allocated:1; unsigned cm_pinned:1; }; A coremap entry has bit flags that indicate if pages are kernel pages, pinned (busy), etc. May add other flags to support your design

COREMAP_ENTRY v.s. LPAGE Each lpage is a logical piece of memory The memory may be in memory or in swap (on disk) A lpage points to the location of its data The coremap maps the physical memory storage When you need physical memory, consult the coremap to see what memory is free. A coremap entry points to a lpage

COREMAP Operations tlb_replace: returns index of TLB entry to replace TLB replacement algorithm. tlb_invalidate: marks a given TLB entry as invalid tlb_clear: flushes the TLB by loading it with invalid entries tlb_unmap: searches the TLB for a specific virtual address translation and invalidates it if it exits mips_getslot: gets a TLB slot for use, replacing an existing one if necessary and performing any at- replacement actions page_replace: returns an index into the coremap for the selected victim page

COREMAP Operations coremap_bootstrap: allocates memory for the coremap and initlaizes its entries do_evict: performs the eviction of the specific slot in coremap do_page_replace: starting point for the page replacement code, calls page_replace and do_evict mark_page_allocated: update coremap entries for newly allocated pages and update coremap counters Called from coremap_alloca_one_page and coremap_alloc_multipages coremap_free: deallocates a specific physical address and any subsequent pages allocated in the same block coremap_pin: marks a specific page pinned for manipulation of its contents coremap_unpin: unpins a specific page mmu_map: enters a translation into the MMU.

Page Faults Minor fault: desired page is in memory but not found in TLB Update the TLB and coremap coremap.c : mmu_map Major fault: desired page is not in memory It’s either in swap space, or hasn’t been created yet How do you know if it’s a major fault? lp_paddr is INVALID_PADDR if the page is not in memory Page hasn’t been created yet A new page is allocated to the process and initialized (zero-filled) In src/kern/vm/addrspace.c: as_fault Page is on disk We need to swap the page into memory from swap space

Page Replacement Updating the victim’s PTE to show that it is in swap Evicting/invalidating victim’s PTE from the TLB Copying it to disk iff its dirty Loading the new page into memory Updating the new page’s PTE and inserting it into the TLB

Synchronization OS/161 assumes that lpage, vm_objects and address spaces are not shared But one thread may access an lpage belonging to another thread, in order to evict a page Don’t need locks when accessing address space and vm_objects, but lpages do need synchronization Bit lock is used to save space: lpage_lock, lpage_unlock Locks for the Virtual Memory system global_paging_lock: limits number of pages pinned at any one time swaplock: synchronizes swapmap and counters Used by swap_alloc, swap_free, swap_reserve, swap_unreserve cm_pinned: locks pages that are being used One bit lock per lpage Lock ordering, i.e., you should acquire in this order global_paging_lock BEFORE coremap pages BEFORE lpages

PAGE_REPLACE page_replace takes no arguments and returns an index into the coremap for the selected victim page. You will write two versions of this function. Sequential Page Replacement Clock Page Replacement Configuration ASST3-FIFO ASST3-CLOCK

PAGE_REPLACE: FIFO Sequential Page Replacement Tips Select page to be evicted from the coremap sequentially. Skip pinned pages and kernel pages Tips Map need a global variable for the head of the queue

PAGE_REPLACE: LRU Clock Page Replacement Tips Scans pages in coremap sequentially. Skip pinned pages, kernel pages, and pages with the reference bit set. Turn off the reference bit if a page is skipped because the reference bit was 1. Tips May need a bit field in coremap_entry for the reference bit May need a global variable for the clock hand May need to modify several functions for the reference bit

LPAGE_FAULT and LPAGE_EVICT lpage_fault: handles a fault on a specific lpage. If a page is resident in memory, get a physical page from coremap and swap it in. lpage_evict: evicts an lpage from physical memory to swap space Action: Evict the contents of the page at lp_paddr by writing it to lp_swapaddr on the swap device (if it is dirty), and mark lp_paddr as invalid Called by do_evict when a physical page is chosen for eviction Synchronization Stats counters should be updated under global lock protection Read the comments in the code