Verifying Lock-Freedom Using Well-Founded Orders

Colvin, Robert; Dongol, Brijesh

doi:10.1007/978-3-540-75292-9_9

Cited by 5 publications

(6 citation statements)

References 18 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Further, even for algorithms without nested loops, such as the MSqueue, we do not really need to come up with a custom global well-founded order because the default heap path decrementing heuristic explained in Section 4.2 suffices. In an earlier paper [1], the same authors verified the Treiber stack using just a global well-founded order, but as the authors themselves admit in their next paper [2] the global approach it too difficult to apply for more advanced algorithms.…”

Section: Related Workmentioning

confidence: 99%

“…The literature contains a few approaches for verifying lockfreedom, but these are unnecessarily complicated and difficult to automate. We discuss them in detail in Section 6, but it suffices to say that they involve either a global termination argument (e.g., [1,2]) or non-trivial extensions to previously known concurrent program logics (e.g., [4,9,10]).…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Proving Lock-Freedom Easily and Automatically

Jia

Vafeiadis

2015

Proceedings of the 2015 Conference on Certified Programs and Proofs

View full text Add to dashboard Cite

Lock-freedom is a liveness property satisfied by most non-blocking concurrent algorithms. It ensures that at any point at least one thread is making progress towards termination; so the system as a whole makes progress.As a global property, lock-freedom is typically shown by global proofs or complex iterated arguments. We show that this complexity is not needed in practice. By introducing simple loop depth counters into the programs, we can reduce proving lock-freedom to checking simple local properties on those counters. We have implemented the approach in CAVE and report on our findings.

show abstract

Section: Related Workmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

Proving Lock-Freedom Easily and Automatically

Jia

Vafeiadis

2015

Proceedings of the 2015 Conference on Certified Programs and Proofs

View full text Add to dashboard Cite

show abstract

“…Colvin and Dongol [7] have recently proved the most basic nonblocking algorithm, Treiber's stack [33], to be lock-free. They did this by manually constructing a global well-founded ordering over program counters and local variables of all the threads in the algorithm's most general client.…”

Section: Related Workmentioning

confidence: 99%

Proving that non-blocking algorithms don't block

Gotsman

Cook

Parkinson

et al. 2009

Proceedings of the 36th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages

View full text Add to dashboard Cite

A concurrent data-structure implementation is considered nonblocking if it meets one of three following liveness criteria: waitfreedom, lock-freedom, or obstruction-freedom. Developers of nonblocking algorithms aim to meet these criteria. However, to date their proofs for non-trivial algorithms have been only manual pencil-and-paper semi-formal proofs. This paper proposes the first fully automatic tool that allows developers to ensure that their algorithms are indeed non-blocking. Our tool uses rely-guarantee reasoning while overcoming the technical challenge of sound reasoning in the presence of interdependent liveness properties.

show abstract

“…Colvin and Dongol [10], [34] use manually-derived global well-founded orderings and temporal logic to prove the lockfreedom of Treiber's stack [6], Michael and Scott's queue [7], and a bounded array-based queue. Their technique is a nonmodular whole program analysis of the most general client of the data structure.…”

Section: Related Workmentioning

confidence: 99%

“…Classically, verification of lock-freedom is reduced to modelchecking liveness properties on whole-program execution traces [10], [11], [12]. Recently, Gotsman et al [13] have argued that lock-freedom can be reduced to modular, threadlocal termination proofs of concurrent programs in which each thread only executes a single data-structure operation.…”

Section: Introductionmentioning

confidence: 99%

Quantitative Reasoning for Proving Lock-Freedom

Hoffmann

Marmar

Shao

2013

2013 28th Annual ACM/IEEE Symposium on Logic in Computer Science

View full text Add to dashboard Cite

Abstract-This article describes a novel quantitative proof technique for the modular and local verification of lock-freedom. In contrast to proofs based on temporal rely-guarantee requirements, this new quantitative reasoning method can be directly integrated in modern program logics that are designed for the verification of safety properties. Using a single formalism for verifying memory safety and lock-freedom allows a combined correctness proof that verifies both properties simultaneously.This article presents one possible formalization of this quantitative proof technique by developing a variant of concurrent separation logic (CSL) for total correctness. To enable quantitative reasoning, CSL is extended with a predicate for affine tokens to account for, and provide an upper bound on the number of loop iterations in a program. Lock-freedom is then reduced to total-correctness proofs. Quantitative reasoning is demonstrated in detail, both informally and formally, by verifying the lockfreedom of Treiber's non-blocking stack. Furthermore, it is shown how the technique is used to verify the lock-freedom of more advanced shared-memory data structures that use eliminationbackoff schemes and hazard-pointers.

show abstract

Verifying Lock-Freedom Using Well-Founded Orders

Cited by 5 publications

References 18 publications

Proving Lock-Freedom Easily and Automatically

Proving Lock-Freedom Easily and Automatically

Proving that non-blocking algorithms don't block

Quantitative Reasoning for Proving Lock-Freedom

Contact Info

Product

Resources

About