Outlines. Dynamic Memory Dynamic Memory Dynamic Memory The malloc Package. malloc Example

Transcription

1 Outlines Dynmic Memory CSCI 01: Mchine Architecture nd Bsic concepts Implicit free lists Explicit free lists Pen- Chung Yew Deprtment Computer Science nd Engineering University of Minnesot With Slides from Brynt, O Hllron nd Zhi Dynmic Memory Alloc@on Dynmic Memory Alloc@on Progrmmers use dynmic memory lloctors (such s mlloc) to cquire VM t run 5me. For dt structures whose size is only known t run5me. Dynmic memory lloctors mnge n re of process virtul memory known s hep. Different for ech process Iden@cl for ech process %esp brk 0x (3) 0x (6) Process- specific dt structs (ptbles, tsk nd mm structs, kernel stck) Physicl memory Kernel code nd dt User stck Memory mpped region for shred librries Run@me hep (mlloc) Unini@lized dt (.bss) Ini@lized dt (.dt) Progrm text (.text) Kernel virtul memory Process virtul memory Alloctor mintins hep s collec5on of vrible sized blocks, which re either llocted or free Types of lloctors Explicit lloctor: pplic5on lloctes nd frees spce e.g., mlloc nd free in C Implicit lloctor: pplic5on lloctes, but does not free spce e.g. grbge collec@on in Jv, ML, nd Lisp 0 The mlloc Pckge mlloc Exmple #include <stdlib.h> void *mlloc(size_t size) Successful: Returns pointer to memory block of t lest size bytes (typiclly) ligned to 8- byte boundry If size == 0, returns NULL Unsuccessful: returns NULL (0) nd sets errno void free(void *p) Returns the block pointed t by p to pool of vilble memory p must come from previous cll to mlloc or relloc Other func@ons #include <unistd.h> void *sbrk(intprt_t incr); clloc: Version of mlloc tht ini5lizes llocted block to zero. relloc: Chnges the size of previously llocted block. sbrk: Used internlly by lloctors to grow or shrink the hep 5 void foo(int n, int m) { int i, *p; } /* llocte block of n ints */ p = (int *) mlloc(n * sizeof(int)); if (p == NULL) { perror("mlloc"); exit(0); } /* initilize llocted block */ for (i=0; i<n; i++) p[i] = i; /* return p to the hep */ free(p); 6

2 Mde Here Memory is word ddressed (ech word cn hold pointer) Exmple p1 = mlloc() p = mlloc(5) Allocted block ( words) block (3 words) word Allocted word p3 = mlloc(6) free(p) p = mlloc() 7 8 Requirements in Designing Alloctors Applic@ons Cn issue rbitrry sequence of mlloc nd free requests A free request must be to mlloc d block Alloctors Requirements Cn t control number or size of llocted blocks Must respond immeditely to mlloc requests i.e., cn t reorder or buffer requests Must llocte blocks from free memory i.e., cn only plce llocted blocks in free memory Must lign blocks to s5sfy ll lignment requirements Performnce Metric: Pek Memory U@liz@on Given some sequence of mlloc nd free requests: R 0, R 1,..., R k,..., R n- 1 Def: Aggregte pylod P k mlloc(p) results in block with pylod of p bytes AUer request R k hs completed, the ggregte pylod P k is the sum of currently llocted pylods Def: Current hep size H k Assume H k is monotoniclly nondecresing i.e., hep only grows when lloctor uses sbrk Def: Pek memory u+liz+on der k requests 8- byte lignment for GNU mlloc (libc mlloc) on Linux boxes Cn mnipulte nd modify only free memory U k = ( mx i<k P i ) / H k Cn t move llocted blocks once they re mlloc d i.e., compc@on is not llowed becuse other objects my hve pointed to the llocted blocks 11 Performnce Metric: Throughput Throughput: Number of completed requests per Exmple: 5,000 mlloc clls nd 5,000 free clls i0 seconds Throughput is 1,000 oper5ons/second Performnce Gols Given some sequence of mlloc nd free requests: R 0, R 1,..., R k,..., R n sequence of llocte nd free requests P 0, P 1,..., P k,..., P n ggregte pylods H 0, H 1,..., H k,..., H n resul5ng size (high wter- mrk) of hep Gols: mximize pek memory u@liz@on nd throughput These gols re oden conflic@ng Pek Memory U@liz@on U k = (mx i k P i )/ H k - - pek memory u5liz5on Uer R k Throughput: Number of completed requests per 1 13

