The Tortured History of Real-Time Garbage Collection

Transcription

1 The Tortured History of Real-Time Garbage Collection doc/ Fall 2003 Seminar on Programming Languages

2 Real-Time Garbage Collection: Introduction Introduction Why a tortured history? claims, counterclaims, misconceptions hard vs. soft real-time specialized hardware inconsistently-used terminology What is the history? GC turned 43 this year! What were alternatives to GC at the time it was popularized? How do the competing claims of real-time behavior match up? What are the general flavors of garbage collector design? * Counting from [McCarthy 1960]. What are the modern-day real-time alternatives to GC? 1

3 Real-Time Garbage Collection: History of GC Flashback: 1950s In the beginning... global and stack data only Newell-Shaw-Simon IPL address decrement needed to know memory requirements up front dynamic allocation structures could vary memory usage data restructuring during execution list processing vs. array/vector processing theorem prover for the propositional calculus Gelernter [1960] tells us that NSS theorem prover was 3 5 Π orders of magnitude slower than competing provers. lack of adequate system support (addressing modes etc.) Π 2

4 Real-Time Garbage Collection: History of GC List processing 3

5 Real-Time Garbage Collection: History of GC How to collect garbage in 1960 Owner-borrower model Fortran List Processing Language (FLPL) Gelernter et al. (1960, IBM) the first reference is an owner, subsequent ones are borrowers when the owner points away, the item is collected dynamically determined contrast: Boyapati & Rinard s ownership types Π Garbage collection McCarthy (1960, MIT) LISt Processor (LISP) 4 mark/sweep GC

6 Real-Time Garbage Collection: History of GC How to collect garbage in 1960 (continued) Reference counting Collins (1960, IBM) considered GC seen as alternative to GC nowadays, anything that automatically reclaims memory is cycles ( self-referential lists ) not collectable depending on your data structures, you may not care Π Knuth [1973] writes that using reference counting for real-time systems is problematic because there isn t a clear bound on the work done when a count drops to zero 5

7 Real-Time Garbage Collection: History of GC Early evolution of GC J. Weizenbaum s Symmetric List Processor (SLIP) (1963, GE) doubly-linked list structure reference-count only the heads of lists lazy reclamation incremental free list (LAVS) system (retaining incremental reclamation) Later (1969, MIT), Weizenbaum proposes hybrid RC + M&S 6

8 Real-Time Garbage Collection: Mark & Sweep Techniques How to do Mark & Sweep Knuth [1973] gives us five basic algorithms: 1. multiple scan naïve and inecient 2. depth-first search with stack where does the stack space come from?! 3. hybrid1&2withfixedstacksize 4. threaded stack marking requires field in objects 5. Deutsch-Schorr-Waite (DSW) threaded stack marking reuses existing fields (CAR, CDR, ATOM, MARK) [Knuth 1973]: Best at the time was probably a hybrid of 3 & 5 M&Sisall or nothing you can t cut corners on the marking critical if we consider an incremental or concurrent M & S 7

9 Real-Time Garbage Collection: Baker s Real-Time Copying Collector [Baker 1978]: Real-Time Serial List Processing Real-time copying collector in the spirit of [Cheney 1970] Elementary list operations need to be bounded by a constant Incremental but not concurrent Scans k copied to-space objects during CONS Baker constructs an argument that to-space doesn t exhaust in equlibrium conditions, given suitable to-space size from space to space copy free space read scanned relocated available 8

10 Real-Time Garbage Collection: Definitions Definitions (inconsistently used) mutator - user program collector - GC code/thread/algorithm/whatever conservative collector - GC that assumes anything is a pointer exact/precise collector - GC that distinguishes pointers from data incremental collector - GC cycle done in small steps concurrent collector - one collector thread executes concurrently parallel collector - multiple collector threads [Cheng 2001] tracing collector - GC that computes reachability directly stop-the-world collector - mutator threads pause (non-incremental) copying collector - tracing GC, moves live objects out semispace collector - copying GC with to-space and from-space generational collector - copying GC with generations based on age stop-and-copy collector - mutator threads pause for a full copy roots - global data and mutator stack ( base registers ) equilibrium - one cell allocated : one cell freed 9

