An Abstraction Technique for Describing Concurrent Program Behaviour

This paper presents a technique to reason about functional properties of shared-memory concurrent software by means of abstraction. The abstract behaviour of the program is described using process algebras. In the program we indicate which concrete atomic steps correspond to the actions that are used in the process algebra term. Each action comes with a specification that describes its effect on the shared state. Program logics are used to show that the concrete program steps adhere to this specification. Separately, we also use program logics to prove that the program behaves as described by the process algebra term. Finally, via process algebraic reasoning we derive properties that hold for the program from its abstraction. This technique allows reasoning about the behaviour of highly concurrent, non-deterministic and possibly non-terminating programs. The paper discusses various verification examples to illustrate our approach. The verification technique is implemented as part of the VerCors toolset. We demonstrate that our technique is capable of verifying data- and control-flow properties that are hard to verify with alternative approaches, especially with mechanised tool support.

[1]  Jan Friso Groote,et al.  The Syntax and Semantics of μCRL , 1995 .

[2]  G. G. Stokes "J." , 1890, The New Yale Book of Quotations.

[3]  Marieke Huisman,et al.  Permission-Based Separation Logic for Multithreaded Java Programs , 2014, Log. Methods Comput. Sci..

[4]  Viktor Vafeiadis,et al.  Concurrent Abstract Predicates , 2010, ECOOP.

[5]  Nobuko Yoshida,et al.  Multiparty asynchronous session types , 2008, POPL '08.

[6]  Cliff B. Jones,et al.  Tentative steps toward a development method for interfering programs , 1983, TOPL.

[7]  Marieke Huisman,et al.  History-Based Verification of Functional Behaviour of Concurrent Programs , 2015, SEFM.

[8]  John C. Reynolds,et al.  Separation logic: a logic for shared mutable data structures , 2002, Proceedings 17th Annual IEEE Symposium on Logic in Computer Science.

[9]  Xinyu Feng,et al.  Deny-Guarantee Reasoning , 2009, ESOP.

[10]  Marieke Huisman,et al.  The VerCors Tool Set: Verification of Parallel and Concurrent Software , 2017, IFM.

[11]  Jan Friso Groote,et al.  The Syntax and Semantics of mCRL , 1994 .

[12]  Jan Friso Groote,et al.  Modeling and Analysis of Communicating Systems , 2014 .

[13]  Marina Zaharieva Stojanovski Closer to reliable software: verifying functional behaviour of concurrent programs , 2015 .

[14]  Mirko Viroli,et al.  Type-based Self-stabilisation for Computational Fields , 2015, Log. Methods Comput. Sci..

[15]  Lars Birkedal,et al.  Impredicative Concurrent Abstract Predicates , 2014, ESOP.

[16]  Nobuko Yoshida,et al.  Verification of MPI Programs Using Session Types , 2012, EuroMPI.

[17]  Lars Birkedal,et al.  The Essence of Higher-Order Concurrent Separation Logic , 2017, ESOP.

[18]  Marieke Huisman,et al.  The VerCors Tool for Verification of Concurrent Programs , 2014, FM.

[19]  John Tang Boyland,et al.  Checking Interference with Fractional Permissions , 2003, SAS.

[20]  Philippa Gardner,et al.  Steps in modular specifications for concurrent modules , 2015 .

[21]  Philippa Gardner,et al.  Steps in Modular Specifications for Concurrent Modules (Invited Tutorial Paper) , 2015, MFPS.

[22]  Ilya Sergey,et al.  Specifying and Verifying Concurrent Algorithms with Histories and Subjectivity , 2014, ESOP.

[23]  Lars Birkedal,et al.  Iris: Monoids and Invariants as an Orthogonal Basis for Concurrent Reasoning , 2015, POPL.

[24]  Alexey Gotsman,et al.  Local Reasoning for Storable Locks and Threads , 2007, APLAS.

[25]  Philippa Gardner,et al.  TaDA: A Logic for Time and Data Abstraction , 2014, ECOOP.

[26]  Jun Pang,et al.  Abstraction of parallel uniform processes with data , 2004, Proceedings of the Second International Conference on Software Engineering and Formal Methods, 2004. SEFM 2004..

[27]  Peter W. O'Hearn,et al.  Permission accounting in separation logic , 2005, POPL '05.

[28]  Ilya Sergey,et al.  Mechanized verification of fine-grained concurrent programs , 2015, PLDI.

[29]  Andrey Rybalchenko,et al.  Compositional Termination Proofs for Multi-threaded Programs , 2012, TACAS.

[30]  Peter W. O'Hearn,et al.  Resources, concurrency, and local reasoning , 2007 .

[31]  Lars Birkedal,et al.  Unifying refinement and hoare-style reasoning in a logic for higher-order concurrency , 2013, ICFP.