Partial Marking GC. A traditional parallel mark and sweep GC algorithm has, however,

Transcription

1 Partial Marking GC Yoshio Tanaka 1 Shogo Matsui 2 Atsushi Maeda 1 and Masakazu Nakanishi 1 1 Keio University, Yokohama 223, Japan 2 Kanagawa University, Hiratsuka , Japan Abstract Garbage collection (GC) normally causes pause of execution Parallel GC has a great potential for real time (non-disruptive) processing A traditional parallel mark and sweep GC algorithm has, however, well known disadvantages In this paper, we propose a new GC scheme called Partial Marking GC (PMGC) which is a valiant of generational GC We implemented a Lisp interpreter with PMGC on a general purpose multi-cpu workstation As a result, in the best case, PMGC is provided to be twice as ecient as the original algorithm PMGC is very eective for implementing practical parallel GC 1 Introduction A list processing system needs large number of cells, which are basic units of a linked list, and garbage collection (GC) is required to collect and recycle disposed cells GC normally causes long pause of execution, which restricts application of list processing systems The pause times is getting shorter in modern GC algorithms such as generation scavenging GC[6], however can not be eliminated perfectly More ecient and/or real time (non-disruptive) GC algorithm is still a very important research theme In this paper, we point out the disadvantages common to parallel GC algorithms, and propose Partial Marking GC The marking process of Partial Marking GC is ecient and the performance of parallel GC is much improved by Partial Marking GC We also report an implementation and evaluation of our system 2 Snapshot-at-Beginning Algorithm Most practical parallel GC algorithms are Snapshot-at-Beginning algorithms (SB algorithm)[7] The basic idea is to take a snapshot of heap space at the ning of garbage collection and preserve all cells that are reachable from the roots at that time and cells created during the collection process In previous studies, we have designed and implemented this type of parallel mark and sweep garbage collector for Lisp machine SYNAPSE[4] Our garbage collector is almost the same as well-known Yuasa's snapshot GC[8] except that the snapshot GC is not parallel but incremental SB algorithm uses three colors as a tag for marking; black, white and o-white O-white is a tag for cells in the free list GC process (GP) repeats a GC cycle which consists of following three phases

2 1 root insertion phase GP collects roots from the List Processor (LP) 2 marking phase GP marks all cells (ie change the tags to black) which are reachable from the roots 3 sweep phase GP connects all cells whose tag is white to the free list Black and o-white tags are changed to white except the cells in the free list LP does not change a tag of a CONSed cell; that is, leaves a tag as o-white The cells which are created during a marking phase are never collected in the subsequent sweep phase, because the tags of newly created cells by CONS are o-white If LP writes over the pointer on the cell when GP is in a marking phase, the overwritten value is passed to GP for later examination, ie all live cells at the root insertion phase are marked even if the links to the cells are removed SB algorithm's correctness is guaranteed by these operations SB algorithm is very simple and can be easily implemented as both parallel GC and incremental GC Implemented as parallel GC, LP's overhead is very low because only additional procedures of LP are root insertion and notication of replaced pointers On SB algorithm, cells which are either active at the point of root insertion or created during a marking phase are never collected in the subsequent sweep phase Therefore, cells which died immediately during the marking phase are collected not in the subsequent sweep phase but in the next sweep phase but one However, the time spent for marking is the same as that of sequential mark and sweep GC ig 1 illustrates the disadvantage of SB algorithm Just after marking phase, there are many cells which are CONSed during the marking phase and whose tag is o-white Most of the cells are actually garbage cells, however, the garbage cells are not collected but only changed the tag to white in the subsequent sweep phase They are collected in the next sweep phase We dene collection ability as the number of reclaimed cells per unit time, and collection eciency as (collection ability of parallel GC) / (collection ability of sequential GC) As shown in Hickey's analysis[2], the collection eciency of this type of algorithm is 1=2 urthermore, since most cells are short lived[3, 6], the marking cost is more serious if the applications consume many cells LP is indeed frequently suspended in the execution of applications which consume many cells, because the collection of garbage cells by GP can not catch up the consumption of cells by LP 3 Partial Marking GC 31 Basic Idea Partial Marking GC(PMGC)[5] is a variant of generational GC[6] incorporated into SB algorithm PMGC is to improve the collection eciency by reducing the time spent for marking

