[Paper Review] Local Linearizability

Andreas Haas, Thomas A. Henzinger+7 more|arXiv (Cornell University)|Feb 25, 2015

Distributed systems and fault tolerance34 references4 citations

TL;DR

This paper introduces local linearizability, a relaxed consistency condition for container-type concurrent data structures like queues and stacks, which ensures each thread observes its own operations and those removing its values in a linearizable order. By using existing linearizable building blocks and a local fast path optimization, the authors achieve significant performance and scalability improvements over traditional linearizable and relaxed implementations, outperforming even k-out-of-order variants in key workloads.

ABSTRACT

The semantics of concurrent data structures is usually given by a sequential specification and a consistency condition. Linearizability is the most popular consistency condition due to its simplicity and general applicability. Nevertheless, for applications that do not require all guarantees offered by linearizability, recent research has focused on improving performance and scalability of concurrent data structures by relaxing their semantics. In this paper, we present local linearizability, a relaxed consistency condition that is applicable to container-type concurrent data structures like pools, queues, and stacks. While linearizability requires that the effect of each operation is observed by all threads at the same time, local linearizability only requires that for each thread T, the effects of its local insertion operations and the effects of those removal operations that remove values inserted by T are observed by all threads at the same time. We investigate theoretical and practical properties of local linearizability and its relationship to many existing consistency conditions. We present a generic implementation method for locally linearizable data structures that uses existing linearizable data structures as building blocks. Our implementations show performance and scalability improvements over the original building blocks and outperform the fastest existing container-type implementations.

Motivation & Objective

• To address the performance and scalability limitations of linearizability in concurrent data structures by introducing a relaxed consistency condition.
• To define a consistency model that preserves per-thread correctness while reducing global synchronization overhead.
• To provide a generic implementation method using existing linearizable data structures as building blocks.
• To empirically evaluate the performance and scalability of locally linearizable implementations against existing approaches.
• To demonstrate that local linearizability enables practical, high-performance concurrent data structures for real-world workloads.

Proposed method

• Proposes local linearizability as a thread-local consistency condition, requiring only that each thread's induced history (its own insertions and removals of its values) be linearizable.
• Defines a thread-induced history as the projection of global execution onto a thread's insertions and removals of values it inserted, regardless of where the removals occur.
• Uses existing linearizable data structures (e.g., MS queue, Treiber stack) as building blocks and enhances them with a local fast path for improved performance.
• Employs a hybrid approach combining local operations with remote synchronization, where local operations are processed without immediate global consistency checks.
• Applies a modular verification technique: correctness of the overall structure follows from linearizability of the building blocks and local linearizability of the induced histories.
• Employs microbenchmarks (producer-consumer, sequential alternating) on a 40-core system to evaluate performance and scalability across varying thread counts.

Experimental results

Research questions

• RQ1 Can a relaxed consistency condition be defined that preserves per-thread correctness while improving performance and scalability?
• RQ2 How does local linearizability compare to existing relaxed semantics like k-out-of-order or quiescent consistency in practice?
• RQ3 Can existing linearizable data structures be composed into locally linearizable ones with minimal modification and measurable performance gains?
• RQ4 What is the impact of local fast paths on scalability in high-contention workloads?
• RQ5 Does local linearizability enable correct and efficient implementations of common container types like queues and stacks?

Key findings

• The LCRQ (Locally Consistent Ring Queue) and LLD (Locally Linearized Dual) data structures outperform both standard linearizable and k-out-of-order variants in high-contention workloads.
• LLD LCRQ and LL + D Treiber stack show nearly linear scaling across 80 threads, outperforming MS queue and Treiber stack beyond 10 threads.
• The LLD optimization, which prioritizes local operations, significantly improves performance, especially in nearly empty states where k-FIFO performs poorly.
• In the sequential alternating workload, LLD LCRQ and LLD k-Stack outperform their k-out-of-order counterparts, demonstrating the benefit of local fast paths.
• Local linearizability enables implementations that are both correct and highly scalable, with performance improvements up to several times faster than traditional linearizable counterparts.
• Verification of local linearizability is modular and compositional, relying on linearizability of building blocks and a simple axiomatic condition on ordering of enqueues and dequeues.