Specifying concurrent programs in separation logic: morphisms and simulations

In addition to pre- and postconditions, program specifications in recent separation logics for concurrency have employed an algebraic structure of resources—a form of state transition systems—to describe the state-based program invariants that must be preserved, and to record the permissible atomic changes to program state. In this paper we introduce a novel notion of resource morphism, i.e. structure-preserving function on resources, and show how to effectively integrate it into separation logic, using an associated notion of morphism-specific simulation. We apply morphisms and simulations to programs verified under one resource, to compositionally adapt them to operate under another resource, thus facilitating proof reuse.

[1]  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.

[2]  Thomas A. Henzinger,et al.  Interface automata , 2001, ESEC/FSE-9.

[3]  Michael L. Scott,et al.  Algorithms for scalable synchronization on shared-memory multiprocessors , 1991, TOCS.

[4]  Stephen D. Brookes,et al.  A Semantics for Concurrent Separation Logic , 2004, CONCUR.

[5]  Martín Abadi,et al.  The existence of refinement mappings , 1988, [1988] Proceedings. Third Annual Information Symposium on Logic in Computer Science.

[6]  Alexey Gotsman,et al.  Proving Linearizability Using Partial Orders , 2017, ESOP.

[7]  Bruno Barras,et al.  The Implicit Calculus of Constructions as a Programming Language with Dependent Types , 2008, FoSSaCS.

[8]  Xinyu Feng,et al.  Progress of concurrent objects with partial methods , 2018, Proc. ACM Program. Lang..

[9]  Nicolas Tabareau,et al.  Definitional proof-irrelevance without K , 2019, Proc. ACM Program. Lang..

[10]  Yves Bertot,et al.  Interactive Theorem Proving and Program Development: Coq'Art The Calculus of Inductive Constructions , 2010 .

[11]  Lars Birkedal,et al.  Modular Reasoning about Separation of Concurrent Data Structures , 2013, ESOP.

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

[13]  Frank Piessens,et al.  Expressive modular fine-grained concurrency specification , 2011, POPL '11.

[14]  David Lorge Parnas,et al.  Concurrent control with “readers” and “writers” , 1971, CACM.

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

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

[17]  Charles Antony Richard Hoare Towards a theory of parallel programming , 2002 .

[18]  Jan J. M. M. Rutten,et al.  Universal coalgebra: a theory of systems , 2000, Theor. Comput. Sci..

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

[20]  Xinyu Feng,et al.  A rely-guarantee-based simulation for verifying concurrent program transformations , 2012, POPL '12.

[21]  Thomas Shrimpton,et al.  Building a Collision-Resistant Compression Function from Non-compressing Primitives , 2008, ICALP.

[22]  Robin Milner,et al.  A Theory of Type Polymorphism in Programming , 1978, J. Comput. Syst. Sci..

[23]  BanerjeeAnindya,et al.  Specifying concurrent programs in separation logic: morphisms and simulations , 2019 .

[24]  François Pottier Hiding Local State in Direct Style: A Higher-Order Anti-Frame Rule , 2008, 2008 23rd Annual IEEE Symposium on Logic in Computer Science.

[25]  Zhong Shao,et al.  Certified concurrent abstraction layers , 2018, PLDI.

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

[27]  Ilya Sergey,et al.  Hoare-style specifications as correctness conditions for non-linearizable concurrent objects , 2016, OOPSLA.

[28]  허진호 [參觀記] European Conference on Object Oriented Programming 참관기 , 1988 .

[29]  Hongseok Yang,et al.  A step-indexed Kripke model of hidden state , 2013, Math. Struct. Comput. Sci..

[30]  Stephen Brookes A semantics for concurrent separation logic , 2007, Theor. Comput. Sci..

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

[32]  Lars Birkedal,et al.  Iron: managing obligations in higher-order concurrent separation logic , 2019, Proc. ACM Program. Lang..

[33]  Hugo Herbelin,et al.  The Coq proof assistant : reference manual, version 6.1 , 1997 .

[34]  Maurice Herlihy,et al.  Counting networks , 1994, JACM.

[35]  John Derrick,et al.  How to Prove Algorithms Linearisable , 2012, CAV.

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

[37]  Maurice Herlihy,et al.  The art of multiprocessor programming , 2020, PODC '06.

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

[39]  Peter Müller,et al.  Viper: A Verification Infrastructure for Permission-Based Reasoning , 2016, VMCAI.

[40]  Constantin Enea,et al.  Proving Linearizability Using Forward Simulations , 2017, CAV.

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

