CS 423 Operating System Design: Virtual Memory Management - - PowerPoint PPT Presentation

cs 423 operating system design virtual memory management
SMART_READER_LITE
LIVE PREVIEW

CS 423 Operating System Design: Virtual Memory Management - - PowerPoint PPT Presentation

CS 423 Operating System Design: Virtual Memory Management Professor Adam Bates CS 423: Operating Systems Design Goals for Today Learning Objective: Understand properties of virtual memory systems Announcements, etc: MP2 out


slide-1
SLIDE 1

CS 423: Operating Systems Design

Professor Adam Bates

CS 423
 Operating System Design: Virtual Memory Management

slide-2
SLIDE 2

CS 423: Operating Systems Design 2

Goals for Today

Reminder: Please put away devices at the start of class

  • Learning Objective:
  • Understand properties of virtual memory systems
  • Announcements, etc:
  • MP2 out on Monday!
  • C4 submission pages are live
slide-3
SLIDE 3

CS 423: Operating Systems Design

History: Summary

3

Overlay Fixed Partitions Relocation

  • No multi-

programming support

  • Supports multi-

programming

  • Internal

fragmentation

  • No internal

fragmentation

  • Introduces

external fragmentation

slide-4
SLIDE 4

CS 423: Operating Systems Design

Virtual Memory

4

■ Provide user with virtual memory that is as big as

user needs

■ Store virtual memory on disk ■ Cache parts of virtual memory being used in real

memory

■ Load and store cached virtual memory without user

program intervention

slide-5
SLIDE 5

CS 423: Operating Systems Design

Paging

5

1 2 3 4 Memory Virtual Memory Stored on Disk 1 2 3 4 5 6 7 8 1 2 3 4 Page Table VM Frame

slide-6
SLIDE 6

CS 423: Operating Systems Design

Paging

6

3 1 2 3 4 Memory Virtual Memory Stored on Disk 1 2 3 4 5 6 7 8 1 2 3 4 Page Table VM Frame

Request Page 3…

slide-7
SLIDE 7

CS 423: Operating Systems Design 7

Paging

3 1 1 2 3 4 Memory Virtual Memory Stored on Disk 1 2 3 4 5 6 7 8 1 2 3 4 Page Table VM Frame

Request Page 1…

slide-8
SLIDE 8

CS 423: Operating Systems Design 8

Paging

3 1 1 6 2 3 4 Memory Virtual Memory Stored on Disk 1 2 3 4 5 6 7 8 1 2 3 4 Page Table VM Frame

Request Page 6…

slide-9
SLIDE 9

CS 423: Operating Systems Design 9

Paging

3 1 1 6 2 3 4 Memory Virtual Memory Stored on Disk 1 2 3 4 5 6 7 8 1 2 3 4 Page Table VM Frame 2

Request Page 2…

slide-10
SLIDE 10

CS 423: Operating Systems Design 10

Paging

Request Page 8. Swap Page 1 to Disk First…

3 1 1 6 2 3 4 Memory Virtual Memory Stored on Disk 1 2 3 4 5 6 7 8 1 2 3 4 Page Table VM Frame 2

slide-11
SLIDE 11

CS 423: Operating Systems Design 11

Paging

Request Page 8. … now load Page 8 into Memory.

3 1 6 2 3 4 Memory Virtual Memory Stored on Disk 1 2 3 4 5 6 7 8 1 2 3 4 Page Table VM Frame 2 8

slide-12
SLIDE 12

CS 423: Operating Systems Design

Page Mapping Hardware

12

Contents(P,D) Contents(F,D) P D F D P→F 1 1 1 1 Page Table Virtual Memory Virtual Address (P,D) Physical Address (F,D) P F D D 4 Physical Memory

slide-13
SLIDE 13

CS 423: Operating Systems Design

Page Mapping Hardware

13

Contents(4006) Contents(5006) 004 006 005 006 4→5 1 1 1 1 Page Table Virtual Memory Physical Memory Virtual Address (004006) Physical Address (F,D) 004 005 006 006 4 Page size 1000 Number of Possible Virtual Pages 1000 Number of Page Frames 8

slide-14
SLIDE 14

CS 423: Operating Systems Design

Page Faults

14

■ Access a virtual page that is not mapped into

any physical page

■ A fault is triggered by hardware

■ Page fault handler (in OS’s VM subsystem)

■ Find if there is any free physical page available

■ If no, evict some resident page to disk (swapping space)

■ Allocate a free physical page ■ Load the faulted virtual page to the prepared physical

page

■ Modify the page table

slide-15
SLIDE 15

CS 423: Operating Systems Design

Reasoning about Page Tables

15

■ On a 32 bit system we have 2^32 B virtual address space ■ i.e., a 32 bit register can store 2^32 values

■ # of pages are 2n (e.g., 512 B, 1 KB, 2 KB, 4 KB…)

■ Given a page size, how many pages are needed? ■ e.g., If 4 KB pages (2^12 B), then 2^32/2^12=… ■ 2^20 pages required to represent the address space ■ But! each page entry takes more than 1 Byte of space to

represent.

■ suppose page table entry is 4 bytes (Why?) ■ (2*2) * 2^ 20 = 4 MB of space required to represent our

page table in physical memory.

slide-16
SLIDE 16

CS 423: Operating Systems Design

Paging Issues

16

■ Page size is 2n

■ usually 512 bytes, 1 KB, 2 KB, 4 KB, or 8 KB ■ E.g. 32 bit VM address may have 220 (1 MB) pages with

4k (212) bytes per page

■ Page table:

■ 220 page entries take 222 bytes (4 MB) ■ Must map into real memory ■ Page Table base register must be changed for context