3 root stack root stack free list free list garbage cells (not marked) mark is cleared marked cells free cells free cells CONSed cells during sweep phase CONSed cells during marking phase (These will not be collected in the subsequent sweep phase) (These will not be collected in the next sweep phase) Just after marking phase Just after sweep phase ig 1 Disadvantage of SB algorithm In a sweep phase of PMGC, GP leaves the black tag (does not change to white) which was set in the previous marking phase In the next marking phase, GP does not mark the cells marked in the previous marking phase because the tags of those cells are left as black Such marking is called partial marking and the phase including partial marking is called partial marking phase The cells which are created in the previous GC cycle and still active in the current GC cycle are marked in the partial marking phase The time spent for marking is very short because most of active cells are already marked As a result, garbage cells died (changed the tag to white) during the previous GC cycle are collected in much shorter period than original SB algorithm The collection ability is improved by reducing the time spent for marking, and the collection eciency is also improved When GP changes the black tag to white in the previous sweep phase, the following marking will be an ordinary marking (called full marking) ig 2 illustrates the process of PMGC In the sweep phase after the full marking phase, the black tag is left as black, and the o-white tag is changed to white In the next partial marking phase, only two cells are created and marked The other seven cells are not marked in the partial marking phase because the tags of the cells are black In the sweep phase after the partial marking phase, the black tag is changed to white The next marking is the ordinary marking A GC cycle containing partial marking phase is called partial cycle and a GC cycle containing

4 root stack root stack free list free list garbage cells (not marked) clear the gray tag marked cells leave the black tag free cells free cells CONSed cells during marking phase (These will not be collected in the subsequent sweep phase) CONSed cells during sweep phase (These will not be collected in the next sweep phase) Just after full marking phase Just after sweep phase root stack M root stack free list M free list garbage cells (not marked) clear the gray or black tag cells already marked free cells free cells CONSed cells during marking phase (These will not be collected in the subsequent sweep phase) CONSed cells during sweep phase (These will not be collected in the next sweep phase) M cells marked in this phase Just after partial marking phase Just after sweep phase ig 2 Partial Marking GC

5 full marking phase is called full cycle Whether the cycle will be partial cycle or full cycle is determined by the process of previous sweep phase A full cycle and some (one or more) partial cycle(s) construct a sequence GP repeats this sequence in PMGC The cells marked in full marking phase are equivalent to long lived cells in generation scavenging[6] Partial cycles are equivalent to scavenging for creation space and young object space in generation scavenging PMGC can be considered as generation scavenging whose period is very short (scavenge old space once per several GC cycles) 32 Algorithm of PMGC The cells active at the point of root insertion are usually marked because each cycle of PMGC is the same as the SB algorithm except the sweep phase There are some active cells which are never marked in the following two cases 1 Where LP writes a pointer onto the cell colored black during a full marking phase when the pointer points to an o-white cell 2 Where LP writes a pointer onto the cell colored black during a sweep phase in a full cycle when the pointer points to either an o-white or a white cell In the above cases, the written pointers are not passed to GP if those pointers are contained in the roots The o-white tag is changed to white in the sweep phase In both cases, there are some pointers from a black cell to a white cell at the point of root insertion of partial cycle Those cells are never marked in the partial marking phase unless there are another links to those cells, because the marking process is terminated when GP nds a black cell Those cells are collected in the next sweep phase even if they are alive To avoid the improper collection, extra process which are not necessary in SB algorithm is added in PMGC In the above cases, not only the overwritten pointers but also the written pointers have to be passed to GP for later examination This is the same as the remembered set of generation scavenging GC This extra overhead is not considerable because the replacing of pointers are not of frequent occurrence The algorithm of PMGC is shown in ig 3 (GP) and ig 4 (LP) To simplify the algorithm, the tag of a cell specied by the rst argument is not checked in procedure LP rplaca and LP rplacd in ig 4 In this algorithm, the number of partial cycles between full cycles is considered as 1, ie GP executes a full cycle and a partial cycle alternately A cell has two pointer elds ( left, right ) and a tag eld (color) The total number of cells is M The free list is pointed to by REE REEleft points the head of the free list, and REEright points the tail of the free list A special pointer f is stored in left part of every free cells 4 Implementation Partial Marking GC has been implemented on OMRON LUNA-88K workstation LUNA-88K comprises 4 processors and uses MACH operating system developed in CMU MACH provides a set of low-level primitives for manipulating threads of

