Virtual Memory 1

Virtual Memory 1

Virtual Memory 1 To do … q Segmentation q Paging q A hybrid system Address spaces and multiple processes IBM OS/360 – Split memory in n parts (possible != sizes) 0 – A process per partition Operating System Program 64K Code Partition 1 Heap 128K Partition 2 (free) 256K Stack Partition 3 320K Partition 4 512K How do deal with large address spaces with potentially a lot of free space? 2 The overlay solution Split programs into pieces (overlays), keep in memory only what’s needed Overlay approach (~1960s) – Swapping was done by the OS, but – Splitting was done manually by the user – Easy on the OS, hard on programmers Symbol tables 20K Overlay for a two-pass assembler: Pass 1 70KB Common Pass 2 80KB routines 30K Symbol Table 20KB Common Routines 30KB Overlay 10K Total 200KB driver Two overlays: 120 + 130KB Pass 2 Pass 1 70K 80K 3 Virtual memory – Goals Transparency – Programs should not know that memory is virtualized – Program flexibility – processes can run in machines with less physical memory than they need Efficiency – Both in time and space; not making processes too slow and using physical memory efficiently Protection – Isolating processes from each other; i.e., a process should not be able to access the memory of any other or the OS itself 4 Virtual memory – Segmentation Hide the complexity, let the OS do the job How? A related idea, to generalize base/limit – Each segment can grow independently – Only used space is allocated Program Code – Yes, segmentation fault (segfault) comes Heap from this! (free) Stack <base> <limit> Heap <base> <limit> Stack Stack Code <base> <limit> Heap Program Code 5 Which segment? How does the HW know which segment an address refers to? Explicit approach – With three segments, use two bits of the virtual address – The rest are offset into the segment // Get segment number Segment = (VirtAddr & SEG_MASK) >> SEG_SHIFT; // Now get offset Offset = VirtAddr & OFFSET_MASK; 13 12 11 10 9 8 7 6 5 4 3 2 1 0 if (Offset >= Limit[Segment]) /* protection fault */ else PhysAddr = Base[Segment] + Offset Segment Offset ... Implicit – how was the address formed? – PC? Code segment; from the stack or base pointer? Stack ... 6 Sharing and fragmentation With a little bit more HW support – sharing memory segments (e.g., code) – Just a few bits per segments for read/write/execute rights Rather than code, stack, … finer grain segmentation – OS can keep track of segments in use and manage memory more efficiently – A segment table to track them – Need more HW support Many small variable-sized segments … – External fragmentation! – Compaction is expensive, free-list management may help a bit 7 And then came paging Avoid fragmentation from variable-sized blocks – Use fixed-sized blocks – pages Virtual address space split into pages – Each a contiguous range of addresses Physical memory split into page frames Virtual memory Page 0 Pages mapped Physical memory to page frames Page frame 0 Page 1 Page frame 1 Page 2 … … Page frame M Page N 8 Virtual memory – paging Pages and page frames are, typically, = size – Many processors support multiple page sizes (e.g., x86-64: 4KB, 2MB, 1GB) Pages are mapped onto frames – Doing the translation – OS + MMU – Key – not all pages have to be in at once – If page is in memory, system does the mapping else, OS is told to get the missing page and re-execute the failed instruction 9 Paging – Good for everyone For developers – Memory seems a contiguous address space with size independent of hardware – Simple and flexible – no assumptions on how memory is used For memory manager – Physical memory can be used efficiently with minimal internal (small units) & no external fragmentation (fixed size units) Protection is easy since processes can’t access each other’s memory 10 Address translation with paging Virtual to physical address – Two parts – virtual page number and offset 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 Virtual Page # Offset – Virtual page number – index into a page table – Page table maps virtual pages to page frames • Managed by the OS • One entry per page in virtual address space – Physical address – page number and offset 11 Address translation with paging Virtual address Physical memory Virtual page # offset Page frame 0 Page table Physical address Page frame i Page frame # Page frame # offset Page frame N Each process has its own page table 12 Translation in action MMU with 16 4KB pages Page # (first 4 bits) index into page table Physical Page # Offset If not there 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 – Page fault 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 Else 15 000 0 – Output register + 14 000 0 – 12 bit offset → 13 000 0 12 000 0 – 15 bit physical 11 111 1 address 2 110 1 110 1 001 1 Present Bit 0 010 1 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 Virtual Page # Offset 13 Pages, page frames and tables A simple example with 64KB virtual address space 4KB pages Virtual address 32KB physical address space space 60-64K X 16 pages and 8 page frames 56-60K X 52-56K X 48-52K X 44-48K 7 40-44K X Physical 36-40K 5 memory Try to access : address 32-36K X • MOV REG, 0 28-32K X 28-32K Virtual address 0 24-28K X 24-28K Page frame 2 20-24K 3 20-24K Physical address 8192 16-20K 4 16-20K 12-16K 0 12-16K 8-12K 6 8-12K 4-8K 1 4-8K 0-4K 2 0-4K 14 Pages, page frames and tables A simple example with 64KB virtual address space 4KB pages Virtual address 32KB physical address space space 60-64K X 16 pages and 8 page frames 56-60K X 52-56K X 48-52K X 44-48K 7 40-44K X Physical Try to access : 36-40K 5 memory address • MOV REG, 8192 32-36K X Virtual address 8192 28-32K X 28-32K Page frame 6 24-28K X 24-28K Physical address 24576 20-24K 3 20-24K 16-20K 4 16-20K • MOV REG, 20500 12-16K 0 12-16K Virtual address 20500 (20480 + 20) 8-12K 6 8-12K Page frame 3 4-8K 1 4-8K Physical address 20+12288 0-4K 2 0-4K 15 Since virtual memory >> physical memory Use a present/absent bit MMU checks – Virtual address – If not there, “page fault” to the OS space (trap) 60-64K X 56-60K X – OS picks a victim (?) 52-56K X – … sends victim to disk 48-52K X 44-48K 7 – … brings new one 40-44K X Physical 36-40K 5 memory address – … updates page table 32-36K X 28-32K X 28-32K 24-28K X 24-28K 20-24K 3 20-24K 16-20K 4 16-20K MOVE REG, 32780 12-16K 0 12-16K Virtual address 32780 8-12K 6 8-12K Virtual page 8, byte 12 (32768+12) 4-8K 1 4-8K Page is unmapped – page fault! 0-4K 2 0-4K 16 Page table entry An opportunity – there’s a PTE lookup per memory ref., what else can we do with it? Looking at the details Caching disabled Modified Present/absent Page frame number Referenced Protection – Page frame number – the most important field – Protection – 1 bit for R&W or R or 3 bits for RWX 17 Page table entry Looking at the details Caching disabled Modified Present/absent Page frame number Referenced Protection – Present/absent bit • Says whether or not the virtual address is used – Modified (M): dirty bit • Set when a write to the page has occurred – Referenced (R): Has it being used? – To ensure we are not reading from cache (D) • Key for pages that map onto device registers rather than memory 18 Segmentation and paging Segmentation pros and cons ✔– It’s more logical –✔ Facilitates sharing and reuse –✗ But all the problems of variable partitions Paging pros and cons –✔ Easy to allocate physical memory –✔ Naturally leads to virtual memory –✗ Address translation time ✗ – Page tables can be large 19 Segmentation w/ paging - MULTICS Large segment? Page them – MULTICS, x86 and x86-64 MULTICS: process’ virtual memory – 218 segments of ~64K words (36-bit) – Each process has a segment table (itself a paged segment) – Segment table address found in a Descriptor segment Descriptor Base Register; one entry …. per segment Segment desc. Segment desc. Segment desc. Segment desc. Segment desc. Segment desc. Segment desc. 20 Segmentation w/ paging - MULTICS Most (but not all) segments are paged Segment descriptor indicates if in memory and points to page table – Address of segment in secondary memory in another table Segment # to get segment descriptor Page table Virtual Address Descriptor …. segment Segment # (18b) PageSegment # (6b) offset Offset # (16b) (10b) Page entry …. Page entry Segment desc. Page entry Address within Segment desc. the segment …. Segment desc. Page entry Page entry Page entry 21 Segmentation w/ paging - MULTICS If segment in mem, segment’s page table is in memory Protection violation? Fault Look at the page table’s entry - is page in memory? Page fault Add offset to page origin to get word location … to speed things up – cache (TLB, first system) 18 9 1 1 1 3 3 Segment Main memory address Segment length Descriptor of the page table (in pages) Page size 0 – 1024 words 1 = 64 words Segment paged? Misc bits Protection bits 22 Next … considerations with page tables Two key issues with page tables Mapping must be fast – Done on every memory reference, at least 1 per instruction With large address spaces, page tables will be large – 32b & 4KB page → 12 bit offset, 20 bit page # ~ 1million PTE – 64b & 4KB page → 212 (offset) + 252 pages ~ 4.5x1015!!! Simplest solutions – Page table in registers • Fast during execution, $$$ & slow to context switch – Page table in memory & Page Table Base Register (PTBR) • Fast to context switch & cheap, but slow during execution 23 And now a short break … xkcd 24 .

View Full Text

Details

  • File Type
    pdf
  • Upload Time
    -
  • Content Languages
    English
  • Upload User
    Anonymous/Not logged-in
  • File Pages
    24 Page
  • File Size
    -

Download

Channel Download Status
Express Download Enable

Copyright

We respect the copyrights and intellectual property rights of all users. All uploaded documents are either original works of the uploader or authorized works of the rightful owners.

  • Not to be reproduced or distributed without explicit permission.
  • Not used for commercial purposes outside of approved use cases.
  • Not used to infringe on the rights of the original creators.
  • If you believe any content infringes your copyright, please contact us immediately.

Support

For help with questions, suggestions, or problems, please contact us