We survey basic garbage collection algorithms, and variations such as incremental and generational collection; we then discuss low-level implementation considerations and the relationships between storage management systems, languages, and compilers. Throughout, we attempt to present a uni ed view based on abstract traversal strategies, addressing issues of conservatism, opportunism, and immediacy of reclamation; we also point outavariety of implementation details that are likely to have a significant impact on performance.

A real-time list processing system is one in which the time required by the elementary list operations (e.g. CONS, CAR, COR, RPLACA, RPLACD, EQ, and ATOM in LISP) is bounded by a (small) constant. Classical implementations of list processing systems lack this property because allocating a list cell from the heap may cause a garbage collection, which process requires time proportional to the heap size to finish. A real-time list processing system is presented which continuously reclaims garbage, including directed cycles, while linearizing and compacting the accessible cells into contiguous locations to avoid fragmenting the free storage pool. The program is small and requires no time-sharing interrupts, making it suitable for microcode. Finally, the system requires the same average time, and not more than twice the space, of a classical implementation, and those space requirements can be reduced to approximately classical proportions by compact list representation. Arrays of different sizes, a program stack, and hash linking are simple extensions to our system, and reference counting is found to be inferior for many applications. Key Words and Phrases: real-time, compacting, garbage collection, list processing, virtual memory, file or database management, storage management, storage

Generational garbage collection algorithms achieve efficiency because newer records point to older records; the only way an older record can point to a newer record is by a store operation to a previously-created record, and such operations are rare in many languages. A garbage collector that concentrates just on recently allocated records can take advantage of this fact. Such a garbage collector can be so efficient that the allocation of records costs more than their disposal. A scheme for quick record allocation attacks this bottleneck. Many garbage-collected environments don't know when to ask the operating system for more memory. A robust heuristic solves this problem. This paper presents a simple, efficient, low-overhead version of generational garbage collection with fast allocation, suitable for implementation in a Unix environment.

This paper discusses garbage collection techniques used in a high-performance Lisp implementation with a large virtual memory, the Symbolics 3600. Particular attention is paid to practical issues and experience. In a large system problems of scale appear and the most straightforward garbage-collection techniques do not work well. Many of these problems involve the interaction of the garbage collector with demand-paged virtual memory. Some of the solutions adopted in the 3600 are presented, including incremental copying garbage collection, approximately depth-first copying, ephemeral objects, tagged architecture, and hardware assists. We discuss techniques for improving the efficiency of garbage collection by recognizing that objects in the Lisp world have a variety of lifetimes. The importance of designing the architecture and the hardware to facilitate garbage collection is stressed. Automatic Storage Management Storage management is the part of a Lisp implementation that controls the use of memory to contain representations of objects. When a new object is created, memory must be allocated to contain its representation. When an object is no longer in use, the memory occupied by its representation can be reused for other purposes. Storage management can have a major impact on the efficiency and usability of a Lisp system. Automatic storage management allows the user to think entirely in terms of objects while the system takes care of the memory behind the scenes. Its most important aspect is automatic storage reclamation: the system finds all the objects that can be proved to be no longer in use and Permission to copy without fee all oz " part of this material is granted provided that the copies arc not made or distributed for direct commercial advantagc, the ACM copyright notice and the title of the publication and its date appear, and notice is given that copying is by

We present a method for adapting garbage collectors designed to run sequentially with the client, so that they may run concurrently with it. We rely on virtual memory hardware to provide information about pages that have been updated or "dirtied" during a given period of time. This method has been used to construct a mostly parallel trace-and-sweep collector that exhibits very short pause times. Performance measurements are given. 1. Introduction Garbage collection is an important feature of many modern computing environments. There are basically two styles of garbage collection algorithms: reference-counting collectors and tracing collectors. In this paper we consider only tracing collectors. A straightforward implementation of tracing collection prevents any client action from occurring while the tracing operation is performed. When applied to a system with a large heap, such stop-the-world implementations cause long pauses. One of the primary arguments against wide adoption of garb...

The cost of accessing main memory is increasing. Machine designers have tried to mitigate the consequences of the processor and memory technology trends underlying this increasing gap with a variety of techniques to reduce or tolerate memory latency. These techniques, unfortunately, are only occasionally successful for pointer-manipulating programs. Recent research has demonstrated the value of a complementary approach, in which pointer-based data structures are reorganized to improve cache locality. This paper studies a technique for using a generational garbage collector to reorganize data

