Recitation 9 (Nov. 8) Outline Virtual memory Lab 6 hints Reminders Lab 6: Get correctness points Exam 2: Nov.
Download
Report
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;
}