Impredicative Concurrent Abstract Predicates

@inproceedings{Svendsen2014ImpredicativeCA,
  title={Impredicative Concurrent Abstract Predicates},
  author={Kasper Svendsen and L. Birkedal},
  booktitle={ESOP},
  year={2014}
}
We present impredicative concurrent abstract predicates --- iCAP --- a program logic for modular reasoning about concurrent, higher-order, reentrant, imperative code. Building on earlier work, iCAP uses protocols to reason about shared mutable state. A key novel feature of iCAP is the ability to define impredicative protocols; protocols that are parameterized on arbitrary predicates, including predicates that themselves refer to protocols. We demonstrate the utility of impredicative protocols… Expand
A Generic Logic for Proving Linearizability (Extended Version)
TLDR
This work proposes a logic for proving linearizability that is generic: it can be instantiated with different means of compositional reasoning about concurrency, such as separation logic or rely-guarantee, and shows that it is powerful enough to handle concurrent algorithms with challenging features,such as helping. Expand
A Generic Logic for Proving Linearizability
TLDR
This work proposes a logic for proving linearizability that is generic: it can be instantiated with different means of compositional reasoning about concurrency, such as separation logic or rely-guarantee, and shows that it is powerful enough to handle concurrent algorithms with challenging features,such as helping. Expand
Iris: Monoids and Invariants as an Orthogonal Basis for Concurrent Reasoning
TLDR
Iris, a concurrent separation logic with a simple premise: monoids and invariants are all you need, supports the encoding of *logically atomic specifications*, i.e., Hoare-style specs that permit the client of an operation to treat the operation essentially as if it were atomic, even if it is not. Expand
Reasoning with time and data abstractions
TLDR
This thesis addresses the problem of verifying the functional correctness of concurrent programs, with emphasis on fine-grained concurrent data structures, and presents TaDA, a sound program logic for verifying clients and implementations that use abstract specifications that incorporate both abstract atomicity and abstract disjointness. Expand
TaDA: A Logic for Time and Data Abstraction
TLDR
TaDA is presented, a program logic that combines the benefits of abstract atomicity and abstract disjointness and the introduction of atomic triples, which offer an expressive approach to specifying program modules. Expand
Specifying concurrent programs in separation logic: morphisms and simulations
TLDR
A novel notion of resource morphism is introduced, i.e. structure-preserving function on resources, and it is shown how to effectively integrate it into separation logic, using an associated notion of morphism-specific simulation. Expand
Abstract Specifications for Concurrent Maps
TLDR
It is shown how to verify client programs, such as a concurrent set and a producer-consumer client, and a substantial first proof that the main operations of ConcurrentSkipListMap in java.util.concurrent satisfy the map specification. Expand
ModuRes: A Coq Library for Modular Reasoning About Concurrent Higher-Order Imperative Programming Languages
TLDR
The ModuRes Coq library is presented, which provides an easy way to solve certain kinds of recursive domain equations and can be used to construct models of type systems and logics for reasoning about concurrent higher-order imperative programming languages. Expand
Actris: session-type based reasoning in separation logic
TLDR
It is shown that Actris provides a suitable level of abstraction by proving functional correctness of a variety of examples, including a distributed merge sort, a distributed load-balancing mapper, and a variant of the map-reduce model, using relatively simple specifications. Expand
A Higher-Order Logic for Concurrent Termination-Preserving Refinement
TLDR
This paper extends Iris, a recent higher-order concurrent separation logic, with support for reasoning about termination-preserving refinements, and proves the correctness of an efficient implementation of a higher- order, session-typed language. Expand
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 27 REFERENCES
Concurrent Abstract Predicates
TLDR
This work presents a program logic for reasoning abstractly about data structures that provides a fiction of disjointness and permits compositional reasoning about a module's implementation using separation logic with permissions. Expand
Modular reasoning for deterministic parallelism
TLDR
This paper examines the formal specification and verification of concurrent abstract predicates used to encapsulate racy behaviour in the library's implementation, and shows that the high-level specification abstracts the details of deterministic parallelism by verifying two different low-level implementations of the library. Expand
A Concurrent Logical Relation
TLDR
A Parallelization Theorem is proved, which expresses when it is sound to run two expressions in parallel instead of sequentially, and is the first such result for a concurrent higher- order language with higher-order store and dynamic memory allocation. Expand
Views: compositional reasoning for concurrent programs
TLDR
This paper presents the "Concurrent Views Framework", a metatheory of concurrent reasoning principles that proves each of these systems is sound without requiring induction on the operational semantics. Expand
Unifying refinement and hoare-style reasoning in a logic for higher-order concurrency
TLDR
CaReSL is presented, the first logic to support the use of granularity abstraction for modular verification of higher-order concurrent programs, and its effectiveness is demonstrated by using it to tackle a significant case study: the first formal proof of (partial) correctness for Hendler et al.'s "flat combining" algorithm. Expand
A very modal model of a modern, major, general type system
TLDR
A model of recursive and impredicatively quantified types with mutable references is presented, interpreting all of the type constructors needed for typed intermediate languages and typed assembly languages used for object-oriented and functional languages and establishing a soundness proof of the typing systems underlying these TILs and TALs---ensuring that every well-typed program is safe. Expand
First Steps in Synthetic Guarded Domain Theory: Step-Indexing in the Topos of Trees
TLDR
It is proposed that the internal logic of S provides the right setting for the synthetic construction of abstract versions of step-indexed models of programming languages and program logics. Expand
Modular Reasoning about Separation of Concurrent Data Structures
TLDR
A new logic and a new style of specification for thread-safe concurrent data structures that allow clients to refine usage protocols and associate ownership of additional resources with instances of these data structures. Expand
On the Relationship Between Concurrent Separation Logic and Assume-Guarantee Reasoning
TLDR
This work shows that CSL (adapted for the low-level language) can be viewed as a specialization of the extended A-G logic by enforcing the invariant that "shared resources are well-formed outside of critical regions". Expand
Oracle Semantics for Concurrent Separation Logic
TLDR
This work defines a modular operational semantics for Concurrent C minor--a language with shared memory, spawnable threads, and first-class locks, and proves its soundness with respect to the operational semantics and proved the sequential C.S.L. rules (those inherited from sequential Separation Logic) simply by adapting Appel & Blazy's machine-checked soundness proofs. Expand
...
1
2
3
...