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

Method look-up for dynamically typed object-oriented languages, such as SMALLTALK-80 or OBJECTIVE-C, is usually implemented by a cached inheritance search. Unfortunately, this technique is slow. A selector-indexed dispatch table implementation speeds up messages to within 10% of the speed of a statically typed language such as C++. We present a fast technique for generating compact selector-indexed dispatch tables.

Existing techniques for garbage collection and machine code optimizations can interfere with each other. The inability to fully optimize code in a garbage-collected system is a hidden cost of garbage collection. One solution to this problem is proposed; an inexpensive protocol that permits most optimizations and garbage collection to coexist. A second approach to this problem and a separate problem in its own right is to reduce the need for garbage collection. This requires analysis of storage lifetime. Inferring storage lifetime is di#cult in a language with nested and recursive data structures, but it is precisely these languages in which garbage collection is most useful. An improved analysis for "storage containment" is described. Containment information can be represented in a directed graph. The derivation of this graph falls into a monotone data-flow analysis framework; in addition, the derivation has the Church-Rosser property. The graphs produced in the analysis of a value-a...

This paper explores an alternative called compact dispatch tables suited to environments with high requirements in time and space efficiency. Compact dispatch tables are one solution to achieve fast, and constant-time, message passing in dynamically typed languages and to bring them one step closer to the efficiency of statically typed languages

Many programming languages provide automatic garbage collection to reduce the need for memory management related programming. However, traditional garbage collection techniques lead to long and unpredictable delays and are therefore not satisfactory in a number of settings, such as interactive systems, where non-disruptive behavior is of paramount importance. Advanced techniques, such as generation-based collection, alleviate the problem somewhat by concentrating collection efforts on small but hopefully gainful areas of memory, the so-called young generations. This approach reduces the need for collecting the remaining large memory area, the old generation, but in no way obviates it. Traditionally, conventional techniques have been employed for old generation collection, leading to pauses which, although less frequent, are still highly disruptive. Recently, however, Hudson & Moss have introduced a new algorithm, the Train Algorithm, for performing efficient incremental collection of o...

This paper describes a mechanism for secondary storage garbage collection that may be used to reclaim inaccessible resources in decentralized persistent object based systems. Schemes for object addressing and object identification are discussed and a proposal is made which handles volatile objects separately from persistent objects. The garbage collection of the space of volatile objects is decoupled from the garbage collection of the space of persistent objects. The first kind of garbage collection can avoid the complexity and overhead of a distributed algorithm by classifying "exported" objects as persistent. The problem of detecting and collecting "distributed garbage" is then deferred to garbage collection of persistent objects. 1 Introduction Object Oriented programming generates large numbers of dynamically allocated objects. Many of these are used for a limited period of time and then become unreachable. To detect such "garbage" and make it available for reuse is the garbage co...

Distributed systems present a new challenge to garbage collection design. Garbage collection schemes for linked, heterogeneous data-structures distributed over a network are reviewed for the first time. As distributed garbage collectors evolved from single address space collectors, these are classified first. The classification is extended to distributed collectors taking into account the additional issues of distribution: locality; latency and synchronisation. Categories and Subject Descriptors: C.2.4 [Computer-Communications Networks]: Distributed Systems; D.1.3 [Programming Techniques]: Concurrent Programming, Distributed programming, parallel programming; D.4.2 [Operating Systems]: Storage management; D.4.3: File systems management. Additional key words and phrases: memory management, automatic storage reclamation, garbage collection, reference counting, distributed systems, distributed memories, distributed file systems, network communication. Contents 1 Introduction 3 2 Taxonom...

in multiprocessor systems. Pipes allow a sequence of remote invocations to be performed in order, but asynchronously with respect to the calling thread. Using pipes results in programs that are easier to understand and debug than those with explicit synchronization between asynchronous invocations.

Garbage collector performance in LISP systems on custom hardware has been substantially improved by the adoption of lifetime-based garbage collection techniques. To date, however, successful lifetime-based garbage collectors have required special-purpose hardware, or at least privileged access to data structures maintained by the virtual memory system. I present here a lifetime-based garbage collector requiring no special-purpose hardware or virtual memory system support, and discuss its performance.

this paper, a method is described which can reduce storage requirements for systems which use generation scavenging as a memory reclamation technique. This method also improves the performance of the checkpoint operation and offline garbage-collection