research-article

Distributed garbage collection for general graphs

Authors:

Steven R. Brandt,

Gokarna SharmaAuthors Info & Claims

ISMM 2018: Proceedings of the 2018 ACM SIGPLAN International Symposium on Memory Management

Pages 29 - 44

https://doi.org/10.1145/3210563.3210572

Published: 18 June 2018 Publication History

Abstract

We propose a scalable, cycle-collecting, decentralized, reference counting garbage collector with partial tracing. The algorithm is based on the Brownbridge system but uses four different types of references to label edges. Memory usage is O (log n) bits per node, where n is the number of nodes in the graph. The algorithm assumes an asynchronous network model with a reliable reordering channel. It collects garbage in O (E a ) time, where E a is the number of edges in the in- duced subgraph. The algorithm uses termination detection to manage the distributed computation, a unique identifier to break the symmetry among multiple collectors, and a transaction-based approach when multiple collectors conflict. Unlike existing algorithms, ours is not centralized, does not require barriers, does not require migration of nodes, does not require back-pointers on every edge, and is stable against concurrent mutation.

References

[1]

Saleh E. Abdullahi and Graem A. Ringwood. Garbage collecting the internet: A survey of distributed garbage collection. ACM Comput. Surv., 30(3):330–373, September 1998.

Digital Library

[2]

Stephen M. Blackburn, Richard L. Hudson, Ron Morrison, J. Eliot B. Moss, David S. Munro, and John Zigman. Starting with termination: A methodology for building distributed garbage collection algorithms. Aust. Comput. Sci. Commun., 23(1):20–28, January 2001.

Digital Library

[3]

Steven R. Brandt, Hari Krishnan, Gokarna Sharma, and Costas Busch. Concurrent, parallel garbage collection in linear time. In Proceedings of the 13th International Symposium on Memory Management . ACM, 2014.

Digital Library

[4]

D.R. Brownbridge. Cyclic reference counting for combinator machines. In Jean-Pierre Jouannaud, editor, Functional Programming Languages and Computer Architecture, volume 201 of Lecture Notes in Computer Science, pages 273–288. 1985. Procedure action(sender): if cd = NULLthen return toggle() if old weight < weightthen PhantomizeAll(sender) else if is initiator()then action initiator(sender) else if cd.recv = HEALTHYthen if cd.phantom count = 0 and cd.rcc = 0 and cd.wait count = 0then return to sender(sender) cd = NULL else if cd.recv = PHANTOMthen if not phantom flag() and (old weight < weight or strong count = 0)then PhantomizeAll(sender) else if cd.incrRCC and phantom flag()then ClaimAll() else return to parent() else if cd.recv = RECOVERthen if cd.state, RECOVERthen if strong count > 0then BuildAll(sender) else if phantom flag()then RecoverAll() else PhantomizeAll(sender) else if strong count > 0then BuildAll(sender) else if weak count > 0then PhantomizeAll(sender) else return to parent() else if cd.recv = BUILDthen if phantom flag()then BuildAll(sender) else return to parent() if cd.phantom count = 0then return to sender(sender) cd = NULL else if cd.recv = INFECTEDthen if cd.state, INFECTEDthen if phantom flag()then InfectAll() if ready() and strong count = 0 and weak count = 0 and cd.phantom count = 0then cd.state = DEAD Procedure Phantom Flag(): if cd = NULLthen return FALSE else return cd.state = PHANTOM or RECOVER or INFECTED

Digital Library

[5]

Rodrigo Bruno and Paulo Ferreira. A study on garbage collection algorithms for big data environments. ACM Comput. Surv., 51(1):20:1– 20:35, January 2018.

Digital Library

[6]

Sylvan Clebsch and Sophia Drossopoulou. Fully concurrent garbage collection of actors on many-core machines. SIGPLAN Not., 48(10):553– 570, October 2013.

Digital Library

[7]

Sukumar Ghosh. Distributed systems: an algorithmic approach. CRC press, 2014.

Digital Library

[8]

Ionel Gog, Jana Giceva, Malte Schwarzkopf, Kapil Vaswani, Dimitrios Vytiniotis, Ganesan Ramalingam, Manuel Costa, Derek G Murray, Steven Hand, and Michael Isard. Broom: Sweeping out garbage collection from big data systems. In 15th Workshop on Hot Topics in Operating Systems (HotOS XV), 2015.

Digital Library

[9]

Paul Hudak and Robert M. Keller. Garbage collection and task deletion in distributed applicative processing systems. In Proceedings of the 1982 ACM Symposium on LISP and Functional Programming, LFP ’82, pages 168–178, New York, NY, USA, 1982. ACM.

Digital Library

[10]

Richard Jones, Antony Hosking, and Eliot Moss. The garbage collection handbook: the art of automatic memory management . Chapman and Hall/CRC, 2016.

Digital Library

[11]

Hartmut Kaiser, Maciek Brodowicz, and Thomas Sterling. Parallex an advanced parallel execution model for scaling-impaired applications. In Parallel Processing Workshops, 2009. ICPPW’09. International Conference on, pages 394–401. IEEE, 2009.

Digital Library

[12]

Laxmikant V Kale and Sanjeev Krishnan. Charm++: Parallel programming with message-driven objects. Parallel programming using C+, pages 175–213, 1996.

[13]

R. Ladin and B. Liskov. Garbage collection of a distributed heap. In Distributed Computing Systems, 1992., Proceedings of the 12th International Conference on, pages 708–715, Jun 1992.

[14]

Fabrice Le Fessant, Ian Piumarta, and Marc Shapiro. An implementation of complete, asynchronous, distributed garbage collection. In Proceedings of the ACM SIGPLAN 1998 Conference on Programming Language Design and Implementation, PLDI ’98, pages 152–161, New York, NY, USA, 1998. ACM.