switch

■ No external fragmentation; internal fragmentation on

last page only

slide-17
SLIDE 17

CS 423: Operating Systems Design

Translation Lookaside Buffers

17

  • ffset

Virtual address

. . . PPage#

...

PPage#

...

PPage#

...

PPage #

  • ffset

Physical address VPage #

TLB Hit Miss Real page table

VPage# VPage# VPage#

Optimization:

slide-18
SLIDE 18

CS 423: Operating Systems Design 18

■ If a virtual address is presented to MMU, the

hardware checks TLB by comparing all entries simultaneously (in parallel).

■ If match is valid, the page is taken from TLB

without going through page table.

■ If match is not valid

■ MMU detects miss and does a page table lookup. ■ It then evicts one page out of TLB and replaces it

with the new entry, so that next time that page is found in TLB.

Translation Lookaside Buffers

slide-19
SLIDE 19

CS 423: Operating Systems Design 19

Translation Lookaside Buffers

■ What TLB entry to be replaced?

■ Random ■ Least Recently Used (LRU)

■ What happens on a context switch?

■ Invalidate the entire TLB contents

■ What happens when changing a page table

entry?

■ Change the entry in memory ■ Invalidate the TLB entry

Issues:

slide-20
SLIDE 20

CS 423: Operating Systems Design 20

Translation Lookaside Buffers

Effective Access Time:

■ TLB lookup time = σ time unit ■ Memory cycle = m µs ■ TLB Hit ratio = η ■ Effective access time

■ Eat = (m + σ) η + (2m + σ)(1 – η) ■ Eat = 2m + σ – m η

Note: Doesn’t consider page faults. How would we extend?

slide-21
SLIDE 21

CS 423: Operating Systems Design

Question

21

Applications might make sparse use of their virtual address space. How can we make our page tables more efficient?

slide-22
SLIDE 22

CS 423: Operating Systems Design

Multi-level Page Tables

22

Directory . . .

pte

. . . . . . . . . dir table

  • ffset

Virtual address

What does this buy us?

slide-23
SLIDE 23

CS 423: Operating Systems Design

Multi-level Page Tables

23

Directory . . .

pte

. . . . . . . . . dir table

  • ffset

Virtual address

What does this buy us? Answer: Sparse address spaces, and easier paging

slide-24
SLIDE 24

CS 423: Operating Systems Design 24

■ A logical address (on 32-bit x86 with 4k page size)

is divided into

■ A page number consisting of 20 bits ■ A page offset consisting of 12 bits

■ Divide the page number into

■ A 10-bit page directory ■ A 10-bit page number

Multi-level Page Tables

Example: Addressing in a Multi-level Page Table system.

slide-25
SLIDE 25

CS 423: Operating Systems Design

Multi-level Paging Performance

25

Since each level is stored as a separate table in memory, converting a logical address to a physical one with an n-level page table may take n+1 memory accesses. Why?

slide-26
SLIDE 26

CS 423: Operating Systems Design

Question

26

In 64-bit system, up to 2^52 PT entries. 2^52 ~= 1,000,000,000,000,000 … bro, can I borrow some RAM?

slide-27
SLIDE 27

CS 423: Operating Systems Design

Inverted Page Tables

27

Hash the process ID and virtual page number to get an index into the HAT.

Look up a Physical Frame Number in the HAT.

Look at the inverted page table entry, to see if it is the right process ID and virtual page

  • number. If it is, you're done.

If the PID or VPN does not match, follow the pointer to the next link in the hash chain. Again, if you get a match then you're done; if you don't, then you continue. Eventually, you will either get a match or you will find a pointer that is marked invalid. If you get a match, then you've got the translation; if you get the invalid pointer, then you have a miss.

slide-28
SLIDE 28

CS 423: Operating Systems Design

Paging Policies

28

■ Fetch Strategies

■ When should a page be brought into primary (main)

memory from secondary (disk) storage.

■ Placement Strategies

■ When a page is brought into primary storage, where is it

to be put?

■ Replacement Strategies

■ Which page in primary storage is to be removed when

some other page or segment is to be brought in and there is not enough room.

slide-29
SLIDE 29

CS 423: Operating Systems Design

Fetch: Demand Paging

29

■ Algorithm never brings a page into primary

memory until its needed.

  • 1. Page fault
  • 2. Check if a valid virtual memory address. Kill job if not.
  • 3. Find a free page frame.
  • 4. Map address into disk block and fetch disk block into

page frame. Suspend user process.

  • 5. When disk read finished, add vm mapping for page

frame.

  • 6. Restart instruction.
slide-30
SLIDE 30

CS 423: Operating Systems Design

Demand Paging Example

30

Load M

i

Free frame Page table VM ref fault

slide-31
SLIDE 31

CS 423: Operating Systems Design

Page Replacement

31

  • 1. Find location of page on disk
  • 2. Find a free page frame
  • 1. If free page frame use it
  • 2. Otherwise, select a page frame using the page

replacement algorithm

  • 3. Write the selected page to the disk and update any

necessary tables

  • 3. Read the requested page from the disk.
  • 4. Restart instruction.
slide-32
SLIDE 32

CS 423: Operating Systems Design

Issue: Eviction

32

■ Hopefully, kick out a less-useful page

■ Dirty pages require writing, clean pages don’t

■ Hardware has a dirty bit for each page frame indicating this

page has been updated or not

■ Where do you write? To “swap space” on disk.

■ Goal: kick out the page that’s least useful ■ Problem: how do you determine utility?

■ Heuristic: temporal locality exists ■ Kick out pages that aren’t likely to be used again