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

2. 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

3. 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

4. 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

5. 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

6. 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

7. 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

8. 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.

9. 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

10. 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

11. 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

12. 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

13. 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.

14. 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

15. 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

16. 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

17. 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

18. 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

19. 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

20. 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