Dan Touitou

Software transactional memory

Summary. As we learn from the literature, flexibility in choosing synchronization operations greatly simplifies the task of designing highly concurrent programs. Unfortunately, existing hardware is inflexible and is at best on the level of a Load–Linked/Store–Conditional operation on a single word. Building on the hardware based transactional synchronization methodology of Herlihy and Moss, we offer software transactional memory (STM), a novel software method for supporting flexible transactional programming of synchronization operations. STM is non-blocking, and can be implemented on existing machines using only a Load–Linked/Store–Conditional operation. We use STM to provide a general highly concurrent method for translating sequential object implementations to non-blocking ones based on implementing a k-word compare&swap STM-transaction. Empirical evidence collected on simulated multiprocessor architectures shows that our method always outperforms the non-blocking translation methods in the style of Barnes, and outperforms Herlihy’s translation method for sufficiently large numbers of processors. The key to the efficiency of our software-transactional approach is that unlike Barnes style methods, it is not based on a costly “recursive helping” policy.

Wait-free made fast

An implementation of an asynchronous shared-data structure is wait-free if no adversarial scheduler can stop an individual operation on the data structure from making progress (that is the implementation can tolerate a fail-stop fault of any number of processes). An implementation is non-blocking if an adversarial scheduler cannot stop the system from making progress. Existing wait-free implementations of shared data structures are slow when contention (processor concurrency) is low, namely, they have an Cl(n) term in their time complexity, where n is the total number of processes, however their time complexity for each operation is bounded. On the other hand, non-blocking implementations are fast when contention is low, but do not provide bounds on the time complexity of indwidual operations when contention is high. Neither seems to be satisfactory in practice. Inspired by Lamport’s fast mutual exclusion algorithm [Lam87], we pose in this paper the question of implementing fast and wait-free data-structures. We then devise universal methods that combine the advantages of both non-blocking and waitfree approaches, i.e., fast when contention is low and guaranteed progress of any individual operation. The time complexity of the algorithms presented here is not a function of n, but a function of k the actual number of processes that access the object concurrently, Two such methods are presented here; The first method, which is called group update, replaces the O(n) term in the time complexity of wait-free implementations by an O(min(n, k log k)) term (or more precisely, O(k log k +s + kf), where s and ~ are the data structure size and single update complexity, respectively). The second method, which is called individual update, rePermission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the ACM copyri ht notice and the % title of the publication and. KSdate appear,. an notice is given that copym IS by permwon of the Assoc!abon of Computing Machinery. o cop otherwse, or to repubhsh, requires y ‘/’ a fee ancf/or soecl ICoermisslon. STOC’ 95, L& Veg&, Nevada, USA @ 1995 ACM 0-89791 -718-9/95/0005..

Long-lived renaming made adaptive

3.50 places the O(n) term of wait-free implementations with an O(k) term (or O(k~log f)).

Long-lived adaptive collect with applications

Two implementations of an adaptive, wait-free, and long-lived renaming task in the read/write shared memory model are presented. Implementations of longlived and adaptive objects were previously known only in the much stronger model of load-linked and storeconditional (i.e., read-modify-write) shared memory. In read/write shared-memory only one-shot adaptive objects are known. Presented here are two algorithms that assign a new unique id in the range 1, . . . , O(k’) to any process whose initial unique name is taken from a set of size N, for an arbitrary N and where k is the number of processors that actually take steps or hold a name while the new name is being acquired. The step complexity of acquiring a new name is respectively O(k2) and O(k2 log k), while the step complexity of releasing a name is 1. The main differences between the two algorithms are in the precise definition of adaptiveness, and in their space complexity. The first algorithm adapts to the interval contention of an operation while requiring a bounded amount of space. The second algorithm adapts to the point contention but requires an unbounded amount of space. The two algorithms use completely different techniques to achieve their goals.

Long lived adaptive splitter and applications

A distributed algorithm is adaptive if the worst case step complexity of its operations is bounded by a function of the number of processes that are concurrently active during the operation (rather than a function of N, the total number of processes, which is usually much larger). We present long-lived and adaptive algorithms for collect in the read/write shared-memory model. Replacing the reads and writes in long-lived shared memory algorithms with our adaptive collect results in many cases in a corresponding long-lived algorithm which is adaptive. Examples of such applications, which are discussed are atomic-snapshots, and l-exclusion. Following the long-lived and adaptive collect we present a more pragmatic version of collect, called active set. This algorithm is slightly weaker than the collect but has several advantages. We employ this algorithm to transform algorithms, such as the Bakery algorithm, into their corresponding adaptive long-lived version, which is more efficient than the version that was obtained with the collect. Previously, long-lived and adaptive algorithms in this model were presented only for the renaming problem.

Elimination trees and the construction of pools and stacks: preliminary version

Summary. Long-lived and adaptive implementations of mutual exclusion and renaming in the read/write shared memory model are presented. An implementation of a task is adaptive if the step complexity of any operation in the implementation is a function of the number of processes that take steps concurrently with the operation. The renaming algorithm assigns a new unique id in the range

Disentangling multi-object operations (extended abstract)

1,\cdots, 4k^2

Timing conditions for linearizability in uniform counting networks

to any process whose initial unique name is taken from a set of size N, for an arbitrary N and where k is the number of processes that actually take steps or hold a name while the new name is being acquired. The step complexity of acquiring a new name is

Counting networks are practically linearizable

O(k^2)

Methods and apparatus for protecting against overload conditions on nodes of a distributed network

, while the step complexity of releasing a name is 1. The space complexity of the algorithm is