A concise and unified view of the numerous existing algorithms for performing garbage collection of linked data structures is presented. The emphasm is on garbage collection proper, rather than on storage allocatlon. First, the classical garbage collection algorithms are reviewed, and their marking and collecting phases, with and without compacting, are discussed. Algorithms descnbing these phases are classified according to the type of cells to be collected: those for collecting single-sized cells are simpler than those for varimzed cells. Recently proposed algorithms are presented and compared with the classical ones. Special topics in garbage collection are also covered: the use of secondary and virtual storage, the use of reference counters, parallel and real-time collections, analyses of garbage collection algorithms, and language features whlch influence the design of collectors. The bibhography, wlth topical annotations, contains over 100 references.

/pdf/garbage-collection-of-linked-data-structures-147xtf0laq.pdf

Garbage Collection of Linked Data Structures

data types have proved to be a useful technique for structuring systems. In large systems it is sometimes useful to have different regions of the system use different representations for the abstract data values. A technique is described for communicating abstract values between such regions. The method was developed for use in constructing distributed systems, where the regions exist at different computers and the values are communicated over a network. The method defines a call-by-value semantics; it is also useful in nondistributed systems wherever call by value is the desired semantics. An important example of such a use is a repository, such as a file system, for storing long- lived data. Abstract data types have proved to be a useful technique for structuring systems. They permit the programmer to encapsulate details of the representation of data so that these details can be changed with minimal impact on the program as a whole. It is sometimes useful, especially in large programs, to use different implementations of a data abstraction in different regions of the program. Current languages that support data abstraction, however, limit a program to a single implementation (11, 17). The reason for this limitation is the difficulty of com- municating between the regions using different implementations. This paper describes a technique for communicating abstract values between such regions. The method defines a call-by-value semantics. The method was developed for use in distributed systems, where the regions exist at different computers and the values are communicated over the network. It is also useful in

/pdf/a-value-transmission-method-for-abstract-data-types-25t5lqsevu.pdf

A Value Transmission Method for Abstract Data Types

An efficient algorithm is presented for moving arbitrary list structures, using no storage (apart from program variables) other than that required to hold the original list and the copy. The original list is destroyed as it is moved. No mark bits are necessary, but pointers to the copy must be distinguishable from pointers to the original. The algorithm is superior in execution speed to previous algorithms for the same problem. Some variations and extensions o f the algorithm are discussed.

An efficient list-moving algorithm using constant workspace

ion, specification and implementation techniques : with an application to garbage collection Citation for published version (APA): Jonkers, H. B. M. (1982). Abstraction, specification and implementation techniques : with an application to garbage collection. Amsterdam: Stichting Mathematisch Centrum. Document status and date: Published: 01/01/1982 Document Version: Publisher’s PDF, also known as Version of Record (includes final page, issue and volume numbers) Please check the document version of this publication: • A submitted manuscript is the version of the article upon submission and before peer-review. There can be important differences between the submitted version and the official published version of record. People interested in the research are advised to contact the author for the final version of the publication, or visit the DOI to the publisher's website. • The final author version and the galley proof are versions of the publication after peer review. • The final published version features the final layout of the paper including the volume, issue and page numbers. Link to publication General rights Copyright and moral rights for the publications made accessible in the public portal are retained by the authors and/or other copyright owners and it is a condition of accessing publications that users recognise and abide by the legal requirements associated with these rights. • Users may download and print one copy of any publication from the public portal for the purpose of private study or research. • You may not further distribute the material or use it for any profit-making activity or commercial gain • You may freely distribute the URL identifying the publication in the public portal. If the publication is distributed under the terms of Article 25fa of the Dutch Copyright Act, indicated by the “Taverne” license above, please follow below link for the End User Agreement:

Abstraction, specification and implementation techniques : with an application to garbage collection

As programming languages with managed runtimes become increasingly popular, it is essential that virtual machines are implemented efficiently. The performance of the memory management subsystem can be a defining factor in the performance of the virtualachine as a whole. We present a technique by which garbage collector performance can be improved. We describe an algorithm that combines a standard generational copying collector with a mark and compact collector. We observe that, since most objects do not survive a garbage collection, it is not necessary to reserve space to copy them all. The result is a generational copying collector that operates with a smaller copy reserve overhead than traditional Appel-style collectors. We maintain correctness in the worst case through the use of mark and compact collection. When the reduced copy reserve overflows, a compacting phase ensures that all data are accommodated. We have implemented this algorithm within the framework of Jikes RVM and MMTk. For most benchmarks examined, our experiments show that performance is comparable to or better than a standard generational copying collector.

/pdf/reducing-generational-copy-reserve-overhead-with-fallback-3sqgkz2206.pdf

Reducing generational copy reserve overhead with fallback compaction

A bounded workspace copying algorithm for arbitrary list structures is given. This algorithm operates in linear time and does not require tag bits. The best previous bounded workspace copying algorithms achieved n2 time without tag bits and n log n time with one tag. The only restriction on the algorithm given here is that the copy must be placed into a contiguous section of memory. The method is applicable to fixed or variable size nodes.

David A. Fisher

Papers

Copying cyclic list structures in linear time using bounded workspace