Main Points. Address Transla+on Concept. Flexible Address Transla+on. Efficient Address Transla+on

Transcription

1 Address Transla+on

2 Main Points Address Transla+on Concept How do we convert a virtual address to a physical address? Flexible Address Transla+on Segmenta+on Paging Mul+level transla+on Efficient Address Transla+on Transla+on Lookaside Buffers Virtually and physically addressed caches

3 Address Transla+on Concept Processor Virtual Address Translation Invalid Raise Exception Valid Data Physical Address Physical Memory Data

4 Address Transla+on Goals Memory protec+on Isolate process to its only memory Prevent virus from re- wri+ng machine instruc+ons Memory sharing Shared libraries, interprocess communica+on Sparse addresses Dynamically allocated regions: heaps, stacks, mmap Efficiency Reduce fragmenta+on and copying Run+me lookup cost and TLB hit rate Transla+on table size Portability

5 Bonus Feature What if the kernel can regain control whenever a program reads or writes a par+cular virtual memory loca+on? Examples: Copy on write Zero on reference Fill on demand Demand paging Memory mapped files

6 Virtually Addressed Base and Bounds Processor s View Implementation Physical Memory Processor Virtual Address Virtual Memory Processor Virtual Address Base Physical Address Base Bound Base+ Bound Raise Exception

7 Virtually Addressed Base and Bounds Pros? Simple Fast (2 registers, adder, comparator) Safe Can relocate in physical memory without changing process Cons? Can t keep program from accidentally overwri+ng its own code Can t share code/data with other processes Can t grow stack/heap as needed

