scholarly journals Concurrent incorrectness separation logic

2022 ◽  
Vol 6 (POPL) ◽  
pp. 1-29
Author(s):  
Azalea Raad ◽  
Josh Berdine ◽  
Derek Dreyer ◽  
Peter W. O'Hearn
Keyword(s):  
Error Detection ◽  
Separation Logic ◽  
Approximate Reasoning ◽  
Concurrent Programs ◽  
Deadlock Detection ◽  
Sequential Programs ◽  
Memory Safety ◽  
Race Detection ◽  
Meta Theory

Incorrectness separation logic (ISL) was recently introduced as a theory of under-approximate reasoning, with the goal of proving that compositional bug catchers find actual bugs. However, ISL only considers sequential programs. Here, we develop concurrent incorrectness separation logic (CISL), which extends ISL to account for bug catching in concurrent programs. Inspired by the work on Views, we design CISL as a parametric framework, which can be instantiated for a number of bug catching scenarios, including race detection, deadlock detection, and memory safety error detection. For each instance, the CISL meta-theory ensures the soundness of incorrectness reasoning for free, thereby guaranteeing that the bugs detected are true positives.

REACHABILITY TESTING: AN APPROACH TO TESTING CONCURRENT SOFTWARE

1995 ◽  
Vol 05 (04) ◽  
pp. 493-510 ◽  
Author(s):  
GWAN-HWAN HWANG ◽  
KUO-CHUNG TAI ◽  
TING-LU HUANG
Keyword(s):  
Empirical Studies ◽  
Concurrent Programs ◽  
Concurrent Software ◽  
Sequential Programs ◽  
Concurrent Program ◽  
Testing Approach ◽  
Reachability Testing ◽  
Deterministic Behavior

Concurrent programs are more difficult to test than sequential programs because of non-deterministic behavior. An execution of a concurrent program non-deterministically exercises a sequence of synchronization events called a synchronization sequence (or SYN-sequence). Non-deterministic testing of a concurrent program P is to execute P with a given input many times in order to exercise distinct SYN-sequences. In this paper, we present a new testing approach called reachability testing. If every execution of P with input X terminates, reachability testing of P with input X derives and executes all possible SYN-sequences of P with input X. We show how to perform reachability testing of concurrent programs using read and write operations. Also, we present results of empirical studies comparing reachability and non-deterministic testing. Our results indicate that reachability testing has advantages over non-deterministic testing.

scholarly journals TaDA Live: Compositional Reasoning for Termination of Fine-grained Concurrent Programs

2021 ◽  
Vol 43 (4) ◽  
pp. 1-134
Author(s):  
Emanuele D’Osualdo ◽  
Julian Sutherland ◽  
Azadeh Farzan ◽  
Philippa Gardner
Keyword(s):  
Case Studies ◽  
Separation Logic ◽  
Proof System ◽  
Concurrent Programs ◽  
Semantic Model ◽  
Compositional Reasoning ◽  
Fine Grained ◽  
Fundamental Innovation ◽  
Concurrent Separation Logic

We present TaDA Live, a concurrent separation logic for reasoning compositionally about the termination of blocking fine-grained concurrent programs. The crucial challenge is how to deal with abstract atomic blocking : that is, abstract atomic operations that have blocking behaviour arising from busy-waiting patterns as found in, for example, fine-grained spin locks. Our fundamental innovation is with the design of abstract specifications that capture this blocking behaviour as liveness assumptions on the environment. We design a logic that can reason about the termination of clients that use such operations without breaking their abstraction boundaries, and the correctness of the implementations of the operations with respect to their abstract specifications. We introduce a novel semantic model using layered subjective obligations to express liveness invariants and a proof system that is sound with respect to the model. The subtlety of our specifications and reasoning is illustrated using several case studies.

Concurrent Program Schemes

1987 ◽  
Vol 10 (4) ◽  
pp. 337-361
Author(s):  
A.J. Kfoury ◽  
P. Urzyczyn
Keyword(s):  
Concurrent Programs ◽  
Turing Machines ◽  
Computational Power ◽  
Sequential Programs ◽  
Concurrent Program ◽  
Nondeterministic Choice ◽  
Flow Diagrams ◽  
Alternating Turing Machines

We study the programming formalism FD of “flow-diagrams” to which we gradually add various features of concurrency. The weakest form of concurrency is introduced by the construct “and”, which is dual to the nondeterministic choice “or” and plays a role similar to universal states in alternating Turing machines. Stronger (and more realistic) forms of concurrency are obtained when processes are allowed to communicate. We consider communication by channels and communication by messages. We calibrate the computational power of classes of concurrent programs FD+α against that of sequential programs, where α is the addition of one of the following features: {and}, {and, or}, {and, or, channels}, or {and, or, messages}.

