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;
volatile
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 atreplacement 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?



Page hasn’t been created yet


lp_paddr is INVALID_PADDR if the page is not in memory
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
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
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
