ACM Transactions on Programming Languages and Systems (TOPLAS)
Simple, fast, and practical non-blocking and blocking concurrent queue algorithms
PODC '96 Proceedings of the fifteenth annual ACM symposium on Principles of distributed computing
A real-time garbage collector with low overhead and consistent utilization
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Lock-Free Garbage Collection for Multiprocessors
IEEE Transactions on Parallel and Distributed Systems
A Pragmatic Implementation of Non-blocking Linked-Lists
DISC '01 Proceedings of the 15th International Conference on Distributed Computing
Hazard Pointers: Safe Memory Reclamation for Lock-Free Objects
IEEE Transactions on Parallel and Distributed Systems
A study of concurrent real-time garbage collectors
Proceedings of the 2008 ACM SIGPLAN conference on Programming language design and implementation
Progress guarantee for parallel programs via bounded lock-freedom
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
A lock-free, concurrent, and incremental stack scanning mechanism for garbage collectors
ACM SIGOPS Operating Systems Review
The Art of Multiprocessor Programming
The Art of Multiprocessor Programming
Non-blocking binary search trees
Proceedings of the 29th ACM SIGACT-SIGOPS symposium on Principles of distributed computing
Wait-free queues with multiple enqueuers and dequeuers
Proceedings of the 16th ACM symposium on Principles and practice of parallel programming
Hi-index | 0.00 |
The complexity of parallel data structures is often measured by two major factors: the throughput they provide and the progress they guarantee. Progress guarantees are particularly important for systems that require responsiveness such as real-time systems, operating systems, interactive systems, etc. Notions of progress guarantees such as lock-freedom, wait-freedom, and obstruction-freedom that provide different levels of guarantees have been proposed in the literature [4, 6]. Concurrent access (and furthermore, optimistic access) to shared objects makes the management of memory one of the more complex aspects of concurrent algorithms design. The use of automatic memory management greatly simplifies such algorithms [11, 3, 2, 9]. However, while the existence of lock-free garbage collection has been demonstrated [5], the existence of a practical automatic memory manager that supports lock-free or wait-free algorithms is still open. Furthermore, known schemes for manual reclamation of unused objects are difficult to use and impose a significant overhead on the execution [10]. It turns out that the memory management community is not fully aware of how dire the need is for memory managers that support progress guarantees for the design of concurrent data structures. Likewise, designers of concurrent data structures are not always aware of the fact that memory management with support for progress guarantees is not available. Closing this gap between these two communities is a major open problem for both communities. In this talk we will examine the memory management needs of concurrent algorithms. Next, we will discuss how state-of-the-art research and practice deal with the fact that an important piece of technology is missing (e.g., [7, 1]). Finally, we will survey the currently available pieces in this puzzle (e.g., [13, 12, 8]) and specify which pieces are missing. This open problem is arguably the greatest challenge facing the memory management community today.