3 Poor memory cused by internl frgment5on externl frgment5on Internl For given block, internl frgment+on occurs if pylod is smller thn block size Internl Block Pylod Internl 1 Cused by Overhed of mintining hep dt structures Pdding for lignment purposes Explicit policy decisions (e.g., to return big block to s5sfy smll request) Depends only on the pjern of previous requests Thus, esy to mesure 15 Externl Occurs when there is enough ggregte hep memory, but no single free block is lrge enough p1 = mlloc() p = mlloc(5) p3 = mlloc(6) free(p) p = mlloc(6) Oops! (wht would hppen now?) Depends on the pjern of future requests Thus, difficult to mesure 16 Implement@on Issues 1. How do we know how much memory to free given pointer? i.e. how do we know the size of block to be freed?. How do we keep trck of the free blocks? 3. Wht do we do with the extr spce when lloc5ng structure tht is smller thn the free block it is plced in? i.e. do we wnt to leve it s is, or split it to crete one extr free block?. How do we pick block for lloc5on - - mny might fit? 5. How do we reinsert freed block? 17 Knowing How Much to Stndrd method Keep length of block in the word preceding the block. This word is ouen clled heder field or heder Requires n extr word for every llocted block Keeping Trck of Blocks Method 1: Implicit list using length links ll blocks Method : Explicit list mong the free blocks using pointers p0 p0 = mlloc() 5 Method 3: Segregted free list Different free lists for different size clsses free(p0) block size Dt (pylod) 18 Method : Blocks sorted by size Cn use blnced tree (e.g. Red- Blck tree) with pointers within ech free block, nd the length used s key 19

4 Outline Bsic concepts Implicit free lists Explicit free lists Implicit List For ech block we need both size nd sttus Could store this inform5on in two words: wsteful! Stndrd trick If blocks re ligned, some low- order ddress bits re lwys 0 Insted of storing n lwys- 0 bit, use it s n llocted/free flg When reding size word, must msk out this bit 1 word 0 Formt of llocted nd free blocks Pylod Op@onl pdding = 1: llocted block = 0: free block : block size Pylod: pplic@on dt (llocted blocks only) 1 Detiled Implicit List Exmple Implicit List: Finding Block First fit: Serch list from beginning, choose first free block tht fits: Strt of hep Unused 8/0 16/1 3/0 16/1 0/1 p = strt; while ((p < end) && \\ not pssed end ((*p & 1) \\ lredy llocted (*p <= len))) \\ too smll p = p + (*p & -); \\ goto next block (word size)(- 10 = ) Double- word ligned Allocted blocks: shded blocks: unshded Heders: lbeled with size in bytes/llocted bit Cn tke in totl number of blocks (llocted nd free) In prc5ce it cn cuse splinters t beginning of list Next fit: Like first fit, but serch list str@ng where previous serch finished Should ouen be fster thn first fit: voids re- scnning unhelpful blocks Some reserch suggests tht frgment5on is worse Best fit: Serch the list, choose the best free block: fits, with fewest bytes leu over Keeps frgments smll usully helps frgment5on Will typiclly run slower thn first fit 3 Implicit List: Alloc@ng in Block Alloc@ng in free block: spliing Since llocted spce might be smller thn free spce, we might wnt to split the block 6 Implicit List: ing Block Simplest implement@on: Need only cler the llocted flg void free_block(ptr p) { *p = *p & - } #set lloction bit 0 But cn led to flse frgment@on ddblock(p, ) p free(p) p void ddblock(ptr p, int len) { int newsize = ((len + 1) >> 1) << 1; // round up to even int oldsize = *p & -; // msk out sttus bit ( ) *p = newsize 1; // set new length ( ) if (newsize < oldsize) // need splitting? *(p+newsize) = oldsize - newsize; // set length in remining } // prt of block mlloc(5) Oops! There is enough free spce, but the lloctor won t be ble to find it 5

