Intro to Virtual Memory

Objectives

We would like to :

Explore the basics of virtual memory

Notes

This is the end of chapter 9 and the beginning of chapter 10.
Once upon a time, we moved entire processes to hard drive.
- This is called the backing store.
- We wanted it to be as fast as possible.
- UNIX
It required all of the process be written to the backing store
- Memory
- PCB
- Anything else.
PICK
- Idle processes
- Batch/lowest priority processes
- Most recently run processes (when the system is becoming oversubscribed)
This was expensive time wise.
With the advent of pages we could swap out pages
- This is called paging.
- More on this soon.
- A page out process moves the page from memory to backing store.
- A page in process moves the page back into memory.
The rest of chapter 9 gives good real world examples.
Look at pmap pid
But Chapter 10 discusses virtual memory
They note
- Programs have code that handles unusual conditions that is rarely ever called.
- Languages like C encourage declaration of large array, most of which are never used.
- Some program features are rarely or never used. (Think a spreadsheet application, how often do you use the what-if analysis section)
So it is probably not necessary to keep the entire process memory resident for the entire run of the process.
virtual memory is the separation of logical memory from physical memory
- With page tables, your program no longer needs to be in contiguous memory.
- Do we need to keep the entire program in memory? Probably not.
- If not, we could make virtual memory much larger than physical memory.
- Do we need all of the space between the heap and stack to be in memory?
Virtual address space is the address space in which the program operates.
Demand Paging
- Idea: Pages are only loaded when they are needed.
- Mark a bit or two in the frame table.
  - If the bit is set, the page is valid and in memory.
  - If the bit is not set
    - the page is not in memory: load it from secondary storage.
    - Or the page is not valid memory: throw a memory exception.
  - See the picture on page 393
- When a needed page is not in memory, it a page fault occurs.
- The process of handling a page fault is in figure 10.5, page 394
  1. The check to the page table indicates the page requested is invalid.
  2. Call the os through a page fault trap (SIGSEGV, segmentation fault)
    - The os can either continue if the page is legal
    - Or kill the process if the page is illegal
  3. Find a free frame in physical memory (more on that soon)
  4. Move the page from the backing store to the free frame
  5. Modify the page table
  6. restart the instruction.
  7. Top, f, select nMin, nMaj
```
      nMaj  --  Major Page Fault Count
           The  number  of major page faults that have occurred for a task.  A
           page fault occurs when a process attempts to read from or write  to
           a  virtual page that is not currently present in its address space.
           A major page fault is when auxiliary storage access is involved  in
           making that page available.

       nMin  --  Minor Page Fault count
           The  number  of minor page faults that have occurred for a task.  A
           page fault occurs when a process attempts to read from or write  to
           a  virtual page that is not currently present in its address space.
           A minor page fault does not involve  auxiliary  storage  access  in
           making that page available.

       CODE: code size in KB
       
       DATA: data + stack size in KB  
       RSS, RES : resident memory differetn measures in KB 

       SWAP: amount of memory written to swap space in KB
       
```
- This is pure demand paging, only loading a page when needed.
- This type of paging needs
  - A hardware page table.
  - Secondary memory configured for paging (swap space)
  - swapon --show
- And the kernel matins a free-frame-list.
  - Frames are allocated using the zero-fill-on-demand policy.
  - All memory is placed in this list when the system starts.
  - Strategies for finding more when it is empty are on the way.
- They provide a more detailed list of what happens for a page fault on page 397
- Because they want to analyze effective access time.
  - Assume a page fault occurs p% of the time.
  - This means that (1-p)% of the time there is no page fault.
  - If we assume memory access time is t_ma and page fault time is t_p
  - Effective access = (1-p)t_ma + pt_p.
  - They provide some estimates
    - Service the page fault interrupt : several 100 instructions, microseconds
    - Read the page: 8 milliseconds
    - Restart the process several hundred instructions, microseconds
  - So t_ma ≈ 200ns
  - t_p ≈ 8 ms
  - time = 200 + 7,999,800 p,
    - Keeping p small is important.
- Notice copy on write is easier now.
  - A page can be marked as shared.
  - And when it is shared, it can be copied if it is written to.