research-article

Local rely-guarantee reasoning

Author:

Xinyu FengAuthors Info & Claims

POPL '09: Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages

Pages 315 - 327

https://doi.org/10.1145/1480881.1480922

Published: 21 January 2009 Publication History

Abstract

Rely-Guarantee reasoning is a well-known method for verification of shared-variable concurrent programs. However, it is difficult for users to define rely/guarantee conditions, which specify threads' behaviors over the whole program state. Recent efforts to combine Separation Logic with Rely-Guarantee reasoning have made it possible to hide thread-local resources, but the shared resources still need to be globally known and specified. This greatly limits the reuse of verified program modules.

In this paper, we propose LRG, a new Rely-Guarantee-based logic that brings local reasoning and information hiding to concurrency verification. Our logic, for the first time, supports a frame rule over rely/guarantee conditions so that specifications of program modules only need to talk about the resources used locally, and the verified modules can be reused in different threads without redoing the proof. Moreover, we introduce a new hiding rule to hide the resources shared by a subset of threads from the rest in the system. The support of information hiding not only improves the modularity of Rely-Guarantee reasoning, but also enables the sharing of dynamically allocated resources, which requires adjustment of rely/guarantee conditions.

References

[1]

Nick Benton. Abstracting allocation : The new new thing. In Proc. Computer Science Logic (CSL'06), volume 4207 of phLecture Notes in Computer Science, pages 182--196. Springer, September 2006.

Digital Library

[2]

Richard Bornat, Cristiano Calcagno, Peter W. O'Hearn, and Matthew J. Parkinson. Permission accounting in separation logic. In Proc. 32nd ACM Symp. on Principles of Prog. Lang. (POPL'05), pages 259--270. ACM Press, January 2005.

Digital Library

[3]

Stephen Brookes. A semantics for concurrent separation logic. Theor. Comput. Sci., 375 (1-3): 227--270, 2007.

Digital Library

[4]

Cristiano Calcagno, Peter W. O'Hearn, and Hongseok Yang. Local action and abstract separation logic. In Proc. 22nd Annual IEEE Symposium on Logic in Computer Science (LICS'07), pages 366--378. IEEE Computer Society, July 2007.

Digital Library

[5]

Cristiano Calcagno, Matthew J. Parkinson, and Viktor Vafeiadis. Modular safety checking for fine-grained concurrency. In Proc. 14th Int'l Symposium on Static Analysis (SAS'07), volume 4634 of phLecture Notes in Computer Science, pages 233--248. Springer, August 2007.

Digital Library

[6]

Willem-Paul de Roever, Frank de Boer, Ulrich Hanneman, Jozef Hooman, Yassine Lakhnech, Mannes Poel, and Job Zwiers. Concurrency verification: introduction to compositional and noncompositional methods. Cambridge University Press, 2001.

Digital Library

[7]

Xinyu Feng. Local rely-guarantee reasoning (extended version). Technical Report TTIC-TR-2008-1, Toyota Technological Institute at Chicago, Chicago, IL, U.S.A., October 2008. http://www.tti-c.org/technical_reports/ttic-tr-2008-1.pdf.

[8]

Xinyu Feng and Zhong Shao. Modular verification of concurrent assembly code with dynamic thread creation and termination. In Proc. 2005 ACM Int'l Conf. on Functional Prog. (ICFP'05), pages 254--267. ACM Press, September 2005.

Digital Library

[9]

Xinyu Feng, Rodrigo Ferreira, and Zhong Shao. On the relationship between concurrent separation logic and assume-guarantee reasoning. In Proc. 16th European Symp. on Prog. (ESOP'07), volume 4421 of phLecture Notes in Computer Science, pages 173--188. Springer, March 2007.

Digital Library

[10]

Cormac Flanagan, Stephen N. Freund, Shaz Qadeer, and Sanjit A. Seshia. Modular verification of multithreaded programs. Theor. Comput. Sci., 338 (1-3): 153--183, 2005.

Digital Library

[11]

Alexey Gotsman, Byron Cook, Matthew J. Parkinson, and Viktor Vafeiadis. Proving that non-blocking algorithms don't block. In Proc. 36th ACM Symp. on Principles of Prog. Lang. (POPL'09), page to appear. ACM Press, January 2009.

Digital Library

[12]

Maurice Herlihy and Nir Shavit. The Art of Multiprocessor Programming. Morgan Kaufmann Publishers, March 2008.

Digital Library

[13]

Samin S. Ishtiaq and Peter W. O'Hearn. BI as an assertion language for mutable data structures. In Proc. 28th ACM Symp. on Principles of Prog. Lang. (POPL'01), pages 14--26. ACM Press, January 2001.

Digital Library

[14]

Cliff B. Jones. Tentative steps toward a development method for interfering programs. ACM Trans. Program. Lang. Syst., 5 (4): 596--619, 1983.

