Relaxing Concurrent Data-structure Semantics for Increasing Performance: A Multi-structure 2D Design Framework

TL;DR

The paper tackles scalability bottlenecks in concurrent data structures by introducing a deterministic, two-dimensional semantic-relaxation framework that distributes operations across multiple sub-structures (width) while enabling thread-local consecutiveness (depth). It formalizes two variants, WinCoupled and WinDecoupled, proves linearizability under $k$-out-of-order semantics and analyzes complexity, and then instantiates four 2D data structures (2D-Stack, 2D-Queue, 2D-Deque, 2D-Counter) with correctness and lock-freedom guarantees. Through extensive experiments comparing to existing relaxed data structures, it demonstrates significant throughput improvements and monotonic behavior as relaxation increases, while also discussing accuracy trade-offs. The framework is simple to implement on top of existing lock-free algorithms, provides deterministic bounds, and enables tunable locality and contention characteristics to adapt to diverse workloads and hardware. The work thus offers a practical, general method to extend lock-free data structures with deterministic, monotone performance gains via controlled semantic relaxation.

Abstract

There has been a significant amount of work in the literature proposing semantic relaxation of concurrent data structures for improving scalability and performance. By relaxing the semantics of a data structure, a bigger design space, that allows weaker synchronization and more useful parallelism, is unveiled. Investigating new data structure designs, capable of trading semantics for achieving better performance in a monotonic way, is a major challenge in the area. We algorithmically address this challenge in this paper.To address this challenge, we present an efficient lock-free, concurrent data structure design framework for out-of-order semantic relaxation. Our framework introduces a new two dimensional algorithmic design, that uses multiple instances of an implementation of the given data structure. The first dimension of our design is the number of data structure instances onto which operations are spread to, in order to achieve increased parallelism through disjoint memory accesses. The second dimension is the number of consecutive operations of a single thread that can stay at the same data structure instance in order to benefit from data locality. Our design can flexibly explore this two-dimensional space to achieve the property of monotonically increasing throughput performance via relaxing concurrent data structure semantics within a tight deterministic relaxation bound, as we prove in the paper. We show how our framework can instantiate lock-free out-of-order queues, stacks, counters and dequeues. The experimental evaluation shows that our two-dimensional data structures: i) significantly outperform the respected previous proposed ones with respect to scalability and throughput performance and ii) monotonically increase throughput as relaxation increases.

Figures (21)

• Figure 1: An illustration of our 2D design using a Stack as an example. The example employs three sub-stacks$a$, $b$ and $c$. The relaxation bound $k$ is proportional to the area of the green dashed rectangle in which stack operations are bounded to occur. Circles represent stack items. Grey circles depict items that can be Poped. $a$ can be used for both Push and Pop. $b$ can be used for Push but not for Pop. $c$ can be used for Pop but not for Push.
• Figure 2: Single-S
• Figure 3: Multi-S
• Figure 5: Single-S
• Figure 6: Multi-S

Theorems & Definitions (12)

• Lemma 1
• Theorem 2
• Theorem 3
• Lemma 4
• Lemma 5
• Theorem 6
• Theorem 7
• Theorem 8
• Theorem 9
• Theorem 10