Distributionally Linearizable Data Structures

Alistarh, Dan; Brown, Thomas J.; Kopinsky, Justin; Li, Jerry Z.; Nadiradze, Giorgi

doi:10.1145/3210377.3210411

Cited by 31 publications

(47 citation statements)

References 38 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Fast mutual exclusion 1977, 1983 1993, 1997 Shared memory on top of asynchronous message-passing systems Peterson [71] Ben-Or [6], Rabin [73] Alpern, Schneider [1] Herlihy [44] Lamport [58] Pease, Shostak, Lamport [70] Fischer, Lynch, Paterson [34] Herlihy, Moss [46], Shavit, Touitou [85] Attiya, Bar Noy, Dolev [3] Chandra, Hadzilacos, Toueg [17] Nakamoto [66] 1965…”

Section: Impossibility Of Asynchronous Determinisitic Consensusmentioning

confidence: 99%

See 1 more Smart Citation

60 Years of Mastering Concurrent Computing through Sequential Thinking

Rajsbaum¹,

Raynal

2020

SIGACT News

View full text Add to dashboard Cite

Modern computing systems are highly concurrent. Threads run concurrently in shared-memory multi-core systems, and programs run in different servers communicating by sending messages to each other. Concurrent programming is hard because it requires to cope with many possible, unpredictable behaviors of the processes, and the communication media. The article argues that right from the start in 1960's, the main way of dealing with concurrency has been by reduction to sequential reasoning. It traces this history, and illustrates it through several examples, from early ideas based on mutual exclusion (which was initially introduced to access shared physical resources), passing through consensus and concurrent objects (which are immaterial data), until today distributed ledgers. A discussion is also presented, which addresses the limits that this approach encounters, related to fault-tolerance, performance, and inherently concurrent problems.

show abstract

Section: Impossibility Of Asynchronous Determinisitic Consensusmentioning

confidence: 99%

“…The version presented in Algorithm 1 is for two processes, but can be easily generalized to n processes. The two processes p 1 and p 2 share three read/write atomic registers, FLAG [1], FLAG [2], and LAST . Initially FLAG [1], FLAG [2], are down, while LAST does not need to be initialized.…”

Section: Mutual Exclusionmentioning

confidence: 99%

60 Years of Mastering Concurrent Computing through Sequential Thinking

Rajsbaum¹,

Raynal

2020

SIGACT News

View full text Add to dashboard Cite

show abstract

“…Priority schedulers such as k-LSM [35] enforce these properties deterministically, where k is a tunable parameter. We have shown in previous work that the MultiQueue [29] scheduler ensures these properties both in sequential and concurrent executions [4,2] with parameter k = O(q log q), with exponentially low failure probability in q, the number of queues.…”

Section: F Airness: For Any Taskmentioning

confidence: 99%

Efficiency Guarantees for Parallel Incremental Algorithms under Relaxed Schedulers

Alistarh

Nadiradze

Koval

2019

The 31st ACM Symposium on Parallelism in Algorithms and Architectures

Self Cite

View full text Add to dashboard Cite

Several classic problems in graph processing and computational geometry are solved via incremental algorithms, which split computation into a series of small tasks acting on shared state, which gets updated progressively. While the sequential variant of such algorithms usually specifies a fixed (but sometimes random) order in which the tasks should be performed, a standard approach to parallelizing such algorithms is to relax this constraint to allow for out-of-order parallel execution. This is the case for parallel implementations of Dijkstra's single-source shortestpaths (SSSP) algorithm, and for parallel Delaunay mesh triangulation. While many software frameworks parallelize incremental computation in this way, it is still not well understood whether this relaxed ordering approach can still provide any complexity guarantees.In this paper, we address this problem, and analyze the efficiency guarantees provided by a range of incremental algorithms when parallelized via relaxed schedulers. We show that, for algorithms such as Delaunay mesh triangulation and sorting by insertion, schedulers with a maximum relaxation factor of k in terms of the maximum priority inversion allowed will introduce a maximum amount of wasted work of O(log n poly (k)), where n is the number of tasks to be executed. For SSSP, we show that the additional work is O( poly (k) dmax/wmin), where dmax is the maximum distance between two nodes, and wmin is the minimum such distance. In practical settings where n k, this suggests that the overheads of relaxation will be outweighed by the improved scalability of the relaxed scheduler. On the negative side, we provide lower bounds showing that certain algorithms will inherently incur a non-trivial amount of wasted work due to scheduler relaxation, even for relatively benign relaxed schedulers.

