scholarly journals Connectivity graphs: a method for proving deadlock freedom based on separation logic

2022 ◽  
Vol 6 (POPL) ◽  
pp. 1-33
Author(s):  
Jules Jacobs ◽  
Stephanie Balzer ◽  
Robbert Krebbers

We introduce the notion of a connectivity graph —an abstract representation of the topology of concurrently interacting entities, which allows us to encapsulate generic principles of reasoning about deadlock freedom . Connectivity graphs are parametric in their vertices (representing entities like threads and channels) and their edges (representing references between entities) with labels (representing interaction protocols). We prove deadlock and memory leak freedom in the style of progress and preservation and use separation logic as a meta theoretic tool to treat connectivity graph edges and labels substructurally. To prove preservation locally, we distill generic separation logic rules for local graph transformations that preserve acyclicity of the connectivity graph. To prove global progress locally, we introduce a waiting induction principle for acyclic connectivity graphs. We mechanize our results in Coq, and instantiate our method with a higher-order binary session-typed language to obtain the first mechanized proof of deadlock and leak freedom.

2021 ◽  
Vol 5 (POPL) ◽  
pp. 1-29
Author(s):  
Léon Gondelman ◽  
Simon Oddershede Gregersen ◽  
Abel Nieto ◽  
Amin Timany ◽  
Lars Birkedal

Author(s):  
Lars Birkedal ◽  
Bernhard Reus ◽  
Jan Schwinghammer ◽  
Hongseok Yang

Author(s):  
William Mansky ◽  
Wolf Honoré ◽  
Andrew W. Appel

AbstractSeparation logic is a useful tool for proving the correctness of programs that manipulate memory, especially when the model of memory includes higher-order state: Step-indexing, predicates in the heap, and higher-order ghost state have been used to reason about function pointers, data structure invariants, and complex concurrency patterns. On the other hand, the behavior of system features (e.g., operating systems) and the external world (e.g., communication between components) is usually specified using first-order formalisms. In principle, the soundness theorem of a separation logic is its interface with first-order theorems, but the soundness theorem may implicitly make assumptions about how other components are specified, limiting its use. In this paper, we show how to extend the higher-order separation logic of the Verified Software Toolchain to interface with a first-order verified operating system, in this case CertiKOS, that mediates its interaction with the outside world. The resulting system allows us to prove the correctness of C programs in separation logic based on the semantics of system calls implemented in CertiKOS. It also demonstrates that the combination of interaction trees + CompCert memories serves well as a lingua franca to interface and compose two quite different styles of program verification.


Sign in / Sign up

Export Citation Format

Share Document