8 Process Regions or Segments Every process has logical regions or segments Con+guous region of process memory Code, data, heap, stack, dynamic library (code, data), memory mapped files, Each with its own protec+on: read- only, read- write, execute- only sharing: code vs. data access pa[ern: code vs. mmap file

9 Segmenta+on Segment is a con+guous region of virtual memory Each process has a segment table (in hardware) Entry in table = segment Segment can be located anywhere in physical memory Each segment has: start, length, access permission Processes can share segments Same start, length, same/different access permissions

10 Process View Processor Virtual Address Virtual Memory Code Data Heap Segmenta+on Processor Segment Virtual Address Implementation Offset Segment Table Base Bound Access Read R/W R/W R/W Physical Memory Stack Code Base 3 Base+ Bound 3 Base 0 Base+ Bound 0 Base 1 Stack Physical Address Raise Exception Data Base+ Bound 1 Base 2 Heap Base+ Bound 2

11 2 bit segment # 12 bit offset Virtual Memory main: 0:240 store #108, r2 0:244 store pc+8, r31 0:248 jump 360 0:24c strlen: 0:360 loadbyte (r2), r3 0:420 jump (r31) x: 1:108 a b c \0 Segment start x: 108 a b c \0 main: 4240 store #1108, r store pc+8, r jump c strlen: 4360 loadbyte (r2),r jump (r31) length code 0x4000 0x700 data 0 0x500 heap - - stack 0x2000 0x1000 Physical Memory

12 Processor s View Process 1`s View Implementation Physical Memory Virtual Memory P2`s Data Processor Virtual Address 0x0500 Code Data Heap Processor Seg. Offset Virtual Address Code Data Heap Stack Segment Table Base Bound Access Read R/W R/W R/W P1`s Heap P1`s Stack P1`s Data Process 2`s View Stack Physical Address P2`s Heap Processor Virtual Address 0x0500 Code Data Processor Seg. Offset Code Segment Table Base Bound Access Read P1 s+ P2`s Code P2`s Stack Heap Virtual Address Data Heap R/W R/W Stack R/W Stack

13 Ques+on With segmenta+on, what is saved/restored on a process context switch?

14 Pros? Segmenta+on Can share code/data segments between processes Can protect code segment from being overwri[en Cons? Complex memory management Need to find chunk of a par+cular size May need to rearrange memory to make room for new segment or growing segment (e.g., sbrk) External fragmenta+on: wasted space between chunks

15 Paged Transla+on Manage memory in fixed size units, or pages Finding a free page is easy Bitmap alloca+on: Each bit represents one physical page frame Each process has its own page table Stored in physical memory Hardware registers pointer to page table start page table length

16 Proces View Physical Memory Code0 Frame 0 VPage 0 VPage 1 Code Data Heap Data0 Heap1 Code1 Heap0 Data1 VPage N Stack Heap2 Stack 1 Stack 0 Frame M

17 Physical Memory Physical Address Frame 0 Frame 1 Processor Frame Offset Virtual Address Frame Page Table Access Page # Offset Virtual Address Page # Offset Physical Address Frame Offset Frame M

18 Process View A B C D E F G H I J K L Physical Memory Page Table I J K L E F G H A B C D

19 Paging Ques+ons With paging, what is saved/restored on a process context switch? Pointer to page table, size of page table Page table itself is in main memory What if page size is very small? What if page size is very large? Internal fragmenta+on: if we don t need all of the space inside a fixed size chunk

20 Paging and Sharing Can we use page tables to share memory between processes? Set page tables to point to same page frame Need core map Array of informa+on about each physical page frame Set of processes poin+ng to that page frame When reference count goes to zero, can reclaim!

21 Ques+on How big a user stack should I allocate? What if some programs need a large stack and others need a small one?

22 Expand Stack on Reference When program references memory beyond end of stack Page fault into OS kernel Kernel allocates some addi+onal memory How much? Remember to zero the memory to avoid accidentally leaking informa+on! Modify page table Resume process

23 UNIX fork seems inefficient Makes a complete copy of process Throw copy away on exec Do we need to make the copy? One solu+on: change the syscall interface!

24 Copy on Write Paging allows an efficient fork Copy page table of parent into child Mark all pages (in new/old page tables) as read- only Start child process; restart parent Trap into kernel on write (in child or parent) Copy page Mark both as writeable Resume execu+on

25 Ques+on Can I start running a program before all of its code is in memory?

26 Fill On Demand Set all page table entries to invalid When a page is referenced for first +me, kernel trap Kernel brings page in from disk Resume execu+on Remaining pages can be transferred in the background while program is running

27 Beyond Paging: Sparse Address Spaces Might want many separate segments Per- processor heaps Per- thread stacks Memory- mapped files Dynamically linked libraries What if virtual address space is large? 32- bits, 4KB pages => 500K page table entries 64- bits => 4 quadrillion page table entries

28 Mul+- level Transla+on Tree of transla+on tables Paged segmenta+on Mul+- level page tables Mul+- level paged segmenta+on All have pages as lowest level; why?

29 Mul+level Transla+on with Pages at Lowest Level Efficient memory alloca+on (vs. segments) Efficient for sparse addresses (vs. 1 level paging) Efficient disk transfers (fixed size units) Easier to build transla+on lookaside buffers Efficient reverse lookup (from physical - > virtual) Variable granularity for protec+on/sharing Except: see discussion of superpages

30 Paged Segmenta+on Process memory is segmented Segment table entry: Pointer to page table Page table length (# of pages in segment) Access permissions Page table entry: Page frame Access permissions Share memory or set access permissions at either page or segment- level

31 Implementation Physical Memory Processor Segment Virtual Address Page Offset Exception Page Table Frame Access Read Read Segment Table Page Table Size Access Frame Read R/W R/W R/W Physical Address Offset

32 Ques+on With paged segmenta+on, what must be saved/restored across a process context switch?

33 Mul+- level or hierarchical page tables Ex: 2- level page table Level 1 table: each PTE points to a page table Level 2 table: each PTE points to a page Can share/protect/page in/out at either level 1 or level 2 Level 1 Table... Level 2 Tables...

34 Implementation Physical Memory Processor Virtual Address Index 1 Index 2 Index 3 Level 1 Offset Frame Physical Address Offset Level 2 Level 3

35 Ques+on Write pseudo- code for transla+ng a virtual address to a physical address for a system using 3- level paging, with 8 bits of address per level

36 x86 Mul+level Paged Segmenta+on Global Descriptor Table (segment table) Each segment descriptor Pointer to (mul+level) page table Segment length Segment access permissions Context switch change global descriptor table register (GDTR), pointer to global descriptor table Side effect: invalidates TLB

37 x86 Mul+level Paging Omit sub- tree if no valid addresses Good for sparse address space 4KB pages Each level of page table fits in one page 32- bit: two level page table (per segment) 64- bit: four level page table (per segment)

38 x86-32 Paging VPN3 VPN4 12 VPO Virtual address Page Directory Page Table PDE PTE CR3 20 PPN 12 PPO Physical address

39 x86-64 Paging 16 Sign 9 VPN VPN2 VPN3 VPN4 12 VPO Virtual address Page Directory Page Map Level 4 Pointer Table Page Directory Page Table PM4LE PDPE PDE PTE CR3 36 PPN 12 PPO Physical address

40 Page directory entries (x86 32 bit) Empty Ignored 0 4MB page Bits 31:22 of address of 4MB page frame 0 Ign G 1 D A P C D P U W / T S R / 1 W Page table Bits 31:12 of address of page table Ign 0 I g n A P C D P U W / T S R / 1 W

41 Page table entries (x86 32 bit) Empty Ignored 0 4KB page Bits 31:12 of address of page frame Ign G 0 D A P C D P U W / T S R / 1 W

42 Small page transla+on CR3 register Address of page directory SBZ Virtual address PDE index PTE index Offset Address of PDE PDE Address of page directory PDE index 0 0 Page table base address Access control 1 Note: addresses in physical memory! Address of PTE Page table base address PTE index 0 0 PTE Small page base address Access control 1 Physical address Small page base address Offset

43 Page table for small pages Base address entries 4kB 4kB page 1024 entries 4kB Translates VA[21:12] Page table 4kB page Page directory VA[11:0] = offset in page Translates VA[31:22] Page table

44 Mul+level Transla+on Pros: Allocate/fill only page table entries that are in use Simple memory alloca+on Share at segment or page level Cons: Space overhead: one pointer per virtual page Mul+ple lookups per memory reference

45 Page Transla+on in the OS OS s need to keep their own data structures List of memory objects (segments) Virtual page - > physical page frame Physical page frame - > set of virtual pages Keep track of copy on write, load on demand, Why not just use the hardware page tables?

46 Kernel Page Transla+on Kernel maintains its own page transla+on data structures Portable, flexible Copy changes down into hardware page tables Example: Inverted page table Hash from virtual page - > physical page Space propor+onal to # of physical pages Example: virtual/shadow page table Linux kernel tables mirror x86 structure, even on ARM

47 Efficient Address Transla+on Transla+on lookaside buffer (TLB) Cache of recent virtual page - > physical page transla+ons If cache hit, use transla+on If cache miss, walk mul+- level page table Cost of transla+on = Cost of TLB lookup + Prob(TLB miss) * cost of page table lookup

48 TLB and Page Table Transla+on Processor Virtual Address TLB Virtual Address Miss Page Table Invalid Raise Exception Hit Valid Frame Frame Data Offset Physical Address Physical Memory Data

49 Virtual Address TLB Lookup Physical Memory Page# Offset Translation Lookaside Buffer (TLB) Virtual Page Page Frame Access Physical Address Matching Entry Frame Offset Page Table Lookup

50 Ques+on What happens on a context switch? Reuse TLB? Discard TLB? (xk resets TLB) Solu+on: Tagged TLB Each TLB entry has process ID TLB hit only if process ID matches current process

51 Processor Virtual Address Implementation Physical Memory Page Frame Page# Offset Process ID Matching Entry Translation Lookaside Buffer (TLB) Process ID Page Frame Access Frame Physical Address Offset Page Table Lookup

52 MIPS Address Transla+on Soxware- Loaded Transla+on lookaside buffer (TLB) Cache of virtual page - > physical page transla+ons If TLB hit, physical address If TLB miss, trap to kernel Kernel fills TLB with transla+on and resumes execu+on Kernel can implement any page transla+on Page tables Mul+- level page tables Inverted page tables

53 Ques+on What is the cost of a TLB miss on a modern processor? Cost of mul+- level page table walk MIPS: plus cost of trap handler entry/exit

54 Hardware Design Principle The bigger the memory, the slower the memory

55 Intel i7

56 Memory Hierarchy i7 has 8MB as shared 3 rd level cache; 2 nd level cache is per- core

57 Ques+on What is the cost of a first level TLB miss? Second level TLB lookup What is the cost of a second level TLB miss? 64 bit x86: 4- level page table walk How expensive is a 4- level page table walk?

58 Virtually Addressed vs. Physically Addressed Caches First level cache has at most a few cycles Delays every instruc+on fetch and data reference Lookup TLB to get physical address, then lookup physical address in the cache? Too slow! Instead, lookup virtual address in cache In parallel, lookup TLB in case of a cache miss

59 Virtually Addressed Caches Processor Virtual Address Virtual Cache Virtual Address Virtual Address Miss TLB Miss Page Invalid Table Raise Exception Hit Hit Valid Data Frame Frame Data Offset Physical Address Physical Memory Data

60 Ques+on With a virtual cache, what do we need to do on a context switch?

61 Physically Addressed Cache Processor Virtual Address Virtual Cache Virtual Address Miss TLB Virtual Address Miss Page Table Invalid Raise Exception Hit Hit Valid Data Frame Frame Data Offset Physical Address Physical Cache Hit Miss Physical Address Physical Memory Data Data

62 TLB Size (Intel Kaby Lake, 2017) First level TLB Instruc+on: 128 entries Data: 64 entries Second level TLB 1536 entries Modern server can have 10 TB (!) of DRAM 10-20% of server CPU +me spent in TLB misses

63 When Do TLBs Work/Not Work? Video Frame Buffer: 32 bits x 1K x 1K = 4MB Page# Video Frame Buffer 2017 laptop: 3K x 2K = 24MB 4K display: 4K x 3K = 48MB

64 Superpages On x86 and ARM, TLB entry can be A page A superpage: a set of con+guous, aligned pages x86: superpage is set of pages in one page table One page: 4KB One page table: 2MB One page table of page tables: 1GB One page table of page tables of page tables: 0.5TB

65 Virtual Address Superpages Physical Memory Page# SP Offset Offset Translation Lookaside Buffer (TLB) Matching Entry Superpage (SP) or Page# Superframe (SF) or Frame Access Frame Physical Address Offset Matching Superpage Page Table Lookup SF Offset

66 When Do TLBs Work/Not Work, part 2 What happens when the OS changes the permissions on a page? For demand paging, copy on write, zero on reference, TLB may contain old transla+on OS must ask hardware to purge TLB entry On a mul+core: TLB shootdown OS must ask each CPU to purge TLB entry

67 TLB Shootdown Processor 1 TLB = = Process ID 0 VirtualPage PageFrame Access 0x0053 0x0003 R/W 1 0x4OFF 0x0012 R/W Processor 2 TLB = = 0 0x0053 0x0003 R/W 0 0x0001 0x0005 Read Processor 3 TLB = = 1 0x4OFF 0x0012 R/W 0 0x0001 0x0005 Read

68 Virtual Cache Shootdown When permissions change for a page, we must shoot down the TLB entry on every CPU What about the contents of the virtual cache? Lazy shootdown of the virtual cache: Lookup virtually addressed cache and TLB in parallel Use the TLB to verify virtual address is s+ll valid! Evict entry from cache if not

69 Virtual Cache Aliases Alias: two (or more) virtual cache entries that refer to the same physical memory A consequence of a tagged virtually addressed cache! A write to one copy needs to update all copies Solu+on: Virtual cache keeps both virtual and physical address for each entry Lookup virtually addressed cache and TLB in parallel Check if physical address from TLB matches any other entries, and update/invalidate those copies

70 x86 caches 64 byte line size Physically indexed Physically tagged Write buffer

71 Mul+core and Hyperthreading Modern CPU has several func+onal units Instruc+on decode Arithme+c/branch Floa+ng point Instruc+on/data cache TLB Mul+core: replicate func+onal units (i7: 4) Share second/third level cache, second level TLB Hyperthreading: logical processors that share func+onal units (i7: 2) Be[er func+onal unit u+liza+on during memory stalls No difference from the OS/programmer perspec+ve Except for performance, affinity,

72 Address Transla+on Uses Process isola+on Keep a process from touching anyone else s memory, or the kernel s Efficient interprocess communica+on Shared regions of memory between processes Shared code segments E.g., common libraries used by many different programs Program ini+aliza+on Start running a program before it is en+rely in memory Dynamic memory alloca+on Allocate and ini+alize stack/heap pages on demand

73 Address Transla+on (more) Cache management Page coloring Program debugging Data breakpoints when address is accessed Zero- copy I/O Directly from I/O device into/out of user memory Memory mapped files Access file data using load/store instruc+ons Demand- paged virtual memory Illusion of near- infinite memory, backed by disk or memory on other machines

74 Address Transla+on (even more) Checkpoin+ng/restart Transparently save a copy of a process, without stopping the program while the save happens Persistent data structures Implement data structures that can survive system reboots Process migra+on Transparently move processes between machines Informa+on flow control Track what data is being shared externally Distributed shared memory Illusion of memory that is shared between machines