Portable, unobtrusive garbage collection for multiprocessor systems

Doligez, Damien; Gonthier, Georges

doi:10.1145/174675.174673

Cited by 128 publications

(148 citation statements)

References 18 publications

Supporting

Mentioning

148

Contrasting

Order By: Relevance

“…Our garbage collector might best be described as a "locally-concurrent/globally-sequential" collector. It is based on the approach of Doligez, Leroy, and Gonthier [24,23]. The heap is organized into a fixed-size local heap for each vproc and a shared global heap ( Figure 5).…”

Section: Runtime Kernelmentioning

confidence: 99%

Programming in Manticore, a Heterogenous Parallel Functional Language

Fluet

Bergström

Ford

et al. 2010

Central European Functional Programming School

View full text Add to dashboard Cite

The Manticore project is an effort to design and implement a new functional language for parallel programming. Unlike many earlier parallel languages, Manticore is a heterogeneous language that supports parallelism at multiple levels. Specifically, the Manticore language combines Concurrent ML-style explicit concurrency with fine-grain, implicitly threaded, parallel constructs. These lectures will introduce the Manticore language and explore a variety of programs written to take advantage of heterogeneous parallelism. At the explicit-concurrency level, Manticore supports the creation distinct threads of control and the coordination of threads through first-class synchronous-message passing. Message-passing synchronization, in contrast to shared-memory synchronization, fits naturally with the functional-programming paradigm. At the implicit-parallelism level, Manticore supports a diverse collection of parallel constructs for different granularities of work. Many of these constructs are inspired by common functional-programming idioms.In addition to describing the basic mechanisms, we will present a number of useful programming techniques that are enabled by these mechanisms. Finally, we will briefly discuss some of the implementation techniques used to execute Manticore programs on commodity multicore computers.

show abstract

Section: Runtime Kernelmentioning

confidence: 99%

Programming in Manticore, a Heterogenous Parallel Functional Language

Fluet

Bergström

Ford

et al. 2010

Central European Functional Programming School

View full text Add to dashboard Cite

show abstract

“…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. However, concurrent GC and Stop-The-World (STW) GC designs are fundamentally different: they have different design goals, evaluation metrics, and algorithms: concurrent GC is designed to reduce pause time, whereas STW GC is designed to increase throughput.…”

Section: Related Workmentioning

confidence: 99%

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

Liu

Wang²,

Li³

et al. 2010

Int J Parallel Prog

View full text Add to dashboard Cite

As multithreaded server applications and runtime systems prevail, garbage collection is becoming an essential feature to support high performance systems, especially those running data-intensive applications. The fundamental issue of garbage collector (GC) design is to maximize the recycled space with minimal time overhead. This paper proposes two innovative solutions: one to improve space efficiency, and the other to improve time efficiency. To achieve space efficiency, we propose the Space Tuner that utilizes the novel concept of allocation speed to reduce wasted space. Conventional static space partitioning techniques often lead to inefficient space utilization. The Space Tuner adjusts the heap partitioning dynamically such that when a collection is triggered, all space partitions are fully filled. To achieve time efficiency, we propose a novel parallelization method that reduces the compacting GC parallelization problem into a tree traversal parallelization problem. This method can be applied for both normal and large object compaction. Object compaction is hard to parallelize due to strong data dependencies such that the source object can not be moved to its target location until the object originally in the target location has been moved out. Our proposed algorithm overcomes the difficulties by dividing the heap into equal-sized blocks and parallelizing the movement of the independent blocks. It Parallel Prog (2011) 39:451-472 is noteworthy that these proposed algorithms are generic such that they can be utilized in different GC designs. The proposed techniques have been implemented in Apache Harmony JVM and we evaluated the proposed algorithms with SPECjbb and Dacapo benchmark suites. The experiment results demonstrate that our proposed algorithms greatly improve space utilization and the corresponding parallelization schemes are scalable, which brings time efficiency.

show abstract

“…The explanation is therefore limited to the description of the mechanisms relevant for root scanning. We have implemented an incremental mark and sweep collector, but the technique might as well be applied to different incremental garbage collection techniques that have been presented in earlier publications [4,5,6,7]. For compacting or copying techniques, additional difficulties might arise when updating of root references is required.…”

Section: The Garbage Collectormentioning

confidence: 99%

“…To avoid long unpredictable pauses caused by the collector, incremental or concurrent garbage collection techniques are employed [4,5,6,7]. A garbage collection cycle can be performed in small increments while the main application executes.…”

Section: Introductionmentioning

confidence: 99%

Constant-Time Root Scanning for Deterministic Garbage Collection

Siebert

2001

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Abstract. Root scanning is the task of identifying references to heap objects that are stored outside of the heap itself, in global and local variables and on the execution stack. Root scanning is particularly difficult within an incremental garbage collector that needs to be deterministic or give hard realtime guarantees. Here, a method that allows exact root scanning is presented. The basic idea is to ensure that copies of all root references exist on the heap whenever the garbage collector might become active. This approach reduces the root scanning phase of the garbage collection cycle to an efficient constant-time operation. A Java virtual machine and a static Java bytecode compiler that use this technique have been implemented and analysed using the SPECjvm98 benchmark suite. This Java implementation allows for deterministic memory management as needed in real-time systems that is difficult to achieve with traditional methods to perform root scanning.

show abstract

Portable, unobtrusive garbage collection for multiprocessor systems

Abstract: Redescribeand prove the correctness of anew concurrent mark-and-sweep garbage collection algorithm. This algo-

Cited by 128 publications

References 18 publications

Programming in Manticore, a Heterogenous Parallel Functional Language

Programming in Manticore, a Heterogenous Parallel Functional Language

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

Constant-Time Root Scanning for Deterministic Garbage Collection

Contact Info

Product

Resources

About