Introduction to algorithms
Linux Journal
Hazard Pointers: Safe Memory Reclamation for Lock-Free Objects
IEEE Transactions on Parallel and Distributed Systems
Exploiting deferred destruction: an analysis of read-copy-update techniques in operating system kernels
Threads cannot be implemented as a library
Proceedings of the 2005 ACM SIGPLAN conference on Programming language design and implementation
TxLinux: using and managing hardware transactional memory in an operating system
Proceedings of twenty-first ACM SIGOPS symposium on Operating systems principles
Performance of memory reclamation for lockless synchronization
Journal of Parallel and Distributed Computing
Software Transactional Memory: Why Is It Only a Research Toy?
Queue - The Concurrency Problem
Early experience with a commercial hardware transactional memory implementation
Proceedings of the 14th international conference on Architectural support for programming languages and operating systems
A relativistic enhancement to software transactional memory
HotPar'11 Proceedings of the 3rd USENIX conference on Hot topic in parallelism
Resizable, scalable, concurrent hash tables via relativistic programming
USENIXATC'11 Proceedings of the 2011 USENIX conference on USENIX annual technical conference
A case for relativistic programming
Proceedings of the 2012 ACM workshop on Relaxing synchronization for multicore and manycore scalability
A Read-Copy Update based parallel server for distributed crowd simulations
The Journal of Supercomputing
Hi-index | 0.00 |
This paper presents a novel concurrent hash table implementation which supports wait-free, near-linearly scalable lookup, even in the presence of concurrent modifications. In particular, this hash table implementation supports concurrent moves of hash table elements between buckets, for purposes such as renames. Implementation of this algorithm in the Linux kernel demonstrates its performance and scalability. Benchmarks on a 64-way POWER system showed a 6x scalability improvement versus fine-grained locking, and a 1.5x improvement versus the current state of the art in Linux. To achieve these scalability improvements, the hash table implementation uses a new concurrent programming technique known as relativistic programming. This approach uses a copy-based update strategy to allow readers and writers to run concurrently without conflicts, avoiding many of the non-scalable costs of synchronization, inter-processor communication, and cache coherence. New techniques such as the proposed hash-table move algorithm allow readers to tolerate the resulting weak memory-ordering behavior that arises from allowing one version of a structure to be read concurrently with updates to a different version of the same structure. Relativistic programming techniques provide performance and scalability advantages over traditional synchronization, as demonstrated through several benchmarks.