5 Implicit List: Colescing Join (colesce) with next/previous blocks, if they re free Colescing with next block free(p) 6 p logiclly gone Implicit List: Bidirec@onl Colescing Boundry tgs [Knuth73] Replicte size/llocted word t bojom (end) of free blocks Allows us to trverse the list bckwrds, but requires extr spce Importnt nd generl technique! 6 6 void free_block(ptr p) { *p = *p & -; // cler llocted flg next = p + *p; // find next block if ((*next & 1) == 0) *p = *p + *next; // dd to this block if } // not llocted But how do we colesce with previous block? 6 Formt of llocted nd free blocks Heder Boundry tg (footer) Pylod nd pdding = 1: Allocted block = 0: block : Totl block size Pylod: Applic@on dt (llocted blocks only) 7 Constnt Time Colescing Constnt Time Colescing (Cse 1) Cse 1 Cse Cse 3 Cse Block being freed Allocted Allocted Allocted Allocted n 0 n Constnt Time Colescing (Cse ) Constnt Time Colescing (Cse 3) m1 0 n+m1 0 n+m 0 m1 0 m 0 n+m1 0 m 0 n+m

6 Constnt Time Colescing (Cse ) Disdvntges of Boundry Tgs m1 0 m1 0 m 0 n+m1+m 0 Internl frgment@on Cn it be op@mized? Which blocks need the footer tg? Wht does tht men? m 0 n+m1+m Summry of Key Alloctor Policies Plcement policy: First- fit, next- fit, best- fit, etc. Trdes off lower throughput for less frgment5on Interes@ng observ@on: segregted free lists Approximte best fit plcement policy without hving to serch en5re free list Spliwng policy: When do we go hed nd split free blocks? How much internl frgment5on re we willing to tolerte? Colescing policy: Immedite colescing: colesce ech 5me free is clled Deferred colescing: try to improve performnce of free by deferring colescing un5l needed. Exmples: Colesce s you scn the free list for mlloc Colesce when the mount of externl frgment5on reches 3 some threshold Implicit Lists: Summry Implement@on: very simple Allocte cost: Liner 5me worst cse cost: Constnt 5me worst cse even with colescing Memory usge: Depend on plcement policy First- fit, next- fit or best- fit Not used in prc@ce for mlloc/free becuse of lloc@on Used in mny specil purpose pplic5ons However, the concepts of spliwng nd boundry tg colescing re generl to ll lloctors 35 Outlines Bsic concepts Implicit free lists Explicit free lists Keeping Trck of Blocks Method 1: Implicit free list using length links ll blocks Method : Explicit free list mong the free blocks using pointers Method 3: Segregted free list Different free lists for different size clsses Method : Blocks sorted by size Cn use blnced tree (e.g. Red- Blck tree) with pointers within ech free block, nd the length used s key 3

7 Explicit Lists Explicit Lists Allocted (s before) Logiclly: Next A B C Pylod nd pdding Prev Mintin list(s) of free blocks, not ll blocks The next free block could be nywhere So we need to store forwrd/bck pointers, not just sizes S5ll need boundry tgs for colescing We trck only free blocks, so we cn use pylod re Physiclly: blocks cn be in ny order Forwrd (next) links A B 6 6 C Bck (prev) links 5 Alloc@ng From Explicit Lists conceptul grphic ing With Explicit Lists Inser+on policy: Where in the free list do you put newly freed block? LIFO (lst- in- first- out) policy Insert freed block t the beginning of the free list Pro: simple nd constnt 5me Con: studies suggest frgment@on is worse thn ddress ordered Ader = mlloc( ) (with spliwng) 6 Address- ordered policy Insert freed blocks so tht free list blocks re lwys in ddress order: ddr(prev) < ddr(curr) < ddr(next) Con: requires serch Pro: studies suggest frgment5on is lower thn LIFO 7 ing With LIFO Policy (Cse 1) free( ) conceptul grphic ing With LIFO Policy (Cse ) conceptul grphic free( ) Insert the freed block t the root of the list AQer Splice out predecessor block, colesce both memory blocks, nd insert the new block t the root of the list AQer 8 9

8 ing With LIFO Policy (Cse 3) free( ) conceptul grphic ing With LIFO Policy (Cse ) conceptul grphic free( ) Splice out successor block, colesce both memory blocks nd insert the new block t the root of the list AQer Splice out predecessor nd successor blocks, colesce ll 3 memory blocks nd insert the new block t the root of the list AQer Explicit List Summry Comprison to implicit list: Allocte is liner 5me in number of free blocks insted of ll blocks Much fster when most of the memory is full Slightly more complicted llocte nd free since needs to splice blocks in nd out of the list Some extr spce for the links ( extr words needed for ech block) Does this increse internl frgment7on? Keeping Trck of Blocks Method 1: Implicit list using length links ll blocks Method : Explicit list mong the free blocks using pointers Most common use of linked lists is in conjunc5on with segregted free lists Keep mul5ple linked lists of different size clsses, or possibly for different types of objects 5 Method 3: Segregted free list Different free lists for different size clsses Method : Blocks sorted by size Cn use blnced tree (e.g. Red- Blck tree) with pointers within ech free block, nd the length used s key 53 Segregted List (Seglist) Alloctors Seglist Alloctor Ech size clss of blocks hs its own free list Given n rry of free lists, ech one for some size clss To llocte block of size n: Serch pproprite free list for block of size m > n If n pproprite block is found: Split block nd plce frgment on pproprite list (op5onl) If no block is found, try next lrger clss Repet un5l block is found 9- inf Oden hve seprte clsses for ech smll size For lrger sizes: One clss for ech two- power size 5 If no block is found: Request ddi5onl hep memory from OS (using sbrk()) Allocte block of n bytes from this new memory Plce reminder s single free block in lrgest size clss. 55

9 Seglist Alloctor (cont.) To free block: Colesce nd plce on pproprite list (op5onl) Advntges of seglist lloctors Higher throughput log 5me for power- of- two size clsses Bejer memory First- fit serch of segregted free list pproximtes best- fit serch of en7re hep. Extreme cse: Giving ech block its own size clss is equivlent to best- fit. 56