1 / 30

Recitation 9 (Nov. 8)

Outline Virtual memory Lab 6 hints Reminders Lab 6: Get correctness points Exam 2: Nov. 16 (Next Tue). Minglong Shao shaoml+213@cs.cmu.edu Office hours: Thursdays 5-6PM Wean Hall 1315. Recitation 9 (Nov. 8). Virtual memory (VM). One of the most important concepts in CS

minh
Download Presentation

Recitation 9 (Nov. 8)

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Outline Virtual memory Lab 6 hints Reminders Lab 6: Get correctness points Exam 2: Nov. 16 (Next Tue) Minglong Shao shaoml+213@cs.cmu.edu Office hours: Thursdays 5-6PM Wean Hall 1315 Recitation 9 (Nov. 8)

  2. Virtual memory (VM) • One of the most important concepts in CS • Why use virtual memory (VM) • Use RAM as a cache for disk • Easier memory management • Access protection

  3. 0: 1: CPU N-1: Virtual memory Memory Page Table Virtual Addresses Physical Addresses 0: 1: P-1: Disk Page, page table, page hits, page faults Demand paging

  4. Conceptual address translation • Higher bits of address (page number) mapped from virtual addr. to physical addr. • Lower bits (page offset) stay the same. p p–1 0 n–1 virtual address virtual page number (VPN) page offset address translation m–1 p p–1 0 physical page number (PPN) page offset physical address

  5. Address translation through page table • Translation • Separate (set of) page table(s) per process • VPN forms index into page table (points to a page table entry)

  6. hit miss VA PA TLB Lookup Cache Main Memory CPU miss hit Trans- lation data Integrating VM and cache • Most caches are physically addressed • Perform address translation before cache lookup • Another cache: Translation Lookaside Buffer

  7. Address translation with TLB n–1 p p–1 0 virtual address virtual page number page offset valid tag physical page number TLB . . . = TLB hit physical address tag byte offset index valid tag data Cache = data cache hit

  8. Example • Understand end-to-end addr. translation • 20-bit virtual addresses • 18-bit physical addresses • Page size is 1024 bytes • TLB is 2-way associative with 16 total entries

  9. Example: TLB and page table

  10. 0 16 14 13 12 11 10 9 2 1 6 5 4 3 17 18 7 8 2 15 10 0 1 16 15 14 17 12 19 13 9 8 7 6 5 4 3 11 Part 1 • A. Virtual address • B. Physical address TLBT TLBI VPN VPO PPN PPO

  11. Part 2 Virtual address 0x78E6 • A. 078E6 = • B. Address translation • C. Physical address 0000 0111 1000 1110 0110 01 0101 1100 1110 0110

  12. Part 2 Virtual address 0x04AA4 • A. 04AA4 = 0000 0100 1010 1010 0100 • B. Address translation • C. Physical address 01 1010 0010 1010 0100

  13. End-to-end address translation • Section 10.6.4: a concrete example • Read carefully and solve practice problem 10.4 • Multi-level page table

  14. Malloc Lab (Lab 6) • Submit twice • Checkpoint submission: • Only check correctness: 15 pts • Final submission: • Correctness: 10 pts • Performance: 60 pts • Interposition test: 5 pts • Style: 5 pts • Start early!! • Get correctness points this week

  15. Design options • Organize free blocks • Implicit free list • Explicit free list • Segregate lists/search trees • Find free blocks • First fit/next fit • Blocks sorted by address with first fit • Best fit • Large design space • Step by step

  16. Example implementation • Section 10.9.12 • Understand every line of the code • Implicit free list + immediate boundary tag coalescing + first fit • Code is available at http://csapp.cs.cmu.edu/public/ics/code/vm/malloc.c • Use it as a starting point

  17. Block format Header 32 bits Payload Pointer returned by malloc (Block Pointer (bp)) >= what user asked for in malloc Footer 32 bits

  18. 3 2 1 0 31 size 0 0 a Header/footer format • Double word alignment • Three lower-order bits of size always 0 • Pack size and allocated bits into a single integer • Size = 24 (0x18). Block is allocated Header = 0 x18 | 0x1 = 0x19

  19. Heap format Allocated and Free Blocks 4 bytes Pad Prologue Epilogue 8|1 8|1 HDR FTR HDR FTR 0|1 Double Word Alignment (8 bytes)

  20. Very useful macros • #define WSIZE 4 • #define DSIZE 8 • #define CHUNKSIZE (1<<12) • #define OVERHEAD 8

  21. Very useful macros • #define PACK(size, alloc) ((size) | (alloc)) • #define GET(p) (*(size_t*)(p)) • #define PUT(p, val) (*(size_t*)(p) = (val)) • #define GET_SIZE(p) (GET(p) & ~0x7) • #define GET_ALLOC(p) (GET(p) & 0x1)

  22. Very useful macros • #define HDRP(bp) ((char *)(bp) - WSIZE) • #define FTRP(bp) ((char *)(bp) + GET_SIZE(HDRP(bp)) - DSIZE) • #define NEXT_BLKP(bp) ((char *)(bp) + GET_SIZE(((char *)(bp) - WSIZE))) • #define PREV_BLKP(bp) ((char *)(bp) - GET_SIZE(((char *)(bp) - DSIZE)))

  23. Initializing the heap int mm_init(void) { if ((heap_listp = mem_sbrk(4*WSIZE)) == NULL) return -1; PUT(heap_listp, 0); PUT(heap_listp+WSIZE, PACK(OVERHEAD, 1)); PUT(heap_listp+DSIZE, PACK(OVERHEAD, 1)); PUT(heap_listp+WSIZE+DSIZE, PACK(0, 1)); heap_listp += DSIZE; if (extend_heap(CHUNKSIZE/WSIZE) == NULL) return -1; return 0; }

  24. Extending the heap static void *extend_heap(size_t words) { char *bp; size_t size; size = (words % 2) ? (words+1)*WSIZE : words*WSIZE; if ((int)(bp = mem_sbrk(size)) < 0) return NULL; PUT(HDRP(bp), PACK(size, 0)); PUT(FTRP(bp), PACK(size, 0)); PUT(HDRP(NEXT_BLKP(bp)), PACK(0, 1)); return coalesce(bp); }

  25. Malloc void *mm_malloc(size_t size) { size_t asize, extendsize; char *bp; if (size <= 0) return NULL; if (size <= DSIZE) asize = DSIZE+OVERHEAD; else asize = DSIZE*((size+(OVERHEAD)+(DSIZE-1))/DSIZE); if ((bp = find_fit(asize)) != NULL) { place(bp, asize); return bp; } extendsize = MAX(asize,CHUNKSIZE); if ((bp = extend_heap(extendsize/WSIZE)) == NULL) return NULL; place(bp, asize); return bp; }

  26. Finding first fit static void *find_fit(size_t asize) { void *bp; for (bp = heap_listp; GET_SIZE(HDRP(bp)) > 0; bp = NEXT_BLKP(bp)) if (!GET_ALLOC(HDRP(bp)) && (asize <= GET_SIZE(HDRP(bp)))) return bp; return NULL; }

  27. Malloc void *mm_malloc(size_t size) { size_t asize, extendsize; char *bp; if (size <= 0) return NULL; if (size <= DSIZE) asize = DSIZE+OVERHEAD; else asize = DSIZE*((size+(OVERHEAD)+(DSIZE-1))/DSIZE); if ((bp = find_fit(asize)) != NULL) { place(bp, asize); return bp; } extendsize = MAX(asize,CHUNKSIZE); if ((bp = extend_heap(extendsize/WSIZE)) == NULL) return NULL; place(bp, asize); return bp; }

  28. Placing a block in a free block static void place(void *bp, size_t asize) { size_t csize = GET_SIZE(HDRP(bp)); if ((csize - asize) >= (DSIZE + OVERHEAD)) { PUT(HDRP(bp), PACK(asize, 1)); PUT(FTRP(bp), PACK(asize, 1)); bp = NEXT_BLKP(bp); PUT(HDRP(bp), PACK(csize-asize, 0)); PUT(FTRP(bp), PACK(csize-asize, 0)); } else { PUT(HDRP(bp), PACK(csize, 1)); PUT(FTRP(bp), PACK(csize, 1)); } }

  29. Free void mm_free(void *bp) { size_t size = GET_SIZE(HDRP(bp)); PUT(HDRP(bp), PACK(size, 0)); PUT(FTRP(bp), PACK(size, 0)); coalesce(bp); }

  30. Coalesce: called by mm_free() & extend_heap() static void *coalesce(void *bp) { size_t prev_alloc = GET_ALLOC(FTRP(PREV_BLKP(bp))); size_t next_alloc = GET_ALLOC(HDRP(NEXT_BLKP(bp))); size_t size = GET_SIZE(HDRP(bp)); if (prev_alloc && next_alloc) { return bp; } else if (prev_alloc && !next_alloc) { …… } else if (!prev_alloc && next_alloc) { size += GET_SIZE(HDRP(PREV_BLKP(bp))); PUT(FTRP(bp), PACK(size, 0)); PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0)); bp = PREV_BLKP(bp); } else { …… } return bp; }

More Related