Digital Library

[15]

Cliff B. Jones. Wanted: a compositional approach to concurrency. In Programming Methodology, pages 5--15. Springer-Verlag, 2003.

Digital Library

[16]

Ioannis T. Kassios. Dynamic frames: Support for framing, dependencies and sharing without restrictions. In Proc. 14th International Symposium on Formal Methods (FM'06), volume 4085 of phLecture Notes in Computer Science, pages 268--283. Springer, August 2006.

Digital Library

[17]

Maged M. Michael. Hazard pointers: Safe memory reclamation for lock-free objects. IEEE Transactions on Parallel and Distributed Systems, 15 (6): 491--504, 2004.

Digital Library

[18]

Peter W. O'Hearn. Resources, concurrency and local reasoning. Theor. Comput. Sci., 375 (1-3): 271--307, 2007.

Digital Library

[19]

Peter W. O'Hearn, Hongseok Yang, and John C. Reynolds. Separation and information hiding. In Proc. 31th ACM Symp. on Principles of Prog. Lang. (POPL'04), pages 268--280. ACM Press, January 2004.

Digital Library

[20]

Matthew J. Parkinson, Richard Bornat, and Cristiano Calcagno. Variables as resource in hoare logics. In Proc. 21st Annual IEEE Symposium on Logic in Computer Science (LICS'06), pages 137--146. IEEE Computer Society, August 2006.

Digital Library

[21]

Matthew J. Parkinson, Richard Bornat, and Peter W. O'Hearn. Modular verification of a non-blocking stack. In Proc. 34th ACM Symp. on Principles of Prog. Lang. (POPL'07), pages 297--302. ACM Press, January 2007.

Digital Library

[22]

John C. Reynolds. Separation logic: A logic for shared mutable data structures. In Proc. 17th Annual IEEE Symposium on Logic in Computer Science (LICS'02), pages 55--74. IEEE Computer Society, July 2002.

Digital Library

[23]

Viktor Vafeiadis. Modular Fine-Grained Concurrency Verification. PhD thesis, University of Cambridge, July 2007.

[24]

Viktor Vafeiadis and Matthew J. Parkinson. A marriage of rely/guarantee and separation logic. In Proc. 18th Int'l Conf. on Concurrency Theory (CONCUR'07), volume 4703 of phLecture Notes in Computer Science, pages 256--271, September 2007.

Digital Library

[25]

Hongseok Yang. Relational separation logic. Theor. Comput. Sci., 375 (1-3): 308--334, 2007.

Digital Library

[26]

Hongseok Yang and Peter W. O'Hearn. A semantic basis for local reasoning. In Proc. 5th Int'l Conf. on Foundations of Software Science and Computation Structures (FoSSaCS'02), volume 2303 of phLecture Notes in Computer Science, pages 402--416. Springer, April 2002.

Digital Library

[27]

Dachuan Yu and Zhong Shao. Verification of safety properties for concurrent assembly code. In Proc. 2004 ACM Int'l Conf. on Functional Prog. (ICFP'04), pages 175--188. ACM Press, September 2004.

Digital Library

Cited By

Zou MDu DDong MChen HGavrilovska ATerry D(2024)Using dynamically layered definite releases for verifying the RefFS file systemProceedings of the 18th USENIX Conference on Operating Systems Design and Implementation10.5555/3691938.3691972(629-648)Online publication date: 10-Jul-2024
https://dl.acm.org/doi/10.5555/3691938.3691972
Kim JGu RShao Z(2024) : A simplified and abstract multicore hardware model for large scale system software formal verification Journal of Systems Architecture10.1016/j.sysarc.2023.103049147(103049)Online publication date: Feb-2024
https://doi.org/10.1016/j.sysarc.2023.103049
Kim JKoenig JChen HGu RShao Z(2024) : A template to build verified thread-local interfaces with software scheduler abstractions Journal of Systems Architecture10.1016/j.sysarc.2023.103046147(103046)Online publication date: Feb-2024
https://doi.org/10.1016/j.sysarc.2023.103046
Show More Cited By

Index Terms

Local rely-guarantee reasoning
1. Software and its engineering
  1. Software creation and management
    1. Software verification and validation
      1. Formal software verification
  2. Software organization and properties
    1. Software functional properties
      1. Correctness
      2. Formal methods
2. Theory of computation
  1. Logic
    1. Proof theory
  2. Semantics and reasoning
    1. Program reasoning

Recommendations

A rely-guarantee-based simulation for verifying concurrent program transformations
POPL '12: Proceedings of the 39th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages

Verifying program transformations usually requires proving that the resulting program (the target) refines or is equivalent to the original one (the source). However, the refinement relation between individual sequential threads cannot be preserved in ...
Local rely-guarantee reasoning
POPL '09

