Deterministic coin tossing with applications to optimal parallel list ranking
Information and Control
Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
ACM Transactions on Programming Languages and Systems (TOPLAS)
Locality in distributed graph algorithms
SIAM Journal on Computing
Performance issues in non-blocking synchronization on shared-memory multiprocessors
PODC '92 Proceedings of the eleventh annual ACM symposium on Principles of distributed computing
Locking without blocking: making lock based concurrent data structure algorithms nonblocking
PODS '92 Proceedings of the eleventh ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems
Communications of the ACM
A methodology for implementing highly concurrent data objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
Transactional memory: architectural support for lock-free data structures
ISCA '93 Proceedings of the 20th annual international symposium on computer architecture
A method for implementing lock-free shared-data structures
SPAA '93 Proceedings of the fifth annual ACM symposium on Parallel algorithms and architectures
The PowerPC architecture: a specification for a new family of RISC processors
The PowerPC architecture: a specification for a new family of RISC processors
Primitives for asynchronous list compression
Proceedings of the 4th ACM symposium on Parallel algorithms and architectures
Disjoint-access-parallel implementations of strong shared memory primitives
PODC '94 Proceedings of the thirteenth annual ACM symposium on Principles of distributed computing
The synergy between non-blocking synchronization and operating system structure
OSDI '96 Proceedings of the second USENIX symposium on Operating systems design and implementation
Localizing Failures in Distributed Synchronization
IEEE Transactions on Parallel and Distributed Systems
Universal operations: unary versus binary
PODC '96 Proceedings of the fifteenth annual ACM symposium on Principles of distributed computing
Disentangling multi-object operations (extended abstract)
PODC '97 Proceedings of the sixteenth annual ACM symposium on Principles of distributed computing
Contention in shared memory algorithms
Journal of the ACM (JACM)
Universal Constructions for Large Objects
IEEE Transactions on Parallel and Distributed Systems
Distributed Algorithms
The Performance of Spin Lock Alternatives for Shared-Memory Multiprocessors
IEEE Transactions on Parallel and Distributed Systems
Efficient Wait-Free Implementation of a Concurrent Priority Queue
WDAG '93 Proceedings of the 7th International Workshop on Distributed Algorithms
The power of DCAS: highly-concurrent software transactional memory
Proceedings of the twenty-sixth annual ACM symposium on Principles of distributed computing
Concurrency and the Principle of Data Locality
IEEE Distributed Systems Online
Highly-concurrent multi-word synchronization
ICDCN'08 Proceedings of the 9th international conference on Distributed computing and networking
Highly concurrent multi-word synchronization
Theoretical Computer Science
Built-in coloring for highly-concurrent doubly-linked lists
DISC'06 Proceedings of the 20th international conference on Distributed Computing
Time and space lower bounds for implementations using k-CAS
DISC'05 Proceedings of the 19th international conference on Distributed Computing
Obstruction-Free step complexity: lock-free DCAS as an example
DISC'05 Proceedings of the 19th international conference on Distributed Computing
| Hi-index | 0.01 |
We present an algorithm for implementing binary operations (of any type) from unary load-linked (LL) and store-conditional (SC) operations. The performance of the algorithm is evaluated according to its sensitivity, measuring the distance between operations in the graph induced by conflicts, which guarantees that they do not influence the step complexity of each other. The sensitivity of our implementation is O(log* n), where n is the number of processors in the system. That is, operations that are Ω(log* n) apart in the graph induced by conflicts do not delay each other. Constant sensitivity is achieved for operations used to implement heaps and array-based linked lists.We also prove that there is a problem which can be solved in O(1) steps using binary LL/SC operations, but requires O(log log* n) operations if only unary LL/SC operations are used. This indicates a non-constant gap between unary and binary, LL/SC operations.