Mechanized verification of fine-grained concurrent programs

Abstract

Efficient concurrent programs and data structures rarely employ coarse-grained synchronization mechanisms (i.e., locks); instead, they implement custom synchronization patterns via fine-grained primitives, such as compare-and-swap. Due to sophisticated interference scenarios between threads, reasoning about such programs is challenging and error-prone, and can benefit from mechanization.In this paper, we present the first completely formalized framework for mechanized verification of full functional correctness of fine-grained concurrent programs. Our tool is based on the recently proposed program logic FCSL. It is implemented as an embedded domain-specific language in the dependently-typed language of the Coq proof assistant, and is powerful enough to reason about programming features such as higher-order functions and local thread spawning. By incorporating a uniform concurrency model, based on state-transition systems and partial commutative monoids, FCSL makes it possible to build proofs about concurrent libraries in a thread-local, compositional way, thus facilitating scalability and reuse: libraries are verified just once, and their specifications are used ubiquitously in client-side reasoning. We illustrate the proof layout in FCSL by example, and report on our experience of using FCSL to verify a number of concurrent algorithms and data structures.

Iris from the ground up: A modular foundation for higher-order concurrent separation logic

“…FCSL (Sergey et al, 2015) takes an opposite approach to our base logic. To ease reasoning about programs in a proof assistant, they avoid reasoning in separation logic as much as possible, and reason mostly in the ambient logic (in their case, the Coq logic).…”

Dijkstra monads forever: termination-sensitive specifications for interaction trees

“…There is also a vast body of prior work on Coq-based Proof Frameworks for program correctness. Systems like YNot [Malecha et al 2011], based on Hoare Type Theory, Iris [Jung et al 2016], VST [Appel 2014], and FCSL [Sergey et al 2015], all based on concurrent separation logic, and CertiKOS [Gu et al 2016] [Gu et al 2019], which uses certified abstraction layers, have had major success in the field of large scale program verification. Those models typically rely on smallstep, relationally-specified operational semantics, and are especially useful for reasoning about concurrent programsÐa domain that is still being explored for ITrees.…”

“…To date, numerous proof frameworks have been developed to facilitate these kinds of verification efforts. In the realm of Coq, prominent examples include YNot [Malecha et al 2011], FCSL [Sergey et al 2015], VST [Appel 2014] and Iris [Jung et al 2016]. In the context of F ★ , Dijkstra monads [Swamy et al 2013] have been shown to be an effective way to reason about (impure) programs.…”

Automated Verification of Parallel Nested DFS

“…Raad et al [38] verified four concurrent graph algorithms in the context of CoLoSL, but the proofs have not been automated. Sergey et al [42] verified a concurrent spanning tree algorithm, but interactively, through an embedding in Coq.…”