virtual memory 2 1 last time page table: map from virtual to - PowerPoint PPT Presentation

xv6: fjnding page table entries fjrst-level table (‘page directory’) phys. page# pgtab return value PTX(va) pgdir: pointer to fjrst-level page table (‘page directory’) retrieve (pointer to) page table entry from retrieve location of second-level page table PDX(va) PTE_ADDR(*pde) — return physical page address from page table entry convert page-table physical address to virtual retrieve (pointer to) second-level page table entry from second-level table check if fjrst-level page table entry is valid possibly create new second-level table + update fjrst-level table if it is not second-level PT 10 // Return the address of the PTE in page table pgdir pgtab = (pte_t*)P2V(PTE_ADDR(*pde)); // that corresponds to virtual address va. If alloc!=0, // create any required page table pages. { pde = &pgdir[PDX(va)]; if (*pde & PTE_P){ } return &pgtab[PTX(va)]; } fjrst-level PT static pte_t * walkpgdir(pde_t *pgdir, const void *va, int alloc) pde_t *pde; pgdir → pte_t *pgtab; pde → } else { ... /* create new second-level page table */

xv6: creating second-level page tables return NULL if not trying to make new page table U for “user-mode” (in addition to kernel) W for “writable” P for “present” (valid) with physical address of second-level page table create a fjrst-level page entry present = 0 PTE = 0 clear the new second-level page table (and return NULL if that fails) otherwise use kalloc to allocate it } ... *pde = V2P(pgtab) | PTE_P | PTE_W | PTE_U; // entries, if necessary. // be further restricted by the permissions in the page table // The permissions here are overly generous, but they can memset(pgtab, 0, PGSIZE); // Make sure all those PTE_P bits are zero. return 0; if (!alloc || (pgtab = (pte_t*)kalloc()) == 0) pgtab = (pte_t*)P2V(PTE_ADDR(*pde)); if (*pde & PTE_P){ 14 } else {

xv6: creating second-level page tables } U for “user-mode” (in addition to kernel) W for “writable” P for “present” (valid) with physical address of second-level page table create a fjrst-level page entry clear the new second-level page table (and return NULL if that fails) otherwise use kalloc to allocate it return NULL if not trying to make new page table *pde = V2P(pgtab) | PTE_P | PTE_W | PTE_U; ... // entries, if necessary. // be further restricted by the permissions in the page table // The permissions here are overly generous, but they can memset(pgtab, 0, PGSIZE); // Make sure all those PTE_P bits are zero. return 0; if (!alloc || (pgtab = (pte_t*)kalloc()) == 0) pgtab = (pte_t*)P2V(PTE_ADDR(*pde)); if (*pde & PTE_P){ 15 PTE = 0 → present = 0 } else {

xv6: creating second-level page tables return NULL if not trying to make new page table U for “user-mode” (in addition to kernel) W for “writable” P for “present” (valid) with physical address of second-level page table create a fjrst-level page entry present = 0 PTE = 0 clear the new second-level page table (and return NULL if that fails) otherwise use kalloc to allocate it } ... // entries, if necessary. // be further restricted by the permissions in the page table // The permissions here are overly generous, but they can memset(pgtab, 0, PGSIZE); // Make sure all those PTE_P bits are zero. return 0; if (!alloc || (pgtab = (pte_t*)kalloc()) == 0) pgtab = (pte_t*)P2V(PTE_ADDR(*pde)); if (*pde & PTE_P){ 15 } else { *pde = V2P(pgtab) | PTE_P | PTE_W | PTE_U;

xv6: creating second-level page tables ... U for “user-mode” (in addition to kernel) W for “writable” P for “present” (valid) create a fjrst-level page entry present = 0 PTE = 0 clear the new second-level page table (and return NULL if that fails) otherwise use kalloc to allocate it return NULL if not trying to make new page table } // entries, if necessary. // be further restricted by the permissions in the page table // The permissions here are overly generous, but they can memset(pgtab, 0, PGSIZE); // Make sure all those PTE_P bits are zero. return 0; if (!alloc || (pgtab = (pte_t*)kalloc()) == 0) pgtab = (pte_t*)P2V(PTE_ADDR(*pde)); if (*pde & PTE_P){ 15 with physical address of second-level page table } else { *pde = V2P(pgtab) | PTE_P | PTE_W | PTE_U;