6 procedure GP root insert; push all roots onto the stack end procedure GP mark; while the stack is not empty do n := pop; while (n 6= NIL) and (nleft 6= f) and (ncolor 6= black) do ncolor := black; push(nright); n := nleft; end end procedure GP collect leave mark; for i := 1 to N do if icolor = white then APPEND(i) else if (icolor = o-white) and (ileft 6= f) then icolor := white procedure GP collect clear mark; for i := 1 to N do if icolor = white then APPEND(i) else if ileft 6= f then icolor := white procedure GP partial marking gc; while true do CYCLE := ULL; GP root insert; PHASE := MARKING; GP mark; PHASE := SWEEP; GP collect leave mark; CYCLE := PARTIAL; GP root insert; PHASE := MARKING; GP mark; PHASE := SWEEP; GP collect clear mark; end ig 3 The algorithm of PMGC (GP) control A thread facility allows us to write programs with multiple simultaneous points of execution, synchronizing through shared memory In our experiments, two threads are created; one is for list processing (we call this LP thread) and the other is for GC (we call this GC thread) We used a Lisp system based on Klisp, a Lisp 15 dialect developed at Keio University In order to execute GC concurrently, ps stack is added as new data area The LP thread noties the GC thread of rewriting cells during the marking phase through the ps stack The ps stack is shared data between the GC thread and the LP thread, and must be accessed only from a thread Some semaphores and ags are also added

7 procedure LP rplaca(m, n); if (cycle = ULL) and (ncolor!= black) then push(n); if (phase = MARKING) and (mleftcolor!= black) then push(mleft); mleft = n procedure LP rplacd(m, n); if (cycle = ULL) and (ncolor!= black) then push(n); if (phase = MARKING) and (mrightcolor!= black) then push(mright); mright = n procedure LP cons(m, n); sleep while REEleft = REEright NEW := REEleft; REEleft := REEleftright; NEWleft := m; NEWright := n ig 4 The algorithm of PMGC (LP) 41 Implementation of Partial Marking GC List processing and GC are processed concurrently by a LP thread and a GC thread The LP thread executes list processing the same with the traditional Lisp interpreter except that it does not collect garbage cells by itself The LP thread checks the root insertion ag every time CONS is called because interruption is not available in C-threads library The root insertion ag is set when the GC thread enters the root insertion phase The LP thread inserts all roots into the root stack when it nds that the root insertion ag is set The LP thread noties the GC thread of rewriting cells during the marking phase through the ps stack The LP thread is blocked while the free list is empty The GC thread awakens the blocked LP thread at entering the sweep phase In the root insertion phase, the GC thread sets the root insertion ag and blocks until the LP thread nishes to insert all roots into the root stack In our implementation, the algorithm of PMGC is the same as the algorithm shown in ig 3, ie the GC thread executes a full cycle and a partial cycle alternately 5 Evaluation 51 Evaluation of parallel GC To evaluate parallel GC, we dene the following parameters seq-lisp is the traditional Lisp interpreter with sequential mark and sweep garbage collector para-

