week 12 march 28th n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Week 12 (March 28th) PowerPoint Presentation
Download Presentation
Week 12 (March 28th)

Loading in 2 Seconds...

play fullscreen
1 / 28

Week 12 (March 28th) - PowerPoint PPT Presentation


  • 172 Views
  • Uploaded on

Outline Memory Allocation Lab 6 Reminders Lab 6: April 7 th (next Thurs) Start Early!!! Exam 2: April 5 th (Next Tue). TA: Kun Gao. Week 12 (March 28th). Memory Allocation Overview. Maintains heap as a collection of various sized blocks Each block contiguous chunk of virtual mem.

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 'Week 12 (March 28th)' - christoffer


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
week 12 march 28th
Outline

Memory Allocation

Lab 6

Reminders

Lab 6:

April 7th (next Thurs)

Start Early!!!

Exam 2:

April 5th (Next Tue)

TA: Kun Gao

Week 12 (March 28th)
memory allocation overview
Memory Allocation Overview
  • Maintains heap as a collection of various sized blocks
    • Each block contiguous chunk of virtual mem.
  • Allocating memory
  • Freeing memory
dynamic memory allocation
Dynamic Memory Allocation
  • Do not know memory requirements beforehand
  • Explicit allocators
    • C standard library ‘malloc’ and ‘free’
  • Implicit allocators (garbage collection)
    • Lisp, ML, Java
c malloc and free
C ‘Malloc’ and ‘Free’
  • Malloc allocates using:
    • mmap, munmap
    • void *sbrk(int incr)
    • double word aligned (8-bytes)
  • Free:
    • void free(void *ptr)
    • *ptr must be a valid pointer returned by malloc
allocator requirements and goals
Allocator Requirements and Goals
  • Constraints
    • Handle arbitrary request sequences
    • Making immediate responses to requests
    • Using only the heap
    • Aligning blocks
    • Not modifying allocated blocks
  • Goals
    • Maximize throughput
    • Maximize utilization
placement policy
Placement Policy
  • Best-Fit
  • First-Fit
  • Next-Fit
  • No placement policy is perfect!
    • Unless you know the future
best fit not always best
Best Fit not always ‘Best’!

Memory in use

4 bytes free

6 bytes free

  • Consider the following accesses (not counting header sizes):
  • malloc(3)
  • malloc(3)
  • malloc(4)

First Fit will be able to allocate memory for all three. Best fit will not!

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
    • Why is size only 29 bits?
  • Lower 3 bits
    • a = 1: allocated, or a = 0: free
  • 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)

example
Example
  • Assume initial 4-byte padding, no prologue, both header and foot, and first fit
  • Allocator starts at 0xA0000000
    • Malloc(1) = ?
    • Malloc(2) = ?
very useful macros
Very useful macros
  • #define WSIZE 4
    • Size of word
  • #define DSIZE 8
    • Size of double word
  • #define CHUNKSIZE (1<<12)
    • Initial size of heap (for expanding)
  • #define OVERHEAD 8
    • Extra bytes used by header and footer
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)))

using the macros
Using the Macros
  • What is the size of the next block in memory?
    • size_t size = GET_SIZE(HDRP(NEXT_BLKP(bp)));
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));

}

}

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

}

design options
Design options
  • Organize free blocks
    • Implicit free list
    • Explicit free list
    • Segregate lists/search trees
  • Find free blocks
    • First fit/Next fit/Best Fit
    • Blocks sorted by address with first fit
lab 6
Lab 6
  • Implementation
    • mm_init, malloc, free, realloc, calloc
    • mm_heapcheck sanity checks
  • You will be graded on
    • Correctness (25)
    • Performance + Space (60 max)
    • Interposition (5)
    • Consistency Checker (5)
    • Style (5)
lab 61
Lab 6
  • Strategies?
garbage collection
Garbage Collection
  • Reference Counting
  • Mark and Sweep
  • Copy Collect