xv6: creating second-level page tables return NULL if not trying to make new page table U for “user-mode” (in addition to kernel) W for “writable” P for “present” (valid) with physical address of second-level page table create a fjrst-level page entry present = 0 PTE = 0 clear the new second-level page table (and return NULL if that fails) otherwise use kalloc to allocate it } ... // entries, if necessary. // be further restricted by the permissions in the page table // The permissions here are overly generous, but they can memset(pgtab, 0, PGSIZE); // Make sure all those PTE_P bits are zero. return 0; if (!alloc || (pgtab = (pte_t*)kalloc()) == 0) pgtab = (pte_t*)P2V(PTE_ADDR(*pde)); if (*pde & PTE_P){ 15 } else { *pde = V2P(pgtab) | PTE_P | PTE_W | PTE_U;

aside: permissions xv6: sets fjrst-level page table entries with all permissons …but second-level entries can override 16

xv6 page table-related functions kalloc / kfree — allocate physical page, return kernel address walkpgdir — get pointer to second-level page table entry …to check it/make it valid/invalid/point somewhere/etc. mappages — set range of page table entries implementation: loop using walkpgdir allockvm — create new set of page tables, set kernel (high) part entries for 0x8000 0000 and up set allocate new fjrst-level table plus several second-level tables allocuvm — allocate new user memory setup user-accessible memory allocate new second-level tables as needed deallocuvm — deallocate user memory 17

