Scalable FIFO Channels for Programming via Communicating Sequential Processes

Koval, Nikita; Alistarh, Dan; Elizarov, Roman

doi:10.1007/978-3-030-29400-7_23

Cited by 6 publications

(4 citation statements)

References 17 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…In the asynchronous mode, resume(..) finishes immediately (line 20). In the synchronous mode, it waits in a bounded loop waiting for the value to be taken and finishes if it happens (lines [23][24]. If the value has not been taken, the operation attempts to break the cell and fail, completing successfully if the value was taken after all and the corresponding CAS fails (line 26).…”

Section: B1 Extension To the Basic Cqsmentioning

confidence: 99%

“…Then, it locates the required segment by following the chain of next pointers starting from the one already read before the increment, updating suspendSegm if required (line 10). The findAndMoveForwardSusp(..) implementation is straightforward -it finds the required segment first (lines [18][19][20][21][22][23][24], creating new segments if needed (lines [22][23], and then updates suspendSegm to the one that was found if it has not been updated to it or one of the later segments yet (lines 26-29).…”

Section: C1 Basics Algorithm Without Cancellationmentioning

confidence: 99%

“…At the algorithmic level, our CQS implementation builds on ideas from both the classic Michael-Scott queue [32] and the highly-efficient LCRQ queue design of Afek and Morrison [33]. The latter was also used by Izraelevitz and Scott [16] to build blocking synchronous queues, and by Koval et al [24] to build channels. The CQS supports much more general semantics, requiring significant changes to the design, in particular to support cancellations.…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

A Formally-Verified Framework for Fair Synchronization in Kotlin Coroutines

Koval¹,

Khalanskiy²,

Alistarh³

2021

Preprint

Self Cite

View full text Add to dashboard Cite

Writing concurrent code that is both correct and efficient is notoriously difficult: thus, programmers often prefer to use synchronization abstractions, which render code simpler and easier to reason about. Despite a wealth of work on this topic, there is still a gap between the rich semantics provided by synchronization abstractions in modern programming languages-specifically, fair FIFO ordering of synchronization requests and support for abortable operations-and frameworks for implementing such semantics correctly and efficiently. Supporting such semantics is critical given the rising popularity of constructs for asynchronous programming, such as coroutines, which abort frequently, and should be cheaper to suspend and resume compared to native threads. We introduce a new framework called the CancellableQueueSynchronizer (CQS), which enables efficient fair and abortable implementations of fundamental synchronization primitives such as mutexes, semaphores, barriers, count-down-latches, and blocking pools. Our first contribution is algorithmic, as implementing both fairness and abortability efficiently at this level of generality is non-trivial. Importantly, all our algorithms come with formal proofs in the Iris framework for Coq. These proofs are modular, so it is easy to prove correctness for new primitives implemented on top of CQS. To validate practical impact, we integrated CQS into the Kotlin Coroutines library. Compared against Java's AbstractQueuedSynchronizer, the only practical abstraction to provide similar semantics, CQS shows significant improvements across all benchmarks, of up to two orders of magnitude. In sum, CQS is the first framework to combine expressiveness with formal guarantees and strong practical performance, and should be extensible to other languages and other families of synchronization primitives.

show abstract

Section: B1 Extension To the Basic Cqsmentioning

confidence: 99%

Section: C1 Basics Algorithm Without Cancellationmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

A Formally-Verified Framework for Fair Synchronization in Kotlin Coroutines

Koval¹,

Khalanskiy²,

Alistarh³

2021

Preprint

Self Cite

View full text Add to dashboard Cite

show abstract

“…Infinite array. To simulate an infinite array, we can use the approach used for synchronous queues in [11], maintaining a Michael-Scott linked list of numbered segments. Each segment contains 𝐾 element cells and has a unique id (thus, segm.next.id = segm.id + 1), and the counter value 𝑖 corresponds to cell 𝑖 modulo 𝐾 in the segment with id equals to 𝑖/𝐾.…”

Section: Memory-friendly Bounded Queue Algorithmmentioning

confidence: 99%

Memory-Optimal Non-Blocking Queues

Aksenov¹,

Koval²,

Kuznetsov³

et al. 2021

Preprint

Self Cite

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

Lincheck: A Practical Framework for Testing Concurrent Data Structures on JVM

Koval

Федоров

Sokolova

et al. 2023

Lecture Notes in Computer Science

View full text Add to dashboard Cite

This paper presents , a new practical and user-friendly framework for testing concurrent algorithms on the Java Virtual Machine (JVM). provides a simple and declarative way to write concurrent tests: instead of describing how to perform the test, users specify what to test by declaring all the operations to examine; the framework automatically handles the rest. As a result, tests written with are concise and easy to understand. The framework automatically generates a set of concurrent scenarios, examines them using stress-testing or bounded model checking, and verifies that the results of each invocation are correct. Notably, if an error is detected via model checking, provides an easy-to-follow trace to reproduce it, significantly simplifying the bug investigation.To the best of our knowledge, is the first production-ready tool on the JVM that offers such a simple way of writing concurrent tests, without requiring special skills or expertise. We successfully integrated in the development process of several large projects, such as Kotlin Coroutines, and identified new bugs in popular concurrency libraries, such as a race in Java’s standard and a liveliness bug in Java’s framework, which is used in most of the synchronization primitives. We believe that can significantly improve the quality and productivity of concurrent algorithms research and development and become the state-of-the-art tool for checking their correctness.

show abstract

Scalable FIFO Channels for Programming via Communicating Sequential Processes

Cited by 6 publications

References 17 publications

A Formally-Verified Framework for Fair Synchronization in Kotlin Coroutines

A Formally-Verified Framework for Fair Synchronization in Kotlin Coroutines

Memory-Optimal Non-Blocking Queues

Lincheck: A Practical Framework for Testing Concurrent Data Structures on JVM

Contact Info

Product

Resources

About