Skip to content
Book Open access

DeterV: Verifying Deterministic Parallel Execution

Sep 2026 · Proceedings of the 14th Workshop on Programming Languages and Operating Systems · 0 citations · 48 references

TL;DR

DeterV is a deterministic parallel runtime which uses Verus to verify its correctness and equivalence to serial execution in the input order and attains a 3:1 proof-to-code ratio and incurs only trivial runtime overhead compared to an unverified baseline.

Abstract

Deterministic execution is a critical component for replicated systems, where each replica is required to advance its state deterministically in an agreed-upon order even in the presence of concurrent execution. Despite the extensive efforts on the design space, the correctness of deterministic parallel execution engines is not yet backed by provable guarantees. We close this gap with DeterV, a deterministic parallel runtime which uses Verus to verify its correctness and equivalence to serial execution in the input order. DeterV establishes determinism via per-object local reasoning, an effect-boundary contract which limits the determinism enforcement to a single point, and a series of refinements that compose these local guarantees globally. DeterV attains a 3:1 proof-to-code ratio and incurs only trivial runtime overhead compared to an unverified baseline. Despite being a single system implementation, we discuss how DeterV's ideas can generalize to other usecases and designs.

Read PDF

Similar papers

Book Open access Sep 2026

Lion: Modular Verification of Async Runtime Liveness

This work introduces an append-only logical event log that abstracts implementation details and enables a Kamp-style translation of Linear Temporal Logic into First-Order Logic, which enables deductive program verifiers to reason about progress via monotonic timestamps without needing native temporal logic support.

Ti Zhou, Zi-Hao Zhang, Omar Chowdhury et al. · 1 citation
Preprint Aug 2026

Composable Building Blocks for Resilient Asynchronous Code

This work shows how higher-order combinators solve higher-order problems of asynchronous calls to a network service, database, or language model uniformly, including timeouts, retries, rate limiting, caching, reentrant locking, and cancellation.

Frank Tip · 0 citations
Book Open access Sep 2026

Verifying a high-performance distributed transaction system using permissioned state machines

The permissioned state machine (PSM) approach, which extends TLA-style protocol reasoning with ideas from concurrent separation logic, enables the developer to specify and verify complex protocols, such as Tulip, by breaking them down into smaller modules.

Yun-Sheng Chang, Joseph Tassarotti, Frans Kaashoek et al. · 0 citations
Preprint Oct 2026

Modular Responsiveness Verification of Rust Async Runtimes

This work presents a lightweight and modular proof technique for verifying eventual progression guarantees for Rust async runtimes and realizes this proof technique as a set of static analyses for Rust and uses these to verify eventual progression of several key components of multiple Rust async runtime implementations...

Yan-Ze Li, I. Beschastnikh, Alexander J. Summers · 0 citations

We use cookies to run the site and, with your consent, for analytics and to show ads. See our Cookie Policy.