11 Real-Time Garbage Collection: Beyond list processing But we ve moved beyond list processing! We heap-allocate Cartesian product data structures and arrays To implement these with list-processing linked data structures, we have O(log n) instead of O(1) retrieval of data items! 10

12 Real-Time Garbage Collection: Extensions to [Baker 1978] Extensions to [Baker 1978] Problems with [Baker 1978] not concurrent requires special hardware to be ecient first implementations were bad doesn t consider variable-sized requests for memory can t do copying with a conservative GC Brooks [1984] uses unconditional indirection cost of one word per object Kelvin Nilsen [1988] extended Baker s collector to strings allocation should take O(n) 11

13 Real-Time Garbage Collection: Extensions to [Baker 1978] Extensions to [Baker 1978] Appel, Ellis, and Li [Appel 1988] present...the first copying garbage-collection algorithm that is ecient, real-time, concurrent, runs on stock commercial uniprocessors and multiprocessors, and requires no change to compilers. uses virtual memory page protections to effect a R/W barrier rather than catching dereferences of pointers into from-space, it catches reads of unscanned pointer values from to-space that point into from-space scans and copies objects pagewise Johnson [1992]: pagewise copy induces large worst-case latency makes [Appel 1988] lazier doesn t copy object, just initializes it (copies later) 12 Sub-page card-marking also possible

14 Real-Time Garbage Collection: Baker s Treadmill Baker s Treadmill Real-Time Garbage Collection Without the Motion Sickness [Baker 1992] Allocation In-place collector using tri-color marking New Free Scanning To From * Figure from [Wilson 1994], redrawn 13

15 Real-Time Garbage Collection: Replication Collection The Nettles-O Toole Approach Real-Time Replication Garbage Collection [Nettles 1993] Incremental copying with a twist Allow the mutator to only see from-space objects during GC Flip from-space and to-space after the GC cycle also must do root updates! No Baker-style read barrier required for object forwarding...but we have a write-barrier instead to replicate changes to already-copied objects This isn t a problem if updates are rare or nonexistent e.g., in functional languages 14 Generally, far fewer updates than reads in real programs

16 Real-Time Garbage Collection: The Train Garbage Collection by Train Hudson and Moss, Incremental Collection of Mature Objects [IWMM 1992] focus on being non-disruptive, not real-time Reduces space overhead, copies only part of the heap at a time traincars are cleaned round-robin, each has remembered set Train A B Train B A C D E F root R S T * Figure from [Hudson 1992], redrawn and colorized 15

17 Real-Time Garbage Collection: Contaminated GC Contaminated Garbage Collection Cannarozzi, Plezbert, and Cytron [PLDI 2000] Puts heap objects into equilive sets each equilive set is associated to a stack frame when stack frame pops, associated equilive sets are freed symmetric contamination: (X ref Y)! (Y ref X) if X and Y are from different sets, they are unioned Π Interesting design: tracing or non-tracing? (Non-copying Train?) Static pointer of death (life?) and the Plezbert Optimization Approximate not guaranteed to detect all unreachable objects Suitable for real-time? 16

18 Real-Time Garbage Collection: Contaminated GC Contaminated Garbage Collection 17

19 Real-Time Garbage Collection: Contaminated GC Contaminated Garbage Collection 17

20 Real-Time Garbage Collection: Contaminated GC Contaminated Garbage Collection 17

21 Real-Time Garbage Collection: Contaminated GC Contaminated Garbage Collection 17

22 Real-Time Garbage Collection: Contaminated GC Contaminated Garbage Collection 17

23 Real-Time Garbage Collection: Contaminated GC Contaminated Garbage Collection 17

24 Real-Time Garbage Collection: Contaminated GC Contaminated Garbage Collection 17

25 Real-Time Garbage Collection: Contaminated GC Contaminated Garbage Collection 17

26 Real-Time Garbage Collection: Contaminated GC Contaminated Garbage Collection 17

27 Real-Time Garbage Collection: Contaminated GC Contaminated Garbage Collection 17

