Recitation 9 (Nov. 8)

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
• shaoml213_at_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
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.

0
p1
p
n1
virtual address
virtual page number (VPN)
page offset
address translation
0
p1
p
m1
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
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
n1
0
p1
p
virtual address
virtual page number
page offset
valid
physical page number
tag
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
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
parameter Value Parameter Value
VPN 0x01E TLB hit? N
TLB Index 0x6 Page fault? N
TLB Tag 0x03 PPN 0x57
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

parameter Value Parameter Value
VPN 0x012 TLB hit? Y
TLB Index 0x2 Page fault? N
TLB Tag 0x02 PPN 0x68
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))
gt what user asked for in malloc
Footer
32 bits
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

19
Heap format
Allocated and Free Blocks
4 bytes Pad
Prologue
Epilogue
81
81
01
HDR
FTR
HDR
FTR
Double Word Alignment (8 bytes)
20
Very useful macros

• define WSIZE 4
• define DSIZE 8
• define CHUNKSIZE (1ltlt12)
• 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(4WSIZE)) NULL)
• return -1
• PUT(heap_listp, 0)
• PUT(heap_listpWSIZE, PACK(OVERHEAD, 1))
• PUT(heap_listpDSIZE, PACK(OVERHEAD, 1))
• PUT(heap_listpWSIZEDSIZE, 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) ? (words1)WSIZE
  wordsWSIZE
• if ((int)(bp mem_sbrk(size)) lt 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 lt 0) return NULL
• if (size lt DSIZE)
• asize DSIZEOVERHEAD
• else
• asize DSIZE((size(OVERHEAD)(DSIZE-1))/DSIZ
  E)
• 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)) gt 0
• bp NEXT_BLKP(bp))
• if (!GET_ALLOC(HDRP(bp))
• (asize lt GET_SIZE(HDRP(bp))))
• return bp
• return NULL

27
Malloc

• void mm_malloc(size_t size)
• size_t asize, extendsize
• char bp
• if (size lt 0) return NULL
• if (size lt DSIZE)
• asize DSIZEOVERHEAD
• else
• asize DSIZE((size(OVERHEAD)(DSIZE-1))/DSIZ
  E)
• 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) gt (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