Abstract
Verifying fine-grained optimistic concurrent programs remains an open problem. Modern program logics provide abstraction mechanisms and compositional reasoning principles to deal with the inherent complexity. However, their use is mostly confined to pencil-and-paper or mechanized proofs. We devise a new separation logic geared towards the lacking automation. While local reasoning is known to be crucial for automation, we are the first to show how to retain this locality for (i) reasoning about inductive properties without the need for ghost code, and (ii) reasoning about computation histories in hindsight. We implemented our new logic in a tool and used it to automatically verify challenging concurrent search structures that require inductive properties and hindsight reasoning, such as the Harris set.
- Martín Abadi and Leslie Lamport. 1991. The Existence of Refinement Mappings. Theor. Comput. Sci., 82, 2 (1991), 253–284. https://doi.org/10.1016/0304-3975(91)90224-P
Google Scholar
Digital Library
- Parosh Aziz Abdulla, Frédéric Haziza, Lukás Holík, Bengt Jonsson, and Ahmed Rezine. 2013. An Integrated Specification and Verification Technique for Highly Concurrent Data Structures. In TACAS (LNCS, Vol. 7795). Springer, 324–338. https://doi.org/10.1007/978-3-642-36742-7_23
Google Scholar
Digital Library
- Parosh Aziz Abdulla, Bengt Jonsson, and Cong Quy Trinh. 2018. Fragment Abstraction for Concurrent Shape Analysis. In ESOP (LNCS, Vol. 10801). Springer, 442–471. https://doi.org/10.1007/978-3-319-89884-1_16
Google Scholar
Cross Ref
- Christian J. Bell, Andrew W. Appel, and David Walker. 2010. Concurrent Separation Logic for Pipelined Parallelization. In SAS (LNCS, Vol. 6337). Springer, 151–166. https://doi.org/10.1007/978-3-642-15769-1_10
Google Scholar
Cross Ref
- Ahmed Bouajjani, Michael Emmi, Constantin Enea, and Jad Hamza. 2013. Verifying Concurrent Programs against Sequential Specifications. In ESOP (LNCS, Vol. 7792). Springer, 290–309. https://doi.org/10.1007/978-3-642-37036-6_17
Google Scholar
Digital Library
- Ahmed Bouajjani, Michael Emmi, Constantin Enea, and Jad Hamza. 2015. On Reducing Linearizability to State Reachability. In ICALP (2) (LNCS, Vol. 9135). Springer, 95–107. https://doi.org/10.1007/978-3-662-47666-6_8
Google Scholar
Digital Library
- Ahmed Bouajjani, Michael Emmi, Constantin Enea, and Suha Orhun Mutluergil. 2017. Proving Linearizability Using Forward Simulations. In CAV (2) (LNCS, Vol. 10427). Springer, 542–563. https://doi.org/10.1007/978-3-319-63390-9_28
Google Scholar
Cross Ref
- Cristiano Calcagno, Peter W. O’Hearn, and Hongseok Yang. 2007. Local Action and Abstract Separation Logic. In LICS. IEEE Computer Society, 366–378. https://doi.org/10.1109/LICS.2007.30
Google Scholar
Digital Library
- Patrick Cousot and Radhia Cousot. 1977. Abstract Interpretation: A Unified Lattice Model for Static Analysis of Programs by Construction or Approximation of Fixpoints. In POPL. ACM, 238–252. https://doi.org/10.1145/512950.512973
Google Scholar
Digital Library
- Patrick Cousot and Radhia Cousot. 1979. Systematic Design of Program Analysis Frameworks. In POPL. ACM Press, 269–282. https://doi.org/10.1145/567752.567778
Google Scholar
Digital Library
- Tyler Crain, Vincent Gramoli, and Michel Raynal. 2013. A Contention-Friendly Binary Search Tree. In Euro-Par (LNCS, Vol. 8097). Springer, 229–240. https://doi.org/10.1007/978-3-642-40047-6_25
Google Scholar
Digital Library
- Tyler Crain, Vincent Gramoli, and Michel Raynal. 2016. A Fast Contention-Friendly Binary Search Tree. Parallel Process. Lett., 26, 3 (2016), 1650015:1–1650015:17. https://doi.org/10.1142/S0129626416500158
Google Scholar
Cross Ref
- Pedro da Rocha Pinto, Thomas Dinsdale-Young, and Philippa Gardner. 2014. TaDA: A Logic for Time and Data Abstraction. In ECOOP (LNCS, Vol. 8586). Springer, 207–231. https://doi.org/10.1007/978-3-662-44202-9_9
Google Scholar
Digital Library
- Leonardo Mendonça de Moura and Nikolaj S. Bjørner. 2008. Z3: An Efficient SMT Solver. In TACAS (LNCS, Vol. 4963). Springer, 337–340. https://doi.org/10.1007/978-3-540-78800-3_24
Google Scholar
Cross Ref
- Germán Andrés Delbianco, Ilya Sergey, Aleksandar Nanevski, and Anindya Banerjee. 2017. Concurrent Data Structures Linked in Time. In ECOOP (LIPIcs, Vol. 74). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 8:1–8:30. https://doi.org/10.4230/LIPIcs.ECOOP.2017.8
Google Scholar
Cross Ref
- Edsger W. Dijkstra. 1976. A Discipline of Programming. Prentice-Hall. isbn:013215871X https://www.worldcat.org/oclc/01958445
Google Scholar
- Thomas Dinsdale-Young, Lars Birkedal, Philippa Gardner, Matthew J. Parkinson, and Hongseok Yang. 2013. Views: compositional reasoning for concurrent programs. In POPL. ACM, 287–300. https://doi.org/10.1145/2429069.2429104
Google Scholar
Digital Library
- Thomas Dinsdale-Young, Pedro da Rocha Pinto, Kristoffer Just Andersen, and Lars Birkedal. 2017. Caper - Automatic Verification for Fine-Grained Concurrency. In ESOP (LNCS, Vol. 10201). Springer, 420–447. https://doi.org/10.1007/978-3-662-54434-1_16
Google Scholar
Digital Library
- Thomas Dinsdale-Young, Mike Dodds, Philippa Gardner, Matthew J. Parkinson, and Viktor Vafeiadis. 2010. Concurrent Abstract Predicates. In ECOOP (LNCS, Vol. 6183). Springer, 504–528. https://doi.org/10.1007/978-3-642-14107-2_24
Google Scholar
Cross Ref
- Tayfun Elmas, Shaz Qadeer, Ali Sezgin, Omer Subasi, and Serdar Tasiran. 2010. Simplifying Linearizability Proofs with Reduction and Abstraction. In TACAS (LNCS, Vol. 6015). Springer, 296–311. https://doi.org/10.1007/978-3-642-12002-2_25
Google Scholar
Digital Library
- Yotam M. Y. Feldman, Constantin Enea, Adam Morrison, Noam Rinetzky, and Sharon Shoham. 2018. Order out of Chaos: Proving Linearizability Using Local Views. In DISC (LIPIcs, Vol. 121). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 23:1–23:21. https://doi.org/10.4230/LIPIcs.DISC.2018.23
Google Scholar
Cross Ref
- Yotam M. Y. Feldman, Artem Khyzha, Constantin Enea, Adam Morrison, Aleksandar Nanevski, Noam Rinetzky, and Sharon Shoham. 2020. Proving highly-concurrent traversals correct. Proc. ACM Program. Lang., 4, OOPSLA (2020), 128:1–128:29. https://doi.org/10.1145/3428196
Google Scholar
Digital Library
- Xinyu Feng. 2009. Local rely-guarantee reasoning. In POPL. ACM, 315–327. https://doi.org/10.1145/1480881.1480922
Google Scholar
Digital Library
- Keir Fraser. 2004. Practical lock-freedom. Ph. D. Dissertation. University of Cambridge, UK. https://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.599193
Google Scholar
- Ming Fu, Yong Li, Xinyu Feng, Zhong Shao, and Yu Zhang. 2010. Reasoning about Optimistic Concurrency Using a Program Logic for History. In CONCUR (LNCS, Vol. 6269). Springer, 388–402. https://doi.org/10.1007/978-3-642-15375-4_27
Google Scholar
Cross Ref
- Alexey Gotsman, Noam Rinetzky, and Hongseok Yang. 2013. Verifying Concurrent Memory Reclamation Algorithms with Grace. In ESOP (LNCS, Vol. 7792). Springer, 249–269. https://doi.org/10.1007/978-3-642-37036-6_15
Google Scholar
Digital Library
- Ronghui Gu, Zhong Shao, Jieung Kim, Xiongnan (Newman) Wu, Jérémie Koenig, Vilhelm Sjöberg, Hao Chen, David Costanzo, and Tahina Ramananandro. 2018. Certified concurrent abstraction layers. In PLDI. ACM, 646–661. https://doi.org/10.1145/3192366.3192381
Google Scholar
Digital Library
- Timothy L. Harris. 2001. A Pragmatic Implementation of Non-blocking Linked-Lists. In DISC (LNCS, Vol. 2180). Springer, 300–314. https://doi.org/10.1007/3-540-45414-4_21
Google Scholar
Cross Ref
- Steve Heller, Maurice Herlihy, Victor Luchangco, Mark Moir, William N. Scherer III, and Nir Shavit. 2005. A Lazy Concurrent List-Based Set Algorithm. In OPODIS (LNCS, Vol. 3974). Springer, 3–16. https://doi.org/10.1007/11795490_3
Google Scholar
Digital Library
- Nir Hemed, Noam Rinetzky, and Viktor Vafeiadis. 2015. Modular Verification of Concurrency-Aware Linearizability. In DISC (LNCS, Vol. 9363). Springer, 371–387. https://doi.org/10.1007/978-3-662-48653-5_25
Google Scholar
Digital Library
- Thomas A. Henzinger, Ranjit Jhala, Rupak Majumdar, and Shaz Qadeer. 2003. Thread-Modular Abstraction Refinement. In CAV (LNCS, Vol. 2725). Springer, 262–274. https://doi.org/10.1007/978-3-540-45069-6_27
Google Scholar
Cross Ref
- Maurice Herlihy and Nir Shavit. 2008. The art of multiprocessor programming. Morgan Kaufmann. isbn:978-0-12-370591-4
Google Scholar
- Maurice Herlihy and Jeannette M. Wing. 1990. Linearizability: A Correctness Condition for Concurrent Objects. ACM Trans. Program. Lang. Syst., 12, 3 (1990), 463–492. https://doi.org/10.1145/78969.78972
Google Scholar
Digital Library
- Shachar Itzhaky, Anindya Banerjee, Neil Immerman, Ori Lahav, Aleksandar Nanevski, and Mooly Sagiv. 2014. Modular reasoning about heap paths via effectively propositional formulas. In POPL. ACM, 385–396. https://doi.org/10.1145/2535838.2535854
Google Scholar
Digital Library
- Ralf Jung, Robbert Krebbers, Jacques-Henri Jourdan, Ales Bizjak, Lars Birkedal, and Derek Dreyer. 2018. Iris from the ground up: A modular foundation for higher-order concurrent separation logic. J. Funct. Program., 28 (2018), e20. https://doi.org/10.1017/S0956796818000151
Google Scholar
Cross Ref
- Ralf Jung, Rodolphe Lepigre, Gaurav Parthasarathy, Marianna Rapoport, Amin Timany, Derek Dreyer, and Bart Jacobs. 2020. The future is ours: prophecy variables in separation logic. Proc. ACM Program. Lang., 4, POPL (2020), 45:1–45:32. https://doi.org/10.1145/3371113
Google Scholar
Digital Library
- Ralf Jung, David Swasey, Filip Sieczkowski, Kasper Svendsen, Aaron Turon, Lars Birkedal, and Derek Dreyer. 2015. Iris: Monoids and Invariants as an Orthogonal Basis for Concurrent Reasoning. In POPL. ACM, 637–650. https://doi.org/10.1145/2676726.2676980
Google Scholar
Digital Library
- Bernhard Kragl, Shaz Qadeer, and Thomas A. Henzinger. 2020. Refinement for Structured Concurrent Programs. In CAV (1) (LNCS, Vol. 12224). Springer, 275–298. https://doi.org/10.1007/978-3-030-53288-8_14
Google Scholar
Digital Library
- Siddharth Krishna, Nisarg Patel, Dennis E. Shasha, and Thomas Wies. 2020. Verifying concurrent search structure templates. In PLDI. ACM, 181–196. https://doi.org/10.1145/3385412.3386029
Google Scholar
Digital Library
- Siddharth Krishna, Dennis E. Shasha, and Thomas Wies. 2018. Go with the flow: compositional abstractions for concurrent data structures. Proc. ACM Program. Lang., 2, POPL (2018), 37:1–37:31. https://doi.org/10.1145/3158125
Google Scholar
Digital Library
- Siddharth Krishna, Alexander J. Summers, and Thomas Wies. 2020. Local Reasoning for Global Graph Properties. In ESOP (LNCS, Vol. 12075). Springer, 308–335. https://doi.org/10.1007/978-3-030-44914-8_12
Google Scholar
Digital Library
- Kfir Lev-Ari, Gregory V. Chockler, and Idit Keidar. 2015. A Constructive Approach for Proving Data Structures’ Linearizability. In DISC (LNCS, Vol. 9363). Springer, 356–370. https://doi.org/10.1007/978-3-662-48653-5_24
Google Scholar
Digital Library
- Justin J. Levandoski, David B. Lomet, and Sudipta Sengupta. 2013. The Bw-Tree: A B-tree for new hardware platforms. In ICDE. IEEE Computer Society, 302–313. https://doi.org/10.1109/ICDE.2013.6544834
Google Scholar
Digital Library
- Hongjin Liang and Xinyu Feng. 2013. Modular verification of linearizability with non-fixed linearization points. In PLDI. ACM, 459–470. https://doi.org/10.1145/2491956.2462189
Google Scholar
Digital Library
- Zohar Manna and Amir Pnueli. 1995. Temporal verification of reactive systems - safety. Springer. isbn:978-0-387-94459-3
Google Scholar
- Roland Meyer, Thomas Wies, and Sebastian Wolff. 2022. Artifact for "A Concurrent Program Logic with a Future and History". https://doi.org/10.5281/zenodo.7080459 or
Google Scholar
Digital Library
- Roland Meyer, Thomas Wies, and Sebastian Wolff. 2022. A Concurrent Program Logic with a Future and History. CoRR, abs/2207.02355 (2022), https://doi.org/10.48550/arXiv.2207.02355
Google Scholar
- Roland Meyer and Sebastian Wolff. 2019. Decoupling lock-free data structures from memory reclamation for static analysis. Proc. ACM Program. Lang., 3, POPL (2019), 58:1–58:31. https://doi.org/10.1145/3290371
Google Scholar
Digital Library
- Roland Meyer and Sebastian Wolff. 2020. Pointer life cycle types for lock-free data structures with memory reclamation. Proc. ACM Program. Lang., 4, POPL (2020), 68:1–68:36. https://doi.org/10.1145/3371136
Google Scholar
Digital Library
- Maged M. Michael. 2002. High performance dynamic lock-free hash tables and list-based sets. In SPAA. ACM, 73–82. https://doi.org/10.1145/564870.564881
Google Scholar
Digital Library
- Ike Mulder, Robbert Krebbers, and Herman Geuvers. 2022. Diaframe: automated verification of fine-grained concurrent programs in Iris. In PLDI. ACM, 809–824. https://doi.org/10.1145/3519939.3523432
Google Scholar
Digital Library
- Peter W. O’Hearn, John C. Reynolds, and Hongseok Yang. 2001. Local Reasoning about Programs that Alter Data Structures. In CSL (LNCS, Vol. 2142). Springer, 1–19. https://doi.org/10.1007/3-540-44802-0_1
Google Scholar
Cross Ref
- Peter W. O’Hearn, Noam Rinetzky, Martin T. Vechev, Eran Yahav, and Greta Yorsh. 2010. Verifying linearizability with hindsight. In PODC. ACM, 85–94. https://doi.org/10.1145/1835698.1835722
Google Scholar
Digital Library
- Susan S. Owicki and David Gries. 1976. An Axiomatic Proof Technique for Parallel Programs I. Acta Informatica, 6 (1976), 319–340. https://doi.org/10.1007/BF00268134
Google Scholar
Digital Library
- Matthew J. Parkinson, Richard Bornat, and Peter W. O’Hearn. 2007. Modular verification of a non-blocking stack. In POPL. ACM, 297–302. https://doi.org/10.1145/1190216.1190261
Google Scholar
Digital Library
- Nisarg Patel, Siddharth Krishna, Dennis E. Shasha, and Thomas Wies. 2021. Verifying concurrent multicopy search structures. Proc. ACM Program. Lang., 5, OOPSLA (2021), 1–32. https://doi.org/10.1145/3485490
Google Scholar
Digital Library
- Xavier Rival and Laurent Mauborgne. 2007. The trace partitioning abstract domain. ACM Trans. Program. Lang. Syst., 29, 5 (2007), 26. https://doi.org/10.1145/1275497.1275501
Google Scholar
Digital Library
- Fred B. Schneider. 1997. On Concurrent Programming. Springer. isbn:978-1-4612-7303-5 https://doi.org/10.1007/978-1-4612-1830-2
Google Scholar
Cross Ref
- Ilya Sergey, Aleksandar Nanevski, and Anindya Banerjee. 2015. Specifying and Verifying Concurrent Algorithms with Histories and Subjectivity. In ESOP (LNCS, Vol. 9032). Springer, 333–358. https://doi.org/10.1007/978-3-662-46669-8_14
Google Scholar
Digital Library
- Dennis E. Shasha and Nathan Goodman. 1988. Concurrent Search Structure Algorithms. ACM Trans. Database Syst., 13, 1 (1988), 53–90. https://doi.org/10.1145/42201.42204
Google Scholar
Digital Library
- Arshavir Ter-Gabrielyan, Alexander J. Summers, and Peter Müller. 2019. Modular verification of heap reachability properties in separation logic. Proc. ACM Program. Lang., 3, OOPSLA (2019), 121:1–121:28. https://doi.org/10.1145/3360547
Google Scholar
Digital Library
- Viktor Vafeiadis. 2008. Modular fine-grained concurrency verification. Ph. D. Dissertation. University of Cambridge, UK. https://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.612221
Google Scholar
- Viktor Vafeiadis. 2009. Shape-Value Abstraction for Verifying Linearizability. In VMCAI (LNCS, Vol. 5403). Springer, 335–348. https://doi.org/10.1007/978-3-540-93900-9_27
Google Scholar
Digital Library
- Viktor Vafeiadis. 2010. Automatically Proving Linearizability. In CAV (LNCS, Vol. 6174). Springer, 450–464. https://doi.org/10.1007/978-3-642-14295-6_40
Google Scholar
Digital Library
- Viktor Vafeiadis. 2010. RGSep Action Inference. In VMCAI (LNCS, Vol. 5944). Springer, 345–361. https://doi.org/10.1007/978-3-642-11319-2_25
Google Scholar
Digital Library
- Viktor Vafeiadis and Matthew J. Parkinson. 2007. A Marriage of Rely/Guarantee and Separation Logic. In CONCUR (LNCS, Vol. 4703). Springer, 256–271. https://doi.org/10.1007/978-3-540-74407-8_18
Google Scholar
Cross Ref
- Martin T. Vechev and Eran Yahav. 2008. Deriving linearizable fine-grained concurrent objects. In PLDI. ACM, 125–135. https://doi.org/10.1145/1375581.1375598
Google Scholar
Digital Library
- Matt Windsor, Mike Dodds, Ben Simner, and Matthew J. Parkinson. 2017. Starling: Lightweight Concurrency Verification with Views. In CAV (1) (LNCS, Vol. 10426). Springer, 544–569. https://doi.org/10.1007/978-3-319-63387-9_27
Google Scholar
Cross Ref
- Felix A. Wolf, Malte Schwerhoff, and Peter Müller. 2021. Concise Outlines for a Complex Logic: A Proof Outline Checker for TaDA. In FM (LNCS, Vol. 13047). Springer, 407–426. https://doi.org/10.1007/978-3-030-90870-6_22
Google Scholar
Digital Library
- Hongseok Yang, Oukseh Lee, Josh Berdine, Cristiano Calcagno, Byron Cook, Dino Distefano, and Peter W. O’Hearn. 2008. Scalable Shape Analysis for Systems Code. In CAV (LNCS, Vol. 5123). Springer, 385–398. https://doi.org/10.1007/978-3-540-70545-1_36
Google Scholar
Digital Library
- He Zhu, Gustavo Petri, and Suresh Jagannathan. 2015. Poling: SMT Aided Linearizability Proofs. In CAV (2) (LNCS, Vol. 9207). Springer, 3–19. https://doi.org/10.1007/978-3-319-21668-3_1
Google Scholar
Cross Ref
Index Terms
A concurrent program logic with a future and history
Recommendations
Proof Automation for Linearizability in Separation Logic
Recent advances in concurrent separation logic enabled the formal verification of increasingly sophisticated fine-grained (i.e., lock-free) concurrent programs. For such programs, the golden standard of correctness is linearizability, which expresses ...
Completing Herbelin's programme
TLCA'07: Proceedings of the 8th international conference on Typed lambda calculi and applicationsIn 1994 Herbelin started and partially achieved the programme of showing that, for intuitionistic implicational logic, there is a Curry-Howard interpretation of sequent calculus into a variant of the λ-calculus, specifically a variant which manipulates ...
The future is ours: prophecy variables in separation logic
Early in the development of Hoare logic, Owicki and Gries introduced auxiliary variables as a way of encoding information about the history of a program’s execution that is useful for verifying its correctness. Over a decade later, Abadi and Lamport ...






Comments