Soter

D'Osualdo, Emanuele; Kochems, Jonathan; Ong, C.-H. Luke

doi:10.1145/2414639.2414658

Cited by 6 publications

(2 citation statements)

References 8 publications

(9 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Parameterized Verification Counter abstraction [Pnueli et al 2002] is a classic way to exploit symmetry. [D'Osualdo et al 2013[D'Osualdo et al , 2012 convert distributed Erlang programs into a vector addition systems which can be checked for coverability properties, thus excluding e.g., deadlock-freedom. [Farzan et al 2014] and[Gleissenthall et al 2016] automatically infer counting arguments in the form of counting automata or by synthesizing descriptions of sets and referring to their cardinalities, respectively.…”

Section: Related Workmentioning

confidence: 99%

Pretend synchrony: synchronous verification of asynchronous distributed programs

Gleissenthall

Kıcı

Bakst

et al. 2019

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

We present pretend synchrony, a new approach to verifying distributed systems, based on the observation that while distributed programs must execute asynchronously, we can often soundly treat them as if they were synchronous when verifying their correctness. To do so, we compute a synchronization, a semantically equivalent program where all sends, receives, and message buffers, have been replaced by simple assignments, yielding a program that can be verified using Floyd-Hoare style Verification Conditions and SMT. We implement our approach as a framework for writing verified distributed programs in Go and evaluate it with four challenging case studiesÐ the classic two-phase commit, the Raft leader election protocol, single-decree Paxos protocol, and a Multi-Paxos based distributed key-value store. We find that pretend synchrony allows us to develop performant systems while making verification of functional correctness simpler by reducing manually specified invariants by a factor of 6, and faster, by reducing checking time by three orders of magnitude. CCS Concepts: • Theory of computation → Program verification; Program analysis; Distributed computing models; Concurrency; • Software and its engineering → Software notations and tools.

show abstract

Section: Related Workmentioning

confidence: 99%

Pretend synchrony: synchronous verification of asynchronous distributed programs

Gleissenthall

Kıcı

Bakst

et al. 2019

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

show abstract

“…However, this work does not handle programs with infinite control, i.e., an unbounded number of processes. In contrast, [D'Osualdo et al 2013[D'Osualdo et al , 2012 convert an Erlang program into a (infinite-state) vector addition system which can only be checked for coverability properties, thus excluding e.g., deadlock-freedom. [Summers and Müller 2016] describes a logic for reasoning about safety and liveness properties of actor programs.…”

Section: Related Workmentioning

confidence: 99%

Verifying distributed programs via canonical sequentialization

Bakst

Gleissenthall

Kıcı

et al. 2017

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

We introduce canonical sequentialization, a new approach to verifying unbounded, asynchronous, messagepassing programs at compile-time. Our approach builds upon the following observation: due the combinatorial explosion in complexity, programmers do not reason about their systems by case-splitting over all the possible execution orders. Instead, correct programs tend to be well-structured so that the programmer can reason about a small number of representative executions, which we call the program's canonical sequentialization. We have implemented our approach in a tool called Brisk that synthesizes canonical sequentializations for programs written in Haskell, and evaluated it on a wide variety of distributed systems including benchmarks from the literature and implementations of MapReduce, two-phase commit, and a version of the Disco distributed file-system. Brisk verifies unbounded versions of the benchmarks in tens of milliseconds, yielding the first concurrency verification tool that is fast enough to be integrated into a design-implement-check cycle. is limited to finite systems: when the number of processes is unbounded, e.g., if processes are spawned based on input parameters, model checking cannot guarantee correctness as the state space, and hence, the number of executions, is infinite. Consequently, the distributed systems developer is bereft of development-and compile-time tools that guarantee the absence of concurrency errors.Our Approach In this paper, we propose canonical sequentialization, a new approach to verifying concurrency properties of unbounded, asynchronous, message-passing programs at compile-time. Our approach builds upon the following observation: due the combinatorial explosion in complexity, programmers do not reason about their systems by case-splitting over all the possible execution orders. Instead, correct programs tend to be well-structured so that the programmer can reason about a small number of representative executions which we call the program's canonical sequentialization.Example: Two-Phase Commit Consider the classic two-phase commit protocol [Lampson and Sturgis 1976], which consists of a leader process trying to commit a transaction to a number of database nodes. The protocol proceeds in two phases. In the first phase, the leader issues a tentative transaction. The leader then waits for answers from the nodes who may decide to either accept or abort the transaction. This initiates the second phase: if all nodes agreed, the leader sends them a commit message; otherwise, it sends an abort message. Finally, each node sends its acknowledgement of the final decision.Even though leader and database nodes execute in parallel, the concurrency is well-structured. First, due to the lack of a shared memory, most actions executed by different nodes are independent of each other, and thus commute. For example, a tentative proposal sent to one of the database nodes is independent of the messages other database nodes might send or receive. Thus, in the spirit of Lipton's movers [Lipto...

show abstract

Automatic Verification of Erlang-Style Concurrency

D'Osualdo

Kochems

Ong

2013

Lecture Notes in Computer Science

Self Cite

View full text Add to dashboard Cite

This paper presents an approach to verify safety properties of Erlang-style, higher-order concurrent programs automatically. Inspired by Core Erlang, we introduce λACTOR, a prototypical functional language with pattern-matching algebraic data types, augmented with process creation and asynchronous message-passing primitives. We formalise an abstract model of λACTOR programs called Actor Communicating System (ACS) which has a natural interpretation as a vector addition system, for which some verification problems are decidable. We give a parametric abstract interpretation framework for λACTOR and use it to build a polytime computable, flow-based, abstract semantics of λACTOR programs, which we then use to bootstrap the ACS construction, thus deriving a more accurate abstract model of the input program. We have constructed Soter, a tool implementation of the verification method, thereby obtaining the first fully-automatic, infinite-state model checker for a core fragment of Erlang. We find that in practice our abstraction technique is accurate enough to verify an interesting range of safety properties. Though the ACS coverability problem is EX-PSPACE-complete, Soter can analyse these verification problems surprisingly efficiently.

show abstract

Soter

Cited by 6 publications

References 8 publications

Pretend synchrony: synchronous verification of asynchronous distributed programs

Pretend synchrony: synchronous verification of asynchronous distributed programs

Verifying distributed programs via canonical sequentialization

Automatic Verification of Erlang-Style Concurrency

Contact Info

Product

Resources

About