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

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.

💡 Research Summary

The paper tackles the long‑standing challenge of scaling concurrent data structures by exploiting semantic relaxation in a novel two‑dimensional (2D) design space. Traditional approaches either weaken ordering (k‑out‑of‑order) or increase the number of disjoint instances (sub‑structures) to reduce contention, but they suffer from increased search overhead and deteriorated cache locality as the number of instances grows. The authors propose a lock‑free framework that simultaneously controls width (the number of sub‑structures) and depth (the maximum number of consecutive operations a thread may perform on the same sub‑structure).

A Window is defined for each sub‑structure as a range (