scholarly journals Steel: proof-oriented programming in a dependently typed concurrent separation logic

2021 ◽  
Vol 5 (ICFP) ◽  
pp. 1-30
Author(s):  
Aymeric Fromherz ◽  
Aseem Rastogi ◽  
Nikhil Swamy ◽  
Sydney Gibson ◽  
Guido Martínez ◽  
...  
Keyword(s):  
Linked Data ◽  
Separation Logic ◽  
Concurrent Programs ◽  
Interactive Proof ◽  
First Order ◽  
Session Types ◽  
Verification Condition ◽  
New Formulation ◽  
Concurrent Separation Logic ◽  
Efficient Verification

Steel is a language for developing and proving concurrent programs embedded in F ⋆ , a dependently typed programming language and proof assistant. Based on SteelCore, a concurrent separation logic (CSL) formalized in F ⋆ , our work focuses on exposing the proof rules of the logic in a form that enables programs and proofs to be effectively co-developed. Our main contributions include a new formulation of a Hoare logic of quintuples involving both separation logic and first-order logic, enabling efficient verification condition (VC) generation and proof discharge using a combination of tactics and SMT solving. We relate the VCs produced by our quintuple system to solving a system of associativity-commutativity (AC) unification constraints and develop tactics to (partially) solve these constraints using AC-matching modulo SMT-dischargeable equations. Our system is fully mechanized and implemented in F ⋆ . We evaluate it by developing several verified programs and libraries, including various sequential and concurrent linked data structures, proof libraries, and a library for 2-party session types. Our experience leads us to conclude that our system enables a mixture of automated and interactive proof, making it productive to build programs foundationally verified against a highly expressive, state-of-the-art CSL.

scholarly journals Program Verification with Separation Logic and Rely Guarantee

2021 ◽  
Author(s):  
◽  
Allan Tabilog
Keyword(s):  
Program Verification ◽  
Separation Logic ◽  
Concurrent Programs ◽  
Abstract Data Type ◽  
Data Abstraction ◽  
Global State ◽  
Shared Variable ◽  
Concurrent Program ◽  
Abstract Data ◽  
Shared State

<p>This thesis explores two kinds of program logics that have become important for modern program verification - separation logic, for reasoning about programs that use pointers to build mutable data structures, and rely guarantee reasoning, for reasoning about shared variable concurrent programs. We look more closely into the motivations for merging these two kinds of logics into a single formalism that exploits the benefits of both approaches - local, modular, and explicit reasoning about interference between threads in a shared memory concurrent program. We discuss in detail two such formalisms - RGSep and Local Rely Guarantee (LRG), in particular we analyse how each formalism models program state and treats the distinction between global state (shared by all threads) and local state (private to a given thread) and how each logic models actions performed by threads on shared state, and look into the proof rules specifically for reasoning about atomic blocks of code. We present full examples of proofs in each logic and discuss their differences. This thesis also illustrates how a weakest precondition semantics for separation logic can be used to carry out calculational proofs. We also note how in essence these proofs are data abstraction proofs showing that a data structure implements some abstract data type, and relate this idea to a classic data abstraction technique by Hoare. Finally, as part of the thesis we also present a survey of tools that are currently available for doing manual or semi-automated proofs as well as program analyses with separation logic and rely guarantee.</p>

Analyzing Concurrent Programs Title for Potential Programming Errors

2011 ◽  
pp. 380-415
Author(s):  
Qichang Chen ◽  
Liqiang Wang ◽  
Ping Guo ◽  
He Huang
Keyword(s):  
Shared Memory ◽  
Message Passing ◽  
Programming Models ◽  
Concurrent Programs ◽  
Sequential Programs ◽  
Multithreaded Programming ◽  
Testing And Debugging ◽  
Race Condition ◽  
Art Research ◽  
Concurrency Errors

Today, multi-core/multi-processor hardware has become ubiquitous, leading to a fundamental turning point on software development. However, developing concurrent programs is difficult. Concurrency introduces the possibility of errors that do not exist in sequential programs. This chapter introduces the major concurrent programming models including multithreaded programming on shared memory and message passing programming on distributed memory. Then, the state-of-the-art research achievements on detecting concurrency errors such as deadlock, race condition, and atomicity violation are reviewed. Finally, the chapter surveys the widely used tools for testing and debugging concurrent programs.

Sign in / Sign up

Export Citation Format

Share Document