asynchronous programming

This study addresses the challenge of verifying liveness properties in Rust asynchronous runtimes by proposing a lightweight, modular proof technique. Methodologically, it constructs a formal verification framework grounded in a model of the Rust language, integrating static analysis with a modular proof architecture. This approach pioneers a liveness verification paradigm for highly concurrent and heavily optimized libraries, overcoming traditional verification bottlenecks. Experimental results demonstrate that the proposed technique successfully verifies the eventual progress of multiple critical components, ensuring the reliable advancement of asynchronous tasks. Ultimately, this work provides a scalable pathway for formally guaranteeing low-level system infrastructure, significantly enhancing the reliability of the Rust asynchronous ecosystem.

本文探讨了直线路线异步编程的设计空间，通过分析几种现有语言的差异，明确了九个设计维度，以帮助理解不同语言在异步函数调用、任务生命周期及取消处理等方面的语义。

论文提出使用高阶组合子统一解决异步调用中的错误处理问题，包括超时、重试等，并保持业务逻辑不变。

This work addresses the lack of real-time guarantees in Rust asynchronous programming for ROS 2 robotic applications. We first systematically model the coupling between Rust’s async execution model—via the R2R binding—and ROS 2’s real-time scheduling, revealing its detrimental impact on end-to-end response time determinism. To restore temporal predictability, we propose a structured scheduling framework for deterministic real-time operation, comprising (i) dynamic thread priority assignment and (ii) explicit callback-to-thread mapping, compatible with both Tokio and async-std runtimes. We evaluate the framework under synthetic workloads and an autonomous driving case study, demonstrating bounded response times, significantly reduced latency for critical tasks, and practical scalability. This work bridges a critical gap in both the theoretical analysis and practical scheduling of Rust-based asynchronous ROS 2 systems.

Concurrent programming faces a fundamental tension between expressiveness and determinism; conventional shared-memory models suffer from schedule-dependent behavior and non-reproducible outputs due to destructive updates. Method: This paper introduces Clock-Synchronized Memory (CSM), the first shared-memory abstraction that guarantees deterministic semantics for general-purpose concurrent programs—extending beyond the restricted primitives (e.g., registers, signals) supported in traditional synchronous programming (SP). Grounded in the formal mathematical semantics of SP, we design CSM memory primitives, a clock-synchronization protocol, and rigorously defined access rules, ensuring full compatibility with existing SP compilation and verification toolchains. Results: Experiments demonstrate that CSM significantly enhances expressiveness, modularity, and code reusability of concurrent programs while preserving formal verifiability. It provides a theoretically sound and practically deployable deterministic concurrency infrastructure for safety-critical systems.

This study addresses the absence of rigorous formal semantics for Rust’s concurrent and asynchronous programming, which has hindered the deductive verification of such programs. We propose a modular, source-level formal semantics for Rust that adopts a “locally abstract, globally concrete” framework to decouple local evaluation from global traces. This semantics is further extended to model the Tokio runtime, providing the first complete formalization of Rust’s asynchronous features and scheduler fairness. Building upon this semantic foundation, we develop a program logic and prove its soundness, thereby enabling efficient source-level verification of asynchronous Rust programs. Ultimately, this work establishes both the theoretical foundations and methodological support necessary for the formal assurance of safety-critical system-level software.

This study addresses the cumbersome nature of Python coroutine pipelines and the ambiguous specifications of JavaScript push-stream protocols by proposing a producer-driven streaming protocol based on formal refinement. Methodologically, the TLA+ specification language and the TLC model checker are employed to ensure design correctness through stepwise refinement verification. The proposed protocol seamlessly integrates synchronous and asynchronous modules, achieving unbounded buffered flow control and graceful termination. Furthermore, it supports independent termination of intermediate modules with explicit reporting of environmental suspension states, thereby avoiding error recovery mechanisms and eliminating the need for dynamic heap allocation. Experimental results demonstrate that the protocol’s critical properties fully satisfy the formal specification. It can express a superset of JavaScript streaming semantics and significantly outperforms existing Python-based solutions.

This work addresses the end-to-end latency in large language models (LLMs) caused by decoding stalls during synchronous function calls. The authors propose AsyncFC, a framework that enables concurrency between model decoding and function execution—and parallelism across functions—without modifying the model architecture or function implementations. Its key innovation lies in uncovering, for the first time, that LLMs natively possess the capability to reason symbolically about “futures,” thereby supporting non-intrusive asynchronous tool invocation. Built upon this insight, AsyncFC employs a dependency-aware asynchronous scheduler based on future semantics while remaining compatible with existing synchronous protocols. Experimental results demonstrate that AsyncFC substantially reduces task completion time on standard function-calling and software engineering benchmarks, all while preserving output accuracy.

Rust lacks a general-purpose dynamic analysis framework capable of supporting diverse runtime analyses. This work proposes DMIR, the first natively Rust-based, event-driven dynamic analysis infrastructure, which captures MIR-level semantics through compiler instrumentation and, for the first time, integrates high-level language features—such as ownership, types, and the memory model—into dynamic analysis. Runtime behaviors are exposed as structured event streams, enabling rich semantic introspection. Leveraging DMIR, we implement three classes of analysis tools: concolic execution, Rust-specific checkers, and control-flow tracing, demonstrating its expressiveness and practicality while maintaining acceptable runtime overhead.

This work presents the first purely library-based implementation of core synchronous reactive programming mechanisms in standard OCaml 5, without requiring any language extensions. Building upon algebraic effects and deep effect handlers, we introduce the Tempo runtime, which delineates reactive suspension points via effect operations and reifies captured continuations into tasks scheduled according to logical instant semantics. This approach supports cooperative threads, broadcast signals, and dynamic process creation while fully reproducing the core semantics of ReactiveML. Through empirical evaluation, we quantify the runtime overhead incurred by this library-level implementation and identify the key mechanisms responsible for the dominant performance costs.