8 lisp is the Lisp interpreter with parallel garbage collector T seq:gc T seq:lp T seq:total T para:gc T para:lp T para:total The time spent for garbage collection in seq-lisp The time spent for list processing in seq-lisp The total processing time in seq-lisp T seq:total = T seq:gc + T seq:lp The time spent for garbage collection in para-lisp The time spent for list processing in para-lisp The total processing time in para-lisp GC ratio and improvement ratio are dened as follows G = T seq:gc T seq:total ; I = T seq:total 0 T para:total T seq:total (1) I is the ratio of reduction time of the total processing time in para-lisp to the total processing time in seq-lisp Relations between G and I is loaded on the assumption that the application is stable and create cells at the constant rate In this case, T para:total is So, I is T para:total = max(t para:lp ; T para:gc ): (2) I = min( T seq:total 0 T para:lp ; T seq:total 0 T para:gc ): (3) T seq:total T seq:total T para:gc < T para:lp if the collection is enough fast and the free list never be empty In this case, T para:total = T para:lp : LP waits for free cells in each GC cycle if LP exhausts all free cells before GP nish to collect garbage cells In this case, T para:total = T para:gc : Now, let T para:oh be the overhead of LP in para-lisp, and n be the ratio of the eciency of GC in para-lisp to in seq-lisp T para:lp = T seq:lp + T para:oh ; T para:gc = nt seq:gc (n > 0) (4) Overhead ratio is dened that O = T para:oh =T seq:total, then I is as follows I = min(g 0 O; 1 0 ng) (5) I is the reduction rate of the total processing time in para-lisp to the total processing time in seq-lisp G and I are parameters depending on the application program n and O are basically implementation-dependent We are able to estimate n and O from the graph of G and I which we are able to obtain by experiment

9 GP SB 1-GP partial 2-GP SB 2-GP partial I G ig 5 G and I of PMGC 52 Evaluation of PMGC ig 5 shows the relations between G and I of SB algorithm and PMGC We executed a stable application which repeats consuming a cell particular times to waste cells We kept a constant list in the heap and changed GC ratio by changing the length of the list A dotted line shows the ideal processing (n=1, O=0) with one GP In Hickey's terminology, the increasing part of the graph indicates the stable state (LP never waits for cells) The decreasing part is divided into two parts according to its value of I: one is positive part and the other is negative part The positive part indicates the alternating state (LP waits for cells in once per two GC cycles) The negative part indicates the critical state (LP waits for cells in every GC cycle) G which corresponds to the maximum value of I indicates real time performance Real time processing is possible only in the stable state Let us consider the eciency of SB algorithm We nd from the graph, real time processing is possible until GC ratio exceeds 035 when one GP is used (1- GP SB), and applications can be processed in real time until GC ratio exceeds 05 when two GPs are used (2-GP SB) We estimate O as about 5% from this graph So n in formula (4) is determined as 2 when one GP is used The processing with two GPs is closer to the ideal processing with one GP This also means that n is determined as 2 O for two GPs is about 10% O for two GPs increases compared with O for one GP The negative part means that the execution time is longer than in sequential Lisp The negative part appears in higher range of G for one GP and in very low range of G for two GPs rom the analysis above, the collection eciency of SB algorithm is 1=2 compared with traditional sequential

10 mark and sweep garbage collector We also nd that some programs with parallel garbage collector run slower than with sequential garbage collector The eciency of PMGC with one GP (1-GP partial) is obviously much improved compared to the original SB algorithm The processing is closer to the ideal processing, and is almost the same as the original SB algorithm with two GPs The negative part of 1-GP SB is eliminated This means that the execution time in parallel GC Lisp is shorter than in sequential GC Lisp in any conditions G which corresponds to the maximum value of I slides to right Real time processing is possible until G exceeds 05 The maximum value of I also increases and is about 04 This means that the processing time through parallel GC Lisp is 60% of the processing time through sequential mark and sweep GC Lisp This is the case of one GP and one LP The eciency of PMGC with two GPs (2-GP partial) is much more improved than with one GP Real time processing is possible until G exceeds about 06 The maximum value of I is about 05 If G is less than 03, I is lower 1-GP SB, 1-GP partial, 2-GP SB and 2-GP partial in that order This means that the LP's overhead increases according to the eciency of GC As the eciency of GC rises, the number of times of GC per unit time increases and access conicts to the common resources occur more frequently, that is, the LP's overhead increases 6 urther Improvements 61 basic idea It is not necessary to keep garbage collector running when there are enough free cells It is possible to improve the eciency of GC by pausing or resuming GP according to the amount of the rest (usable) free cells when there is no urge demand to execute GC To put it in the concrete, start GP only when the amount of free cells becomes less than a threshold called invoking threshold When the sweep phase has nished, GP stops until the time GC becomes necessary again Invoking threshold is adjusted dynamically according the run-time status of applications Invoking threshold is determined by the number of collected cells in each GC cycle and the number of consumed cells by LP in the same GC cycle as below T he number of consumed cells invoking threshold = T he number of collected cells LP in average does not wait for cells because LP consumes only [invoking threshold 2 The number of whole cells] cells during next GC cycle even if GP has to collect entire cells (6) 62 evaluation We implemented and experimented the above strategy ig 6 shows the eciency of improved PMGC The conditions of the experiments are the same as the

