Separation logic: a logic for shared mutable data structures

@article{Reynolds2002SeparationLA,
  title={Separation logic: a logic for shared mutable data structures},
  author={John C. Reynolds},
  journal={Proceedings 17th Annual IEEE Symposium on Logic in Computer Science},
  year={2002},
  pages={55-74}
}
  • J. C. Reynolds
  • Published 22 July 2002
  • Computer Science
  • Proceedings 17th Annual IEEE Symposium on Logic in Computer Science
In joint work with Peter O'Hearn and others, based on early ideas of Burstall, we have developed an extension of Hoare logic that permits reasoning about low-level imperative programs that use shared mutable data structure. The simple imperative programming language is extended with commands (not expressions) for accessing and modifying shared structures, and for explicit allocation and deallocation of storage. Assertions are extended by introducing a "separating conjunction" that asserts that… Expand
Variables as Resource for Shared-Memory Programs: Semantics and Soundness
TLDR
This work provides a denotational semantics and a soundness proof for the concurrent fragment of their logic, extending earlier work on concurrent separation logic to incorporate permissions in a natural manner. Expand
Separation Logic for Higher-Order Store
TLDR
This paper introduces an extension of the logic and proves it sound, including the Frame Rule that enables specifications of code to be extended by invariants on parts of the heap that are not accessed, and introduces the benefits of local reasoning available to languages with higher-order store. Expand
Tutorial on Separation Logic (Invited Tutorial)
TLDR
This tutorial covers the basics of separating conjunction logic, and describes how that is, and where rough edges lie (programs whose proofs are still more complex than the authors would like). Expand
An Outline of Separation Logic
TLDR
This paper introduces Separation Logic as an extension of the standard Hoare Logic with the help of a programming language that has four pointer manipulating commands. Expand
Recursive Data Structures in SPARK
TLDR
This paper presents a recent extension of the SPARK language and toolset to support pointers, based on an ownership policy inspired by Rust to enforce non-aliasing through a move semantics of assignment. Expand
Amortised Resource Analysis with Separation Logic
TLDR
This work translates the idea of amortised resource analysis to imperative languages by embedding a logic of resources, based on Bunched Implications, within Separation Logic within Coq proof assistant. Expand
Structured Types and Separation Logic
  • Harvey Tuch
  • Computer Science
  • Electron. Notes Theor. Comput. Sci.
  • 2008
TLDR
A generalisation of an earlier formal memory model that captured the low-level features of C's pointers and memory and formed the basis for an expressive implementation of separation logic, with new features providing explicit support for C's structured types is presented. Expand
Recursive Assertions for Data Structures
We present an assertion language for expressing properties of data structures. Its key features are constraints over arrays, multisets and integers which allow the specification of basic assertio ns,Expand
Separation Logic in the Presence of Garbage Collection
TLDR
GCSL permits reasoning about programs that use internal pointers and address arithmetic, supports logical variables that range over pointers, and validates the "frame" rule, as well as a standard interpretation of separation-logic assertions, without requiring any restrictions on existentially-quantified formulae. Expand
L3: A Linear Language with Locations
We present a simple, but expressive type system that supports strong updates - updating a memory cell to hold values of unrelated types at different points in time. Our formulation is based upon aExpand
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 45 REFERENCES
Local Reasoning about Programs that Alter Data Structures
TLDR
An extension of Hoare's logic for reasoning about programs that alter data structures is described, based on a possible worlds model of the logic of bunched implications, and includes spatial conjunction and implication connectives alongside those of classical logic. Expand
Intuitionistic reasoning about shared mutable data structure
TLDR
This work extends Hoare's approach to proving the correctness of imperative programs, to deal with programs that perform destructive updates to data structures containing more than one pointer to the same location. Expand
BI as an assertion language for mutable data structures
TLDR
A model in which the law of the excluded middleholds is given is given, thus showing that the approach is compatible with classical logic, and a local character enjoyed by specifications in the logic is described, which enables a class of frame axioms, which say what parts of the heap don't change, to be inferred automatically. Expand
On Garbage and Program Logic
TLDR
This work presents a semantics of program logic assertions based on a view of the heap as finite, but extensible; this is for a logical language with primitives for dereferencing pointer expressions, and uses the assertion language to formulate notions of partial and total correctness for a small programming language. Expand
Semantic and Logical Properties of Stateful Programming
TLDR
This thesis presents and studies a number of problems that arise when reasoning about imperative languages with pointers, with special emphasis on program logic in the style of Hoare, and proposes two approaches, simpler than previous ones, for proving type safety. Expand
An Example of Local Reasoning in BI Pointer Logic: the Schorr−Waite Graph Marking Algorithm
TLDR
The promise of local reasoning in BI pointer logic is shown by an example: the Schorr-Waite graph marking algorithm, giving an evidence that even in a program with no clear separations of data structures, the locality of memory access can still be exploited in a formal proof with Frame Introduction and BI multiplicative connectives and that the resulting veriication becomes signiicantly simpler. Expand
Computability and Complexity Results for a Spatial Assertion Language for Data Structures
TLDR
It is shown that validity, even for this restricted language, is not r.e., but that the quantifier-free sublanguage is decidable, and the complexity of model checking and validity for several fragments is considered. Expand
Program logic and equivalence in the presence of garbage collection
TLDR
A study of a small language whose operational semantics includes a rule for reclaiming garbage and results include an analysis of propositions that are garbage insensitive, and full abstraction results connecting partial and total correctness to two natural notions of observational equivalence between programs. Expand
Alias Types for Recursive Data Structures
TLDR
This paper describes a pseudo-linear type system that allows a degree of aliasing and memory reuse as well as the ability to define complex recursive data structures and demonstrates the flexibility of the type system by encoding two common space-conscious algorithms: destination-passing style and Deutsch-Schorr-Waite or "link-reversal" traversal algoithms. Expand
Stack-based typed assembly language
TLDR
STAL is a variant of Typed Assembly Language with constructs and types to support a limited form of stack allocation and the type system of STAL ensures that a wide class of errors cannot occur at run time, and therefore the language can be adapted for use in certifying compilers where security is a concern. Expand
...
1
2
3
4
5
...