Proving Lock-Freedom Easily and Automatically

Jia, Xiao; Li, Wei; Vafeiadis, Viktor

doi:10.1145/2676724.2693179

Cited by 6 publications

(4 citation statements)

References 17 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Automated techniques have been introduced for proving both correctness (e.g., [2,8,13,40]) and progress (e.g., [22,27]) properties of non-blocking data structures. In this work, we focus on the progress property of lock-freedom, a liveness property that ensures absence of livelocks: Despite interleaved execution of multiple threads altering the data structure, some thread is guaranteed to complete its operation eventually.…”

Section: Non-blocking Data Structuresmentioning

confidence: 99%

“…They describe its verification for a fixed number of threads and a given progress bound using model checking, but leave finding the bound to the user. Existing approaches for automatically proving progress properties like the ones presented in [22,27] are limited to eventual (unbounded) progress. To our knowledge, bounded progress guarantees have not been inferred automatically before.…”

Section: Non-blocking Data Structuresmentioning

confidence: 99%

See 1 more Smart Citation

Rely-guarantee bound analysis of parameterized concurrent shared-memory programs

Pani

Weißenbacher

Zuleger

2021

Form Methods Syst Des

View full text Add to dashboard Cite

We present a thread-modular proof method for complexity and resource bound analysis of concurrent, shared-memory programs. To this end, we lift Jones’ rely-guarantee reasoning to assumptions and commitments capable of expressing bounds. The compositionality (thread-modularity) of this framework allows us to reason about parameterized programs, i.e., programs that execute arbitrarily many concurrent threads. We automate reasoning in our logic by reducing bound analysis of concurrent programs to the sequential case. As an application, we automatically infer time complexity for a family of fine-grained concurrent algorithms, lock-free data structures, to our knowledge for the first time.

show abstract

Section: Non-blocking Data Structuresmentioning

confidence: 99%

Section: Non-blocking Data Structuresmentioning

confidence: 99%

Rely-guarantee bound analysis of parameterized concurrent shared-memory programs

Pani

Weißenbacher

Zuleger

2021

Form Methods Syst Des

View full text Add to dashboard Cite

show abstract

“…We do not consider the lack of the formal proofs of progress guarantees a major issue. Although it is possible to write such proofs (see [18] for a comprehensive analysis), we find it much easier to discuss this question separately.…”

Section: Progress Guaranteesmentioning

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%

A Formally-Verified Framework for Fair Synchronization in Kotlin Coroutines

Koval¹,

Khalanskiy²,

Alistarh³

2021

Preprint

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