skip to main content

A concurrent program logic with a future and history

Published:31 October 2022Publication History
Skip Abstract Section

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.

References

  1. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  2. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  3. 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 ScholarGoogle ScholarCross RefCross Ref
  4. 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 ScholarGoogle ScholarCross RefCross Ref
  5. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  6. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  7. 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 ScholarGoogle ScholarCross RefCross Ref
  8. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  9. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  10. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  11. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  12. 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 ScholarGoogle ScholarCross RefCross Ref
  13. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  14. 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 ScholarGoogle ScholarCross RefCross Ref
  15. 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 ScholarGoogle ScholarCross RefCross Ref
  16. Edsger W. Dijkstra. 1976. A Discipline of Programming. Prentice-Hall. isbn:013215871X https://www.worldcat.org/oclc/01958445 Google ScholarGoogle Scholar
  17. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  18. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  19. 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 ScholarGoogle ScholarCross RefCross Ref
  20. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  21. 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 ScholarGoogle ScholarCross RefCross Ref
  22. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  23. Xinyu Feng. 2009. Local rely-guarantee reasoning. In POPL. ACM, 315–327. https://doi.org/10.1145/1480881.1480922 Google ScholarGoogle ScholarDigital LibraryDigital Library
  24. 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 ScholarGoogle Scholar
  25. 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 ScholarGoogle ScholarCross RefCross Ref
  26. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  27. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  28. 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 ScholarGoogle ScholarCross RefCross Ref
  29. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  30. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  31. 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 ScholarGoogle ScholarCross RefCross Ref
  32. Maurice Herlihy and Nir Shavit. 2008. The art of multiprocessor programming. Morgan Kaufmann. isbn:978-0-12-370591-4 Google ScholarGoogle Scholar
  33. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  34. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  35. 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 ScholarGoogle ScholarCross RefCross Ref
  36. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  37. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  38. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  39. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  40. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  41. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  42. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  43. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  44. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  45. Zohar Manna and Amir Pnueli. 1995. Temporal verification of reactive systems - safety. Springer. isbn:978-0-387-94459-3 Google ScholarGoogle Scholar
  46. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  47. 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 ScholarGoogle Scholar
  48. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  49. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  50. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  51. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  52. 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 ScholarGoogle ScholarCross RefCross Ref
  53. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  54. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  55. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  56. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  57. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  58. 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 ScholarGoogle ScholarCross RefCross Ref
  59. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  60. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  61. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  62. 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 ScholarGoogle Scholar
  63. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  64. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  65. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  66. 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 ScholarGoogle ScholarCross RefCross Ref
  67. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  68. 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 ScholarGoogle ScholarCross RefCross Ref
  69. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  70. 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 ScholarGoogle ScholarDigital LibraryDigital Library
  71. 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 ScholarGoogle ScholarCross RefCross Ref

Index Terms

  1. A concurrent program logic with a future and history

            Recommendations

            Comments

            Login options

            Check if you have access through your login credentials or your institution to get full access on this article.

            Sign in

            Full Access

            PDF Format

            View or Download as a PDF file.

            PDF

            eReader

            View online with eReader.

            eReader
            About Cookies On This Site

            We use cookies to ensure that we give you the best experience on our website.

            Learn more

            Got it!