28 Real-Time Garbage Collection: Stack Reference Counting Stack Reference Counting Implemented by DOC group to compare against CGC and M & S Only reference-counts heap references to objects, and associates to lowest referring stack frame 1. when a reference count drops to zero (or new object created), associate with current frame 2. if object returned (or thrown), associate with parent frame 3. when a stack frame pops, free all associated objects Advantages: simple to implement, doesn t require reference counts on simple register shuing Disadvantages: it s reference counting (and approximate at that) 18

29 Real-Time Garbage Collection: Cheng-Blelloch The Cheng-Blelloch Approach A Parallel, Real-Time Garbage Collector [PLDI 2001] Target: SML on shared-memory multiprocessors n mutators, m collectors Write-barrier replication variant Use spinlocks to avoid double-copying As in [Baker 1978], 1 byte allocated! K bytes scanned/copied Incremental collection of large structures 19

30 Real-Time Garbage Collection: The Metronome Bacon s Metronome Low Overhead and Consistent Utilization [POPL 2003] Bacon, Cheng, and Rajan A Real-time Garbage Collector with Identifies problems with previous work techniques limited to CONS cells only (no fragmentation) copying techniques limited by space copying fixes fragmentation, but 3 5x space overhead?!? Π low mutator utilization & missed deadlines you can t just measure maximum pause time! Π fine-grained copiers (e.g., Train) reduce space overhead, but what about large objects? * The paper cited doesn t name the collector Metronome; this development came in following months. 20

31 Real-Time Garbage Collection: The Metronome Metronome (continued) Metronome is a non-parallel, incremental, non-copying GC......that does some copying if fragmentation occurs Uses [Brooks 1984]-style unconditional indirection Jikes RVM s optimizing compiler optimizes the read barriers Snapshot-at-the-beginning, allocates black At time of POPL paper, stack processing not yet incremental, arraylets also incomplete Consistent utilization through time-based scheduling Have we been wrong all along?? [Bacon 2003] identifies flaws in the [Baker 1978] definition of real-time as a work-based one (defeating utilization) 21 Attend David Bacon s talk on 31 October!

32 Real-Time Garbage Collection: Java enters the fray What About Java?? 22

33 Real-Time Garbage Collection: Java enters the fray Java for Real-Time? Diculty in accepting Java as a real-time platform memory allocation nuclearreactor.on(); new Foo(); nuclearreactor.off(); Real-Time Specification for Java (RTSJ) addresses real-time issues Real-time schedulability Asynchronous transfer of control Non-garbage collected regions of memory They didn t believe anything we ve seen today was suitable Π for real-time this was before Metronome? 23

34 Real-Time Garbage Collection: Java enters the fray RTSJ Memory Areas Associate memory areas with a particular scope of execution Objects allocated from the memory area are collected when the scope exits Scoped memory areas may be nested Objects within a memory area may not reference objects that are in shorter-lived memory areas ScopedMemory lt = new LTMemory(1024, 1024); // 1 KiB lt.enter(new f Runnable() public void run() f System.out.println("Hello from inside a scope!"); g g); System.out.println("Hello from outside a scope!"); 24

35 Real-Time Garbage Collection: RTSJ scoped memory regions A pretty picture of scopes 25

36 Real-Time Garbage Collection: Implementing scopes Implementing scopes The RTSJ requires runtime checks inter-object references single parent rule These can t all be satisfied at compile-time......but some can [Sălcianu 2001]...and they needn t be expensive [Corsaro 2003]...or you could always scope-annotate your program such that compile-time checking of these annotations (and therefore your scopes) is possible [Boyapati 2003] 26

37 Real-Time Garbage Collection: Implementing scopes runtime scope checks [Corsaro 2003] O(1) Use displays at nodes in the scope tree Each scope has a depth and a display of ancestors A 0 [ A ] 1 B [ A B ] D [ A D ] C E F G 2 [ A B C ] [ A D E ] [ A D F ] [ A D G ] 27

38 Real-Time Garbage Collection: Implementing scopes runtime scope checks [Corsaro 2003] O(1) (X ref Y): X.scope.depth >= Y.scope.depth && X.scope.display[Y.scope.depth] == Y A 0 [ A ] 1 B [ A B ] D [ A D ] C E F G 2 [ A B C ] [ A D E ] [ A D F ] [ A D G ] 27

