Queue Delegation Locking

User-level threading or task-parallel systems have been developed over decades to provide efficient and flexible threading features missing from kernel-level threading for both parallel and concurrent programming. Some of the existing state-of-the-art user-level threading libraries provide interfaces to customize the implementation of thread scheduling to adapt to different workloads from both applications and upper-level systems. However, most of them are typically built as huge sets of monolithic components which achieve customizability with additional costs via concrete C APIs. We have noticed that the zero-overhead abstraction of C++ is beneficial for assembling flexible user-level threading in a clearer manner. To demonstrate our ideas, we have implemented a new user-level threading library ComposableThreads which provides customizability while minimizing the interfacing costs. We show that the users can pick up, insert, or replace the individual classes of ComposableThreads for their own purposes. Com-posableThreads offers several characteristic abstractions to build high-level constructs of user-level threading including suspended threads (one-shot continuations) and lock delegators. We evaluate both the customizability and performance of our runtime system through the microbenchmark and application results.

show abstract

“…Klaftenegger et al [14] proposed queue delegation locking to implement lock delegation based on MCS locks and circular buffers.…”

Section: Lock Delegationmentioning

confidence: 99%

ComposableThreads: Rethinking User-level Threads with Composability and Parametricity in C++

Endo

Sato

Taura

2022

Journal of Information Processing

View full text Add to dashboard Cite

show abstract

“…There are variants of the delegation technique that use queues to delegate work to the threads currently inside the lock [21]. These are better suited to use in centralized schedulers as they do not require dedicated cores for each lock.…”

Section: Delegation Ticket Lock (Dtlock)mentioning

confidence: 99%

Advanced synchronization techniques for task-based runtime systems

Álvarez

Sala

Maroñas

et al. 2021

Proceedings of the 26th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming

View full text Add to dashboard Cite

Task-based programming models like OmpSs-2 and OpenMP provide a flexible data-flow execution model to exploit dynamic, irregular and nested parallelism. Providing an efficient implementation that scales well with small granularity tasks remains a challenge, and bottlenecks can manifest in several runtime components. In this paper, we analyze the limiting factors in the scalability of a task-based runtime system and propose individual solutions for each of the challenges, including a wait-free dependency system and a novel scalable scheduler design based on delegation. We evaluate how the optimizations impact the overall performance of the runtime, both individually and in combination. We also compare the resulting runtime against state of the art OpenMP implementations, showing equivalent or better performance, especially for fine-grained tasks.CCS Concepts: • Computing methodologies → Parallel programming languages.

show abstract

“…Systems such as [33] are particularly concerned with data access pattern issues, as their operations are mostly uniform among threads. We do not discuss task scheduling, as we do not rely on approaches such as delegation [6,25] or flat-combining [19,14], which do bring concerns related to this issue because of the non-uniform work division among threads.…”

Section: Related Workmentioning

confidence: 99%

Layering Data Structures over Skip Graphs for Increased NUMA Locality

Thomas

Mendes

2019

Proceedings of the 2019 ACM Symposium on Principles of Distributed Computing

View full text Add to dashboard Cite

We present a technique based on layering thread-local, sequential maps over variants of skip graphs in order to increase NUMA locality in concurrent data structures. Thread-local maps are used to "jump" into an underlying, concurrent skip graph near to where the insertions/removals/searches take place or complete. The skip graph is constrained in height and employs a data partitioning scheme that increases NUMA locality and reduces synchronization overhead. Our numbers indicate a 70% of reduction on the number of remote CAS operations, and a 41.4% increase in CAS success rate for 92 threads compared to skip lists in high contention.Besides, qualitatively speaking, our locality improvements are such that the larger the distance between two NUMA nodes, the bigger the reduction in remote accesses between threads pinned to those nodes. We implemented lazy and non-lazy variations of our technique, and our lazy version operates at least 80% faster under high-contention settings (32% of operations being successful updates on a 2 10 -sized structure), and at least 32% faster under low-contention/lowupdate settings (4% of operations being successful updates on a 2 17 -sized structure) with 96 threads. We also developed an additional skip graph variant, which we called sparse skip graph, that causes our thread-local maps as well as our shared structure to become simultaneously more sparse, performing more than 2.5 times faster than competing NUMA-aware approaches in lower-contention/low-update settings.

show abstract

Queue Delegation Locking

Cited by 13 publications

References 28 publications

ComposableThreads: Rethinking User-level Threads with Composability and Parametricity in C++

ComposableThreads: Rethinking User-level Threads with Composability and Parametricity in C++

Advanced synchronization techniques for task-based runtime systems

Layering Data Structures over Skip Graphs for Increased NUMA Locality

Contact Info

Product

Resources

About