GARBAGE COLLECTION METHODS. Hanan Samet

Transcription

1 gc0 GARBAGE COLLECTION METHODS Hanan Samet Compute Science Depatment and Cente fo Automation Reseach and Institute fo Advanced Compute Studies Univesity of Mayland College Pak, Mayland 07 Copyight 997 Hanan Samet These notes may not e epoduced y any means (mechanical o electonic o any othe) without the epess witten pemission of Hanan Samet

2 GARBAGE COLLECTION 8 gc Management of stoage allocation fom a heap (e.g., stings, lists, etc.) Allocation is usually eplicit (e.g., CONS in LISP, NEW in PASCAL) Deallocation is eplicit o implicit. PL/: eplicit via FREE. LISP: implicit via gaage collection pocess of detemining what pat of stoage is no longe eing efeenced and etuning it to the availale pool pocedue evese(); if empty() then else evese(,ω); pocedue evese(,y) if empty() then y else evese(est(),add(fist(),y)); add(,y) gas a -element cell fom AVAIL and yields evese[(a B C)] evese[(a B C),Ω] y y Ω Ω A B C

3 GARBAGE COLLECTION 8 gc Management of stoage allocation fom a heap (e.g., stings, lists, etc.) Allocation is usually eplicit (e.g., CONS in LISP, NEW in PASCAL) Deallocation is eplicit o implicit. PL/: eplicit via FREE. LISP: implicit via gaage collection pocess of detemining what pat of stoage is no longe eing efeenced and etuning it to the availale pool pocedue evese(); if empty() then else evese(,ω); pocedue evese(,y) if empty() then y else evese(est(),add(fist(),y)); add(,y) gas a -element cell fom AVAIL and yields evese[(a B C)] evese[(a B C),Ω] y y y Ω Ω Ω A B C A

4 GARBAGE COLLECTION z 8 gc Management of stoage allocation fom a heap (e.g., stings, lists, etc.) Allocation is usually eplicit (e.g., CONS in LISP, NEW in PASCAL) Deallocation is eplicit o implicit. PL/: eplicit via FREE. LISP: implicit via gaage collection pocess of detemining what pat of stoage is no longe eing efeenced and etuning it to the availale pool pocedue evese(); if empty() then else evese(,ω); pocedue evese(,y) if empty() then y else evese(est(),add(fist(),y)); add(,y) gas a -element cell fom AVAIL and yields evese[(a B C)] evese[(a B C),Ω] y y y y Ω Ω Ω A B C B A

5 GARBAGE COLLECTION g z 8 gc Management of stoage allocation fom a heap (e.g., stings, lists, etc.) Allocation is usually eplicit (e.g., CONS in LISP, NEW in PASCAL) Deallocation is eplicit o implicit. PL/: eplicit via FREE. LISP: implicit via gaage collection pocess of detemining what pat of stoage is no longe eing efeenced and etuning it to the availale pool pocedue evese(); if empty() then else evese(,ω); pocedue evese(,y) if empty() then y else evese(est(),add(fist(),y)); add(,y) gas a -element cell fom AVAIL and yields evese[(a B C)] evese[(a B C),Ω] y Ω y y y Ω Ω y Ω A B C C B A

6 GARBAGE COLLECTION 5 v g z 8 gc Management of stoage allocation fom a heap (e.g., stings, lists, etc.) Allocation is usually eplicit (e.g., CONS in LISP, NEW in PASCAL) Deallocation is eplicit o implicit. PL/: eplicit via FREE. LISP: implicit via gaage collection pocess of detemining what pat of stoage is no longe eing efeenced and etuning it to the availale pool pocedue evese(); if empty() then else evese(,ω); pocedue evese(,y) if empty() then y else evese(est(),add(fist(),y)); add(,y) gas a -element cell fom AVAIL and yields evese[(a B C)] evese[(a B C),Ω] y Ω y y y Ω Ω y Ω A B C C B A new cells have een allocated List (A B C) peviously pointed at y is no longe elevant o pointed at y the esult of evese (A B C) is gaage if no othe pat of the pogam can access it

7 STORAGE MAP 8 gc View of memoy used fee A B C D E G F H I J K L M N O P Q

8 STORAGE MAP 8 gc View of memoy used fee accessile inaccessile A B C D E G F H I J K L M N O P Q

9 STORAGE MAP z 8 gc View of memoy used fee accessile inaccessile used fee Gaage collection is the pocess of coalescing FREE and INACCESSIBLE to fom a new FREE aea A B C D E G F H I J K L M N O P Q