xv6: setting last-level page entries return 0; and next virtual page ( va ) advance to next physical page ( pa ) and P for present with specifjed permission bits (write and/or user-mode) pointing to physical page at pa set page table entry to valid value in upcoming homework: this is not true in stock xv6: never change valid page table entry make sure it’s not already set (or fail if out of memory) get its page table entry for each virtual page in range: loop for a = va to va + size and pa = pa to pa + size } } static int pa += PGSIZE; { a = ( char *)PGROUNDDOWN((uint)va); for (;;){ if ((pte = walkpgdir(pgdir, a, 1)) == 0) 18 if (*pte & PTE_P) panic("remap"); *pte = pa | perm | PTE_P; if (a == last) break ; a += PGSIZE; mappages(pde_t *pgdir, void *va, uint size, uint pa, int perm) char *a, *last; pte_t *pte; last = ( char *)PGROUNDDOWN(((uint)va) + size − 1); return − 1;

xv6: setting process page tables ( exec() ) exec step 1: create new page table with kernel mappings setupkvm() (recall: kernel mappings — high addresses) exec step 2a: allocate memory for executable pages allocuvm() in loop new physical pages chosen by kalloc() exec step 2b: load executable pages from executable fjle loaduvm() in a loop copy from disk into newly allocated pages (in loaduvm() ) exec step 3: allocate pages for heap, stack ( allocuvm() calls) 20

create new page table (kernel mappings) } free everything on failure (no space for new second-level page tales) and not all physical addresses are usable) because some addresses need difgerent fmags (hard-coded table including fmag bits, etc. for everything above address 0x8000 0000 iterate through list of kernel-space mappings initialize to 0 — every page invalid (“page directory”) allocate fjrst-level page table } return pgdir; return 0; pde_t* freevm(pgdir); for (k = kmap; k < &kmap[NELEM(kmap)]; k++) panic("PHYSTOP too high"); if (P2V(PHYSTOP) > ( void *)DEVSPACE) memset(pgdir, 0, PGSIZE); return 0; if ((pgdir = (pde_t*)kalloc()) == 0) { setupkvm( void ) 22 pde_t *pgdir; struct kmap *k; if (mappages(pgdir, k − >virt, k − >phys_end − k − >phys_start, (uint)k − >phys_start, k − >perm) < 0) {

reading executables (headers) uint paddr; }; uint align; uint flags; uint memsz; uint filesz; xv6 executables contain list of sections to load, represented by: 24 uint vaddr; uint off; uint type; struct proghdr { /* <-- debugging-only or not? */ /* <-- location in file */ /* <-- location in memory */ /* <-- confusing ignored field */ /* <-- amount to load */ /* <-- amount to allocate */ /* <-- readable/writeable (ignored) */

reading executables (headers) xv6 executables contain list of sections to load, represented by: goto bad; if (loaduvm(pgdir, ( char *)ph.vaddr, ip, ph.off, ph.filesz) < 0) ... goto bad; if ((sz = allocuvm(pgdir, sz, ph.vaddr + ph.memsz)) == 0) ... }; uint align; uint flags; uint memsz; uint filesz; uint paddr; uint vaddr; uint off; uint type; struct proghdr { 24 /* <-- debugging-only or not? */ /* <-- location in file */ /* <-- location in memory */ /* <-- confusing ignored field */ /* <-- amount to load */ /* <-- amount to allocate */ /* <-- readable/writeable (ignored) */

reading executables (headers) xv6 executables contain list of sections to load, represented by: name of the fjeld in struct proc sz — top of heap of new program goto bad; if (loaduvm(pgdir, ( char *)ph.vaddr, ip, ph.off, ph.filesz) < 0) ... goto bad; if ((sz = allocuvm(pgdir, sz, ph.vaddr + ph.memsz)) == 0) ... }; uint align; uint flags; 24 uint memsz; uint filesz; uint paddr; uint vaddr; uint off; uint type; struct proghdr { /* <-- debugging-only or not? */ /* <-- location in file */ /* <-- location in memory */ /* <-- confusing ignored field */ /* <-- amount to load */ /* <-- amount to allocate */ /* <-- readable/writeable (ignored) */

allocating user pages if (mappages(pgdir, ( char *)a, PGSIZE, V2P(mem), PTE_W|PTE_U) < 0){ plus expanding heap on request this function used for initial allocation add page to second-level page table allocate a new, zero page } } return 0; kfree(mem); deallocuvm(pgdir, newsz, oldsz); cprintf("allocuvm out of memory (2)\n"); memset(mem, 0, PGSIZE); } return 0; deallocuvm(pgdir, newsz, oldsz); cprintf("allocuvm out of memory\n"); if (mem == 0){ mem = kalloc(); for (; a < newsz; a += PGSIZE){ a = PGROUNDUP(oldsz); ... { 25 allocuvm(pde_t *pgdir, uint oldsz, uint newsz)

reading executables (headers) xv6 executables contain list of sections to load, represented by: goto bad; if (loaduvm(pgdir, ( char *)ph.vaddr, ip, ph.off, ph.filesz) < 0) ... goto bad; if ((sz = allocuvm(pgdir, sz, ph.vaddr + ph.memsz)) == 0) ... }; uint align; uint flags; uint memsz; uint filesz; uint paddr; uint vaddr; uint off; uint type; struct proghdr { 26 /* <-- debugging-only or not? */ /* <-- location in file */ /* <-- location in memory */ /* <-- confusing ignored field */ /* <-- amount to load */ /* <-- amount to allocate */ /* <-- readable/writeable (ignored) */

loading user pages from executable return 0; P2V(pa) — mapping of physical addresss in kernel memory copy from fjle (represented by struct inode ) into memory then into a virtual address again) (instead of turning it into a physical address, exercise: why don’t we just use addr directly? for read from disk convert back to (kernel) virtual address get physical address from page table entry look up address to load into already allocated earlier get page table entry being loaded } } if (readi(ip, P2V(pa), offset+i, n) != n) n = PGSIZE; else pa = PTE_ADDR(*pte); panic("loaduvm: address should exist"); if ((pte = walkpgdir(pgdir, addr+i, 0)) == 0) for (i = 0; i < sz; i += PGSIZE){ ... { 27 loaduvm(pde_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz) if (sz − i < PGSIZE) n = sz − i; return − 1;

kalloc/kfree kalloc/kfree — xv6’s physical memory allocator keep linked list of free pages list nodes — stored in corresponding free page itself kalloc — return fjrst page in list kfree — add page to list linked list created at boot usuable memory fjxed size (224MB) determined by PHYSTOP in memlayout.h 29 allocates/deallocates whole pages only

xv6 program memory invalid adjusted by sbrk() system call myproc()->sz initial stack pointer 30 KERNBASE argument 0 ... heap argument N 0 nul-terminated string address of argument 0 argv[argc] ... address of argument N argv[0] stack PAGESIZE address of address of argv argument of main guard page argument 0 argc argc argument of main data 0xFFFFFFF return PC for main (empty) text 0

guard page 1 page after stack at lower addresses since stack grows towards lower addresses marked as kernel-mode-only 31 idea: stack overfmow → protection fault → kills program

skipping the guard page void example() { int array[2000]; array[0] = 1000; ... } example: subl $8024, %esp // allocate 8024 bytes on stack movl $1000, 12(%esp) // write near bottom of allocation // goes beyond guard page // since not all of array init'd .... 32

xv6 program memory invalid adjusted by sbrk() system call myproc()->sz initial stack pointer 33 KERNBASE argument 0 ... heap argument N 0 nul-terminated string address of argument 0 argv[argc] ... address of argument N argv[0] stack PAGESIZE address of address of argv argument of main guard page argument 0 argc argc argument of main data 0xFFFFFFF return PC for main (empty) text 0

xv6 program memory invalid myproc()->sz initial stack pointer 33 KERNBASE argument 0 ← adjusted by sbrk() system call ... heap argument N 0 nul-terminated string address of argument 0 argv[argc] ... address of argument N argv[0] stack PAGESIZE address of address of argv argument of main guard page argument 0 argc argc argument of main data 0xFFFFFFF return PC for main (empty) text 0

xv6 heap allocation xv6: every process has a heap at the top of its address space yes, this is unlike Linux where heap is below stack tracked in struct proc with sz = last valid address in process position changed via sbrk(amount) system call sets sz += amount same call exists in Linux, etc. — but also others 34

sbrk sys_sbrk() { if (argint(0, &n) < 0) if (growproc(n) < 0) return addr; } sz : current top of heap sbrk(N) : grow heap by (shrink if negative) returns old top of heap (or -1 on out-of-memory) 35 return − 1; addr = myproc() − >sz; return − 1;

sbrk sys_sbrk() { if (argint(0, &n) < 0) if (growproc(n) < 0) return addr; } sz : current top of heap returns old top of heap (or -1 on out-of-memory) 35 sbrk(N) : grow heap by N (shrink if negative) return − 1; addr = myproc() − >sz; return − 1;

sbrk sys_sbrk() { if (argint(0, &n) < 0) if (growproc(n) < 0) return addr; } sz : current top of heap sbrk(N) : grow heap by (shrink if negative) returns old top of heap (or -1 on out-of-memory) 35 return − 1; addr = myproc() − >sz; return − 1;

growproc growproc( int n) calls kalloc to get each page maps pages for addresses sz to sz + n allocuvm — same function used to allocate initial space } return 0; switchuvm(curproc); } 36 uint sz; if (n > 0){ { struct proc *curproc = myproc(); sz = curproc − >sz; if ((sz = allocuvm(curproc − >pgdir, sz, sz + n)) == 0) return − 1; } else if (n < 0){ if ((sz = deallocuvm(curproc − >pgdir, sz, sz + n)) == 0) return − 1; curproc − >sz = sz;

/* in some user program: */ /* in trap() in trap.c: */ xv6 page faults (now) accessing page marked invalid (not-present) — triggers page fault xv6 now: default case in trap() function *(( int *) 0x800444) = 1; ... cprintf("pid %d %s: trap %d err %d on cpu %d " "eip 0x%x addr 0x%x--kill proc\n", myproc() >pid, myproc() >name, tf >trapno, tf >err, cpuid(), tf >eip, rcr2()); myproc() >killed = 1; pid 4 processname: trap 14 err 6 on cpu 0 eip 0x1a addr 0x800444--kill proc trap 14 = T_PGFLT special register CR2 contains faulting address 37

xv6 page faults (now) accessing page marked invalid (not-present) — triggers page fault xv6 now: default case in trap() function *(( int *) 0x800444) = 1; ... cprintf("pid %d %s: trap %d err %d on cpu %d " "eip 0x%x addr 0x%x--kill proc\n", pid 4 processname: trap 14 err 6 on cpu 0 eip 0x1a addr 0x800444--kill proc trap 14 = T_PGFLT special register CR2 contains faulting address 37 /* in some user program: */ /* in trap() in trap.c: */ myproc() − >pid, myproc() − >name, tf − >trapno, tf − >err, cpuid(), tf − >eip, rcr2()); myproc() − >killed = 1;

xv6 page faults (now) accessing page marked invalid (not-present) — triggers page fault xv6 now: default case in trap() function *(( int *) 0x800444) = 1; ... cprintf("pid %d %s: trap %d err %d on cpu %d " "eip 0x%x addr 0x%x--kill proc\n", trap 14 = T_PGFLT special register CR2 contains faulting address 37 /* in some user program: */ /* in trap() in trap.c: */ myproc() − >pid, myproc() − >name, tf − >trapno, tf − >err, cpuid(), tf − >eip, rcr2()); myproc() − >killed = 1; pid 4 processname: trap 14 err 6 on cpu 0 eip 0x1a addr 0x800444--kill proc

xv6 page faults (now) accessing page marked invalid (not-present) — triggers page fault xv6 now: default case in trap() function *(( int *) 0x800444) = 1; ... cprintf("pid %d %s: trap %d err %d on cpu %d " "eip 0x%x addr 0x%x--kill proc\n", pid 4 processname: trap 14 err 6 on cpu 0 eip 0x1a addr 0x800444--kill proc trap 14 = T_PGFLT special register CR2 contains faulting address 37 /* in some user program: */ /* in trap() in trap.c: */ myproc() − >pid, myproc() − >name, tf − >trapno, tf − >err, cpuid(), tf − >eip, rcr2()); myproc() − >killed = 1;

void *address = ( void *) rcr2(); xv6: if one handled page faults // actual segfault, kill process that is, immediately after returning from fault if so, setup the page table so it works next time check process control block to see if access okay } } myproc() >killed = 1; cprintf("..."); // return from fault, retry access } else { alternative to crashing: update the page table and return setup_page_table_entry_for(myproc(), address); if (is_address_okay(myproc(), address)) { if (tf >trapno == T_PGFLT) { pseudocode for xv6 implementation (for trap()) example: don’t actually allocate memory until it’s needed “just in time” update of the process’s memory 38 returning from page fault handler normally retries failing instruction

xv6: if one handled page faults } else { that is, immediately after returning from fault if so, setup the page table so it works next time check process control block to see if access okay } } cprintf("..."); // actual segfault, kill process // return from fault, retry access alternative to crashing: update the page table and return setup_page_table_entry_for(myproc(), address); if (is_address_okay(myproc(), address)) { pseudocode for xv6 implementation (for trap()) example: don’t actually allocate memory until it’s needed “just in time” update of the process’s memory 38 returning from page fault handler normally retries failing instruction if (tf − >trapno == T_PGFLT) { void *address = ( void *) rcr2(); myproc() − >killed = 1;

page fault tricks OS can do all sorts of ‘tricks’ with page tables key idea: what processes think they have in memory != their actual memory OS fjxes disagreement from page fault handler 39

space on demand Used by OS Program Memory Stack Heap / other dynamic Writable data Code + Constants used stack space (12 KB) wasted space? (huge??) OS would like to allocate space only if needed 40

allocating space on demand … 0x7FFFE 1 0x12347 0x7FFFF 1 0x12345 … … 1 pushq triggers exception hardware says “accessing address 0x7FFFBFF8 ” OS looks up what’s should be there — “stack” page fault! in exception handler, OS allocates more stack space OS updates the page table then returns to retry the instruction restarted 0x12340 0x7FFFD ... 0x200DF // requires more stack space A: pushq %rbx C: addq %rbx, %rax ... %rsp = 0x7FFFC000 VPN page … … … 0x7FFFB 0 --- 0x7FFFC 1 41 valid? physical B: movq 8(%rcx), %rbx

allocating space on demand … 0x7FFFE 1 0x12347 0x7FFFF 1 0x12345 … … 1 pushq triggers exception hardware says “accessing address 0x7FFFBFF8 ” OS looks up what’s should be there — “stack” page fault! in exception handler, OS allocates more stack space OS updates the page table then returns to retry the instruction restarted 0x12340 0x7FFFD ... 0x200DF // requires more stack space A: pushq %rbx C: addq %rbx, %rax ... %rsp = 0x7FFFC000 VPN page … … … 0x7FFFB 1 0x200D8 0x7FFFC 1 41 valid? physical B: movq 8(%rcx), %rbx

exercise stack pointer is initially a multiple of 4096. I. something else? C. 128 bytes H. depends on cache block size B. 64 bytes A. 16 bytes void foo() { How much physical memory is allocated for array ? stores to or allocation of array , the compiler doesn’t initialize array , and the 4096-byte pages, stack allocated on demand, compiler optimizations don’t omit the } } array[i] = 100; 42 char array[1024 * 128]; for ( int i = 0; i < 1024 * 128; i += 1024 * 16) { D. 4096 bytes ( 4 · 1024 ) G. 131072 bytes ( 128 · 1024 ) E. 16384 bytes ( 16 · 1024 ) F. 32768 bytes ( 32 · 1024 )

space on demand really common for OSes to allocate a lot space on demand sometimes new heap allocations sometimes global variables that are initially zero benefjt: malloc/new and starting processes is faster also, similar strategy used to load programs on demand (more on this later) future assigment: add allocate heap on demand in xv6 43

xv6: adding space on demand struct proc { uint sz; // Size of process memory (bytes) ... }; xv6 tracks “end of heap” (now just for sbrk() ) adding allocate on demand logic for the heap: on sbrk(): don’t change page table right away kill process — out of bounds fjnd virtual page number of address allocate page of memory, add to page table return from interrupt 44 on page fault: if address ≥ sz on page fault: if address < sz

versus more complicated OSes typical desktop/server: range of valid addresses is not just 0 to maximum need some more complicated data structure to represent 45

fast copies recall : fork() (usually, the copy then calls execve — replaces itself with another program) how isn’t this really slow? 46 creates a copy of an entire program!

do we really need a complete copy? Used by OS bash Stack Heap / other dynamic Writable data Code + Constants Used by OS new copy of bash Stack Heap / other dynamic Writable data Code + Constants shared as read-only can’t be shared? 47

trick for extra sharing sharing writeable data is fjne — until either process modifjes the copy can we detect modifjcations? trick: tell CPU (via page table) shared part is read-only processor will trigger a fault when it’s written 48

both processes share all physical pages copy-on-write and page tables 0 0x12340 0 1 0x00603 0x12347 0x00602 1 1 0x12345 0 1 0x00601 … 0x00604 0 … 0x200DF 0x00605 1 0 0x200AF … … … … copy operation actually duplicates page table but marks pages in both copies as read-only when either process tries to write read-only page triggers a fault — OS actually copies the page after allocating a copy, OS reruns the write instruction … … VPN 1 0x12347 1 1 0x00602 0x12345 1 0x00601 1 … … … … page valid? write?physical 0x00603 1 page 0x200AF valid? write?physical VPN … … … … 1 0x12340 1 0x00605 0x200DF 1 1 0x00604 49

copy-on-write and page tables 1 … 0x00601 1 0 0x12345 0x00602 1 0 0x12347 0x00603 1 0 0x12340 0x00604 0 … … after allocating a copy, OS reruns the write instruction triggers a fault — OS actually copies the page when either process tries to write read-only page but marks pages in both copies as read-only both processes share all physical pages copy operation actually duplicates page table … 0x200DF … … 0x200AF 0 1 0x00605 … … VPN 1 0x12347 0 1 0x00602 0x12345 0 0x00601 1 … … … … page valid? write?physical 0x00603 0 page 0x200AF valid? write?physical VPN … … … … 0 0x12340 1 0x00605 0x200DF 0 1 0x00604 49

virtual memory 2 1 last time page table: map from virtual to - PowerPoint PPT Presentation

virtual memory 2 1 last time page table: map from virtual to physical pages omit parts of second level that are entirely invalid last-level points to actual program data fjrst-level points to location of second-level split up virtual page

Virtual Memory and Virtual Memory and Demand Paging Demand Paging Virtual Memory Illustrated

Lecture 19: Virtual Memory Virtual Memory concept, Virtual- physical translation, page table,

Virtual Memory Questions? ! What is virtual memory and when is it useful? CSCI [4|6] 730 ! What is

Lecture 23: Virtual Memory, Multiprocessors Todays topics: Virtual memory

Lecture 24: Virtual Memory, Multiprocessors Todays topics: Virtual memory

Shared Memory OS Lecture 9 UdS/TUKL WS 2015 MPI-SWS 1 Review: Virtual Memory How is virtual

Virtual Memory Virtual Memory - The games we play with addresses and the memory behind them

Virtual Memory Questions? What is virtual memory and when is it useful? CSCI [4|6] 730

Virtual Memory: Demand Paging and Replacment Virtual Memory Illustrated virtual physical

Lecture 21: Virtual Memory, I/O Basics Todays topics: Virtual memory I/O overview

Virtual Memory Goals for Today Virtual memory Mechanism Mechanism How does it

Last class: Virtual Memory Today: Virtual Memory Uses Efficient Use of Physical

Virtual Memory Logical address space can therefore be much larger than physical address

Last class: Paging Today: Virtual Memory Virtual Memory What if programs

Chapter 9: Virtual Memory Chapter 9: Virtual Memory Background Demand Paging

LECTURE 12 Virtual Memory VIRTUAL MEMORY Just as a cache can provide fast, easy access to

Unit 7: Virtual Memory TLBs and memory hierarchy issues

Operating Systems WT 2019/20 Memory Management Shared Memory Process 1 virtual memory most

Virtual Memory Programmer can assume he/she has infinite amount of physical memory

Chapter 10: Virtual Memory Questions? What is virtual memory and when is it useful? CSCI

Virtual Memory Eric McCreath Introduction Virtual memory is a technique that permits processes

Memory Management (Virtual Memory) Mehdi Kargahi School of ECE University of Tehran Spring

Virtual Memory 1 Virtual Memory Main memory is cache for secondary storage

Protecting Memory What is there to protect in memory? Page tables and virtual memory