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

## TL;DR

This paper introduces a novel two-dimensional framework for designing lock-free, concurrent data structures that relax semantics to enhance scalability and performance, demonstrating significant improvements over existing methods.

## Contribution

It presents a flexible, monotonic relaxation framework using multiple data structure instances and operation grouping to improve concurrent data structure performance.

## Key findings

- Framework achieves higher scalability and throughput.
- Monotonically increasing performance with relaxation levels.
- Outperforms existing concurrent data structures in experiments.

## 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.