System Software Prof. Dr. H. Mössenböck

Transcription

1 System Software Prof. Dr. H. Mössenböck 1. Memory Management 2. Garbage Collection 3. Linkers and Loaders 4. Debuggers 5. Text Editors Marks obtained by end-term exam

2 1. Memory Management 1.1 Overview 1.2 Allocation and deallocation of memory 1.3 Single free list 1.4 Multiple free lists 1.5 Buddy system 1.6 Memory fragmentation 2

3 Main tasks of memory management Allocation and deallocation of memory global data global variables, code managed by the loader stack local variables managed by the compiler heap dynamically created objects managed by the run-time system Reclaiming unused memory (garbage collection) p p = q; p q Dealing with memory fragmentation Paging and swapping (virtual memory) not discussed in this course 3

5 Stack-like management of the heap mark/alloc/free top m a m m top m top a top m = mark(); a = alloc(size); more alloc() calls free(m); returns the current end of the heap (top) allocates a block of size size and returns its address a resets the heap end to m (deallocates anything that was allocated after mark()) Advantage simple and efficient int alloc(int size) { if (top + size > heapend) { error(...); a = 0; else { a = top; top = top + size; return a; void free(int m) { top = m; Disadvantage objects must be deallocated in LIFO order (applicable e.g. for the symbol table of a compiler) 5

6 Heap management with a free list allocation of a block a = alloc(size); deallocation of a block dealloc(a); May lead to holes in the heap, which must be maintained by a free list heap free (free list) alloc() must allocate a block from the free list, i.e.: find a sufficiently large block in the free list remove it from the free list dealloc() add the deallocated block to the free list merge the block with free neighbors 6

8 Single free list All blocks are linked into a single large list heap free Possible sort orders of the free list 1. LIFO: the most recently deallocated block is the first in the list. Simple to implement 2. FIFO: the most recently deallocated block is the last in the list. 3. Blocks are sorted by address. Simple block merging; slow insert 4. Blocks are sorted by their size. Simple search of a suitable block; slow insert 8

9 Possible block format used block 1 length data p free block 0 length next unused This format implies a minimum block size (e.g. 8 bytes) Why do we need the length of used blocks? It allows us to traverse the heap sequentially: p = p + p.length; 9

10 Allocation of blocks p = alloc(size); Strategies for searching the free list First Fit returns the first suitable block with length >= size simple and efficient - causes fragmentation (small blocks accumulate at the beginning of the list) Best Fit Next Fit returns the block with the smallest waste (blocks are split) block j : length j >= (size+4) && i j: length i >= length j + minimum waste - slow (must traverse the whole list; good if the list is sorted by block size) variant of First Fit free blocks are linked cyclically; the search starts where it ended last time free free 10

11 Splitting free blocks Free block free list 0 len next unused len Splitting p = alloc(size); 0 len' next unused 1 len'' used p size len' len'' The block is cut off from the end => next does not have to be changed If less than 8 bytes would remain the whole block is used 11

12 Allocation of blocks (pseudo code) static Block free; // free list static Block alloc (int size) { Block start = free; Block prev = free; free = free.next; while (free.len < size+4 && free!= start) { prev = free; free = free.next; if (free == start) { error(...); return null; else { Block p = free; int newlen = p.len - (size+4); if (newlen >= 8) { // split block p = (Block)(p p.len - size); p.len = size + 4; free.len = newlen; else if (free == prev) { // last free block free = null; else { // remove block from list prev.next = free.next; free = prev; Set all data bytes in block p to 0; p.used = true; return p; free prev free 0 len next p free 0 nl next free newlen len 1 len p size len size 12

13 Deallocation of blocks dealloc(p); free left p right - merge block p with free neighbors - add merged block to the free list void dealloc (Block p) { left = left neighbor of p; if (!left.used) { merge left and p; p = left; else { add p to free list; right = right neighbor of p; if (!right.used) { remove right from free list; merge p and right; // traverse heap sequentially // enlarge left.len; left remains in free list // right = (Block)(p + p.len); // seq. search of right's predecessor // p is already in the free list Requires sequential traversals of the heap and the free list => slow 13

14 Boundary tags In order to avoid the sequential searching of blocks Free list is doubly linked length and used bit are also stored at the block end (also in used blocks) 0 len next prev 0 p len minimum block size = 16 bytes right neighbor of p: left neighbor of p: successor of p in free list: predecessor of p in free list: p + p.len p - (p-8).len p.next p.prev There must be a used dummy block at the beginning and the end of the heap. 14

15 Lazy merge dealloc(p) does not merge free blocks with their neighbors free p free If alloc() does not find a sufficiently large block: traverse the heap sequentially merge adjacent free blocks build new free list p.next = free; free = p; p = heapstart; free = null; while (p < heapend) { if (!p.used) { while (right neighbor of p is free) merge neighbor with p; add p to free list; p = (Block)(p + p.len); free 15

17 Allocation of blocks Observation 90% of all blocks have only one of 5 different sizes Multiple free lists for blocks of size 2 i bytes n*1024 free Blocks in the last list have different sizes, but their size is a multiple of 1024 bytes Strategy for allocating a block of size s n = next power of 2 greater or equal than s remove the first block from the list corresponding to n Any surplus stays with the allocated block (block size is always 2 i ) 17

18 Algorithms Block alloc (int size) { if (size > 512) { p = suitable block from the last list (e.g. first fit); put remaining i*1024 byte back to the last list; else { int s = 8, n = 3; // free[0..2] are dummies while (s < size) { s = 2 * s; n++; // n = log 2 (size) ; if (free[n] == null) split(n+1); p = free[n]; free[n] = p.next; initialize block p with 0; return p; // p = first block from free[n] void split (int n) { if (n == 10) { p = cut off 1024 byte block from the last list; else { if (free[n] == null) split(n+1); p = free[n]; free[n] = p.next; split p into two equally sized blocks and add them to free[n-1]; 18

19 Example Allocation of 40 bytes (given the follwing free lists) n* tries to obtain a block of size 64; but the 64-list is empty Split a 1024 byte block and use it to fill the empty lists Take a 64 byte block leaving 24 bytes unused (internal fragmentation) In most cases a suitable block is found with a single access => efficient At the beginning the whole heap is a single block in the 1024-list 19

20 Deallocation of blocks void dealloc (Block p) { int s = 8, n = 3; while (s < p.len) { s = 2 * s; n++; if (n > 10) n = 10; p.next = free[n]; free[n] = p; // n = log 2 (p.len) ; // add p to free[n] Blocks are not merged, because a block of the same size is probably needed soon again (maybe one should do a lazy merge from time to time) 20

21 Reducing internal fragmentation... by more block sizes block sizes 2 i i, 3*2 i k * less internal fragmentation - more free lists - more difficult to compute the right list - more complicated to split blocks 21

22 Reducing internal fragmentation... by free lists containing blocks of variable sizes (in a certain interval) list i contains blocks of size 2 i.. 2 i+1-1 Example we need a block with 40 bytes search the list containing blocks of size ; we find a block of size 58, say split the block into bytes add 18-byte block into list with sizes no internal fragmentation + the lists are shorter than with a single free list - the list must be searched for a suitable block (e.g. next fit) - leads to many small blocks of waste free blocks should be merged lazily from time to time 22

24 Idea of the Buddy System alloc(size) Multiple free lists with blocks of size 2 i as described above dealloc(p) Every block has a partner (buddy) of the same size p q p is the buddy of q and vice versa A block can only be merged with its buddy The address of p's buddy can be computed from the address of p Goal: simple and efficient merging of blocks 24

25 Buddy addresses Buddies emerge from splitting blocks of size 2 i Assume that we have a block of size 64 (= 2 6 ) at address If we split this block we obtain two buddies x and y of size 32 (= 2 5 ) 0 32 adr(x) = 0 = size = adr(y) = 32 = x y 5 If we split y again we obtain x y If we split x again we obtain x y adr(x) = 32 = size = 2 4 adr(y) = 48 = adr(x) = 32 = size = 2 3 adr(y) = 40 = A block of size 2 i has an address which is a multiple of 2 i (it has i zeroes at the end) 25

26 Deallocation of a block of size 2 i Merge the block with its buddy if the buddy is free free p i heap void dealloc (Block p) { // size of p = 2 i int s = 8, i = 3, buddy, beg; while (s < p.len) { s = s * 2; i++; // s = p.len, i = log 2 (p.len) for (;;) { if ( ((p-4) >> i) % 2 == 1) { buddy = p - p.len; beg = buddy; else { buddy = p + p.len; beg = p; if (buddy.used buddy.len!= p.len buddy < heapstart buddy >= heapend) break; remove buddy from free[i]; // seq. search in short list p = beg; p.len = 2 * p.len; i++; add p to free[i]; buddy beg p beg p buddy p if p is deallocated, multiple blocks are merged cannot be merged with its buddy any more => add it to the free list 26

28 External and internal fragmentation heap external fragmentation small (unusable) holes between blocks internal fragmentation unused bytes within an allocated block External fragmentation can be removed by compaction + collects all "holes" into a contiguous area of free memory + allows simple alloc() without free lists (blocks are cut off from the free area) - compaction leads to new block addresses => all references must be updated Some garbage collectors compact the heap automatically (see later) 28

29 Compaction Requires 2 traversals of the heap and 1 traversal through all pointers pointers heap 1. For every block, compute its address after compaction Modify all pointers so that they point to the new address problem: where are the pointers? They can be in local variables or in other objects. 3. Move blocks to their new address allocated blocks must have an extra space to store the new address. 29

30 Compaction with master pointers block size master pointers pointers Pointers reference blocks via master pointers (e.g. "handles" on the Macintosh) Every block is referenced by just a single master pointer Step 1: Reverse master pointers master[] for (all elements i in master) { p = master[i]; master[i] = p.len; p.len = i; Step 2: Compact master[] a = heapstart; for (all blocks p) { if (p.used) { i = p.len; p.len = master[i]; master[i] = a; move block p to a; a = a + p.len; + requires only 2 instead of 3 traversals + blocks do not need extra space to store their new address - indirect access via master pointers is slower than direct access via pointers 30