Rely-Guarantee reasoning is a well-known method for verification of shared-variable concurrent programs. However, it is difficult for users to define rely/guarantee conditions, which specify threads' behaviors over the whole program state. Recent ...
Interleaved Programs and Rely-Guarantee Reasoning with ITL
TIME '11: Proceedings of the 2011 Eighteenth International Symposium on Temporal Representation and Reasoning

This paper presents a logic that extends basicITL with explicit, interleaved programs. The calculus is based on symbolic execution, as previously described. We extend this former work here, by integrating the logic with higher-order logic, adding ...

Comments

Information & Contributors

Information

Published In

cover image ACM Conferences

POPL '09: Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages

January 2009

464 pages

ISBN:9781605583792

DOI:10.1145/1480881

General Chair:
Zhong Shao
Yale University, USA
,
Program Chair:
Benjamin C. Pierce
University of Pennsylvania, USA

ACM SIGPLAN Notices Volume 44, Issue 1
POPL '09
January 2009
453 pages
ISSN:0362-1340
EISSN:1558-1160
DOI:10.1145/1594834
Issue’s Table of Contents

Copyright © 2009 ACM.

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]

Sponsors

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 21 January 2009

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Research-article

Conference

POPL09

Sponsor:

POPL09: The 36th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages

January 21 - 23, 2009

GA, Savannah, USA

Acceptance Rates

Overall Acceptance Rate 824 of 4,130 submissions, 20%

Upcoming Conference

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

144
Total Citations
View Citations
739
Total Downloads

Downloads (Last 12 months)47
Downloads (Last 6 weeks)3

Reflects downloads up to 30 Jan 2025

Other Metrics

View Author Metrics

Citations

Cited By

Zou MDu DDong MChen HGavrilovska ATerry D(2024)Using dynamically layered definite releases for verifying the RefFS file systemProceedings of the 18th USENIX Conference on Operating Systems Design and Implementation10.5555/3691938.3691972(629-648)Online publication date: 10-Jul-2024
https://dl.acm.org/doi/10.5555/3691938.3691972
Kim JGu RShao Z(2024) : A simplified and abstract multicore hardware model for large scale system software formal verification Journal of Systems Architecture10.1016/j.sysarc.2023.103049147(103049)Online publication date: Feb-2024
https://doi.org/10.1016/j.sysarc.2023.103049
Kim JKoenig JChen HGu RShao Z(2024) : A template to build verified thread-local interfaces with software scheduler abstractions Journal of Systems Architecture10.1016/j.sysarc.2023.103046147(103046)Online publication date: Feb-2024
https://doi.org/10.1016/j.sysarc.2023.103046
Dongol BLahav OWehrheim H(2024)A Rely-Guarantee Framework for Proving Deadlock Freedom Under Causal ConsistencyThe Practice of Formal Methods10.1007/978-3-031-66676-6_5(88-108)Online publication date: 4-Sep-2024
https://doi.org/10.1007/978-3-031-66676-6_5
Semenyuk MDongol BHong JLanperne MPark JCerny TShahriar H(2023)Ownership-Based Owicki-Gries ReasoningProceedings of the 38th ACM/SIGAPP Symposium on Applied Computing10.1145/3555776.3577636(1685-1694)Online publication date: 27-Mar-2023
https://dl.acm.org/doi/10.1145/3555776.3577636
Sun HMao ZWang JZhao ZWang W(2023)Applying Rely-Guarantee Reasoning on Concurrent Memory Management and Mailbox in $$\mu $$C/OS-II: A Case StudyFormal Methods for Industrial Critical Systems10.1007/978-3-031-43681-9_13(224-241)Online publication date: 17-Sep-2023
https://doi.org/10.1007/978-3-031-43681-9_13
Hayes IJones CMeinicke L(2023)Specifying and Reasoning About Shared-Variable ConcurrencyTheories of Programming and Formal Methods10.1007/978-3-031-40436-8_5(110-135)Online publication date: 8-Sep-2023
https://doi.org/10.1007/978-3-031-40436-8_5
Zhang HDavid CYu YWang M(2023)Ownership Guided C to Rust TranslationComputer Aided Verification10.1007/978-3-031-37709-9_22(459-482)Online publication date: 17-Jul-2023
https://doi.org/10.1007/978-3-031-37709-9_22
Coughlin NWinter KSmith G(2022)Compositional Reasoning for Non-multicopy Atomic ArchitecturesFormal Aspects of Computing10.1145/357413735:2(1-30)Online publication date: 14-Dec-2022
https://dl.acm.org/doi/10.1145/3574137
Meyer RWies TWolff S(2022)A concurrent program logic with a future and historyProceedings of the ACM on Programming Languages10.1145/35633376:OOPSLA2(1378-1407)Online publication date: 31-Oct-2022
https://dl.acm.org/doi/10.1145/3563337
Show More Cited By

View Options

Login options

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

Full Access

Get this Publication

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Figures

Tables

Media

View Table of Conten