Proving that non-blocking algorithms don't block

A concurrent data-structure implementation is considered non-blocking if it meets one of three following liveness criteria: wait-freedom, lock-freedom, or obstruction-freedom. Developers of non-blocking 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.

[1]  Maged M. Michael,et al.  High performance dynamic lock-free hash tables and list-based sets , 2002, SPAA '02.

[2]  Amir Pnueli,et al.  The Glory of the Past , 1985, Logic of Programs.

[3]  Maurice Herlihy,et al.  Obstruction-free synchronization: double-ended queues as an example , 2003, 23rd International Conference on Distributed Computing Systems, 2003. Proceedings..

[4]  Peter W. O'Hearn,et al.  Automatic Termination Proofs for Programs with Shape-Shifting Heaps , 2006, CAV.

[5]  Xinyu Feng,et al.  On the Relationship Between Concurrent Separation Logic and Assume-Guarantee Reasoning , 2007, ESOP.

[6]  Maurice Herlihy,et al.  Wait-free synchronization , 1991, TOPL.

[7]  Peter Baumgartner,et al.  Workshop on Disproving: Non-Theorems, Non-Validity, Non-Provability , 2004 .

[8]  William N. Scherer,et al.  Scalable synchronous queues , 2006, PPoPP '06.

[9]  Calton Pu,et al.  A Lock-Free Multiprocessor OS Kernel (Abstract) , 1992, ACM SIGOPS Oper. Syst. Rev..

[10]  Nir Shavit,et al.  A scalable lock-free stack algorithm , 2004, SPAA '04.

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

[12]  Moshe Y. Vardi.  Verification of Concurrent Programs: The Automata-Theoretic Framework , 1991, Ann. Pure Appl. Log..

[13]  Peter W. O'Hearn,et al.  Local Action and Abstract Separation Logic , 2007, 22nd Annual IEEE Symposium on Logic in Computer Science (LICS 2007).

[14]  Maged M. Michael,et al.  Simple, fast, and practical non-blocking and blocking concurrent queue algorithms , 1996, PODC '96.

[15]  William N. Scherer,et al.  Scalable synchronous queues , 2009, Commun. ACM.

[16]  Viktor Vafeiadis,et al.  Modular fine-grained concurrency verification , 2008 .

[17]  Zohar Manna,et al.  The Temporal Logic of Reactive and Concurrent Systems , 1991, Springer New York.

[18]  Stephen D. Brookes,et al.  Full abstraction for a shared variable parallel language , 1993, [1993] Proceedings Eighth Annual IEEE Symposium on Logic in Computer Science.

[19]  H. R. Simpson.  Four-slot fully asynchronous communication mechanism , 1990 .

[20]  Brijesh Dongol.  Formalising Progress Properties of Non-blocking Programs , 2006, ICFEM.

[21]  Alexey Gotsman,et al.  Thread-modular shape analysis , 2007, PLDI '07.

[22]  Davide Sangiorgi,et al.  A hybrid type system for lock-freedom of mobile processes , 2008, TOPL.

[23]  Mark Moir,et al.  Formal Verification of a Practical Lock-Free Queue Algorithm , 2004, FORTE.

[24]  Edmund M. Clarke,et al.  Arithmetic Strengthening for Shape Analysis , 2007, SAS.

[25]  Tom Ridge,et al.  The semantics of x86-CC multiprocessor machine code , 2009, POPL '09.

[26]  Amir Pnueli,et al.  In Transition From Global to Modular Temporal Reasoning about Programs , 1989, Logics and Models of Concurrent Systems.

[27]  Martín Abadi,et al.  Conjoining specifications , 1995, TOPL.

[28]  Davide Sangiorgi,et al.  A Hybrid Type System for Lock-Freedom of Mobile Processes , 2008, CAV.

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

[30]  Eran Yahav,et al.  Deriving linearizable fine-grained concurrent objects , 2008, PLDI '08.

[31]  Viktor Vafeiadis,et al.  Modular Safety Checking for Fine-Grained Concurrency , 2007, SAS.

[32]  Bowen Alpern,et al.  Defining Liveness , 1984, Inf. Process. Lett..

[33]  Anna Philippou,et al.  Tools and Algorithms for the Construction and Analysis of Systems , 2018, Lecture Notes in Computer Science.

[34]  J. S. Moore,et al.  A Mechanically Checked Proof of a Multiprocessor Result via a Uniprocessor View , 1999, Formal Methods Syst. Des..

[35]  Stephen D. Brookes.  Full Abstraction for a Shared-Variable Parallel Language , 1996, Inf. Comput..

[36]  Andreas Podelski,et al.  Proving that programs eventually do something good , 2007, POPL '07.

[37]  Jan Maluszy¿ski.  Verification, Model Checking, and Abstract Interpretation , 2009, Lecture Notes in Computer Science.

[38]  Calton Pu,et al.  A Lock-Free Multiprocessor OS Kernel , 1992, OPSR.

[39]  Kenneth L. McMillan,et al.  Circular Compositional Reasoning about Liveness , 1999, CHARME.

[40]  Robert Colvin,et al.  Verifying Lock-Freedom Using Well-Founded Orders , 2007, ICTAC.

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

[42]  Keir Fraser,et al.  A Practical Multi-word Compare-and-Swap Operation , 2002, DISC.

[43]  Cliff B. Jones,et al.  Specification and Design of (Parallel) Programs , 1983, IFIP Congress.

[44]  Viktor Vafeiadis,et al.  A Marriage of Rely/Guarantee and Separation Logic , 2007, CONCUR.