A'(=$B#127$C7D-7E"#%9F< >$7'(-7:;<<"G$&%- 12-*#)+1+)H7IJ->0" ;<<":'(%- 1+687)29:K*,< B>0"$%L.M.D.&%<1+12%&%7< 'K)2$"#=$)2; >%"ON5<'.$D- '(="P6 9F%9:< '(IF9?B127)+/#'(<&=%$$< '($C->0"Q)2$A*0-$%"R<>S- >S%- '1+)2('C&%<1+12%&%7< ' -12;<')27D09UT VW84X.D)2&YDG/'(<Z)2"#%"R[@%"R*,<B#>"$\< >]7D0C7)29FC- >I 7D'(%-"R9CB0$7./- B$\N5< 'K&=< 1+12%&%7)2<>^LE_\<X.=Z3'4$)+>&%`< B'E%- '1+)23' -12;<')27D09aX.-$"#%$)2;>0="bN5<'K$)29c/12c->0-12I$)2$%40)27.D0-"R$<9Fd)29c6 /'(-&=7)2&%- 1.Ne%-7B'(%$%L`M.D#)2$C/0-/,3'C/'(%$3>7$`7D0`%@73>$)2< >$c>%&36 =$$- '(IfNe< 'G-!/#'(-&%7)2&%- 1`)29c/12%9:3>7-7)2< >hgi'(%"B0&()+>0;j%@&=%$$)2Z )+>7('12%-Z)+>0;4kD- >"1+)+>0;!$7-&l$\->0"!; 12<*0-1Z -')2- *12%$%4^'(%"B&3)+>0; "< B*12O-1+12<&%-7)2<>^4->0"G$/,=&3)2- 17'(%-79F3>7C< N12-'(;:->0"!$9:- 1+1 <*m%&%7$%LonK>i)29c/12%9:3>7-7)2< >o*-$%"j<>p7D0G9:<")+[%"q-12;<6 ')27D9r)2$G%Z- 1+B-7%"p< >p-J$=7R< NQstvuPwGxq*y3>0&D9:- 'l$G<>pu B>Jz>73'/')2$bs={{{{#4|-O}~ 68X.-IGd127'(-u/- '(&(6K9?B127)+/'(<&%%$6 $<'L!M<G7D0:*,%$7`< NE<B#':l><X.12%"#;4.7D)2$c)2$:7D:[#'($7`)29c/#12(6 9F3>7-7)2<>J<N-c/- '(-1+123154^'(%-1+67)29Fc;- '*-;`&%<1+12%&%7< 'L M.Dc-Z('(-;Q&%<1+12%&%7<':$/,=%"PB/J)2$FPL t:-7CO/'(<&%%$$<'($c->0" sPL -7FVb/'(<&%%$$<'($%LjwG-@)29CB09r/- B$G7)29:%$:'(- >;RN'(<9 j9F$7<ti9:$%Lr>o&%<>7'(-$7%4:-i>< >65)+>0&('(%9:3>7-1G&%<1+12%&%7< ' X.D%7D3'G;3>0('(-7)2< >- 1< 'R><7(:...

The complexity of systems for automatic control and other safety-critical applications grows rapidly. Computer software represents an increasing part of the complexity. As larger systems are developed, we need to find scalable techniques to manage the complexity in order to guarantee high product quality. Memory management is a key quality factor for these systems. Automatic memory management, or garbage collection, is a technique that significantly reduces the complex problem of correct memory management. The risk of software errors decreases and development time is reduced. Garbage collection techniques suitable for interactive and soft real-time systems exist, but few approaches are suitable for systems with hard real-time requirements, such as control systems (embedded systems). One part of the problem is solved by incremental garbage collection algorithms, which have been presented before. We focus on the scheduling problem which forms the second part of the problem, i.e. how the work of a garbage collector should be scheduled in order

This paper investigates some problems associated with an argument evaluation order that we call "future' order, which is different from both call-by-name and call-by-value. In call-by-future, each formal parameter of a function is bound to a separate process (called a "future") dedicated to the evaluation of the corresponding argument. This mechanism allows the fully parallel evaluation of arguments to a function, and has been shown to augment the expressive power of a language. We discuss an approach to a problem that arises in this context: futures which were thought to be relevant when they were created become irrelevant through being ignored in the body of the expression where they were bound. The problem of irrelevant processes also appears in multiprocessing problem-solving systems which start several processors working on the same problem but with different methods, and return with the solution which finishes first. This parallel method strategy has the drawback that the processes which are investigating the losing methods must be identified, stopped, and reassigned to more useful tasks. The solution we propose is that of garbage collection. We propose that the goal structure of the solution plan be explicitly represented in memory as part of the graph memory (like Lisp's heap) so that a garbage collection algorithm can discover which processes are performing useful work, and which can be recycled for a new task. An incremental algorithm for the unified garbage collection of storage and processes is described.

The runtime data structures of the Standard ML of New Jersey compiler are simple yet general. As a result, code generators are easy to implement, programs execute quickly, garbage collectors are easy to implement and work efficiently, and a variety of runtime facilities can be provided with ease.