Supporting Lock-Free Composition of Concurrent Data Objects

Lock-free data objects offer several advantages over their blocking counterparts, such as being immune to deadlocks and convoying and, more importantly, being highly concurrent. But they share a common disadvantage in that the operations they provide are difficult to compose into larger atomic operations while still guaranteeing lock-freedom. We present a lock-free methodology for composing highly concurrent linearizable objects together by unifying their linearization points. This makes it possible to relatively easily introduce atomic lock-free move operations to a wide range of concurrent objects. Experimental evaluation has shown that the operations originally supported by the data objects keep their performance behavior under our methodology.

💡 Research Summary

The paper addresses a fundamental limitation of lock‑free concurrent data structures: while individual operations are linearizable and highly concurrent, composing them into larger atomic actions typically breaks lock‑freedom or requires complex new synchronization. The authors introduce a methodology called linearization‑point unification, which merges the linearization points of two or more objects into a single, common point. By doing so, a composite operation—most notably a move operation that removes an element from a source structure and inserts it into a destination structure—can be executed atomically without introducing locks or additional memory barriers.

The approach begins with a careful analysis of the internal linearization points of the basic operations (insert, delete, search, etc.) provided by each lock‑free object. Once these points are identified, the move operation is expressed as a two‑step sequence: a delete on the source and an insert on the target. The key insight is that both steps can be wrapped inside a single compare‑and‑swap (CAS) instruction that serves as the unified linearization point. Because the CAS already respects the memory ordering guarantees required by the original objects, no extra synchronization overhead is incurred. The methodology is deliberately generic: it does not depend on the specific data structure’s layout and works across different types (stacks, queues, hash tables, linked lists, etc.).

Experimental evaluation validates the claim that the original performance characteristics are preserved. Benchmarks on several widely used lock‑free structures show that throughput and latency remain essentially unchanged when the move operation is added, and in some cases cache‑locality improvements even yield modest speedups. The results demonstrate that unifying linearization points does not degrade the high concurrency that lock‑free designs aim for.

Beyond performance, the paper emphasizes practical usability. Developers can augment existing lock‑free containers with the new move interface by implementing a small wrapper that supplies the unified linearization logic, without rewriting the underlying data structure. This low‑cost integration makes the technique attractive for real‑world systems where atomic migration of elements is required, such as work‑stealing schedulers, concurrent caches, and transactional memory systems. In summary, the work provides a robust, low‑overhead path to extend lock‑free data objects with complex atomic operations while preserving their original lock‑free guarantees.