Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
skip to main content
research-article
Open access

Gradual verification of recursive heap data structures

Published: 13 November 2020 Publication History

Abstract

Current static verification techniques do not provide good support for incrementality, making it difficult for developers to focus on specifying and verifying the properties and components that are most important. Dynamic verification approaches support incrementality, but cannot provide static guarantees. To bridge this gap, prior work proposed gradual verification, which supports incrementality by allowing every assertion to be complete, partial, or omitted, and provides sound verification that smoothly scales from dynamic to static checking. The prior approach to gradual verification, however, was limited to programs without recursive data structures. This paper extends gradual verification to programs that manipulate recursive, mutable data structures on the heap. We address several technical challenges, such as semantically connecting iso- and equi-recursive interpretations of abstract predicates, and supporting gradual verification of heap ownership. This work thus lays the foundation for future tools that work on realistic programs and support verification within an engineering process in which cost-benefit trade-offs can be made.

Supplementary Material

Auxiliary Presentation Video (oopsla20main-p605-p-video.mp4)
Current static verification techniques do not support incrementality, making it difficult for developers to specify and verify important system properties and components. Dynamic approaches support incrementality, but do not provide static guarantees. To bridge this gap, prior work proposed gradual verification, which supports incrementality by allowing every assertion to be complete, partial, or omitted, and provides sound verification that smoothly scales from dynamic to static checking. Prior work, however, was limited to programs without recursive data structures. This talk at OOPSLA’20 presents an extended gradual verification approach to programs containing recursive heap data structures. I also discuss technical challenges that were addressed, such as semantically connecting iso- and equi-recursive interpretations of predicates. This talk thus gives a foundation for practical tools that support verification within engineering processes where cost benefit trade-offs are made.

References

