How to Relax Instantly: Elastic Relaxation of Concurrent Data Structures

TL;DR

This paper introduces the concept of elastic relaxation and presents the Lateral structure, which is an algorithmic component capable of supporting the design of elastically relaxed concurrent data structures and outlines how to use the Lateral to design elastically relaxed lock-free counters and deques.

Abstract

The sequential semantics of many concurrent data structures, such as stacks and queues, inevitably lead to memory contention in parallel environments, thus limiting scalability. Semantic relaxation has the potential to address this issue, increasing the parallelism at the expense of weakened semantics. Although prior research has shown that improved performance can be attained by relaxing concurrent data structure semantics, there is no one-size-fits-all relaxation that adequately addresses the varying needs of dynamic executions. In this paper, we first introduce the concept of elastic relaxation and consequently present the Lateral structure, which is an algorithmic component capable of supporting the design of elastically relaxed concurrent data structures. Using the Lateral , we design novel elastically relaxed, lock-free queues and stacks capable of reconfiguring relaxation during run time. We establish linearizability and define upper bounds for relaxation errors in our designs. Experimental evaluations show that our elastic designs hold up against state-of-the-art statically relaxed designs, while also swiftly managing trade-offs between relaxation and operational latency. We also outline how to use the Lateral to design elastically relaxed lock-free counters and deques.

Figures (5)

• Figure 1: The 2D queue has two windows defining the operable area for the enqueue and dequeue operations.
• Figure 2: By adding a Lateral to the 2D queue, changes in width at Win$^{\IfNoValueTF{tail}{}{\textit{tail}}}_{\IfNoValueTF{-NoValue-}{}{\textit{-NoValue-}}}$ can be tracked and adjusted to by Win$^{\IfNoValueTF{head}{}{\textit{head}}}_{\IfNoValueTF{-NoValue-}{}{\textit{-NoValue-}}}$ .
• Figure 3: Scalability of throughput and rank error during static relaxation. When scaling with threads (top row), the error bound is fixed as $k=5\times10^3$. When scaling with error bound, 256 threads are used.
• Figure 4: Performance during one run, where threads repeatedly insert or remove items at random, and vertical lines indicate user-initiated elastic changes. It runs for four seconds with 128 threads. The width (W) and depth (D) are annotated for every relaxation period.
• Figure 5: Producer-consumer system with a variable number of producers over time for the elastic LaW queue. The Dynamic Relaxation plots use a controller to adjust the relaxation, stabilizing the producer's latency.

Theorems & Definitions (19)

• definition thmcounterdefinition
• theorem thmcountertheorem
• proof
• lemma thmcounterlemma
• proof
• theorem thmcountertheorem
• proof
• lemma thmcounterlemma
• proof
• lemma thmcounterlemma