Efficient synchronization primitives for large-scale cache-coherent multiprocessors
ASPLOS III Proceedings of the third international conference on Architectural support for programming languages and operating systems
ACM Transactions on Programming Languages and Systems (TOPLAS)
Process coordination with fetch-and-increment
ASPLOS IV Proceedings of the fourth international conference on Architectural support for programming languages and operating systems
A methodology for implementing highly concurrent data objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
A completeness theorem for a class of synchronization objects
PODC '93 Proceedings of the twelfth annual ACM symposium on Principles of distributed computing
Journal of the ACM (JACM)
Parallel algorithms with processor failures and delays
Journal of Algorithms
STOC '95 Proceedings of the twenty-seventh annual ACM symposium on Theory of computing
Algorithms for the Certified Write-All Problem
SIAM Journal on Computing
A time complexity lower bound for randomized implementations of some shared objects
PODC '98 Proceedings of the seventeenth annual ACM symposium on Principles of distributed computing
ACM Transactions on Programming Languages and Systems (TOPLAS)
Introduction to algorithms
Time and Space Lower Bounds for Nonblocking Implementations
SIAM Journal on Computing
The Performance of Spin Lock Alternatives for Shared-Memory Multiprocessors
IEEE Transactions on Parallel and Distributed Systems
Linearizable counting networks
Distributed Computing
Optimal-time adaptive strong renaming, with applications to counting
Proceedings of the 30th annual ACM SIGACT-SIGOPS symposium on Principles of distributed computing
Scalable address spaces using RCU balanced trees
ASPLOS XVII Proceedings of the seventeenth international conference on Architectural Support for Programming Languages and Operating Systems
| Hi-index | 0.00 |
A Fetch&Inc object stores a non-negative integer and supports a single operation, fi, that returns the value of the object and increments it. Such objects are used in many asynchronous shared memory algorithms, such as renaming, mutual exclusion, and barrier synchronization. We present an efficient implementation of a wait-free Fetch&Inc object from registers and load-linked/store-conditional (ll/sc) objects. In a system with p processes, every fi operation finishes in O(log2p) steps, and only a polynomial number of registers and O(logp)-bit ll/sc objects are needed. The maximum number of fi operations that can be supported is limited only by the maximum integer that can be stored in a shared register. This is the first wait-free implementation of a Fetch&Inc object that achieves both poly-logarithmic step complexity and polynomial space complexity, but does not require unrealistically large ll/sc objects or registers.