Advanced Operating Systems - Lecture 21: Explicit free lists. This lecture will cover the following: explicit free lists base allocator details; freeing with LIFO policy; segregated free lists; exploiting allocation patterns of programs and exploiting peaks via arena allocators; garbage collection;...
CS703 Advanced Operating Systems By Mr Farhan Zaidi Lecture No. 21 Overview of today’s lecture Explicit free lists base allocator details Freeing with LIFO policy Segregated free lists Exploiting allocation patterns of programs Exploiting peaks via arena allocators Garbage collection Explicit Free Lists A B C Forward links A B 4 6 C 4 Back links Allocating From Explicit Free Lists pred Before: succ free block pred After: (with splitting) succ free block Freeing With Explicit Free Lists Insertion policy: Where in the free list you put a newly freed block? LIFO (last-in-first-out) policy Insert freed block at the beginning of the free list Address-ordered policy Insert freed blocks so that free list blocks are always in address order i.e addr(pred) < addr(curr) < addr(succ) Freeing With a LIFO Policy pred (p) Case 1: a-a-a a succ (s) self a Case 2: a-a-f p s before: a self f p after: a f s Freeing With a LIFO Policy (cont) p s before: f Case 3: f-a-a p self a s after: f Case 4: f-a-f p1 a s1 p2 s2 before: f p1 self s1 f p2 after: f s2 Explicit List Summary Comparison to implicit list: Allocate is linear time in number of free blocks instead of total blocks much faster allocates when most of the memory is full Slightly more complicated allocate and free since needs to move blocks in and out of the list Some extra space for the links (2 extra words needed for each block) Main use of linked lists is in conjunction with segregated free lists Keep multiple linked lists of different size classes, or possibly for different types of objects Simple Segregated Storage Separate free list for each size class No splitting Tradeoffs: Fast, but can fragment badly Segregated Fits Array of free lists, each one for some size class To free a block: Coalesce and place on appropriate list (optional) Tradeoffs: Faster search than sequential fits (i.e., log time for power of two size classes) Controls fragmentation of simple segregated storage Coalescing can increase search times Deferred coalescing can help Known patterns of real programs ramps: accumulate data monotonically over time bytes peaks: allocate many objects, use briefly, then free all bytes plateaus: allocate many objects, use for a long time bytes Exploiting peaks Peak phases: alloc a lot, then free everything Advantages: alloc is a pointer increment, free is “free”, & there is no wasted space for tags or list pointers 64k 64k free pointer Implicit Memory Management: Garbage Collection Garbage collection: automatic reclamation of heap-allocated storage -application never has to free Garbage Collection How does the memory manager know when memory can be freed? Need to make certain assumptions about pointers Memory manager can distinguish pointers from nonpointers All pointers point to the start of a block Cannot hide pointers (e.g., by coercing them to an int, and then back again) Reference counting Algorithm: counter pointers to object each object has “ref count” of pointers to it increment when pointer set to it decremented when pointer killed void foo(bar c) { bar a, b; a = c; c>refcnt++; b = a; a>refcnt++; a = 0; a>refcnt; return; b>refcnt; } a b ref=2 Problems Circular data structures always have refcnt > ref=1 ref=1 ref=1 Memory as a Graph We 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) Assumptions Instructions used by the Garbage Collector is_ptr(p): determines whether p is a pointer length(b): returns the length of block b, not including the header get_roots(): returns all the roots ... Case 1: a-a-a a succ (s) self a Case 2: a-a-f p s before: a self f p after: a f s Freeing With a LIFO Policy (cont) p s before: f Case 3: f-a-a p self a s after: f Case 4: f-a-f p1 a s1... the free list you put a newly freed block? LIFO (last-in-first-out) policy Insert freed block at the beginning of the free list Address-ordered policy Insert freed blocks so that free list.. .Lecture? ?No. 21 Overview of today’s? ?lecture Explicit free lists base allocator details Freeing with LIFO policy