[42]  Frank Pfenning,et al.  Intensionality, extensionality, and proof irrelevance in modal type theory , 2001, Proceedings 16th Annual IEEE Symposium on Logic in Computer Science.

[43]  Pierre Castéran,et al.  Interactive Theorem Proving and Program Development , 2004, Texts in Theoretical Computer Science An EATCS Series.

[44]  Lars Birkedal,et al.  Partiality, State and Dependent Types , 2011, TLCA.

[45]  Nancy A. Lynch,et al.  Forward and Backward Simulations, II: Timing-Based Systems , 1996, Inf. Comput..

[46]  Hongseok Yang,et al.  Parameterised Linearisability , 2014, ICALP.

[47]  Nir Shavit,et al.  Flat combining and the synchronization-parallelism tradeoff , 2010, SPAA '10.

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

[49]  Ilya Sergey,et al.  Programming and proving with distributed protocols , 2017, Proc. ACM Program. Lang..

[50]  Xinyu Feng,et al.  Compositional verification of termination-preserving refinement of concurrent programs , 2014, CSL-LICS.

[51]  Mark Moir,et al.  Concurrent Data Structures , 2004 .

[52]  Song Jiang,et al.  Wormhole: A Fast Ordered Index for In-memory Data Management , 2018 .

[53]  Peter W. O'Hearn,et al.  Local Reasoning about Programs that Alter Data Structures , 2001, CSL.

[54]  Lars Birkedal,et al.  Polymorphism and separation in hoare type theory , 2006, ICFP '06.

[55]  Xinyu Feng,et al.  Modular verification of linearizability with non-fixed linearization points , 2013, PLDI 2013.

[56]  Lars Birkedal,et al.  ReLoC: A Mechanised Relational Logic for Fine-Grained Concurrency , 2018, LICS.

[57]  Maurice Herlihy,et al.  Linearizability: a correctness condition for concurrent objects , 1990, TOPL.

[58]  Frank Piessens,et al.  VeriFast: A Powerful, Sound, Predictable, Fast Verifier for C and Java , 2011, NASA Formal Methods.

[59]  Lars Birkedal,et al.  Iris from the ground up: A modular foundation for higher-order concurrent separation logic , 2018, Journal of Functional Programming.

[60]  Ana Sokolova,et al.  Coalgebraic Components in a Many-Sorted Microcosm , 2009, CALCO.

[61]  M. Dal Cin,et al.  The Algebraic Theory of Automata , 1980 .

[62]  Nancy A. Lynch,et al.  Forward and Backward Simulations: I. Untimed Systems , 1995, Inf. Comput..

[63]  John Derrick,et al.  Mechanically verified proof obligations for linearizability , 2011, TOPL.

[64]  Bart Jacobs,et al.  Introduction to Coalgebra: Towards Mathematics of States and Observation , 2016, Cambridge Tracts in Theoretical Computer Science.

[65]  Peter W. O'Hearn,et al.  Blaming the client: on data refinement in the presence of pointers , 2009, Formal Aspects of Computing.

[66]  Peter W. O'Hearn,et al.  Resources, Concurrency and Local Reasoning , 2004, CONCUR.

[67]  N. Lynch,et al.  Forward and backward simulations , 1993 .

[68]  Marieke Huisman,et al.  Verification of Shared-Reading Synchronisers , 2018, MeTRiD@ETAPS.

[69]  Yu Guo,et al.  Deep Specifications and Certified Abstraction Layers , 2015, POPL.

[70]  Ilya Sergey,et al.  Communicating State Transition Systems for Fine-Grained Concurrent Resources , 2014, ESOP.

[71]  Hongseok Yang,et al.  Linearizability with Ownership Transfer , 2012, CONCUR.

[72]  Lars Birkedal,et al.  Ynot: dependent types for imperative programs , 2008, ICFP.

[73]  Radha Jagadeesan,et al.  Between Linearizability and Quiescent Consistency - Quantitative Quiescent Consistency , 2014, ICALP.

[74]  Adrian Colbrook,et al.  Concurrent Data Structures , 1991, ICCI.

[75]  Peter W. O'Hearn,et al.  Abstraction for concurrent objects , 2009, Theor. Comput. Sci..

[76]  Richard Bornat,et al.  Separation logic and concurrency , 2010 .

[77]  Ilya Sergey,et al.  Concurrent Data Structures Linked in Time , 2017, ECOOP.

[78]  Thomas A. Henzinger,et al.  Aspect-Oriented Linearizability Proofs , 2013, CONCUR.

[79]  Aleksandar Nanevski,et al.  Subjective auxiliary state for coarse-grained concurrency , 2013, POPL.