10 STORAGE MAP g z 8 gc View of memoy used fee accessile inaccessile used fee Gaage collection is the pocess of coalescing FREE and INACCESSIBLE to fom a new FREE aea A B C D E G F H I J K L M N O P Q. A, G, and M ae the immediately accessile cells mak all accessile cells A, B, C, D, E, F, G, H, I, J, L, M, and N

11 STORAGE MAP 5 v g z 8 gc View of memoy used fee accessile inaccessile used fee Gaage collection is the pocess of coalescing FREE and INACCESSIBLE to fom a new FREE aea A B C D E G F H I J K L M N O P Q. A, G, and M ae the immediately accessile cells mak all accessile cells A, B, C, D, E, F, G, H, I, J, L, M, and N. K, O, P, and Q ae inaccessile and ae gaage collected

12 STORAGE MANAGEMENT TECHNIQUES gc. Use keeps diect contol dange is dangling efeences if stoage shaed, feeing a lock causes polems if anothe pat of pogam elieves the lock is still in use X A B D E Z A a. '(D E) is shaed y the inding of X and Z. deallocating inding of Z leaves a dangling efeence to '(D E) in the inding of X. System contol via use of efeence countes incement wheneve allocate stoage o a cell is ound to an additional vaiale decement when cell is no longe eing efeenced (i.e., at lock eit) deallocation when efeence counte is zeo dawacks a. countes equie space can stoe sepaately fom data (sepaation of data and contol). ecusive stuctues such as cicula lists will neve have thei efeence countes go to zeo. Gaage collection system eplenishes availale pool of stoage

13 MECHANICS OF GARBAGE COLLECTION gc Two phases:. mak all accessile nodes. sweep though memoy placing all unmaked nodes in availale pool of stoage Polems:. slow when memoy is almost full. invalid infomation in pointe fields. mak its take up space can stoe in a sepaate tale. limited amount of memoy fo gaage collection pocess to un

14 gc5 ALGORITHM Sequentially step though memoy and each time encounte a maked node p, eset the cuent node to e the minimum of the unmaked addesses in the CAR and CDR fields of p Stop when each the end of memoy pocedue ALG(low,high); egin value intege low,high; gloal addess aay m; intege i,j; i low; while i high do egin if ATOM(m[i]) o NOT(MARK(m[i])) then i i+ else egin j i+; if NOT(MARK(CAR(m[i]))) then egin MARK(CAR(m[i])) tue; if NOT(ATOM(CAR(m[i]))) then j min(j,car(m[i])); if NOT(MARK(CDR(m[i]))) then egin MARK(CDR(m[i])) tue; if NOT(ATOM(CDR(m[i]))) then j min(j,cdr(m[i])); i j; mak CAR CDR only and initially accessile; stat sequential scan at. and its CAR and CDR aleady maked; esume scan at 5 8

15 gc5 ALGORITHM Sequentially step though memoy and each time encounte a maked node p, eset the cuent node to e the minimum of the unmaked addesses in the CAR and CDR fields of p Stop when each the end of memoy pocedue ALG(low,high); egin value intege low,high; gloal addess aay m; intege i,j; i low; while i high do egin if ATOM(m[i]) o NOT(MARK(m[i])) then i i+ else egin j i+; if NOT(MARK(CAR(m[i]))) then egin MARK(CAR(m[i])) tue; if NOT(ATOM(CAR(m[i]))) then j min(j,car(m[i])); if NOT(MARK(CDR(m[i]))) then egin MARK(CDR(m[i])) tue; if NOT(ATOM(CDR(m[i]))) then j min(j,cdr(m[i])); i j; mak CAR CDR only and initially accessile; stat sequential scan at. and its CAR and CDR aleady maked; esume scan at. and CDR() ae maked while CAR() is not maked; esume scan at afte making it 5 8

16 gc5 ALGORITHM Sequentially step though memoy and each time encounte a maked node p, eset the cuent node to e the minimum of the unmaked addesses in the CAR and CDR fields of p Stop when each the end of memoy pocedue ALG(low,high); egin value intege low,high; gloal addess aay m; intege i,j; i low; while i high do egin if ATOM(m[i]) o NOT(MARK(m[i])) then i i+ else egin j i+; if NOT(MARK(CAR(m[i]))) then egin MARK(CAR(m[i])) tue; if NOT(ATOM(CAR(m[i]))) then j min(j,car(m[i])); if NOT(MARK(CDR(m[i]))) then egin MARK(CDR(m[i])) tue; if NOT(ATOM(CDR(m[i]))) then j min(j,cdr(m[i])); i j; mak CAR CDR only and initially accessile; stat sequential scan at. and its CAR and CDR aleady maked; esume scan at. and CDR() ae maked while CAR() is not maked; esume scan at afte making it. CAR() and CDR() ae aleady maked; esume scan at 5 z 8

