List processing in real time on a serial computer

@article{Baker1978ListPI,
  title={List processing in real time on a serial computer},
  author={Henry G. Baker},
  journal={Commun. ACM},
  year={1978},
  volume={21},
  pages={280-294}
}
  • H. Baker
  • Published 1 April 1978
  • Computer Science
  • Commun. ACM
A real-time list processing system is one in which the time required by the elementary list operations (e.g. CONS, CAR, CDR, 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… 
Trading data space for reduced time and code space in real-time garbage collection on stock hardware
TLDR
This paper shows that copying compacting real-time garbage collection algorithms do not always need to protect user programs from seeing uncopied data, so long as a slightly more complicated collection termination condition is used, and opens the way to adding an indirection pointer to all LISP heap objects making it unnecessary to check the garbage collection status of pointers.
A performance analysis of the active memory system
  • W. Srisa-an, D. Lo, J. Chang
  • Computer Science
    Proceedings 2001 IEEE International Conference on Computer Design: VLSI in Computers and Processors. ICCD 2001
  • 2001
TLDR
The performance analysis of the proposed Active Memory Module (AMM) for embedded systems is presented and it is presented that the AMM can perform a memory allocation in a predictable and hounded fashion and can also yield a bounded sweeping time regardless of the number of live objects or heap size.
A practical parallel garbage collection algorithm and its implementation
TLDR
This paper presents a new practical parallel garbage collection algorithm and its improvements, and proposes a special processor for Parallel garbage collection that satisfies the effectiveness condition for parallelism, even if the list process node consumption rate is high.
Limits of parallel marking garbage collection
TLDR
An upper bound is given for the number of stalls that may occur as a function of simple properties of the memory graph for the Java applications that are part of the SPECjvm98 benchmark suite and the theoretical worst-case scalability of a parallel mark phase is analysed.
Staccato : A Parallel and Concurrent Real-time Compacting Garbage Collector for Multiprocessors Bill
TLDR
Staccato is able to achieve maximum pause times of 753μs and an MMU of 85% over a 5ms time window, out-performing both IBM's Metronome-based product and Azul’s soft real-time, hardwareassisted collector.
A parallel, real-time garbage collector
TLDR
This paper presents the extensions necessary for a practical implementation of a parallel, real-time garbage collector: reducing excessive interleaving, handling stacks and global variables, reducing double allocation, and special treatment of large and small objects.
A Measurement-Based Study of Memory Usage and Garbage Collection in a Lisp System
TLDR
The variation of collector efficiency over the execution of the measured programs suggests the potential for improved performance by more closely matching garbage collection policy with program characteristics.
Parallel Real-Time Garbage Collection
TLDR
Two implementations, Metronome-TS and JamaicaVM will be presented in more detail since these two represent two typical instances of the time-based and work-based approaches of running the garbage collector.
Cost-effective object space management for hardware-assisted real-time garbage collection
TLDR
The design of an OSM (Object Space Manager) that allows partitioning of real memory on object, rather than page, boundaries is described, in which the worst-case stop-and-wait garbage collection delay ranges between 10 and 500 μsec, depending on the system configuration.
...
...

References

SHOWING 1-10 OF 62 REFERENCES
List Processing in Real Time on a Serial Computer
TLDR
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.
Analysis of an algorithm for real time garbage collection
TLDR
Algorithms for recovering discarded list structures in this manner are presented and analyzed to determine sufficient conditions under which the list processor never needs to wait on the collector, which are suitable for measuring the typical behavior of the algorithm.
An efficient, incremental, automatic garbage collector
This paper describes a new way of solving the storage reclamation problem for a system such as Lisp that allocates storage automatically from a heap, and does not require the programmer to give any
A LISP machine
TLDR
The implementation is based on a powerful microprogrammed processor designed specifically for LISP, which manipulates items which have a built-in data-type field and incorporates the personal computer philosophy.
C.ai : a LISP processor for C.ai
TLDR
A special microprogram controlled process designed for efficient interpretation of the LISP language is described, which includes a storage-compacting garbage-collector, which can be made to operate incrementally in parallel with user-program execution.
A model and stack implementation of multiple environments
TLDR
This paper presents an implementation technique using a single stack to hold procedure activation storage which allows retention of that storage for durations not necessarily tied to control flow, and applications to multitasking, coroutines, backtracking, label-valued variables, and functional arguments are discussed.
Multiprocessing compactifying garbage collection
TLDR
Algorithms for a multiprocessing compactifying garbage collector are presented and discussed and particular attention is given to the problems of marking and relocating list cells while another processor may be operating on them.
A LISP garbage-collector for virtual-memory computer systems
TLDR
A garbage-collection algorithm for list-processing systems which operate within very large virtual memo, ies is described, which is more the compaction of active storage than the discovery of free storage.
An empirical study of list structure in Lisp
TLDR
Pointers to atoms are found to obey, roughly, Zipf's law, which governs word frequencies in natural languages; pointers to lists usually point to a location physically nearby in memory.
Symmetric list processor
A list processing system in which each list cell contains both a forward and a backward link as well as a datum is described. This system is intended for imbedding in higher level languages capable
...
...