Csc369 operating system
1 / 20

CSC369: Operating System - PowerPoint PPT Presentation

  • Uploaded on

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

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about ' CSC369: Operating System' - bart

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Csc369 operating system

CSC369: Operating System

Tutorial 8

March 9, 2012

TA: Europa Shang

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


  • 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 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_objectcontains 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


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


  • 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

  • A coremap entry has bit flags that indicate if pages are kernel pages, pinned (busy), etc.

    • May add other flags to support your design

structcoremap_entry {

structlpage *cm_lpage;


int cm_tlbix:7;

unsigned cm_cpunum:5;

unsigned cm_kernel:1,




unsigned cm_pinned:1;


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


    • 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