17 gc5 ALGORITHM Sequentially step though memoy and each time encounte a maked node p, eset the cuent node to e the minimum of the unmaked addesses in the CAR and CDR fields of p Stop when each the end of memoy pocedue ALG(low,high); egin value intege low,high; gloal addess aay m; intege i,j; i low; while i high do egin if ATOM(m[i]) o NOT(MARK(m[i])) then i i+ else egin j i+; if NOT(MARK(CAR(m[i]))) then egin MARK(CAR(m[i])) tue; if NOT(ATOM(CAR(m[i]))) then j min(j,car(m[i])); if NOT(MARK(CDR(m[i]))) then egin MARK(CDR(m[i])) tue; if NOT(ATOM(CDR(m[i]))) then j min(j,cdr(m[i])); i j; mak CAR CDR only and initially accessile; stat sequential scan at. and its CAR and CDR aleady maked; esume scan at. and CDR() ae maked while CAR() is not maked; esume scan at afte making it. CAR() and CDR() ae aleady maked; esume scan at 5. and its CAR and CDR fields ae aleady maked; esume scan at 5 which is unmaked; eit 5 g z 8

18 gc5 ALGORITHM Sequentially step though memoy and each time encounte a maked node p, eset the cuent node to e the minimum of the unmaked addesses in the CAR and CDR fields of p Stop when each the end of memoy pocedue ALG(low,high); egin value intege low,high; gloal addess aay m; intege i,j; i low; while i high do egin if ATOM(m[i]) o NOT(MARK(m[i])) then i i+ else egin j i+; if NOT(MARK(CAR(m[i]))) then egin MARK(CAR(m[i])) tue; if NOT(ATOM(CAR(m[i]))) then j min(j,car(m[i])); if NOT(MARK(CDR(m[i]))) then egin MARK(CDR(m[i])) tue; if NOT(ATOM(CDR(m[i]))) then j min(j,cdr(m[i])); i j; mak CAR CDR only and initially accessile; stat sequential scan at. and its CAR and CDR aleady maked; esume scan at. and CDR() ae maked while CAR() is not maked; esume scan at afte making it. CAR() and CDR() ae aleady maked; esume scan at 5. and its CAR and CDR fields ae aleady maked; esume scan at 5 which is unmaked; eit Algoithm is slow O(m n) fo m cells in memoy and n maked cells 5 5 v g z 8

19 ALGORITHM 8 gc6 Use a stack to keep tack of cells to e maked. mak all immediately accessile cells and ente them in stack. emove enties fom stack and fo each one that is not an atom, mak its CAR and CDR fields and ente them on the stack if they have not een peviously maked. teminate when the stack is empty mak CAR CDR stack:. initially, only and ae accessile and enteed on the stack 5

20 ALGORITHM 8 gc6 Use a stack to keep tack of cells to e maked. mak all immediately accessile cells and ente them in stack. emove enties fom stack and fo each one that is not an atom, mak its CAR and CDR fields and ente them on the stack if they have not een peviously maked. teminate when the stack is empty mak CAR CDR stack:. initially, only and ae accessile and enteed on the stack. emove fom the stack; ente CAR()= on the stack and mak it 5

21 ALGORITHM z 8 gc6 Use a stack to keep tack of cells to e maked. mak all immediately accessile cells and ente them in stack. emove enties fom stack and fo each one that is not an atom, mak its CAR and CDR fields and ente them on the stack if they have not een peviously maked. teminate when the stack is empty mak CAR CDR stack:. initially, only and ae accessile and enteed on the stack. emove fom the stack; ente CAR()= on the stack and mak it. emove fom the stack; oth CAR() and CDR() have aleady een maked 5

22 ALGORITHM g z 8 gc6 Use a stack to keep tack of cells to e maked. mak all immediately accessile cells and ente them in stack. emove enties fom stack and fo each one that is not an atom, mak its CAR and CDR fields and ente them on the stack if they have not een peviously maked. teminate when the stack is empty mak CAR CDR stack: -. initially, only and ae accessile and enteed on the stack. emove fom the stack; ente CAR()= on the stack and mak it. emove fom the stack; oth CAR() and CDR() have aleady een maked. emove fom the stack; oth CAR() and CDR() have aleady een maked; stack is empty and finished 5

