concurrency and multithreading

Existing user-space coroutine/fiber synchronization mechanisms implicitly assume kernel scheduling, introducing unnecessary latency on critical paths and limiting high-concurrency throughput. This paper proposes Combine-and-Exchange Scheduling (CES), a novel synchronization paradigm for purely user-space cooperative scheduling. CES eliminates cross-thread overhead by retaining critical sections on the same thread during lock contention, while dynamically redistributing parallelizable tasks to idle threads. Crucially, it co-designs user-space synchronization primitives with the scheduler to fully bypass kernel intervention. Experimental evaluation demonstrates that CES achieves up to 3× higher throughput on application-level benchmarks and up to 8× speedup on microbenchmarks—significantly outperforming state-of-the-art user-space synchronization approaches.

This work addresses data races and redundant barrier directives in OpenMP-parallelized C/C++/Fortran programs, proposing the first fully automated repair framework. Methodologically, it integrates OpenMP semantic modeling, context-sensitive static analysis, constraint solving, and lightweight instrumentation-based validation, employing a language-agnostic synchronization construct insertion strategy to precisely localize race sources and generate minimal correctness-preserving patches. Evaluated on 415 real-world OpenMP programs, the tool achieves 100% zero false repairs, successfully fixes all detected data races, and reduces synchronization overhead by 12.7% on average. Its core contribution is the first end-to-end, fully automated repair solution for OpenMP programs—demonstrating generality across languages, high precision in patch generation, and practical deployability.

This work addresses the challenges of latency and scalability in designing efficient concurrent primitives under high write contention in shared-memory systems. It introduces a novel approach based on a contention-resolution algorithm that transforms contention-prone hardware primitives into higher-level concurrent objects within an approximately synchronous randomized scheduling model. For the first time, the study achieves composable, low-latency concurrent primitives against an adaptive adversary, and establishes a theoretical lower bound for the space–latency tradeoff. Using only O(1) read–write registers and a single compare-and-swap (CAS) register, the construction yields—with high probability—O(log P) latency for a variety of primitives, including read–write registers, CAS, load-linked/store-conditional (LL/SC), fetch-and-increment, bounded max registers, and counters.

This work addresses atomicity violations in concurrent programs—a prevalent source of concurrency bugs—by introducing AtomSanitizer, a novel stream-based conflict serializability detection algorithm. AtomSanitizer achieves a time complexity of O(nk²), substantially outperforming existing approaches, and integrates a lightweight runtime monitoring mechanism within the ThreadSanitizer (TSAN) framework to enable low-overhead, real-time atomicity validation. Experimental evaluation demonstrates that AtomSanitizer consistently outperforms state-of-the-art detectors on standard benchmarks, with both time and memory overheads comparable to those of TSAN’s data race detection, thereby offering an efficient solution for runtime atomicity monitoring in concurrent software.

To address the need for high-performance scientific computing, this paper designs and implements a lightweight, lock-free, and highly portable C++17 thread pool that requires no advanced multithreading APIs and enables fine-grained parallelism control. Methodologically, it leverages standard C++17 features—namely `std::thread`, `std::optional`, and `constexpr if`—to achieve full standard-library portability, augmented by lock-free queue optimizations. Key contributions include: (1) a zero-allocation task submission interface built on `std::variant` and coroutine-aware scheduling; (2) a dynamically prioritized task queue coupled with an RAII-based exception propagation mechanism; and (3) a purely standard-compliant implementation with minimal runtime dependencies. Experimental evaluation on multicore CPUs demonstrates near-linear speedup scalability, up to 3.2× improvement in task throughput, and a 92% reduction in memory allocation overhead compared to baseline approaches.

Dynamic data-race detection tools (e.g., ThreadSanitizer) suffer from high runtime overhead due to pervasive instrumentation, severely limiting practical deployment. This paper proposes the first compiler-level, systematic approach to eliminate redundant instrumentation—implemented in LLVM via interprocedural static analysis. Our method jointly models memory access patterns, synchronization operations, and thread creation; it leverages equivalence-class representatives and dominance relations to precisely identify memory accesses guaranteed to be race-free, thereby removing unnecessary race-detection probes. Crucially, the technique preserves full detection completeness and alarm precision. Evaluated on real-world applications, it achieves a 1.34× geometric mean speedup over baseline ThreadSanitizer, with up to 2.5× acceleration in highly concurrent workloads. Compilation overhead is negligible, and the entire process is fully automated. The implementation has been officially accepted and merged into the mainline ThreadSanitizer distribution.

Addressing the long-standing absence of systematic parallel implementations for miniKanren, this paper proposes the first practical implicit parallelization framework. Leveraging Go’s goroutines and channels, we design a lightweight concurrent execution model that enables streaming unification of logic variables and parallel optimization of search strategies—achieving automatic parallelization of non-deterministic inference without modifying existing miniKanren programs. The framework preserves full semantic compatibility with standard miniKanren while significantly improving inference throughput on multi-core hardware. Experimental evaluation on representative benchmarks demonstrates near-linear speedup across varying core counts. Beyond validating the feasibility of parallelizing miniKanren, our work establishes an extensible, cross-language paradigm for parallel logic programming, offering a novel pathway toward high-performance logic programming language design and implementation. (149 words)

Verifying correctness of MPI parallel programs remains challenging due to persistent issues in deadlock freedom, termination, and functional equivalence. This paper introduces DafnyMPI: the first general-purpose MPI concurrency verification framework built as an extension of the mature sequential verification language Dafny—without requiring custom concurrent logics. Instead, it leverages explicit communication topology declarations and preconditions for MPI primitives, integrated with dependency-guarantee reasoning, buffer-safety constraints, and standard Dafny automated verification techniques to rigorously prove that these preconditions guarantee deadlock freedom. DafnyMPI is the first framework to fully verify, within Dafny, three distinct PDE numerical solvers implemented in MPI—establishing functional correctness, termination, and absence of runtime errors. The evaluation demonstrates both the soundness and practical applicability of the approach.

This work addresses the poor performance and high contention of shared stack access under high concurrency by proposing a sharded, blocking linearizable stack design. The approach innovatively integrates an elimination mechanism with request combining and employs a lightweight fetch-and-increment atomic operation to coordinate access across shards. This strategy effectively reduces thread contention and substantially improves parallel efficiency. Experimental results demonstrate that, in highly contended multi-threaded scenarios, the proposed design outperforms existing concurrent stack implementations across most workloads, achieving up to a 2× speedup.

This work addresses the challenge of efficiently parallelizing fixed-point iterations in static analysis, which is hindered by rigid, fixed-granularity task decomposition. To overcome this limitation, the paper proposes a parameterized parallel fixed-point engine that, for the first time, supports dynamic switching of task granularity and unifies two prevailing parallel paradigms—on-the-fly sharing and independent state exploration. The engine extends the top-down solver TD with thread-safe hash tables and a publish/subscribe mechanism, and is integrated into the Goblint framework. Experimental evaluation on large real-world programs demonstrates significant improvements in analysis efficiency, thereby validating the effectiveness of the proposed multi-granularity parallelization strategy.