Linearizable counting networks

Herlihy, Maurice; Shavit, Nir; Waarts, Orli

doi:10.1007/s004460050019

Cited by 42 publications

(56 citation statements)

References 24 publications

(9 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Though they are wait-free and scalable, the counting networks of [1] are not linearizable. Herlihy, Shavit, and Waarts demonstrated that counting networks can be adapted to implement linearizable counters [16]. However, the first counting network they present is not lock-free, while the others are not scalable, since each operation has to access Ω(N ) base objects.…”

Section: Related Workmentioning

confidence: 99%

An Adaptive Technique for Constructing Robust and High-Throughput Shared Objects

Hendler

Kutten

Michalak

2010

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Abstract. Shared counters are the key to solving a variety of coordination problems on multiprocessor machines, such as barrier synchronization and index distribution. It is desired that they, like shared objects in general, be robust, linearizable and scalable. We present the first linearizable and wait-free shared counter algorithm that achieves high throughput without a-priori knowledge about the system's level of asynchrony. Our algorithm can be easily adapted to any other combinable objects as well, such as stacks and queues. In particular, in an N -process execution E, our algorithm achieves high throughput of Ω( N φ 2 E log 2 φ E log N ), where φE is E's level of asynchrony. Moreover, our algorithm stands any constant number of faults. If E contains a constant number of faults, then our algorithm still achieves high throughput of Ω( N φ 2 E log 2 φ E log N ), where φ E bounds the relative speeds of any two processes, at a time that both of them participated in E and none of them failed. Our algorithm can be viewed as an adaptive version of the BoundedWait-Combining (BWC) prior art algorithm. BWC receives as an input an argument φ as a (supposed) upper bound of φE, and achieves optimal throughput if φ = φE. However, if the given φ happens to be lower than the actual φE, or much greater than φE, then the throughput of BWC degraded significantly. Moreover, whereas BWC is only lock-free, our algorithm is more robust, since it is wait-free. To achieve high throughput and wait-freedom, we present a method that guarantees (for some common kind of procedures) the procedure's successful termination in a bounded time, regardless of shared memory contention. This method may prove useful by itself, for other problems.

show abstract

Section: Related Workmentioning

confidence: 99%

An Adaptive Technique for Constructing Robust and High-Throughput Shared Objects

Hendler

Kutten

Michalak

2010

Lecture Notes in Computer Science

View full text Add to dashboard Cite

show abstract

“…If the responses queue is not empty, the length of its first range is computed and stored to the respLen local variable (statements 11,12). Then the length of the next requests entry is computed and stored to reqsLen (statements 13,14). The minimum of these two values is stored to send (statement 15).…”

Section: The Combining Processmentioning

confidence: 99%

“…Though they are wait-free and allow parallelism, the counting networks of [2] are non-linearizable. Herlihy et al demonstrated that counting networks can be adapted to implement wait-free linearizable counters [13]. However, the first counting network they present is blocking while the others do not provide parallelism, as each operation has to access Ω(N ) base objects.…”

Section: Introductionmentioning

confidence: 99%

Constructing Shared Objects That Are Both Robust and High-Throughput

Hendler

Kutten

2006

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Abstract. Shared counters are among the most basic coordination structures in distributed computing. Known implementations of shared counters are either blocking, non-linearizable, or have a sequential bottleneck. We present the first counter algorithm that is both linearizable, nonblocking, and can provably achieve high throughput in semisynchronous executions. The algorithm is based on a novel variation of the software combining paradigm that we call bounded-wait combining. It can thus be used to obtain implementations, possessing the same properties, of any object that supports combinable operations, such as stack or queue. Unlike previous combining algorithms where processes may have to wait for each other indefinitely, in the bounded-wait combining algorithm a process only waits for other processes for a bounded period of time and then 'takes destiny in its own hands'. In order to reason rigorously about the parallelism attainable by our algorithm, we define a novel metric for measuring the throughput of shared objects which we believe is interesting in its own right. We use this metric to prove that our algorithm can achieve throughput of Ω(N/ log N ) in executions where process speeds vary only by a constant factor, where N is the number of processes that can participate in the algorithm. We also introduce and use pseduo-transactions -a technique for concurrent execution that may prove useful for other algorithms.

show abstract

“…Adve and Boehm [1] showed that the choice of memory model determines fundamental properties of a concurrent programming environment, and makes a fundamental tradeoff between scalability and ease of programming. Concurrent hardware and software can scale most effectively with less enforcement of memory ordering, while the simplest implementation techniques rely on stricter ordering models [1,4,30].…”

Section: Design Constraints and Assumptionsmentioning

confidence: 99%

“…However, this strict ordering incurs a high cost [30]. Mutual exclusion limits concurrency to at most one thread accessing any particular piece of shared data at a time, with other threads blocked.…”

Section: Introductionmentioning

confidence: 99%

Relativistic Causal Ordering A Memory Model for Scalable Concurrent Data Structures

Walpole

Triplett

2000

View full text Add to dashboard Cite

High-performance programs and systems require concurrency to take full advantage of available hardware. However, the available concurrent programming models force a difficult choice, between simple models such as mutual exclusion that produce little to no concurrency, or complex models such as Read-Copy Update that can scale to all available resources.Simple concurrent programming models enforce atomicity and causality, and this enforcement limits concurrency. Scalable concurrent programming models expose the weakly ordered hardware memory model, requiring careful and explicit enforcement of causality to preserve correctness, as demonstrated in this dissertation through the manual construction of a scalable hash-table item-move algorithm. Recent research on relativistic programming aims to standardize the programming model of Read-Copy Update, but thus far these efforts have lacked a generalized memory ordering model, requiring datastructure-specific reasoning to preserve causality. To demonstrate the relativistic causal ordering model, I walk through the straightforward construction of a novel concurrent hash-table resize algorithm, including the translation of this algorithm from the relativistic model to a hardware memory model, and show through benchmarks that the resulting algorithm scales far better than those based on mutual exclusion.ii

show abstract

Linearizable counting networks

Cited by 42 publications

References 24 publications

An Adaptive Technique for Constructing Robust and High-Throughput Shared Objects

An Adaptive Technique for Constructing Robust and High-Throughput Shared Objects

Constructing Shared Objects That Are Both Robust and High-Throughput

Relativistic Causal Ordering A Memory Model for Scalable Concurrent Data Structures

Contact Info

Product

Resources

About