Universal constructions that ensure disjoint-access parallelism and wait-freedom

@article{Ellen2012UniversalCT,
  title={Universal constructions that ensure disjoint-access parallelism and wait-freedom},
  author={Faith Ellen and Panagiota Fatourou and Eleftherios Kosmas and Alessia Milani and Corentin Travers},
  journal={Distributed Computing},
  year={2012},
  volume={29},
  pages={251-277}
}
A universal construction is a general mechanism for obtaining a concurrent implementation of an object from its sequential code. We show that there is no universal construction that is both disjoint-access parallel (guaranteeing the processes operating on different parts of an implemented object do not interfere with one another) and wait-free (guaranteeing progress for each nonfaulty process when accessing an object). In contrast, we present a universal construction which results in disjoint… 
A Concurrency-Optimal List-Based Set
TLDR
This paper proposes a new algorithm based on a versioned try-lock that shows to achieve optimal concurrency: it only rejects concurrent schedules that violate correctness of the implemented type and empirically shows that reaching optimality does not induce a signicant overhead.
Distributed Universality
TLDR
This paper significantly extends the universality results introduced by Herlihy and Gafni–Guerraoui by presenting a k-universal construction which satisfies the following five desired properties: among the k objects that are constructed, at least one of the k constructed objects progresses forever.
Brief Announcement: A Concurrency-Optimal List-Based Set
TLDR
Multicore applications require highly concurrent data structures and the algorithm that accepts all correct schedules would then be considered concurrency-optimal.
Disjoint-Access Parallelism: Impossibility, Possibility, and Cost of Transactional Memory Implementations
TLDR
It is shown that adopting WRTO makes it possible to design a strictly DAP TM with invisible and wait-free read-only transactions, while preserving strong progressiveness for write transactions and an isolation level known in literature as Extended Update Serializability.
The PCL theorem: transactions cannot be parallel, consistent and live
TLDR
It is shown that it is impossible to design a transactional memory system which ensures parallelism, i.e. that transactions eventually commit if they run solo, and which is weaker than snapshot isolation, processor consistency, and any other consistency condition stronger than them.
Breaching the Wall of Impossibility Results on Disjoint-Access Parallel TM
TLDR
This paper looks for a breach in the wall of existing impossibility results, by attempting to identify the strongest consistency and liveness guarantees that a TM can ensure while remaining scalable — by ensuring DAP — and maximizing efficiency in read-dominated workloads — by having invisible and wait-free readonly transactions.
Disjoint-Access Parallelism Does Not Entail Scalability
TLDR
This work argues towards revising the two decade old wisdom saying that DAP is a binary condition that splits concurrent programs into scalable and non-scalable, and introduces a new property called generalized disjoint-access parallelism (GDAP) which estimates how much of an algorithm is DAP.
Distributed Universal Constructions: a Guided Tour
TLDR
A guided tour of universal constructions of n-process asynchronous distributed systems that are able to build any object defined by a sequential specification despite the occurrence of up to (n − 1) process crash failures is presented.
Snapshot Isolation Does Not Scale Either
TLDR
It was shown however that a TM cannot ensure strict disjoint-access-parallelism if it also needs to ensure serializability and obstruction-freedom and therefore they are highly desirable when designing TM implementations.
The PCL Theorem
TLDR
It is established that it is impossible to design a transactional memory algorithm that ensures parallelism, i.e., transactions do not need to synchronize unless they access the same application objects.
...
...

References

SHOWING 1-10 OF 51 REFERENCES
Universal constructions for multi-object operations
TLDR
This paper presents timeoptimal, wait-free implementations of Load-Linked and Store- Conditional from Read and Compare-And-Swap, and implementations that eliminate the need to deal with spurious Store-Conditional failures.
Wait-free synchronization
TLDR
A hierarchy of objects is derived such that no object at one level has a wait-free implementation in terms of objects at lower levels, and it is shown that atomic read/write registers, which have been the focus of much recent attention, are at the bottom of the hierarchy.
Disjoint-Access Parallelism in Software Transactional Memory
TLDR
This chapter will formalize the requirement that unrelated transactions progress independently, without interference, even if they occur at the same time, by presenting impossibility results and discussing some of the disjoint-access parallel STM implementations.
A methodology for implementing highly concurrent data structures
TLDR
This paper proposes a new methodology for constructing non-blocking and wait-free implementations of concurrent objects, whose representation and operations are written as stylized sequential programs, with no explicit synchronization.
Inherent Limitations on Disjoint-Access Parallel Implementations of Transactional Memory
TLDR
A lower bound of Ω(t) is proved on the number of writes needed in order to implement a read-only transaction of t items, which successfully terminates in a disjoint-access parallel TM implementation, which assumes strict serializability and thus hold under the assumption of opacity.
Disjoint-access-parallel implementations of strong shared memory primitives
TLDR
An efficient, non-blocking, disjointaccess-parallel implementation of LL and SCn, using Read and CBS and the asynchronous shar-ed memory model is presented.
Universal Constructions for Large Objects
TLDR
This work presents lock-free and wait-free universal constructions for implementing large shared objects, designed to largely shield programmers from this fragmentation and result in lower copying overhead than previous ones.
Wait-free made fast
TLDR
Inspired by Lamport’s fast mutual exclusion algorithm, universal methods that combine the advantages of both non-blocking and waitfree approaches are devised, i.e., fast when contention is low and guaranteed progress of any individual operation are presented.
Disentangling multi-object operations (extended abstract)
TLDR
This work considers the problem of implementing atomic operations on multiple shared memory objects, in systems which directly support only single-object atomic operations, and presents a wait-free solution for atomically accessing up to k objects that has low local contention and local step complexity.
A method for implementing lock-free shared-data structures
TLDR
This work presents a technique that provides the semantics of exclusive access to data without using mutual exclusion, and devise the caching method, a general method of implementing lock-free data structures that is provably better than Herlihy's methodology for many weIl-known data structures.
...
...