Real-time concurrent collection on stock multiprocessors
PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
Lock-free garbage collection for multiprocessors
SPAA '91 Proceedings of the third annual ACM symposium on Parallel algorithms and architectures
Transactional memory: architectural support for lock-free data structures
ISCA '93 Proceedings of the 20th annual international symposium on computer architecture
Proceedings of the fourteenth annual ACM symposium on Principles of distributed computing
On optimistic methods for concurrency control
ACM Transactions on Database Systems (TODS)
An architecture for mostly functional languages
LFP '86 Proceedings of the 1986 ACM conference on LISP and functional programming
On-the-fly garbage collection: an exercise in cooperation
Communications of the ACM
Multiprocessing compactifying garbage collection
Communications of the ACM
Sapphire: copying GC without stopping the world
Proceedings of the 2001 joint ACM-ISCOPE conference on Java Grande
Starting with termination: a methodology for building distributed garbage collection algorithms
ACSC '01 Proceedings of the 24th Australasian conference on Computer science
Transaction Processing: Concepts and Techniques
Transaction Processing: Concepts and Techniques
Trading data space for reduced time and code space in real-time garbage collection on stock hardware
LFP '84 Proceedings of the 1984 ACM Symposium on LISP and functional programming
Software transactional memory for dynamic-sized data structures
Proceedings of the twenty-second annual symposium on Principles of distributed computing
Language support for lightweight transactions
OOPSLA '03 Proceedings of the 18th annual ACM SIGPLAN conference on Object-oriented programing, systems, languages, and applications
Proceedings of the 1st ACM/USENIX international conference on Virtual execution environments
Design tradeoffs in modern software transactional memory systems
LCR '04 Proceedings of the 7th workshop on Workshop on languages, compilers, and run-time support for scalable systems
McRT-STM: a high performance software transactional memory system for a multi-core runtime
Proceedings of the eleventh ACM SIGPLAN symposium on Principles and practice of parallel programming
Optimizing memory transactions
Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation
Compiler and runtime support for efficient software transactional memory
Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation
Enforcing isolation and ordering in STM
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Stopless: a real-time garbage collector for multiprocessors
Proceedings of the 6th international symposium on Memory management
Design and implementation of transactional constructs for C/C++
Proceedings of the 23rd ACM SIGPLAN conference on Object-oriented programming systems languages and applications
Adaptive optimization of the Sun Java™ real-time system garbage collector
Adaptive optimization of the Sun Java™ real-time system garbage collector
Data-race exceptions have benefits beyond the memory model
Proceedings of the 2011 ACM SIGPLAN Workshop on Memory Systems Performance and Correctness
The Collie: a wait-free compacting collector
Proceedings of the 2012 international symposium on Memory Management
Hi-index | 0.00 |
We predict that the ever-growing number of cores on our desktops will require a re-examination of concurrent programming. Two technologies are likely to become mainstream in response: Transactional memory provides a superior programming model to traditional lock-based concurrency, while Concurrent GC can take advantage of multiple cores to eliminate perceptible pauses in desktop applications such as games or Internet telephony. This paper proposes a combination of the two technologies, producing a synergy that improves scalability while eliminating the annoyance of user-perceivable pauses. Specifically, we show how concurrent GC can share some of the mechanisms required for transactional memory. Thus as transactional memory becomes more efficient, so too will concurrent GC. We demonstrate how, using a state of the art software transactional memory system, we can build a state of the art concurrent collector. Our goal was to reduce 90% of pause times to under one millisecond. Of the remainder, we aim for 90% to be under 10ms, and90% of those left to be under 100ms. Our performance results show that we were able to achieve these targets, with pause times between one or two orders of magnitude lower than mainstream technologies.