A Dynamic Elimination-Combining Stack Algorithm

Bar-Nissan, Gal; Hendler, Danny; Suissa, Adi

doi:10.1007/978-3-642-25873-2_37

Cited by 12 publications

(8 citation statements)

References 12 publications

(26 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Concurrent stacks suffer from their inherent single point access bottleneck. In the quest to improve performance scalability, disjoint access strategies have been proposed for designing concurrent stacks including; elimination trees [1,9], combining funnels [10] and elimination back-off [3,5]. Elimination back-off implements a collision array in which pop operations try to collide and cancel with concurrent push operations.…”

Section: Related Workmentioning

confidence: 99%

Brief Announcement

Rukundo

Atalar

Tsigas

2018

Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing

View full text Add to dashboard Cite

We briefly describe an efficient lock-free concurrent stack design with tunable and tenable relaxed semantics to allow for better performance. The design is tunable and allow for a continuous monotonic trade of weaker semantics for better throughput performance. Concurrent stacks have an inherent scalability bottleneck due to their single access point for both their operations. Elimination and semantics relaxation have been proposed in the literature to address this problem. Semantics relaxation has the potential to reach monotonically very high throughput by continuously trading relaxation for throughput. Previous solutions could not fully leverage this potential. We suggest a new two dimensional design that can achieve this by exploiting disjoint access parallelism in one dimension and locality in the other within tight accuracy bounds. The behaviour of the algorithm is tightly bound. We compare experimentally to previous work, with respect to throughput and relaxed behaviour observed, on different relaxation and concurrency settings. The experimental evaluation shows that our algorithm significantly outperform all other algorithms in terms of performance, also maintain better accuracy in contrast to other designs with relaxed semantics.

show abstract

Section: Related Workmentioning

confidence: 99%

Brief Announcement

Rukundo

Atalar

Tsigas

2018

Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing

View full text Add to dashboard Cite

show abstract

“…Our experiments compare the performance and scalability of the TS stack with two high-performance concurrent stacks: the Treiber stack [22] because it is the de-facto standard lock-free stack implementation; and the elimination-backo (EB) stack [9] because it is the fastest concurrent stack we are aware of. 3 We configured the Treiber and EB stacks to perform as well as possible on our test machines: see below for the parameters used.…”

Section: Performance Analysismentioning

confidence: 99%

“…Of course, other high-performance stacks exist. We decided against benchmarking the DECS stack[3] because (1) no implementation is available for our platform and (2) according to their experiments, in peak performance it is no better than a Flat Combining stack. We decided against benchmarking the Flat Combining stack because the EB stack outperforms it when configured to access the backo array before the stack itself.…”

mentioning

confidence: 99%

A Scalable, Correct Time-Stamped Stack

Dodds

Haas

Kirsch

2015

Proceedings of the 42nd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages

View full text Add to dashboard Cite

Concurrent data-structures, such as stacks, queues, and deques, often implicitly enforce a total order over elements in their underlying memory layout. However, much of this order is unnecessary: linearizability only requires that elements are ordered if the insert methods ran in sequence. We propose a new approach which uses timestamping to avoid unnecessary ordering. Pairs of elements can be left unordered if their associated insert operations ran concurrently, and order imposed as necessary at the eventual removal. We realise our approach in a new non-blocking datastructure, the TS (timestamped) stack. Using the same approach, we can define corresponding queue and deque datastructures. In experiments on x86, the TS stack outperforms and outscales all its competitors-for example, it outperforms the elimination-backo stack by factor of two. In our approach, more concurrency translates into less ordering, giving less-contended removal and thus higher performance and scalability. Despite this, the TS stack is linearizable with respect to stack semantics. The weak internal ordering in the TS stack presents a challenge when establishing linearizability: standard techniques such as linearization points work well when there exists a total internal order. We present a new stack theorem, mechanised in Isabelle, which characterises the orderings su cient to establish stack semantics. By applying our stack theorem, we show that the TS stack is indeed linearizable. Our theorem constitutes a new, generic proof technique for concurrent stacks, and it paves the way for future weakly ordered data-structure designs.

show abstract

“…The necessity of reducing contention at the synchronisation access points, and consequently improving scalability, is and has been a major focus for concurrent data structure researchers. Techniques like; elimination [1,19,31], combining [32], dynamic elimination-combining [6] and back-off strategies have been proposed as ways to improve scalability. To address, in a more significant way, the challenge of scalability bottlenecks of concurrent data structures, it has been proposed that the semantic legal behaviour of data structures should be extended [29].…”

Section: Introductionmentioning

confidence: 99%

Relaxing Concurrent Data-structure Semantics for Increasing Performance: A Multi-structure 2D Design Framework

Rukundo¹,

Atalar²,

Tsigas³

2019

Preprint

View full text Add to dashboard Cite

There has been a significant amount of work in the literature proposing semantic relaxation of concurrent data structures for improving scalability and performance. By relaxing the semantics of a data structure, a bigger design space, that allows weaker synchronization and more useful parallelism, is unveiled. Investigating new data structure designs, capable of trading semantics for achieving better performance in a monotonic way, is a major challenge in the area. We algorithmically address this challenge in this paper.We present an efficient, lock-free, concurrent data structure design framework for out-of-order semantic relaxation. Our framework introduces a new two dimensional algorithmic design, that uses multiple instances of a given data structure. The first dimension of our design is the number of data structure instances operations are spread to, in order to benefit from parallelism through disjoint memory access. The second dimension is the number of consecutive operations that try to use the same data structure instance in order to benefit from data locality. Our design can flexibly explore this two-dimensional space to achieve the property of monotonically relaxing concurrent data structure semantics for achieving better throughput performance within a tight deterministic relaxation bound, as we prove in the paper.We show how our framework can instantiate lock-free out-of-order queues, stacks, counters and dequeues. We provide implementations of these relaxed data structures and evaluate their performance and behaviour on two parallel architectures. Experimental evaluation shows that our two-dimensional data structures significantly outperform the respected previous proposed ones with respect to scalability and throughput performance. Moreover, their throughput increases monotonically as relaxation increases.

show abstract

A Dynamic Elimination-Combining Stack Algorithm

Cited by 12 publications

References 12 publications

Brief Announcement

Brief Announcement

A Scalable, Correct Time-Stamped Stack

Relaxing Concurrent Data-structure Semantics for Increasing Performance: A Multi-structure 2D Design Framework

Contact Info

Product

Resources

About