[Paper Review] A Concurrency-Optimal List-Based Set

Aksenov, Vitaly, Vincent Gramoli+3 more|arXiv (Cornell University)|Feb 5, 2015

Distributed systems and fault tolerance24 references3 citations

TL;DR

This paper proposes the Value-Based List (VBL), a concurrency-optimal list-based set algorithm that uses value-aware try-lock synchronization to reject only schedules that violate linearizability. By validating the value in the next node before acquiring locks, VBL achieves higher concurrency and outperforms both the Lazy Linked List and Harris-Michael algorithms by up to 1.6× on highly contended workloads.

ABSTRACT

Designing an efficient concurrent data structure is an important challenge that is not easy to meet. Intuitively, efficiency of an implementation is defined, in the first place, by its ability to process applied operations in parallel, without using unnecessary synchronization. As we show in this paper, even for a data structure as simple as a linked list used to implement the set type, the most efficient algorithms known so far are not concurrency-optimal: they may reject correct concurrent schedules. We propose a new algorithm for the list-based set based on a value-aware try-lock that we show to achieve optimal concurrency: it only rejects concurrent schedules that violate correctness of the implemented set type. We show empirically that reaching optimality does not induce a significant overhead. In fact, our implementation of the concurrency-optimal algorithm outperforms both the Lazy Linked List and the Harris-Michael state-of-the-art algorithms.

Motivation & Objective

• To address the lack of concurrency-optimality in existing list-based set algorithms, which reject correct concurrent schedules unnecessarily.
• To design a concurrent data structure that accepts all correct interleavings—i.e., is concurrency-optimal—without sacrificing performance.
• To evaluate whether achieving optimal concurrency induces significant overhead or enables better scalability under contention.
• To demonstrate that value-aware synchronization can improve both concurrency and performance in list-based sets.

Proposed method

• Introduces a value-aware try-lock mechanism: acquire the lock first, then validate whether the value in the next node has changed before proceeding.
• Combines the wait-free traversal of the Lazy Linked List with the logical deletion model of Harris-Michael to decouple metadata from structural updates.
• Performs value validation before lock acquisition, reducing unnecessary contention on metadata when operations do not modify data.
• Uses compare-and-swap (CAS) for lock acquisition and restarts the operation if the value changes during validation, ensuring consistency.
• Employs Java’s garbage collector for memory reclamation, separating metadata (e.g., deletion marks, versions) from structural data to reduce false sharing and improve performance.
• Formally proves that VBL rejects only schedules that would violate linearizability, making it concurrency-optimal.

Experimental results

Research questions

• RQ1 Can a list-based set be designed to be concurrency-optimal, accepting all correct concurrent schedules?
• RQ2 Does achieving concurrency optimality incur a significant performance overhead compared to existing high-performance algorithms?
• RQ3 Can value-aware synchronization improve both concurrency and throughput in concurrent linked lists?
• RQ4 How does VBL perform under high contention compared to the Lazy Linked List and Harris-Michael algorithms?

Key findings

• VBL achieves concurrency-optimality by rejecting only schedules that would violate linearizability, making it the most concurrent list-based set algorithm to date.
• On a 72-core Intel machine, VBL outperforms the Lazy Linked List by 1.6× under a 20% update workload with 72 threads.
• On read-only workloads, VBL outperforms the Harris-Michael algorithm by up to 1.6× due to reduced metadata access during traversals.
• The performance drop observed in the Lazy Linked List beyond 40 threads is mitigated in VBL, demonstrating improved scalability under high contention.
• Empirical evaluation confirms that optimal concurrency does not incur a significant overhead, and VBL maintains high throughput even in highly contended scenarios.