Digital Library

[15]

Martin Maas, Tim Harris, Krste Asanović, and John Kubiatowicz. Trash day: Coordinating garbage collection in distributed systems. In 15th Workshop on Hot Topics in Operating Systems (HotOS XV), 2015.

Digital Library

[16]

Umesh Maheshwari and Barbara Liskov. Collecting cyclic distributed garbage by controlled migration. Distributed Computing, 10(2):79–86, 1997.

[17]

Umesh Maheshwari and Barbara Liskov. Collecting distributed garbage cycles by back tracing. In Proceedings of the Sixteenth Annual ACM Symposium on Principles of Distributed Computing, PODC ’97, pages 239–248, New York, NY, USA, 1997. ACM.

Digital Library

[18]

John McCorquodale, JD de St Germain, S Parker, and CR Johnson. The uintah parallelism infrastructure: A performance evaluation on the sgi origin 2000. High Performance Computing 2001, 2001.

[19]

David Peleg. Distributed Computing: A Locality-sensitive Approach. Society for Industrial and Applied Mathematics, Philadelphia, PA, USA, 2000.

Digital Library

[20]

E.J.H. Pepels, M.J. Plasmeijer, C.J.D. van Eekelen, and M.C.J.D. Eekelen. A Cyclic Reference Counting Algorithm and Its Proof . Internal report 88-10. Department of Informatics, Faculty of Science, University of Nijmegen, 1988.

[21]

David Plainfossé and Marc Shapiro. A survey of distributed garbage collection techniques. In Proceedings of the International Workshop on Memory Management, IWMM ’95, pages 211–249, London, UK, UK, 1995. Springer-Verlag.

Digital Library

[22]

N. Richer and M. Shapiro. The memory behavior of www, or the www considered as a persistent store. In POS, pages 161–176, 2000.

Digital Library

[23]

J.D. Salkild. Implementation and analysis of two reference counting algorithms. Master thesis, University College, London, 1987.

[24]

Gerard Tel and Friedemann Mattern. The derivation of distributed termination detection algorithms from garbage collection schemes. ACM Trans. Program. Lang. Syst., 15(1):1–35, January 1993.

Digital Library

[25]

L. Veiga and P. Ferreira. Asynchronous complete distributed garbage collection. In Parallel and Distributed Processing Symposium, 2005. Proceedings. 19th IEEE International, pages 24a–24a, April 2005.

Digital Library

Cited By

Yamazaki TNakamaru TShioya RUgawa TChiba S(2023)Collecting Cyclic Garbage across Foreign Function Interfaces: Who Takes the Last Piece of Cake?Proceedings of the ACM on Programming Languages10.1145/35912447:PLDI(591-614)Online publication date: 6-Jun-2023
https://dl.acm.org/doi/10.1145/3591244

Index Terms

Distributed garbage collection for general graphs
1. Software and its engineering
  1. Software organization and properties
    1. Contextual software domains
      1. Operating systems
        Memory management
        Distributed memory
        Garbage collection
2. Theory of computation
  1. Design and analysis of algorithms
    1. Distributed algorithms

Recommendations

Distributed garbage collection for general graphs
ISMM '18

We propose a scalable, cycle-collecting, decentralized, reference counting garbage collector with partial tracing. The algorithm is based on the Brownbridge system but uses four different types of references to label edges. Memory usage is O (log n) ...
Distributed Garbage Collection by Timeouts and Backward Inquiry
COMPSAC '03: Proceedings of the 27th Annual International Conference on Computer Software and Applications

We present a practical and efficient garbage collectionmechanism for large scale distributed systems. Themechanism collects all garbage including distributed cyclicgarbage without global synchronization or backward links.The primary method used for ...
Age-based garbage collection

Modern generational garbage collectors look for garbage among the young objects, because they have high mortality; however, these objects include the very youngest objects, which clearly are still live. We introduce new garbage collection algorithms, ...

Comments

Information & Contributors

Information

Published In

cover image ACM Conferences

ISMM 2018: Proceedings of the 2018 ACM SIGPLAN International Symposium on Memory Management

June 2018

119 pages

ISBN:9781450358019

DOI:10.1145/3210563

General Chair:
Hannes Payer
Google, Germany
,
Program Chair:
Jennifer B. Sartor
Vrije Universiteit Brussel, Belgium

ACM SIGPLAN Notices Volume 53, Issue 5
ISMM '18
May 2018
119 pages
ISSN:0362-1340
EISSN:1558-1160
DOI:10.1145/3299706
Editor:
Matthew Fluet
Rodchester Institude of Technology
Issue’s Table of Contents

Copyright © 2018 ACM.

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected].

Sponsors

SIGPLAN: ACM Special Interest Group on Programming Languages

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 18 June 2018

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Research-article

Conference

ISMM '18

Sponsor:

SIGPLAN

ISMM '18: The International Symposium on Memory Management 2018

June 18, 2018

PA, Philadelphia, USA

Acceptance Rates

Overall Acceptance Rate 72 of 156 submissions, 46%

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

1
Total Citations
View Citations
195
Total Downloads

Downloads (Last 12 months)13
Downloads (Last 6 weeks)0

Reflects downloads up to 08 Feb 2025

Other Metrics

View Author Metrics

Citations

Cited By

Yamazaki TNakamaru TShioya RUgawa TChiba S(2023)Collecting Cyclic Garbage across Foreign Function Interfaces: Who Takes the Last Piece of Cake?Proceedings of the ACM on Programming Languages10.1145/35912447:PLDI(591-614)Online publication date: 6-Jun-2023
https://dl.acm.org/doi/10.1145/3591244

View Options

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Publication

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Figures

Tables

Media

View Table of Conten