CS 153 Design of Operating Systems

Transcription

1 CS 153 Design of Operating Systems Spring 18 Lectre 25: Dynamic Memory (1) Instrctor: Chengy Song Slide contribtions from Nael Ab-Ghazaleh, Harsha Madhyvasta and Zhiyn Qian Some slides modified from originals by Dave O hallaron

2 Dynamic Memory Allocation Where is this important? Heap Kernel heap Physical memory allocator Problems are similar, bt specific sometimes force different soltions CS 153 Lectre 25 Dynamic Memory (1) 2

3 Dynamic Memory Allocation Programmers se dynamic memory allocators (sch as malloc) to acqire VM at rn time. For data strctres whose size is only known at rntime. Dynamic memory allocators manage an area of process virtal memory known as the heap. 0 Application Dynamic Memory Allocator Heap User stack Heap (via malloc) Uninitialized data (.bss) Initialized data (.data) Program text (.text) Top of heap (brk ptr) 3

4 Dynamic Memory Allocation Allocator maintains heap as collection of variable sized blocks, which are either allocated or free Types of allocators Explicit allocator: application allocates and frees space» E.g., malloc and free in C Implicit allocator: application allocates, bt does not free space» E.g. garbage collection in Java, ML, and Lisp Will discss explicit memory allocation CS 153 Lectre 25 Dynamic Memory (1) 4

5 The malloc Package #inclde <stdlib.h> void *malloc(size_t size) Sccessfl:» Retrns a pointer to a memory block of at least size bytes (typically) aligned to 8-byte bondary» If size == 0, retrns NULL Unsccessfl: retrns NULL (0) and sets errno void free(void *p) Retrns the block pointed at by p to pool of available memory p mst come from a previos call to malloc or realloc Other fnctions calloc: Version of malloc that initializes allocated block to zero. realloc: Changes the size of a previosly allocated block. sbrk: Used internally by allocators to grow or shrink the heap 5

6 Allocation Example p1 = malloc(4) p2 = malloc(5) p3 = malloc(6) free(p2) p4 = malloc(2) CS 153 Lectre 25 Dynamic Memory (1) 6

7 Constraints Applications Can isse arbitrary seqence of malloc and free reqests free reqest mst be to a malloc d block Allocators Can t control nmber or size of allocated blocks Mst respond immediately to malloc reqests» i.e., can t reorder or bffer reqests Mst allocate blocks from free memory» i.e., can only place allocated blocks in free memory Mst align blocks so they satisfy all alignment reqirements» 8 byte alignment for GNU malloc (libc malloc) on Linx boxes Can maniplate and modify only free memory Can t move the allocated blocks once they are malloc d» i.e., compaction is not allowed CS 153 Lectre 25 Dynamic Memory (1) 7

8 Goals Given some seqence of malloc and free reqests: R 0, R 1,..., R k,..., R n-1 Goals: maximize throghpt and peak memory tilization These goals are often conflicting Throghpt: Nmber of completed reqests per nit time Utilization: Percentage of the heap that is tilized Poor memory tilization cased by fragmentation, or poor allocation policies CS 153 Lectre 25 Dynamic Memory (1) 8

9 Implementation Isses How do we know how mch memory to free given jst a pointer? How do we keep track of the free blocks? What do we do with the extra space when allocating a strctre that is smaller than the free block it is placed in? How do we pick a block to se for allocation -- many might fit? How do we reinsert freed block? CS 153 Lectre 25 Dynamic Memory (1) 9

10 Knowing How Mch to Free Standard method Keep the length of a block in the word preceding the block.» This word is often called the header field or header Reqires an extra word for every allocated block p0 p0 = malloc(4) 5 block size data free(p0) CS 153 Lectre 25 Dynamic Memory (1) 10

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

12 Method 1: Implicit List For each block we need both size and allocation stats Cold store this information in two words: wastefl! Standard trick If blocks are aligned, some low-order address bits are always 0 Instead of storing an always-0 bit, se it as a allocated/free flag When reading size word, mst mask ot this bit 1 word Format of allocated and free blocks Size Payload a a = 1: Allocated block a = 0: Free block Size: block size Payload: application data (allocated blocks only) Optional padding 12