23 ALGORITHM 5 v g z 8 gc6 Use a stack to keep tack of cells to e maked. mak all immediately accessile cells and ente them in stack. emove enties fom stack and fo each one that is not an atom, mak its CAR and CDR fields and ente them on the stack if they have not een peviously maked. teminate when the stack is empty mak CAR CDR stack:. initially, only and ae accessile and enteed on the stack. emove fom the stack; ente CAR()= on the stack and mak it. emove fom the stack; oth CAR() and CDR() have aleady een maked. emove fom the stack; oth CAR() and CDR() have aleady een maked; stack is empty and finished - Time popotional to nume of cells that ae maked Dawacks. whee to stoe the stack? little memoy availale at time gaage collection is invoked. not inconceivale to un out of stack space when unning algoithm 5

24 ALGORITHM 8 gc7 Avoids use of stack in Algoithm y eusing the CAR and CDR fields to simulate the stack Requies additional one-it DOING_CAR field fo each non-atomic cell p to indicate whethe the cell cuently eing pocessed is pointed at y CAR(p) o CDR(p) DOING_CAR is useful in detecting if oth CAR and CDR of p have een gaage-collected Disadvantages: cannot eecute in paallel with application pogam CAR CDR DOING_CAR top_stack p: 0

25 ALGORITHM 8 gc7 Avoids use of stack in Algoithm y eusing the CAR and CDR fields to simulate the stack Requies additional one-it DOING_CAR field fo each non-atomic cell p to indicate whethe the cell cuently eing pocessed is pointed at y CAR(p) o CDR(p) DOING_CAR is useful in detecting if oth CAR and CDR of p have een gaage-collected Disadvantages: cannot eecute in paallel with application pogam CAR CDR DOING_CAR p: top_stack top_stack p: 0. visiting p fo fist time (assume CAR(p) is not maked) set DOING_CAR to tue set CAR(p) to pedecesso (TOP_STACK) set TOP_STACK to p set p to old value of CAR(p) continue pocessing p

26 ALGORITHM z 8 gc7 Avoids use of stack in Algoithm y eusing the CAR and CDR fields to simulate the stack Requies additional one-it DOING_CAR field fo each non-atomic cell p to indicate whethe the cell cuently eing pocessed is pointed at y CAR(p) o CDR(p) DOING_CAR is useful in detecting if oth CAR and CDR of p have een gaage-collected Disadvantages: cannot eecute in paallel with application pogam CAR CDR DOING_CAR top_stack p: s: top_stack top_stack p:. visiting p fo fist time (assume CAR(p) is not maked) set DOING_CAR to tue set CAR(p) to pedecesso (TOP_STACK) set TOP_STACK to p set p to old value of CAR(p) continue pocessing p. visiting p fo second time (etuning fom s) eset CAR(p) to s set TOP_STACK to pevious value of CAR(p) 0

27 ALGORITHM g z 8 gc7 Avoids use of stack in Algoithm y eusing the CAR and CDR fields to simulate the stack Requies additional one-it DOING_CAR field fo each non-atomic cell p to indicate whethe the cell cuently eing pocessed is pointed at y CAR(p) o CDR(p) DOING_CAR is useful in detecting if oth CAR and CDR of p have een gaage-collected Disadvantages: cannot eecute in paallel with application pogam CAR CDR DOING_CAR top_stack top_stack top_stack p: 0 0 top_stack p: s: :. visiting p fo fist time (assume CAR(p) is not maked) set DOING_CAR to tue set CAR(p) to pedecesso (TOP_STACK) set TOP_STACK to p set p to old value of CAR(p) continue pocessing p. visiting p fo second time (etuning fom s) eset CAR(p) to s set TOP_STACK to pevious value of CAR(p) if =CDR(p) is not maked then a. mak. set CDR(p) to pevious TOP_STACK value c. set TOP_STACK to p d. set DOING_CAR to false e. continue pocessing