11 04 03 I original PMGC improved PMGC G ig 6 G and I of improved PMGC conditions of the experiments shown in ig 5 The results of our experiments show that I of improved PMGC is higher than I of original PMGC when G is less than about 22%, and I is not dierent between the two PMGCs when G exceeds about 22% ig 7 shows the execution time of some applications, relative to seq-lisp The running application is Boyer[1], and executed through both interpreter and compiler The left half of the graph shows the case of GC ratio is low (about 10%) and the right half shows the case of GC ratio is high (about 40%) When GC ratio is high, the execution time is drastically improved by PMGC When GC ratio is low, however, the execution time is longer in PMGC because of the overhead of LP By controlling the execution of GP, PMGC shows the improvement even in low GC ratio case 7 Conclusion and uture Work There is a disadvantage common to parallel GC algorithms; the collection eciency is 1/2 compared to the sequential mark and sweep garbage collector We propose PMGC which makes the marking process of parallel GC more ecient The basic idea is the same as the generational sequential collectors PMGC limits a target of marking and reduces the time spent for marking PMGC improves the collection eciency By controlling the execution of GP, the overhead by parallel processing is reduced It is easy to implement high performance parallel garbage collectors on wide variety of multi processor machines using PMGC SB algorithm is applicable for multiple GPs and multiple LPs We will implement a parallel Lisp interpreter which has multiple threads At rst, all threads execute list processing When there is a necessary to collect garbage, some of the threads stop list processing and execute GC The threads resume list processing

12 Relative Execution Time Relative Execution Time of Boyer Interpreter Compiler GC ratio is 10% Interpreter Compiler GC ratio is 40% Sequential Snapshot PMGC improved PMGC Application ig 7 Relative Execution Time when GC nishes We are planning to attach list processing or GC to multiple threads dynamically References 1 Gabriel, Richard P: Performance and Evaluation of Lisp systems The MIT Press (Cambridge, Massachusetts, 1985) 2 Hickey, T and Cohen, J: Perfromance Analysis of On-the-y garbage collection Comm ACM, 27(11) (1984) 1143{ Lieberman, H and Hewitt, C: A Real-Time Garbage Collector Based on the Lifetimes of Objects Comm ACM, 26(6) (1983) 419{429 4 Matsui, S et al: SYNAPSE: A Multi-micro-processor Lisp Machine with Parallel Garbage Collector Proceedings of the International Workshop on Parallel Algorithms and Architectures (Suhl, GDR, 1987) 131{137 5 Tanaka, Y and Matsui, S et al: Parallel Garbage Collection by Partial Marking and Conditionally Invoked GC Proceedings of the International Conference on Parallel Computing Technologies, 2, (Obninsk, RUSSIA, 1993) 397{408 6 Ungar, D: Generation Scavenging: A Non-disruptive High Performance Storage Reclamation Algorithm ACM SIGPLAN Notices 19(5) (1987) 157{167 7 Wilson, Paul R: Uniprocessor Garbage Collection Techniques Lecture Notes in Computer Science 637 Springer-Verlag (1992) 1{42 8 Yuasa, T: Real-Time Garbage Collection on General-Purpose Machines The Journal of Systems and Software 11(3) (1990) 181{198 This article was processed using the LaT E X macro package with LLNCS style