13 Implicit Free List Example Start of heap Unsed 8/0 16/1 32/0 16/1 0/1 Doble-word aligned Allocated blocks: shaded Free blocks: nshaded Headers: labeled with size in bytes/allocated bit CS 153 Lectre 25 Dynamic Memory (1) 13

14 Implicit List: Finding a Free Block First fit: Search list from beginning, choose first free block that fits: p = start; while ((p < end) && ((*p & 1) (*p <= len))) p = p + (*p & -2); \\ not passed end \\ already allocated \\ too small \\ goto next block (word addressed) Can take linear time in total nmber of blocks (allocated and free) In practice it can case splinters at beginning of list CS 153 Lectre 25 Dynamic Memory (1) 14

15 Implicit List: Finding a Free Block Next fit: Like first fit, bt search list starting where previos search finished Shold often be faster than first fit: avoids re-scanning nhelpfl blocks Some research sggests that fragmentation is worse Best fit: Search the list, choose the best free block: fits, with fewest bytes left over Keeps fragments small sally helps fragmentation Will typically rn slower than first fit CS 153 Lectre 25 Dynamic Memory (1) 15

16 Implicit List: Allocating in Free Block Allocating in a free block: splitting Since allocated space might be smaller than free space, we might want to split the block addblock(p, 4) p void addblock(ptr p, int len) { int newsize = ((len + 1) >> 1) << 1; // rond p to even int oldsize = *p & -2; // mask ot low bit *p = newsize 1; // set new length if (newsize < oldsize) *(p+newsize) = oldsize - newsize; // set length in remaining } // part of block

17 Implicit List: Freeing a Block Simplest implementation: Need only clear the allocated flag void free_block(ptr p) { *p = *p & -2 } Bt can lead to false fragmentation free(p) p malloc(5) Oops! There is enogh free space, bt the allocator won t be able to find it CS 153 Lectre 25 Dynamic Memory (1) 17

18 Implicit List: Coalescing Join (coalesce) with next/previos blocks, if they are free Coalescing with next block free(p) p logically gone void free_block(ptr p) { *p = *p & -2; // clear allocated flag next = p + *p; // find next block if ((*next & 1) == 0) *p = *p + *next; // add to this block if } // not allocated Bt how do we coalesce with previos block? CS 153 Lectre 25 Dynamic Memory (1) 18

19 Implicit List: Bidirectional Coalescing Bondary tags [Knth73] Replicate size/allocated word at bottom (end) of free blocks Allows s to traverse the list backwards, bt reqires extra space Important and general techniqe! Format of allocated and free blocks Header Bondary tag (footer) Size Payload and padding Size a a a = 1: Allocated block a = 0: Free block Size: Total block size Payload: Application data (allocated blocks only) CS 153 Lectre 25 Dynamic Memory (1) 19

20 Constant Time Coalescing Case 1 Case 2 Case 3 Case 4 Block being freed Allocated Allocated Allocated Free Free Allocated Free Free CS 153 Lectre 25 Dynamic Memory (1) 20

21 Constant Time Coalescing (Case 1) m1 1 m1 1 m1 1 n 1 m1 1 n 0 n 1 m2 1 n 0 m2 1 m2 1 m2 1 CS 153 Lectre 25 Dynamic Memory (1) 21

22 Constant Time Coalescing (Case 2) m1 1 m1 1 m1 1 n 1 m1 1 n+m2 0 n 1 m2 0 m2 0 n+m2 0 CS 153 Lectre 25 Dynamic Memory (1) 22

23 Constant Time Coalescing (Case 3) m1 0 n+m1 0 m1 0 n 1 n 1 m2 1 n+m1 0 m2 1 m2 1 m2 1 CS 153 Lectre 25 Dynamic Memory (1) 23

24 Constant Time Coalescing (Case 4) m1 0 n+m1+m2 0 m1 0 n 1 n 1 m2 0 m2 0 n+m1+m2 0 CS 153 Lectre 25 Dynamic Memory (1) 24

25 Next time Heap allocator Preparation Read Modle 14 and 17 CS 153 Lectre 25 Dynamic Memory (1) 25