Distributed garbage collection using reference counting

Bevan, David

doi:10.1007/3-540-17945-3_10

Cited by 89 publications

(33 citation statements)

References 13 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…A weighted reference counting scheme (Bevan, 1987) is used to garbage collect the independent PAEAN heaps. As we have seen, the GIT indicates the possibly live in-pointers for each instance.…”

Section: Global Garbage Collectionmentioning

confidence: 99%

“…One general weakness of this scheme is that it will not collect cycles across independent heaps. Various schemes can be used to deal with this issue, if needed, such as collating cross-heap cycles onto a single instance, where they can be collected (Bevan, 1987). Such a mechanism, however, is not currently implemented in PAEAN.…”

Section: Global Garbage Collectionmentioning

confidence: 99%

See 1 more Smart Citation

PAEAN: Portable and scalable runtime support for parallel Haskell dialects

Berthold

Loidl²,

Hammond

2016

J. Funct. Prog.

View full text Add to dashboard Cite

Over time, several competing approaches to parallel Haskell programming have emerged. Different approaches support parallelism at various different scales, ranging from small multicores to massively parallel high-performance computing systems. They also provide varying degrees of control, ranging from completely implicit approaches to ones providing full programmer control. Most current designs assume a shared memory model at the programmer, implementation and hardware levels. This is, however, becoming increasingly divorced from the reality at the hardware level. It also imposes significant unwanted runtime overheads in the form of garbage collection synchronisation etc. What is needed is an easy way to abstract over the implementation and hardware levels, while presenting a simple parallelism model to the programmer.The PAEAN (PArallEl shAred Nothing) runtime system design aims to provide a portable and high-level shared-nothing implementation platform for parallel Haskell dialects. It abstracts over major issues such as work distribution and data serialisation, consolidating existing, successful designs into a single framework. It also provides an optional virtual shared-memory programming abstraction for (possibly) shared-nothing parallel machines, such as modern multicore/manycore architectures or cluster/cloud computing systems. It builds on, unifies, and extends, existing well-developed support for shared-memory parallelism that is provided by the widely-used GHC Haskell compiler. This paper summarises the state-of-the-art in shared-nothing parallel Haskell implementations, introduces the PAEAN abstractions, shows how they can be used to implement three distinct parallel Haskell dialects, and demonstrates that good scalability can be obtained on recent parallel machines. * Corresponding author. Reported work performed while at the University of Copenhagen (DIKU).

show abstract

Section: Global Garbage Collectionmentioning

confidence: 99%

Section: Global Garbage Collectionmentioning

confidence: 99%

PAEAN: Portable and scalable runtime support for parallel Haskell dialects

Berthold

Loidl²,

Hammond

2016

J. Funct. Prog.

View full text Add to dashboard Cite

show abstract

“…In particular, we use a weighted reference counting [Bevan 1987;Thomas 1981;Watson and Watson 1987]. To implement weighted reference counting transparently, we check incoming and outgoing messages for references.…”

Section: Comparison With Treadmarks For Garbage-collected Applicationsmentioning

confidence: 99%

Run-time support for distributed sharing in safe languages

Cox

et al. 2003

ACM Trans. Comput. Syst.

View full text Add to dashboard Cite

We present a new run-time system that supports object sharing in a distributed system. The key insight in this system is that a handle-based implementation of such a system enables efficient and transparent sharing of data with both fine-and coarse-grained access patterns. In addition, it supports efficient execution of garbage-collected programs. In contrast, conventional distributed shared memory (DSM) systems are limited to providing only one granularity with good performance, and have experienced difficulty in efficiently supporting garbage collection. A safe language, in which no pointer arithmetic is allowed, can transparently be compiled into a handle-based system and constitutes its preferred mode of use. A programmer can also directly use a handle-based programming model that avoids pointer arithmetic on the handles, and achieve the same performance but without the programming benefits of a safe programming language. This new run-time system, DOSA (Distributed Object Sharing Architecture), provides a shared object space abstraction rather than a shared address space abstraction. The key to its efficiency is the observation that a handle-based distributed implementation permits VM-based access and modification detection without suffering false sharing for fine-grained access patterns. We compare DOSA to TreadMarks, a conventional DSM system that is efficient at handling coarse-grained sharing. The performance of fine-grained applications and garbage-collected applications is considerably better than in TreadMarks, and the performance of coarse-grained applications is nearly as good as in TreadMarks. Inasmuch as the performance of such applications is already good in TreadMarks, we consider this an acceptable performance penalty.

show abstract

“…A local mutator may o n l y c hange this connectivity b y o verwriting references to objects. 6 We piggy-back collector acknowledgements on the back of RPC acknowledgements.…”

Section: Scan Phasementioning

confidence: 99%

Cyclic distributed garbage collection with group merger

Rodrigues

Jones

1998

ECOOP’98 — Object-Oriented Programming

View full text Add to dashboard Cite

Abstract. This paper presents a new algorithm for distributed garbage collection and outlines its implementation within the Network Objects system. The algorithm is based on a reference listing scheme augmented by partial tracing in order to collect distributed garbage cycles. Our collector is designed to be exible thereby allowing e ciency, expediency and fault-tolerance to be traded against completeness. Processes may b e dynamically organised into groups, according to appropriate heuristics, in order to reclaim distributed garbage cycles. Unlike previous groupbased algorithms, multiple concurrent distributed garbage collections that span groups are supported: when two collections meet they may either merge, overlap or retreat. The algorithm places no overhead on local collectors and suspends local mutators only brie y. P artial tracing of the distributed graph involves only objects thought t o be part of a garbage cycle: no collaboration with other processes is required.

show abstract

Distributed garbage collection using reference counting

Cited by 89 publications

References 13 publications

PAEAN: Portable and scalable runtime support for parallel Haskell dialects

PAEAN: Portable and scalable runtime support for parallel Haskell dialects

Run-time support for distributed sharing in safe languages

Cyclic distributed garbage collection with group merger

Contact Info

Product

Resources

About