1 / 39

Dynamic Memory Allocation II

This article explores the topics of explicit doubly-linked free lists, segregated free lists, and garbage collection in dynamic memory allocation. It also discusses memory-related perils and pitfalls.

rgill
Download Presentation

Dynamic Memory Allocation II

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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Dynamic Memory Allocation II • Topics • Explicit doubly-linked free lists • Segregated free lists • Garbage collection • Memory-related perils and pitfalls

  2. Explicit Lists

  3. Keeping Track of Free Blocks • Method 1: Implicit list using lengths -- links all blocks • Method 2: Explicit list among the free blocks using pointers within the free blocks • Method 3: Segregated free lists • Different free lists for different size classes • Method 4: Blocks sorted by size (not discussed) • Can use a balanced tree (e.g. Red-Black tree) with pointers within each free block, and the length used as a key 5 4 6 2 5 4 6 2

  4. A B C Explicit Free Lists • Use data space for link pointers • Typically doubly linked • Still need boundary tags for coalescing • It is important to realize that links are not necessarily in the same order as the blocks Forward links A B 4 4 4 4 6 6 4 4 4 4 C Back links

  5. Allocating From Explicit Free Lists pred succ free block Before: pred succ After: (with splitting) free block

  6. Freeing With Explicit Free Lists • Insertion policy: Where in the free list do you put a newly freed block? • LIFO (last-in-first-out) policy • Insert freed block at the beginning of the free list • Pro: simple and constant time • Con: studies suggest fragmentation is worse than address ordered. • Address-ordered policy • Insert freed blocks so that free list blocks are always in address order • i.e. addr(pred) < addr(curr) < addr(succ) • Con: requires search • Pro: studies suggest fragmentation is better than LIFO

  7. 31 31 3 3 2 2 1 1 0 0 Block size Block size a/f a/f Header Header Payload pred (Predecessor) succ (Successor) Old payload Padding (optional) Padding (optional) Block size Block size a/f a/f Footer Footer Pointers for Explicit Lists • Implementation • Only needed for free list • Implies minimum payload size Free block Allocated block

  8. Freeing With a LIFO Policy • Free block “x”: • Case 1: a-x-a • Prev & next blocks allocated (boundary tags) • Insert x at beginning of free list • Case 2: a-x-f • Next block is free • Splice out next from free list, coalesce x and next, add to beginning of free list prev (p) next (n) a x a p n before: a x f n p after: a f

  9. Freeing With a LIFO Policy p n • Case 3: f-x-a • Splice out prev, coalesce with x, and add to beginning of free list • Case 4: f-x-f • Splice out prev and next, coalesce with x, and add to beginning of list before: f x a p n after: f a p n p n before: f x f p n after: f

  10. Explicit List Summary • Comparison to implicit list • Faster • allocate traverses free blocks instead of all blocks • allocates faster when memory is near-full • Slightly more complex • since needs to splice blocks in and out of the list • Extra space for the links • 2 extra words needed for each block • can overlay with payload

  11. Segregated Lists

  12. Keeping Track of Free Blocks • Method 1: Implicit list using lengths -- links all blocks • Method 2: Explicit list among the free blocks using pointers within the free blocks • Method 3: Segregated free list • Different free lists for different size classes • Method 4: Blocks sorted by size • Can use a balanced tree (e.g. Red-Black tree) with pointers within each free block, and the length used as a key 5 4 6 2 5 4 6 2

  13. 1-2 3 4 5-8 9-16 Segregated Storage • Each size class has its own collection of blocks • Often have separate size class for every small size (2,3,4,…) • For larger sizes typically have a size class for each power of 2

  14. Segregated Lists – No Splitting • Separate heap and free list for each size class • No splitting • To allocate a block of size n: • If memory exists on free list for size n • allocate first block on list (note, list can be implicit or explicit) • If free list is empty • get a new page • create new free list from all blocks in page • allocate first block on list • Constant time • To free a block: • Add to free list • If whole page is free, return the page for use by another size • Tradeoffs: • Fast, but lots of internal fragmentation

  15. Segregated Lists – With Splitting • Array of free lists, each one for some size class • To allocate a block of size n: • Search appropriate free list for block of size m > n • If an appropriate block is found: • Split block and place fragment on appropriate list • If no block is found, try next larger class • Repeat until block is found • To free a block: • Coalesce and place on appropriate list • Advantages • Fast first fit search for space • Approximates best fit search of entire heap • Reduces fragmentation • Used in production-quality allocators (GNU malloc)

  16. For More Information • D. Knuth, “The Art of Computer Programming, Second Edition”, Addison Wesley, 1973 • The classic reference on dynamic storage allocation • Wilson et al, “Dynamic Storage Allocation: A Survey and Critical Review”, Proc. 1995 Int’l Workshop on Memory Management, Kinross, Scotland, Sept, 1995. • Comprehensive survey • For this document and others, see Memory Management link on schedule

  17. Garbage Collection

  18. Garbage Collection • Garbage collection: automatic reclamation of heap-allocated storage -- application never has to free void foo() { int *p = malloc(128); return; /* p block is now garbage */ } • Common in functional languages, scripting languages, and modern object oriented languages: • Lisp, Java, Perl, Mathematica, C#, Managed C++ • Conservative garbage collectors exist for C and Unmanaged C++ • Cannot collect all garbage

  19. Central Concept • When can a garbage collector free a block? • When it’s no longer used • Check to see if any pointers address block • If nothing points to a block, the block can be freed

  20. Classic GC algorithms • Reference counting (Collins, 1960) • Does not move blocks • Smart pointers in C++ • Mark and sweep collection (McCarthy, 1960) • Does not move blocks (unless you also “compact”) • Marks reachable blocks, sweeps (frees) unmarked blocks • For more information, see Jones and Lin, “Garbage Collection: Algorithms for Automatic Dynamic Memory”, John Wiley & Sons, 1996.

  21. Memory Has Structure • We can view memory as a directed graph • Each block is a node in the graph • Each pointer is an edge in the graph • Locations not in the heap that contain pointers into the heap are called root nodes (e.g. registers, locations on the stack, global variables) Root nodes Heap nodes reachable Not-reachable(garbage) • A node (block) is reachable if there is a path from any root to that node. • Non-reachable nodes are garbage (never needed by the application)

  22. Mark and Sweep • Can build on top of malloc/free package • So that given an address to any byte we can find block header • Need special data structures • Allocate using malloc until you “run out of space” • When out of space: • Use extra mark bit in the head of each block • Two passes through memory: mark and sweep • Mark: Start at roots and set mark bit on all reachable memory • Sweep: Scan all blocks and free blocks that are not marked Mark bit set root Before mark After mark After sweep free free

  23. Mark and Sweep Mark using depth-first traversal of the memory graph ptr mark(ptr p) { if (!is_ptr(p)) return; // do nothing if not pointer if (markBitSet(p)) return; // check if already marked setMarkBit(p); // set the mark bit for (i=0; i < length(p); i++) // mark all children mark(p[i]); return; } Sweep using lengths to find next block ptr sweep(ptr p, ptr end) { while (p < end) { if markBitSet(p) clearMarkBit(); else if (allocateBitSet(p)) free(p); p += length(p); }

  24. Conservative Mark and Sweep in C • A conservative collector for C programs • Is_ptr() determines if a word is a pointer by checking if it points to an allocated block of memory. • But, in C pointers can point to the middle of a block. • So how do we find the beginning of the block? • Have malloc set up a balanced tree to keep track of all allocated blocks. Key field contains location • Balanced tree pointers can be stored in header (use two additional words) ptr header head data size left right

  25. Conservative Mark and Sweep in C • Given a pointer, we can • Determine what block it points to • Where the block begins and ends • Scan the entire block checking for more pointers • How do we know if data is a pointer? • It could be an integer whose value is a legal pointer • Make worst-case assumption • Not all memory will be freed

  26. Memory-Related Bugs

  27. What’s wrong? scanf(“%d”, val);

  28. What’s wrong? /* return y = Ax */ int *matvec(int **A, int *x) { int *y = malloc(N*sizeof(int)); int i, j; for (i = 0; i < N; i++) for (j = 0; j < N; j++) y[i] += A[i][j] * x[j]; return y; }

  29. What’s wrong? double **p; p = malloc(N*sizeof(double)); for (i=0; i < N; i++) { p[i] = malloc(M*sizeof(double)); }

  30. What’s wrong? double **p; p = malloc(N*sizeof(double *)); for (i=0; i <= N; i++) { p[i] = malloc(M*sizeof(double)); }

  31. What’s wrong? char s[8]; int i; gets(s); /* reads “12345678” from stdin */

  32. What’s wrong? • Basis for classic buffer overflow attacks • 1988 Internet worm • Modern attacks on Web servers • AOL/Microsoft IM war char s[8]; int i; gets(s); /* reads “12345678” from stdin */

  33. What’s wrong? int *search(int *p, int val) { while (*p && *p != val) p += sizeof(int); return p; }

  34. What’s wrong? int *foo () { int val = 5; return &val; } int main() { return *foo(); }

  35. What’s wrong? x = malloc(N*sizeof(int)); <manipulate x> free(x); y = malloc(M*sizeof(int)); <manipulate y> free(x);

  36. What’s wrong? x = malloc(N*sizeof(int)); <manipulate x> free(x); ... y = malloc(N*sizeof(int)); for (i=0; i < N; i++) y[i] = x[i]++;

  37. What’s wrong? foo() { int *x = malloc(N*sizeof(int)); ... return; }

  38. Solution?

  39. Java

More Related