show abstract

“…where m is the number of distinct priority queues [2]. This holds even in concurrent executions [1]. In the following, it will be convenient to assume a single parameter k, which upper bounds both the rank and the relaxation parameters.…”

Section: Modeling Relaxed Priority Schedulersmentioning

confidence: 99%

Relaxed Schedulers Can Efficiently Parallelize Iterative Algorithms

Alistarh

Brown

Kopinsky

et al. 2018

Proceedings of the 2018 ACM Symposium on Principles of Distributed Computing

Self Cite

View full text Add to dashboard Cite

There has been significant progress in understanding the parallelism inherent to iterative sequential algorithms: for many classic algorithms, the depth of the dependence structure is now well understood, and scheduling techniques have been developed to exploit this shallow dependence structure for efficient parallel implementations. A related, applied research strand has studied methods by which certain iterative task-based algorithms can be efficiently parallelized via relaxed concurrent priority schedulers. These allow for high concurrency when inserting and removing tasks, at the cost of executing superfluous work due to the relaxed semantics of the scheduler.In this work, we take a step towards unifying these two research directions, by showing that there exists a family of relaxed priority schedulers that can efficiently and deterministically execute classic iterative algorithms such as greedy maximal independent set (MIS) and matching. Our primary result shows that, given a randomized scheduler with an expected relaxation factor of k in terms of the maximum allowed priority inversions on a task, and any graph on n vertices, the scheduler is able to execute greedy MIS with only an additive factor of poly(k) expected additional iterations compared to an exact (but not scalable) scheduler. This counter-intuitive result demonstrates that the overhead of relaxation when computing MIS is not dependent on the input size or structure of the input graph. Experimental results show that this overhead can be clearly offset by the gain in performance due to the highly scalable scheduler. In sum, we present an efficient method to deterministically parallelize iterative sequential algorithms, with provable runtime guarantees in terms of the number of executed tasks to completion. arXiv:1808.04155v1 [cs.DS] 13 Aug 2018 may only depend on a small subset of other nodes, namely its neighbors which are higher priority in the random order. Blelloch, Fineman and Shun [7] performed an in-depth study of the asymptotic properties of this dependence structure, proving that, for any graph, the maximal depth of a chain of dependences is in fact O(log 2 n) with high probability, where n is the number of nodes in the graph. Recently, an impressive analytic result by Fischer and Noever [13] provided tight Θ(log n) bounds on the maximal dependency depth for greedy sequential MIS, effectively closing this problem for MIS. Beyond greedy MIS, there has been significant progress in analyzing the dependency structure of other fundamental sequential algorithms, such as algorithms for matching [7], list contraction [25], Knuth shuffle [25], linear programming [5], and graph connectivity [5].An alternative approach has been to employ relaxed data structures to schedule task-based programs. Starting with Karp and Zhang [19], the general idea is that, in some applications, the scheduler can relax the strict order induced by following the sequential algorithm, and allow tasks to be processed speculatively ahead of their dependencies, without loss o...

show abstract

Distributionally Linearizable Data Structures

Cited by 31 publications

References 38 publications

60 Years of Mastering Concurrent Computing through Sequential Thinking

60 Years of Mastering Concurrent Computing through Sequential Thinking

Efficiency Guarantees for Parallel Incremental Algorithms under Relaxed Schedulers

Relaxed Schedulers Can Efficiently Parallelize Iterative Algorithms

Contact Info

Product

Resources

About