Docstoc

Virtual Memory The Virtual Address Space

Document Sample
Virtual Memory The Virtual Address Space Powered By Docstoc
					                             Virtual Memory



                                            Fred Kuhns
                       (fredk@arl.wustl.edu, http://www.arl.wustl.edu/~fredk)
                          Applied Research Laboratory
                  Department of Computer Science and Engineering
                        Washington University in St. Louis




                                              Washington
                                         WASHINGTON UNIVERSITY IN ST LOUIS




                  UNIX Memory Management

• UNIX uses a demand paged virtual memory architecture
    – anticipatory paging: OS proactively loads page before that are
        actually needed
• Memory is managed at the page level
    – page frame or simply frame == physical page
    – virtual page or simply page == virtual page
• page-level allocator:
    – has two principle clients: paging system and kernel memory
      allocator
    – paging system: allocate pages to user processes
    – kernel memory allocator: manage memory used by kernel.




 Fred Kuhns (10/13/2005)         CSE522– Advanced Operating Systems                             2




              The Virtual Address Space
 kernel memory

                                         proc struct




kernel stack/u area                 kernel stack/u area                      kernel stack/u area
          Stack                                   Stack                            Stack



           Data                                    Data                            Data
     Text (shared)                       Text (shared)                          Text (shared)


 Fred Kuhns (10/13/2005)         CSE522– Advanced Operating Systems                             3
     Process Address Space (one approach)


                    0xffffffff
                                         Kernel stack

            Kernel address space

                  0x7fffffff
                                              stack

              Process address space

                                               Data

                  0x00000000             Text (shared)


 Fred Kuhns (10/13/2005)      CSE522– Advanced Operating Systems   4




                           Virtual Memory Goals
• Run applications larger than physical memory.
• Run partially loaded programs.
• Multiprogramming: > one program simultaneously reside
  in memory.
• Allow relocatable programs – anywhere, anytime
• Application Portability:
     – Applications should not have to manage memory resources
     – Write machine independent code – program should not depend
       on memory architecture.
• Permit sharing of memory segments or regions. For
  example, read-only code segments should be shared
  between program instances.



 Fred Kuhns (10/13/2005)      CSE522– Advanced Operating Systems   5




                           Virtual Memory Costs

• Space: Translation tables and other data used by VM
  system reduce available memory to programs
• Time: Address translation time is added to the cost
  (execution time) of each instruction.
• Asynchronous: Page fault handling may result in page
  I/O operations increasing latency and possibly
  affecting unrelated processes.
• Overhead: Memory management operations have been
  measured to consume up to 10% of the CPU time on a
  busy system.
• Efficiency: Allocating memory in pages may result in
  fragmentation


 Fred Kuhns (10/13/2005)      CSE522– Advanced Operating Systems   6
                    Processes and Memory
• Process runs on a virtual machine as defined by the
  underlying hardware.
• Focus is on Hardware support for a virtual address
  space
        virtual addresses independent of physical memory
• Key hardware component is the Memory Management
  Unit (MMU)
        address translation: virtual to physical memory
        simplifies context switching
        ensures virtual address space protection




 Fred Kuhns (10/13/2005)    CSE522– Advanced Operating Systems                    7




                           Memory allocation
                                                                       physical page



                                   Page-level
                                    allocator




              Kernel memory                               Paging
                Allocator                                 system



 Network             Data       temp
                                                process          Buffer cache
 buffers          structures   storage

 Fred Kuhns (10/13/2005)    CSE522– Advanced Operating Systems                    8




                     Page-level Allocation
• Kernel maintains a list of free page frames (physical
  memory)
• Since kernel and user space programs use virtual
  memory addresses, the physical location of a page is not
  important
• Pages are allocated from the free list
• Two principal clients:
       paging system
       kernel memory allocator




 Fred Kuhns (10/13/2005)    CSE522– Advanced Operating Systems                    9
                             The Paging System
• Allocating and managing process address space
• Goal: virtual address space abstraction, perform address
  translations transparently
• Demand-paged VM: page is basic unit of memory
  allocation, protection and address translation. Virtual
  address is converted to frame number and offset.
• Requirements:
   – Address space management
   – Address Translation
   – Physical memory management
   – Memory Protection
   – Memory Sharing
   – Monitoring system load
   – Other facilities – for example memory mapped files or
     shared libraries

 Fred Kuhns (10/13/2005)     CSE522– Advanced Operating Systems                   10




                           Paged Virtual Memory
   Working set
                                     Physical
      P1 virtual                  address space                     P2 virtual
    address space                                                 address space
                                     page0
        page0                                                       page0
                                     page1
        page1                                                       page1
                                     page2
        page2                                                       page2
                                     page3
        page3                                                       page3
                                     page4
                                     page5
        pagen                                                       pagen
                                     page6                          pagen

     resident                        page7             Address
                                                      Translation         Page
     Non-resident
                                                                         frames
 Fred Kuhns (10/13/2005)     CSE522– Advanced Operating Systems                   11




                   The Virtual Address Space

 • Address space along with processes register context
   reflects the current state
 • exec causes kernel to build new process image:
      – memory “regions”: text, initialized data, uninitialized data,
        modified data, stack, heap, shared memory and shared
        libraries.
      – These regions may differ in protection, initialization and
        sharing. Protections usually set at page level when allocated.
 • Process may start running before any of its pages are
   resident in memory.




 Fred Kuhns (10/13/2005)     CSE522– Advanced Operating Systems                   12
                           Initial Access to Pages

  • Text and initialized data are read in from
    executable file.
  • Uninitialized data are zero-filled pages
  • Shared libraries from library file
  • The u area and stacks are setup during process
    creation (copied from parent).




 Fred Kuhns (10/13/2005)       CSE522– Advanced Operating Systems   13




                Swap Area: VM Backing Store
• Swap Area: Pages are copied to the swap device to free
  up space for running programs.
• Swapping plus paging for two-tiered scheme
• Requires a swap map to locate swapped out pages
• MMU set dirty bit for page if it has been modified
• Text pages need not be backed by swap




 Fred Kuhns (10/13/2005)       CSE522– Advanced Operating Systems   14




                             Translation Maps
• Hardware Translation Table – each access to memory must
  have the virtual address translated to a physical memory
  location
   – Page tables provide the MMU with this mapping
   – MMU uses TLB to cache recent translations
• Other maps used by the OS:
   – Address space map – describes a virtual address space for a
     process or kernel
   – Physical memory map – kernel uses to perform reverse maps and to
     describe a pages ownership, references and protections.
   – Backing store map – used to locate non-resident pages




 Fred Kuhns (10/13/2005)       CSE522– Advanced Operating Systems   15
                        Replacement Algorithms
• Deciding when to reclaim a page: Defined in terms of
  criteria used for selecting pages to reclaim
• Reference string: pages referenced over time
• fault rate: page faults for some length of a reference
  string (i.e. over a period of time)
• Algorithms evaluated based on effectiveness on collected
  (real) reference strings
• Implementations usually require sample reference strings
• Local versus global policies:
   – Most UNIX implementation use a global replacement policy but
      guarantee a minimum




   Fred Kuhns (10/13/2005)    CSE522– Advanced Operating Systems              16




                             Working set Model
• Assumes a slowing changing locality of reference
    – processes tend to localize references to a small set of pages
    – implies that if a page was recently accessed then it will be accessed again
      in the “near” future
    – if working set is in memory then few page faults
• A simple model is a least recently used (LRU) policy:
    – if a page has been accessed “recently” then assume it will be need again
      else assume it will not be needed
    – else free pages not accessed “recently”
• Implement using an approximate set:
    – number of pages held versus fault rate.
    – Set high and low water marks
• Most kernels implement a scheme whereby pages are periodically
  freed and placed on a free pool.
• Prepaging: working set resident before scheduling process



   Fred Kuhns (10/13/2005)    CSE522– Advanced Operating Systems              17




                             Working set model
 • Reference pattern nonuniform but clustered
 • w(k,t) = pages (set) corresponding to the last k memory references,
   at time t.
     – w(1,t) ⊆ w(2,t) ⊆ … ⊆ w(n,t)
     – |w(k,t)| = size of w is monotonically increasing with k
 • Practical considerations lead to using a processes virtual time rather
   than k recent references
     – consider page references in past τ virtual time units.
     – clear R bit every clock tick, it is set when a page is referenced
     – on page fault if R is set then update virtual time of last use
       else set age = current_vt – last_use_vt.
         If age > τ then reclaim page
         else it is in the working set.
       continue to scan all entries
       if no entries found then reclaim oldest. If all had R bit set then randomly
       select page to reclaim.




   Fred Kuhns (10/13/2005)    CSE522– Advanced Operating Systems              18
                                WSClock Algorithm
• Similar to clock algorithm with circular list and clock
  hand.
• scans list and if R = 1 then it is cleared and the current
  virtual time is written.
• advance hand
• if R = 0 then check timestamp > T then replace (if dirty
  schedule for write else put on free list)
• Alternatively, can use two clock hands




 Fred Kuhns (10/13/2005)                CSE522– Advanced Operating Systems          19




                             Example Paging System


                                                            CPU
                              Unitialized data
      DRAM                                                       Stack and heap
              Low Address
              (0x00000000)      Text (shared)       Allocated virtual pages
                               Initialized Data
                 app1         Unitialized Data                            Swap
             Address space    Heap (Dynamic)                   Disk
                                                                           UFS
              High Address    stack (dynamic)
              (0x7fffffff)      Environment

                                                       Text and
                                                    initialized data         app1



 Fred Kuhns (10/13/2005)                CSE522– Advanced Operating Systems          20




                             Hardware Requirements

• Protection: Prevent process from changing own memory
  maps
• Residency: CPU distinguishes between resident and non-
  resident pages
• Loading: Load pages and restart interrupted program
  instructions
• Dirty: Determine if pages have been modified




 Fred Kuhns (10/13/2005)                CSE522– Advanced Operating Systems          21
                Address Translation Overview



                                 MMU
     CPU           Virtual
                   address        TLB                 physical
                                                                       cache
                                                      address
                             context table pointer
                             context




                                                          Page tables




  Fred Kuhns (10/13/2005)         CSE522– Advanced Operating Systems           22




                       SVR4 VM Architecture
• File Mapping – Two interpretations
    – Used as a Fundamental Organizational scheme. Entire Address Space
      viewed as a collection of mappings to different objects (such as files)
    – Applications map a file into their address space
• Types of Mappings: Shared and Private
• Memory Object: represents mapping from a region of memory to
  backing store (swap, local/remote file, frame buffer)
• VM provides common framework, Memory objects provide the
  specific implementation
    – operations such as fetching and flushing page to backing store




  Fred Kuhns (10/13/2005)         CSE522– Advanced Operating Systems           23




                                                     VM
• Address space is a set of mappings to data objects.
   – An address is only valid if it is mapped to an existing object
• File system provides the name space and mechanisms to access data.
   – Uses the vnode layer to interact with the file system.
   – Each named memory object is associated with a vnode (but a vnode may
     map to many objects)
   – Unnamed objects represented by anonymous objects
• Physical memory is treated as a cache for the data objects
• Page is the smallest unit of allocation, protection, address translation
  and mapping.
   – Address space can be thought of as an array of pages




  Fred Kuhns (10/13/2005)         CSE522– Advanced Operating Systems           24
                  File Mapping Versus read/write
        VM Approach                                              Traditional Approach
         Process P1                                                  Process P2

      process                                                         process
                              mmap(): Address space
                              read/write: Copy                                  Copy
       Virtual Memory System                                    Buffer Cache
                           P1 pages


                                   Copy                                         Copy


    Fred Kuhns (10/13/2005)      CSE522– Advanced Operating Systems                     25




           Fundamental Abstractions (data structs)

•    Page (struct page)
•    Address Space (struct as)
•    segment (struct seg)
•    Hardware Address Translation (struct hat)
•    Anonymous Page (struct anon)




    Fred Kuhns (10/13/2005)      CSE522– Advanced Operating Systems                     26




                               VM Architecture
                                                             Physical page
                                                               & offset
                              virtual    Address      physical
             Proc A
                              address Translation address
fork/exec                              fault page tables
                              AS layer
                                        HAT

              anon layer                 vnode layer
                                                                                  ...
    swap layer                                            page layer


              Persistent storage

    Fred Kuhns (10/13/2005)      CSE522– Advanced Operating Systems                     27
                              Physical Memory

• Divided into paged and non-paged regions
• Paged region described by an array of page
  structures, each describing one logical page (cluster
  of hardware pages)
• Each physical page (page frame):
       – described by struct page
       – mapped to some memory object, with the memory object
         represented by a vnode
       – page identity or name = <vnode, offset>




    Fred Kuhns (10/13/2005)   CSE522– Advanced Operating Systems                  28




                                 Page Struct

• page struct stores offset and pointer to corresponding vnode
• may sit on several linked lists, has 3 sets of pointers
       – hash table of vnode and offset
       – vnode contains list of all object pages currently in memory
       – free page list or list of pages waiting to be written to backing store
•     Reference count
•     synchronization flags (lock, wanted, in-transit)
•     Copies of modified and referenced bits
•     HAT field used to locate all translations for this page




    Fred Kuhns (10/13/2005)   CSE522– Advanced Operating Systems                  29




                                    AS Layer
     • High-level abstraction describing the virtual address
       space.
     • References a linked list of seg (segment) structs
       that represent non-overlapping page-aligned address
       regions
     • Contains the hat structure and a hint to the last
       segment that had a page fault
     • Supports two set of operations: those operating on
       the entire address space and those that affect
       ranges within the space.




    Fred Kuhns (10/13/2005)   CSE522– Advanced Operating Systems                  30
                             Segment Drivers
• Segments represent mappings between backing store and address
  regions
• Segment represents an abstract base class with specific drivers
  being derived classes.
• seg struct contains pointer to
     – a seg_ops vector, these represent the virtual functions. i.e. the type
       dependent interface to the class.
     – Methods = {dup, fault, faulta, setprot, checkprot, unmap, swapout,
       sync}
     – type-dependent data structure which hold private data
• Each segment defines a create routine




 Fred Kuhns (10/13/2005)      CSE522– Advanced Operating Systems                31




                             Segment Drivers
• Different types: seg_vn, seg_map, seg_dev, seg_kmem
   – seg_vn: vnode segment, maps to regular files and anonymous
     object.
   – Seg_map: One in system. Use by kernel for transient file
     mappings for implementing read/write.




 Fred Kuhns (10/13/2005)      CSE522– Advanced Operating Systems                32




                           Process Address Space

proc struct                  struct seg {      struct segvn_data {}
                                                                        text
                              base
                              size}


                                              struct segvn_data {}
     struct as {             struct seg {
      segment list            base
      hint                    size}
                                                                       data
      struct hat {}}

                             struct seg {       struct segvn_data {}
                              base
                              size}
                                                                       stack
    seg_vn ops

                             struct seg {      struct segu_data {}
    seg_u ops                 base
                              size}                                    u area



 Fred Kuhns (10/13/2005)      CSE522– Advanced Operating Systems                33
                               Anonymous Pages
• Page with no permanent storage, created when process write to a
  MAP_PRIVATE object
• Pages can be discarded with process terminates or unmaps the page.
• Swap device used as backing store
• Example: initialized data pages when modified become anonymous
  pages
• Related but distinct concept is an anonymous object.
   – one anonymous object in system represented bu the NULL vnode pointer
     (/dev/zero) and is the source of all zero-filled pages.
   – unitialized data and stack regions are MAP_PRIVATE to it
   – Shared memory regions are MAP_SHARED to it
   – anonymous object pages are anonymous pages




  Fred Kuhns (10/13/2005)        CSE522– Advanced Operating Systems                       34




                                      Anonymous
                                                vnode layer read
           one for each                         and writes pages
           swap device                            to swap device               Swap device
              Swap info                           vnode
                                              pointer to
   as                          anon ref       anon and
                                array          freelist                         t
  seg    anon_map                 0                           anon[]         lis
                                                                          ee
                                                                       fr
 segvn_data
                                  0
                                  0          page
                                                                               one entry for
                  vnode
                                                                                each page
                                             page
            Per page protect     page                                            in swap

  Fred Kuhns (10/13/2005)        CSE522– Advanced Operating Systems                       35




        Hardware Address Translation Layer
 • Isolates all hardware-dependent code from rest of VM
 • Responsible for all address translations
    – setup and maintain mappings used by MMU (page tables, directories etc)
    – each process has it’s own set of translations
 • uses struct hat which is part of the as struct
 • Operations
    – hat layer: hat_alloc, hat_free, hat_dup, hat_swapin, hat_swapout
      (build/rebuild tables when swapping)
    – range of pages: hat_chgprot, hat_unload, hat_memload, hat_devload
    – all translation of a page: hat_pageunload, hat_pagesync (update modified
      and referenced bits using values in page struct)




  Fred Kuhns (10/13/2005)        CSE522– Advanced Operating Systems                       36
                               Misc Topics
• Pagedaemon implements page reclamation (replacement)
  policy. Uses two-handed clock algorithm
• Swapping - swapper daemon will swap processes when
  space gets below a threshold




 Fred Kuhns (10/13/2005)    CSE522– Advanced Operating Systems   37




                           Misc Topics Cont


              • Non-page-aligned backing store
              • Virtual swap space in Solaris (swapfs)
                    – includes physical memory
                    – dynamic reallocation




 Fred Kuhns (10/13/2005)    CSE522– Advanced Operating Systems   38




                     Assessment - Advantages
• Modular design – OO style interface encapsulating
  functionality
• Portability – HAT layer simplifies porting
• Sharing – copy-on-write sharing, MAP_SHARED, shared
  file mappings
    – Lightweight file access – mmap
    – Enabling shared library support
• Leveraging existing interfaces (vnode)
• Integrating VM and buffer cache
• Facilitates break point insertion with MAP_PRIVATE




 Fred Kuhns (10/13/2005)    CSE522– Advanced Operating Systems   39
                  Assessment - Disadvantages
• Increased table size and maintenance requirements
• Increased time to read program text and initialized data from file
  rather than swap
• Performance problems due to longer code paths, complexity and
  indirection
• disk address are computed dynamically
• Invariant interfaces to abstractions may lead to inefficient
  implementation (no control over implementation)
• copy-on-write may not be faster than anticipatory copying
• Swap space allocated per-page basis preventing optimizations like
  clustering and prepaging




 Fred Kuhns (10/13/2005)   CSE522– Advanced Operating Systems     40




                           Improvements



• Reduce high fault rate caused by lazy evaluations




 Fred Kuhns (10/13/2005)   CSE522– Advanced Operating Systems     41

				
DOCUMENT INFO
Shared By:
Categories:
Stats:
views:18
posted:1/4/2011
language:English
pages:14