A scalable mark-sweep garbage collector on large-scale shared-memory machines

Abstract

This work describes implementation of a mark-sweep garbage collector (GC) for shared-memory machines and reports its performance. It is a simple ''parallel'' collector in which all processors cooperatively traverse objects in the global shared heap. The collector stops the application program during a collection and assumes a uniform access cost to all locations in the shared heap. Implementation is based on the Boehm-Demers-Weiser conservative GC (Boehm GC). Experiments have been done on Ultra Enterprise 10000 (Ultra Sparc processor 250 MHz, 64 processors). We wrote two applications, BH (an N-body problem solver) and CKY (a context free grammar parser) in a parallel extension to C++.Through the experiments, We observe that load balancing is the key to achieving scalability. A naive collector without load redistribution hardly exhibits speed-up (at most fourfold speed-up on 64 processors). Performance can be improved by dynamic load balancing, which exchanges objects to be scanned between processors, but we still observe that straightforward implementation severely limits performance. First, large objects become a source of significant load imbalance, because the unit of load redistribution is a single object. Performance is improved by splitting a large object into small pieces before pushing it onto the mark stack. Next, processors spend a significant amount of time uselessly because of serializing method for termination detection using a shared counter. This problem suddenly appeared on more than 32 processors. By implementing non-serializing method for termination detection, the idle time is eliminated and performance is improved. With all these careful implementation, we achieved average speed-up of 28.0 in BH and 28.6 in CKY on 64 processors.

A parallel, incremental, mostly concurrent garbage collector for servers

“…We rescan all thread stacks, and complete the marking of live objects. The parallel marker is similar to that of Endo et al Endo et al [1997].…”

“…They used a private stack for each thread and a single shared stack to exchange objects between threads, and reported a load balancing overhead of 14%. This work, as well as the work of Endo et al Endo et al [1997], provided measurements on a large system of 32 or 64 processors. The overhead is thus incomparable to ours.…”

“…These solutions assign a private (usually very big) mark stack to each thread, and add synchronized sharing mechanisms such as stealing, where each tracing thread exposes some of its excessive objects in a separate attached queue, so that they may be stolen by other "starved" threads [Endo et al 1997]. Another solution is to expose the mark stacks themselves to the other threads [Flood et al 2001].…”

“…This is mentioned as the principal synchronization problem [Endo et al 1997;Cheng and Belloch 2001]. Work packet management detects termination naturally, with little cost.…”

Space-and-Time Efficient Parallel Garbage Collector for Data-Intensive Applications

“…Steele and Dijkstra proposed the first concurrent collectors, which are based on mark-sweep algorithms [18,8]. Endo et al proposed a mostly concurrent collector that does not use compiler supports, such as write barriers, but uses virtual memory primitives [11]. Several groups [9,10,3] have proposed fully concurrent on-the-fly mark-sweep collectors that provide low pause time; but these designs are complex to implement due to the requirement of expensive write barriers.…”