Mark-sweep or copying?: a "best of both worlds" algorithm and a hardware-supported real-time implementation

@inproceedings{Stanchina2007MarksweepOC,
  title={Mark-sweep or copying?: a "best of both worlds" algorithm and a hardware-supported real-time implementation},
  author={Sylvain Stanchina and Matthias Meyer},
  booktitle={ISMM '07},
  year={2007}
}
Copying collectors offer a number of advantages over their mark-sweep counterparts. First, they do not have to deal with mark stacks and potential mark stack overflows. Second, they do not suffer from unpredictable fragmentation overheads since they inherently compact the heap. Third, the tospace invariant maintained by many copying collectors allows for incremental compaction and provides the basisfor efficient real-time implementations. Unfortunately, however, standard copying collectors… 
Fine-Grained Parallel Compacting Garbage Collection through Hardware-Supported Synchronization
  • O. Horvath, M. Meyer
  • Computer Science
    2010 39th International Conference on Parallel Processing Workshops
  • 2010
TLDR
This paper introduces a low-cost multi-core garbage collection coprocessor, based on Cheney's copying algorithm, employs a single worklist and distributes garbage collection work on an object-by-object basis, and achieves well balanced work distribution and good scalability.
Improved replication-based incremental garbage collection for embedded systems
TLDR
Evaluation of this garbage collector implemented in Sun's J2ME Java Virtual Machine showed that all the benchmarks used were able to run without memory starvation using the heap sizes of only 151%-286% of the maximum amount of live data plus 8 KB of the hash table.
Handles revisited: optimising performance and memory costs in a real-time collector
TLDR
This work provides the first thorough study of the overheads of handles, based on an optimised implementation of different handle designs within Ovm's Minuteman real-time collector, and finds that with a good set of optimisations handles are not very expensive.
Flexible reference-counting-based hardware acceleration for garbage collection
TLDR
The key idea is to reduce the frequency of garbage collection by efficiently detecting and reusing dead memory space in hardware via hardware-implemented reference counting, so that software garbage collections become much less frequent and have less impact on overall performance.
Integrated Hardware Garbage Collection
TLDR
The Integrated Hardware Garbage Collector (IHGC) is proposed; a garbage collector tightly coupled with the processor that runs continuously in the background, and introduces a static analysis technique to guarantee that real-time programs are never paused by the collector.
INVESTIGATION & COMPARATIVE STUDY of HARDWARE ASSISTED UNUSED MEMORY COLLECTOR OVER SOFTWARE MEMORY COLLECTOR APPROACH
TLDR
This study is doing investigation and Comparative study how the Hardware assisted Garbage collector give advantage over only Software Garbage Collector in programming languages for Real time and Distributed System by keeping in mind that Hardware module have less running time compare to Software programs.
Virtual Machine Services:An Opportunity for Hardware Customization
TLDR
A heterogeneous multicore processor has the potential to substantially improve energy of managed applications with cores customized for VM services, and is evaluated on actual hardware, rather than through simulation.
Adaptive optimization of the Sun Java™ real-time system garbage collector
TLDR
A framework for dynamically adapting the StartupMemoryThreshold for achieving the optimal balance between the application's throughput and pause time is presented, which was integrated into the beta release of Java RTS 2.2.
Charon: Specialized Near-Memory Processing Architecture for Clearing Dead Objects in Memory
TLDR
This work proposes Charon1, the first 3D stacked memory-based GC accelerator, and derives a set of key algorithmic primitives based on their GC time coverage and implementation complexity in hardware to substantially improve their memory-level parallelism and throughput with a low hardware cost.
Power, performance, and upheaval : an opportunity for managed languages
TLDR
This thesis is that there exists a synergy between managed software and AMP architectures that can be automatically exploited to reduce VM overheads and deliver the efficiency promise of AMP architecture while abstracting over hardware complexity.
...
...

References

SHOWING 1-10 OF 26 REFERENCES
Mark-copy: fast copying GC with less space overhead
TLDR
A mark-copy collection algorithm (MC) that extends generational copying collection and significantly reduces the heap space required to run a program and is significantly faster than mark-sweep in small and moderate size heaps is presented.
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.
Mostly concurrent compaction for mark-sweep GC
TLDR
This work presents a method for reducing the pause time created by compaction at a negligible throughput hit, and implements its compaction on top of the IBM J9 JVM V2.2, and presents measurements of its effect on pause time, throughput, and mutator utilization.
MC2: high-performance garbage collection for memory-constrained environments
TLDR
MC2 (Memory-Constrained Copying), a copying generational garbage collector that meets the needs of memory-constrained devices with soft real-time requirements, has low space over-head and tight space bounds, prevents fragmentation, provides good throughput, and yields short pause times.
An algorithm for parallel incremental compaction
TLDR
A parallel incremental compaction algorithm that reduces pause times by working in parallel and evacuating a part of the heap when the program threads are stopped for garbage collection.
A compacting incremental collector and its performance in a production quality compiler
We present a new near-real-time compacting collector and its implementation in a production quality Scheme compiler (Gambit-C). Our goal is to use this system as a base for an implementation of
An on-chip garbage collection coprocessor for embedded real-time systems
  • M. Meyer
  • Computer Science
    11th IEEE International Conference on Embedded and Real-Time Computing Systems and Applications (RTCSA'05)
  • 2005
TLDR
The design and implementation of an on-chip garbage collection coprocessor that closely cooperates with the main processor and the benefits include low garbage collection overhead, low-cost synchronization of collector and application programs, and hard real-time capabilities are presented.
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.
A true hardware read barrier
TLDR
This paper introduces a novel hardware read barrier design for an object-based RISC architecture that integrates read barrier checking and, for the first time, read barrier fault handling directly into a processor pipeline.
A novel processor architecture with exact tag-free pointers
TLDR
A novel RISC processor architecture that lays the foundation for efficient real-time garbage collection in hardware and guarantees pointer integrity at the machine-code level is proposed.
...
...