[1]
Johannes Bader, Jonathan Aldrich, and Éric Tanter. 2018. Gradual Program Verification. In International Conference on Verification, Model Checking, and Abstract Interpretation. Springer, 25-46.
[2]
Josh Berdine, Cristiano Calcagno, and Peter W O'hearn. 2005. Smallfoot: Modular automatic assertion checking with separation logic. In International Symposium on Formal Methods for Components and Objects. Springer, 115-137.
[3]
Edsger W. Dijkstra. 1975. Guarded Commands, Nondeterminacy and Formal Derivation of Programs. Commun. ACM 18, 8 (Aug. 1975 ), 453-457. https://doi.org/10.1145/360933.360975
[4]
Dino Distefano and Matthew J Parkinson J. 2008. jStar: Towards practical verification for Java. ACM Sigplan Notices 43, 10 ( 2008 ), 213-226.
[5]
Carlo Alberto Furia and Bertrand Meyer. 2010. Inferring loop invariants using postconditions. In Fields of logic and computation. Springer, 277-300.
[6]
Ronald Garcia, Alison M. Clark, and Éric Tanter. 2016. Abstracting Gradual Typing. In Proceedings of the 43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (St. Petersburg, FL, USA) ( POPL '16). ACM, New York, NY, USA, 429-442. https://doi.org/10.1145/2837614.2837670
[7]
Ronald Garcia, Éric Tanter, Roger Wolf, and Jonathan Aldrich. 2014. Foundations of Typestate-Oriented Programming. 36, 4, Article 12 (Oct. 2014 ), 12 : 1-12 :44 pages.
[8]
Charles Antony Richard Hoare. 1969. An axiomatic basis for computer programming. Commun. ACM 12, 10 ( 1969 ), 576-580.
[9]
Nico Lehmann and Éric Tanter. 2017. Gradual Refinement Types. In Proceedings of the 44th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL 2017 ). Paris, France, 775-788.
[10]
K Rustan M Leino. 2010. Dafny: An automatic program verifier for functional correctness. In International Conference on Logic for Programming Artificial Intelligence and Reasoning. Springer, 348-370.
[11]
K Rustan M Leino, Peter Müller, and Jan Smans. 2009. Verification of concurrent programs with Chalice. In Foundations of Security Analysis and Design V. Springer, 195-222.
[12]
Paqui Lucio. 2017. A Tutorial on Using Dafny to Construct Verified Software. arXiv preprint arXiv:1701.04481 ( 2017 ).
[13]
Huu Hai Nguyen, Viktor Kuncak, and Wei-Ngan Chin. 2008. Runtime checking for separation logic. In International Workshop on Verification, Model Checking, and Abstract Interpretation. Springer, 203-217.
[14]
Matthew Parkinson and Gavin Bierman. 2005. Separation logic and abstraction. In ACM SIGPLAN Notices, Vol. 40. ACM, 247-258.
[15]
Guillaume Petiot, Nikolai Kosmatov, Alain Giorgetti, and Jacques Julliand. 2014. StaDy: Deep Integration of Static and Dynamic Analysis in Frama-C. ( 2014 ).
[16]
John C Reynolds. 2002. Separation logic: A logic for shared mutable data structures. In Logic in Computer Science, 2002. Proceedings. 17th Annual IEEE Symposium on. IEEE, 55-74.
[17]
Ilya Sergey and Dave Clarke. 2012. Gradual Ownership Types. In Proceedings of the 21st European Conference on Programming Languages and Systems (Tallinn, Estonia) ( ESOP'12). Springer-Verlag, Berlin, Heidelberg, 579-599. https://doi.org/10. 1007/978-3-642-28869-2_29
[18]
Jeremy Siek and Walid Taha. 2007. Gradual typing for objects. In European Conference on Object-Oriented Programming. Springer, 2-27.
[19]
Jeremy G Siek and Walid Taha. 2006. Gradual typing for functional languages. In Scheme and Functional Programming Workshop, Vol. 6. 81-92.
[20]
Jeremy G Siek, Michael M Vitousek, Matteo Cimini, and John Tang Boyland. 2015. Refined criteria for gradual typing. In LIPIcs-Leibniz International Proceedings in Informatics, Vol. 32. Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik.
[21]
Jan Smans, Bart Jacobs, and Frank Piessens. 2009. Implicit dynamic frames: Combining dynamic frames and separation logic. In European Conference on Object-Oriented Programming. Springer, 148-172.
[22]
Alexander J Summers and Sophia Drossopoulou. 2013. A formal semantics for isorecursive and equirecursive state abstractions. In European Conference on Object-Oriented Programming. Springer, 129-153.
[23]
Jenna Wise, Johannes Bader, Cameron Wong, Jonathan Aldrich, Éric Tanter, and Joshua Sunshine. 2020. Gradual Verification of Recursive Heap Data Structures. Zenodo. https://doi.org/10.5281/zenodo.4085932
[24]
Roger Wolf, Ronald Garcia, Éric Tanter, and Jonathan Aldrich. 2011. Gradual typestate. In European Conference on ObjectOriented Programming. Springer, 459-483.

Cited By

View all
  • (2024)Gradual C0: Symbolic Execution for Gradual VerificationACM Transactions on Programming Languages and Systems10.1145/370480846:4(1-57)Online publication date: 5-Dec-2024
  • (2024)The Faultless Way of ProgrammingProceedings of the 29th European Conference on Pattern Languages of Programs, People, and Practices10.1145/3698322.3698340(1-7)Online publication date: 3-Jul-2024
  • (2024)Design of Fractional Permissions for a Gradual VerifierCompanion Proceedings of the 2024 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity10.1145/3689491.3689972(40-42)Online publication date: 20-Oct-2024
  • Show More Cited By

Index Terms

  1. Gradual verification of recursive heap data structures

      Recommendations

      Comments

      Information & Contributors

      Information

      Published In

      cover image Proceedings of the ACM on Programming Languages
      Proceedings of the ACM on Programming Languages  Volume 4, Issue OOPSLA
      November 2020
      3108 pages
      EISSN:2475-1421
      DOI:10.1145/3436718
      Issue’s Table of Contents
      This work is licensed under a Creative Commons Attribution International 4.0 License.

      Publisher

      Association for Computing Machinery

      New York, NY, United States

      Publication History

      Published: 13 November 2020
      Published in PACMPL Volume 4, Issue OOPSLA

      Permissions

      Request permissions for this article.

      Check for updates

      Author Tags

      1. gradual verification
      2. implicit dynamic frames
      3. recursive predicates
      4. separation logic

      Qualifiers

      • Research-article

      Funding Sources

      Contributors

      Other Metrics

      Bibliometrics & Citations

      Bibliometrics

      Article Metrics

      • Downloads (Last 12 months)419
      • Downloads (Last 6 weeks)32
      Reflects downloads up to 13 Jan 2025

      Other Metrics

      Citations

      Cited By

      View all
      • (2024)Gradual C0: Symbolic Execution for Gradual VerificationACM Transactions on Programming Languages and Systems10.1145/370480846:4(1-57)Online publication date: 5-Dec-2024
      • (2024)The Faultless Way of ProgrammingProceedings of the 29th European Conference on Pattern Languages of Programs, People, and Practices10.1145/3698322.3698340(1-7)Online publication date: 3-Jul-2024
      • (2024)Design of Fractional Permissions for a Gradual VerifierCompanion Proceedings of the 2024 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity10.1145/3689491.3689972(40-42)Online publication date: 20-Oct-2024
      • (2024)Sound Gradual Verification with Symbolic ExecutionProceedings of the ACM on Programming Languages10.1145/36329278:POPL(2547-2576)Online publication date: 5-Jan-2024
      • (2024)Securing Verified IO Programs Against Unverified Code in F*Proceedings of the ACM on Programming Languages10.1145/36329168:POPL(2226-2259)Online publication date: 5-Jan-2024
      • (2022)Derivations with Holes for Concept-Based Program SynthesisProceedings of the 2022 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software10.1145/3563835.3567658(63-79)Online publication date: 29-Nov-2022
      • (2022)More Programming Than Programming: Teaching Formal Methods in a Software Engineering ProgrammeNASA Formal Methods10.1007/978-3-031-06773-0_23(431-450)Online publication date: 20-May-2022
      • (2021)Implementation of an end-to-end gradual verification systemCompanion Proceedings of the 2021 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity10.1145/3484271.3484980(28-30)Online publication date: 17-Oct-2021

      View Options

      View options

      PDF

      View or Download as a PDF file.

      PDF

      eReader

      View online with eReader.

      eReader

      Login options

      Full Access

      Media

      Figures

      Other

      Tables

      Share

      Share

      Share this Publication link

      Share on social media