1. 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

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. Virtual memory CPU 0: 1: N-1: Memory 0: 1: P-1: Page Table Disk Virtual Addresses Physical Addresses 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. virtual page number (VPN)page offset virtual address physical page number (PPN) page offset physical address 0p–1 address translation pm–1 n–1 0p–1p

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. Integrating VM and cache Most caches are physically addressed Perform address translation before cache lookup Another cache: Translation Lookaside Buffer CPU TLB Lookup Cache Main Memory VAPA miss hit data Trans- lation hit miss

7. Address translation with TLB virtual address virtual page numberpage offset physical address n–10p–1p validphysical page numbertag validtagdata = cache hit tagbyte offset index = TLB hit TLB Cache...

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. Part 1 A. Virtual address B. Physical address 161514131211109876543171821019 VPN VPO TLBTTLBI 16151413121110987654317210 PPN PPO

11. Part 2 Virtual address 0x78E6 A. 078E6 = B. Address translation C. Physical address parameterValueParameterValue VPN0x01ETLB hit?N TLB Index0x6Page fault?N TLB Tag0x03PPN0x57 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 parameterValueParameterValue VPN0x012TLB hit?Y TLB Index0x2Page fault?N TLB Tag0x02PPN0x68

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 Pointer returned by malloc (Block Pointer (bp)) 32 bits >= what user asked for in malloc Footer Payload

18. 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 0 0 a size 3 2 1 0 31

19. Heap format 8|1 0|1 Double Word Alignment (8 bytes) 4 bytes Pad PrologueEpilogue Allocated and Free Blocks HDRFTRHDRFTR

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; }