39 Real-Time Garbage Collection: Implementing scopes runtime scope checks [Corsaro 2003] O(1) (X ref Y): X.scope.depth >= Y.scope.depth && X.scope.display[Y.scope.depth] == Y A 0 [ A ] 1 B [ A B ] D [ A D ] C E F G 2 [ A B C ] [ A D E ] [ A D F ] [ A D G ] 27

40 Real-Time Garbage Collection: References References [Appel 1988] Appel, Andrew W., John R. Ellis, and Kai Li. Real-time concurrent collection on stock multiprocessors. ACM SIGPLAN Notices 23(7):11 20 (July 1988). [Bacon 2003] Bacon, David F., Perry Cheng, and V.T. Rajan. A real-time garbage collector with low overhead and consistent utilization. In POPL [Baker 1978] Baker, Henry G. List processing in real-time on a serial computer. CACM 21(4): (April 1978). [Baker 1992] Baker, Henry G. The Treadmill: real-time garbage collection without motion sickness. ACM SIGPLAN Notices 27(3):66 70 (March 1992). [Boyapati 2003] Boyapati, Chandrasekhar, Alexandru Sălcianu, William Beebee, Jr., and Martin Rinard. Ownership Types for Safe Region-Based Memory Management in Real-Time Java. In PLDI [Brooks 1984] Brooks, Rodney A. Trading data space for reduced time and code space in real-time collection on stock hardware. In ACM Symposium on LISP and Functional Programming [LFP 1984]. 28

41 Real-Time Garbage Collection: References [Cannarozzi 2000] Cannarozzi, Dante J., Michael P. Plezbert, and Ron K. Cytron. Contaminated garbage collection. In PLDI [Cheney 1970] Cheney, C. J. A nonrecursive list compacting algorithm. CACM 13(11): (November 1970). [Cheng 2001] Cheng, Perry and Guy Blelloch. A parallel, real-time garbage collector. In PLDI [Collins 1960] Collins, George E. A method for overlapping and erasure of lists. CACM 3(12): (December 1960). [Corsaro 2003] Corsaro, Angelo and Ron K. Cytron. Ecient memory-reference checks for real-time Java. In LCTES [Gelernter 1960] Gelernter, H., J. R. Hansen, and L. L. Gerberich. A Fortran-compiled list-processing language. JACM 7(2) (April 1960). [Hudson 1992] Hudson, Richard L., and J. Eliot B. Moss. Incremental Collection of Mature Objects. In IWMM [Johnson 1992] Johnson, Ralph E. Reducing the latency of a real-time garbage collector. In Letters on Programming Languages and Systems 1(1):46 58 (March 1992). 29

42 Real-Time Garbage Collection: References [Knuth 1973] Knuth, Donald E. The Art of Computer Programming, volume I: Fundamental Algorithms, Chapter 2. Addison-Wesley, second edition, [Lieberman 1983] Lieberman, Henry and Carl E. Hewitt. A real-time garbage collector based on the lifetimes of objects. CACM 26(6): (June 1983). [McCarthy 1960] McCarthy, John. Recursive functions of symbolic expressions and their computation by machine, Part I. CACM 3(4): (April 1960). [Nettles 1993] Nettles, Scott M. and James W. O Toole. Real-time replication garbage collection. In PLDI [Newell 1960] Newell, A., J. C. Shaw, and H. A. Simon. Report on a general problem solving program. In Proceedings of the International Conference on Information Processing. UNESCO, Paris, pp (1960). [Nilsen 1988] Nilsen, Kelvin D. Garbage collection of strings and linked data-structures in real-time. Software Practice and Experience 18(7): (July 1988). [Sălcianu 2001] Sălcianu, Alexandru and Martin C. Rinard. Pointer and escape analysis for multithreaded programs. In PPoPP [Weizenbaum 1963] Weizenbaum, J. Symmetric list processor. CACM 6(9): (September 1963). 30

43 Real-Time Garbage Collection: References [Weizenbaum 1969] Weizenbaum, J. Recovery of reentrant list structures in SLIP. CACM 12(7): (July 1969). [Wilson 1994] Wilson, Paul R. Uniprocessor garbage collection techniques. Technical report, University of Texas (January 1994). 31

44 Real-Time Garbage Collection: Discussion Discussion doc/ Fall 2003 Seminar on Programming Languages 32