A Portable Lock-Free Bounded Queue

Pirkelbauer, Peter; Milewicz, Reed; González, Juan Felipe

doi:10.1007/978-3-319-49583-5_4

Cited by 6 publications

(3 citation statements)

References 19 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…However, it appears that minimizing memory overhead in dynamic concurrent data structures has not been in the highlight until recently. A standard way to implement a lock-free bounded queue, the major running example of this paper, is to use descriptors [15,18] or additional meta-information per each element [4,16,17,19]. The overhead of resulting solutions is proportional to the queue size: a descriptor contains an additional Ω(1) data to distinguish it from a value, while an additional meta-information is Ω(1) memory appended to the value by the definition.…”

Section: Related Workmentioning

confidence: 99%

Memory-Optimal Non-Blocking Queues

Aksenov¹,

Koval²,

Kuznetsov³

et al. 2021

Preprint

View full text Add to dashboard Cite

A bounded container maintains a collection of elements that can be inserted and extracted as long as the number of stored elements does not exceed the predefined capacity. We consider the concurrent implementations of a bounded container more or less memory-friendly depending on how much memory they use in addition to storing the elements. This way, memory-optimal implementation employs the minimal possible memory overhead and ensures that data and metadata are stored most compactly, reducing cache misses and unnecessary memory reclamation.In this paper, we show that non-blocking implementations of a large class of element-independent bounded containers, including queues, stacks, and pools, must incur linear in the number of concurrent processes memory overhead. In the special cases when the ABA problem is excluded, e.g., by assuming that the hardware supports LL/SC instructions or by storing distinct elements, we show that the lower bound can be circumvented, by presenting lock-free bounded queues with constant memory overhead. For the general case, we present a CAS-based bounded queue implementation that asymptotically matches our lower bound. We believe that these results open a new research avenue devoted to the memory-optimality phenomenon.

show abstract

Section: Related Workmentioning

confidence: 99%

Memory-Optimal Non-Blocking Queues

Aksenov¹,

Koval²,

Kuznetsov³

et al. 2021

Preprint

View full text Add to dashboard Cite

show abstract

“…In the previous section, we introduced the notion of a shared task pool. While several lock-free and wait-free data structures for the construction of multi-producer multiconsumer queues exist (Feldman and Dechev 2015;Michael and Scott 1996;Pirkelbauer et al 2016;Yang and Mellor-Crummey 2016), we posit that many of these solutions incur a significant overhead (in the form of contention or the use of expensive atomic operations) even when a thread produces and consumes its own tasks. Thus, we opted for a design where the pool consists of n task queues where each of the n threads owns its own queue.…”

Section: Task Poolmentioning

confidence: 99%

“…The design guarantees that at least one element remains in the queue, thus head and tail will never be null. The inner bounded queue uses a lock-free single-producer and multi-consumer scheme similar to a hybrid circular queue (Pirkelbauer et al 2016), except that we do not reuse buffer elements. Figure 5(a) shows the core interface of our task queue.…”

Section: Task Poolmentioning

confidence: 99%

Blaze-Tasks

Pirkelbauer

Wilson

Peterson

et al. 2018

ACM Trans. Archit. Code Optim.

Self Cite

View full text Add to dashboard Cite

Compared to threads, tasks are a more fine-grained alternative. The task parallel programming model offers benefits in terms of better performance portability and better load-balancing for problems that exhibit nonuniform workloads. A common scenario of task parallel programming is that a task is recursively decomposed into smaller sub-tasks. Depending on the problem domain, the number of created sub-tasks may be nonuniform, thereby creating potential for significant load imbalances in the system. Dynamic load-balancing mechanisms will distribute the tasks across available threads. The final result of a computation may be modeled as a reduction over the results of all sub-tasks.This article describes a simple, yet effective prototype framework, Blaze-Tasks, for task scheduling and task reductions on shared memory architectures. The framework has been designed with lock-free techniques and generic programming principles in mind. Blaze-Tasks is implemented entirely in C++17 and is thus portable. To load-balance the computation, Blaze-Tasks uses task stealing. To manage contention on a task pool, the number of lock-free attempts to steal a task depends on the distance between thief and pool owner and the estimated number of tasks in a victim's pool. This article evaluates the Blaze framework on Intel and IBM dual-socket systems using nine benchmarks and compares its performance with other task parallel frameworks. While Cilk outperforms Blaze on Intel on most benchmarks, the evaluation shows that Blaze is competitive with OpenMP and other library-based implementations. On IBM, the experiments show that Blaze outperforms other approaches on most benchmarks.

show abstract

A wait-free queue with polylogarithmic step complexity

Naderibeni,

Ruppert

2024

Distrib. Comput.

View full text Add to dashboard Cite

A Portable Lock-Free Bounded Queue

Cited by 6 publications

References 19 publications

Memory-Optimal Non-Blocking Queues

Memory-Optimal Non-Blocking Queues

Blaze-Tasks

A wait-free queue with polylogarithmic step complexity

Contact Info

Product

Resources

About