Transcript Recitation 9 (Nov. 8) Outline  Virtual memory  Lab 6 hints Reminders  Lab 6:  Get correctness points  Exam 2:  Nov.

Recitation 9 (Nov. 8)
Outline
 Virtual memory
 Lab 6 hints
Reminders
 Lab 6:
 Get correctness points
 Exam 2:
 Nov. 16 (Next Tue)
Minglong Shao
[email protected]
Office hours:
Thursdays 5-6PM
Wean Hall 1315
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
Virtual memory
Memory
0:
1:
Page Table
Virtual
Addresses
0:
1:
Physical
Addresses
CPU
P-1:
N-1:
Disk
Page, page table, page hits, page faults
Demand paging
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
n–1
virtual page number (VPN)
page offset
0
virtual address
address translation
m–1
p p–1
physical page number (PPN)
0
page offset
physical address
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)
page table base register
VPN acts
as
table index
if valid=0
then page
not in memory
virtual address
n–1
p p–1
virtual page number (VPN)
page offset
0
valid access physical page number (PPN)
m–1
p p–1
physical page number (PPN)
page offset
physical address
0
Integrating VM and cache
 Most caches are physically addressed
 Perform address translation before cache lookup
 Another cache: Translation Lookaside Buffer
hit
PA
VA
CPU
miss
TLB
Lookup
miss
Cache
hit
Translation
data
Main
Memory
Address translation with TLB
n–1
p p–1
0
virtual page number
page offset
valid
.
virtual address
tag physical page number
.
TLB
.
=
TLB hit
physical address
tag
index
valid tag
byte offset
data
Cache
=
cache hit
data
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
Example: TLB and page table
Part 1
 A. Virtual address
TLBT
19
18
17
16
TLBI
15
14
13
12
11
10
9
8
7
6
VPN
5
4
3
2
1
0
3
2
1
0
VPO
 B. Physical address
17
16
15
14
13
PPN
12
11
10
9
8
7
6
5
4
PPO
Part 2
Virtual address 0x78E6
 A. 078E6 = 0000 0111 1000 1110 0110
 B. Address translation
parameter
VPN
Value
0x01E
Parameter
TLB hit?
Value
N
TLB Index
TLB Tag
0x6
0x03
Page fault?
PPN
N
0x57
 C. Physical address
01 0101 1100 1110 0110
Part 2
Virtual address 0x04AA4
 A. 04AA4 = 0000 0100 1010 1010 0100
 B. Address translation
parameter
VPN
Value
0x012
Parameter
TLB hit?
Value
Y
TLB Index
TLB Tag
0x2
0x02
Page fault?
PPN
N
0x68
 C. Physical address
01 1010 0010 1010 0100
End-to-end address translation
 Section 10.6.4: a concrete example
 Read carefully and solve practice problem 10.4
 Multi-level page table
Malloc Lab (Lab 6)
 Submit twice

Checkpoint submission:


Final submission:




Only check correctness: 15 pts
Correctness: 10 pts
Performance: 60 pts
Interposition test: 5 pts
Style: 5 pts
 Start early!!
 Get correctness points this week
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
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
Block format
Header
32 bits
Pointer returned
by malloc
(Block Pointer (bp))
Payload
Footer
>= what user asked
for in malloc
32 bits
Header/footer format
3
31
size
2
1
0
0
0
a
 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
Heap format
Allocated and Free Blocks
4 bytes
Prologue
Pad
8|1 8|1
Epilogue
HDR
Double Word Alignment
(8 bytes)
FTR HDR
FTR
0|1
Very useful macros
 #define WSIZE 4
 #define DSIZE 8
 #define CHUNKSIZE (1<<12)
 #define OVERHEAD 8
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)
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)))
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;
}
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);
}
Malloc
void *mm_malloc(size_t size) {
size_t asize, extendsize;
char *bp;
if (size <=
if (size <=
asize =
else
asize =
0) return NULL;
DSIZE)
DSIZE+OVERHEAD;
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;
}
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;
}
Malloc
void *mm_malloc(size_t size) {
size_t asize, extendsize;
char *bp;
if (size <=
if (size <=
asize =
else
asize =
0) return NULL;
DSIZE)
DSIZE+OVERHEAD;
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;
}
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));
}
}
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);
}
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;
}