recitation 9 nov 8 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Recitation 9 (Nov. 8) PowerPoint Presentation
Download Presentation
Recitation 9 (Nov. 8)

Loading in 2 Seconds...

play fullscreen
1 / 30

Recitation 9 (Nov. 8) - PowerPoint PPT Presentation


  • 56 Views
  • Uploaded on

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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Recitation 9 (Nov. 8)' - minh


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
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
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

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

conceptual address translation
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

address translation through page table
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)
integrating vm and cache

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
address translation with tlb
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

example
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
part 1

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

part 2
Part 2

Virtual address 0x78E6

  • A. 078E6 =
  • B. Address translation
  • C. Physical address

0000 0111 1000 1110 0110

01 0101 1100 1110 0110

part 21
Part 2

Virtual address 0x04AA4

  • A. 04AA4 = 0000 0100 1010 1010 0100
  • B. Address translation
  • C. Physical address

01 1010 0010 1010 0100

end to end address translation
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
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
design options
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
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
Block format

Header

32 bits

Payload

Pointer returned

by malloc

(Block Pointer (bp))

>= what user asked

for in malloc

Footer

32 bits

header footer format

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

heap format
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)

very useful macros
Very useful macros
  • #define WSIZE 4
  • #define DSIZE 8
  • #define CHUNKSIZE (1<<12)
  • #define OVERHEAD 8
very useful macros1
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 macros2
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
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
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
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;

}

finding first fit
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;

}

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

}

placing a block in a free block
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));

}

}

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

}