Concurrent Size

TL;DR

This paper introduces a low-overhead, wait-free method for obtaining a linearizable size of concurrent data structures, significantly improving efficiency over traditional snapshot-based approaches.

Contribution

It presents a novel methodology for adding a linearizable size operation to concurrent sets and dictionaries with minimal performance impact.

Findings

The proposed size operation is wait-free and has linear complexity in the number of threads.

It executes faster than snapshot-based methods by orders of magnitude.

It incurs only 1-20% throughput loss on various Java concurrent data structures.

Abstract

The size of a data structure (i.e., the number of elements in it) is a widely used property of a data set. However, for concurrent programs, obtaining a correct size efficiently is non-trivial. In fact, the literature does not offer a mechanism to obtain a correct (linearizable) size of a concurrent data set without resorting to inefficient solutions, such as taking a full snapshot of the data structure to count the elements, or acquiring one global lock in all update and size operations. This paper presents a methodology for adding a concurrent linearizable size operation to sets and dictionaries with a relatively low performance overhead. Theoretically, the proposed size operation is wait-free with asymptotic complexity linear in the number of threads (independently of data-structure size). Practically, we evaluated the performance overhead by adding size to various concurrent data structures in Java$-$a skip list, a hash table and a tree. The proposed linearizable size operation executes faster by orders of magnitude compared to the existing option of taking a snapshot, while incurring a throughput loss of $1\%-20\%$ on the original data structure's operations.