lock-free algorithms

This work addresses the problem of spurious counterexamples arising from model incompleteness in the liveness verification of mutual exclusion algorithms based on (non-)blocking and (non-)atomic shared registers. To resolve this issue, we introduce justness as a completeness criterion and integrate it with concurrency relations induced by different register semantics to construct a precise model-checking framework. This approach successfully uncovers correctness flaws in several classic mutual exclusion algorithms under specific register assumptions and enables the development of effective corrections. By aligning the verification model more faithfully with the underlying concurrency semantics, our method significantly enhances both the reliability and practical applicability of algorithmic verification for mutual exclusion protocols.

This work addresses the formal correctness verification of mutual exclusion algorithms built upon shared read/write registers—both atomic and non-atomic. We propose a model-checking framework grounded in *justness* as a completeness criterion, integrating multiple concurrency semantics to accurately model register behavior and incorporating strong fairness assumptions to eliminate spurious counterexamples—thereby significantly improving detection accuracy for liveness properties such as livelock compared to conventional weak fairness. Experimental evaluation validates several classical mutual exclusion algorithms, uncovering previously unreported violation traces concerning safety or liveness. Based on these findings, we propose targeted refinements to restore correctness. To our knowledge, this is the first application of justness-based reasoning to mutual exclusion verification under shared register models, advancing both the reliability and depth of concurrent algorithm verification.

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 study investigates concurrency progress conditions for linearizable shared objects that exploit commutativity-awareness in the asynchronous read-write shared-memory model. Addressing limitations of existing progress guarantees, the paper introduces a novel condition termed *conflict-obstruction-freedom*, which ensures that a process can complete its operation even when contending only with commutative operations. Leveraging formal tools from concurrent computation theory and linearizability semantics, the work provides the first rigorous formulation of this condition and proves that a universal construction satisfying it is impossible in the asynchronous read-write model. This impossibility result demonstrates that synchronization overhead remains unavoidable even when contention arises solely from conflicting—yet potentially commutative—operations, thereby establishing a fundamental limitation on progress guarantees in commutativity-aware concurrent systems.

This paper addresses the runtime verification of linearizability for concurrent shared objects. We propose the first fully asynchronous, wait-free, and fault-tolerant detection algorithm—departing from conventional approaches that rely on consensus or synchronization assumptions. Our method builds an indirect verification framework and an object-class transformation mechanism atop primitive read/write objects, enabling strong verification and self-strengthening implementations for arbitrary concurrent objects. We introduce a novel predictive variant of verification and rigorously establish the undecidability boundary for general linearization verification. The system generates machine-checkable certificates and supports generalized correctness conditions—including set-linearizability and interval-linearizability—without requiring consensus primitives. This work establishes a new paradigm for modular, verifiable concurrent systems, delivering provably strong verification guarantees under minimal assumptions.

This study addresses the correctness and efficiency of concurrent linked list access under multithreaded workloads by systematically implementing five representative designs: coarse-grained locking, fine-grained locking, lazy synchronization, optimistic synchronization, and lock-free structures. Through empirical evaluation in C++, the work demonstrates a strong correlation between algorithmic performance and workload characteristics—such as read-write ratios and key ranges—as well as thread count. The findings reveal that coarse-grained locking and lazy lists achieve optimal performance in read-heavy scenarios with small key ranges, whereas lock-free lists exhibit significant advantages under high concurrency and large key ranges. Notably, fine-grained locking consistently underperforms due to per-node locking overhead, challenging the common assumption that finer granularity inherently yields better scalability. These results provide empirical guidance for selecting appropriate concurrent data structures in practice.

This work addresses the problem of determining whether barrier placements in a control flow graph guarantee synchronization of all threads across every execution. To this end, it introduces the first formal definitions of convergent nodes, convergent edges, and well-synchronized programs, along with a novel set of branch-and-merge inference rules. By integrating path-sensitive information with thread divergence analysis, the paper presents a bidirectional, linear-time worklist algorithm that efficiently performs static analysis of synchronization regions. The proposed method significantly enhances the compiler’s ability to optimize barriers on warp-synchronous hardware, achieving both theoretical rigor and practical efficiency.

Traditional reader-writer locks suffer from coarse-grained contention, making them ill-suited for concurrent data structures involving long-running operations. This work proposes SemanticLock, a synchronization mechanism that generalizes read-write semantics to arbitrary semantic conflict relationships among operations. By constructing an operation conflict graph, SemanticLock enables fine-grained concurrency control while allowing flexible specification of operation semantics. The approach has been integrated into array-based structures supporting both point and range queries, as well as an enhanced ConcurrentHashMap. Experimental results demonstrate that SemanticLock substantially improves concurrency performance under complex, long-duration operations.