28 ALGORITHM 5 v g z 8 gc7 Avoids use of stack in Algoithm y eusing the CAR and CDR fields to simulate the stack Requies additional one-it DOING_CAR field fo each non-atomic cell p to indicate whethe the cell cuently eing pocessed is pointed at y CAR(p) o CDR(p) DOING_CAR is useful in detecting if oth CAR and CDR of p have een gaage-collected Disadvantages: cannot eecute in paallel with application pogam CAR CDR DOING_CAR top_stack top_stack top_stack top_stack p: 0 0 top_stack p: s: : s:. visiting p fo fist time (assume CAR(p) is not maked) set DOING_CAR to tue set CAR(p) to pedecesso (TOP_STACK) set TOP_STACK to p set p to old value of CAR(p) continue pocessing p. visiting p fo second time (etuning fom s) eset CAR(p) to s set TOP_STACK to pevious value of CAR(p) if =CDR(p) is not maked then a. mak. set CDR(p) to pevious TOP_STACK value c. set TOP_STACK to p d. set DOING_CAR to false e. continue pocessing. visiting p fo thid time (etuning fom s) eset CDR(p) to s set TOP_STACK to pevious value of CDR(p) continue unwinding

29 STOP-AND-COPY GARBAGE COLLECTION gc8 Polems with sweep phase of mak-and-sweep paadigm:. must eamine each memoy location to see if maked. inefficient if most locations wee maked as will need to einvoke pocess soon poaly pefeale to incease size of FREE aea. also inefficient if few ae maked (i.e., most ae inaccessile) may e cheape to copy contents of maked ones while making in which case emaining stoage is availale fo allocation Altenative is to use stop-and-copy paadigm. motivation is that most locations ae inaccessile cheape to copy accessile while making instead of making followed y a sweep though all of memoy which includes the inaccessile as well. patition memoy into aeas: copied-fom and copied-to only one aea is eve in use. algoithm: when stoage is ehausted in the aea in-use (copied-fom) identify the accessile locations in it and in the pocess copy them to the othe aea (copied-to) continue eecution with all susequent allocation fom the unoccupied locations in copied-to copied-fom will seve as the copied-to aea the net time stoage is ehausted pocess continues with oles of two aeas intechanged. dawacks: need to e caeful so pointes ae coect if shaing is pemitted one half of memoy is not in use

30 GENERATIONAL SCAVENGING gc9 In tems of ojects athe than locations Focus on age (time since initial allocation of oject) Basic pemises (acked y empiical osevations). young ojects die at a faste ate than old ojects. old ojects usually efe to old ojects Implications:. stoage eclamation should focus on young ojects and not waste time on old ojects. since so many young ojects die, it is cheape to copy the suviving ones than to sweep though the copses Two types of gaage collection. vaiant of stop-and-copy (scavenging) vey often. mak-and-sweep less often Memoy patitioned into fou aeas (temed spaces):. NewSpace: new ojects allocated fom hee. PastSuvivoSpace: like copied-fom. FutueSuvivoSpace: like copied-to. OldSpace: suvivied moe than s scavenges Teminology ationale:. scavenge: only eamine most pomising pat of stoage. geneation: don t othe to scavenge when gown up (tenued)

31 MECHANICS OF GENERATIONAL SCAVENGING gc0 Stat with immediately accessile ojects Scavenge at egula intevals o when NewSpace is ehausted. only mak accessile ojects in NewSpace and PastSuvivoSpace and copy to FutueSuvivoSpace apply ecusively. tenue ojects (move into OldSpace) if they have suvived moe than s scavenges (moves fom PastSuvivoSpace to FutueSuvivoSpace). do not pusue pointes to ojects in OldSpace Inaccessile old ojects ae collected y applying mak-and-sweep algoithm to entie memoy. OldSpace. YoungSpace = { NewSpace,PastSuvivoSpace, FutueSuvivoSpace} Rememeed set contains ojects in OldSpace that point to ojects in YoungSpace Time compleity: nume of suviving ojects (including those accessile fom the ememeed set) Space compleity:. it pe oject to indicate if moved fom PastSuvivoSpace to FutueSuvivoSpace. countes fo tenuing

32 MECHANICS OF REMEMBERED SET R gc Ojects added when:. assignment opeation esults in an oject in OldSpace pointing to an oject in YoungSpace (e.g., RPLACA and RPLACD in LISP). oject eing tenued points to an oject in YoungSpace All ojects p pointed at y oject o in R ae scavenged:. if p points to OldSpace, then leave p alone. if p efeences YoungSpace, then: if p aleady moved to f in FutueSuvivoSpace o OldSpace, then update pointe in o to point to f instead of to p if p has not een moved aleady, then: a. move p to f in eithe FutueSuvivoSpace o OldSpace, depending on p's age. eplace contents of p y a pointe to f c. update pointe in o to efe to f instead of p. if afte scavenge update, all ojects p pointed y o ae in OldSpace, then emove o fom R Recusively pocess (scavenge) all ojects moved to FutueSuvivoSpace, OldSpace, and the ememeed set