Multiversion Concurrency with Bounded Delay and Precise Garbage Collection

TL;DR

This paper introduces a multiversion transactional system that guarantees bounded delays for read-only and non-concurrent writing transactions, supports precise garbage collection, and is validated through experiments on balanced tree data structures.

Contribution

It presents the first bounded delay solutions for multiple readers and single writers in transactional systems, using functional data structures and a wait-free version maintenance approach.

Findings

Supports constant delay for read-only transactions.

Achieves delay proportional to the number of processes for non-concurrent writers.

Experimental results show practical efficiency on balanced tree data structures.

Abstract

In this paper we are interested in bounding the number of instructions taken to process transactions. The main result is a multiversion transactional system that supports constant delay (extra instructions beyond running in isolation) for all read-only transactions, delay equal to the number of processes for writing transactions that are not concurrent with other writers, and lock-freedom for concurrent writers. The system supports precise garbage collection in that versions are identified for collection as soon as the last transaction releases them. As far as we know these are first results that bound delays for multiple readers and even a single writer. The approach is particularly useful in situations where read-transactions dominate write transactions, or where write transactions come in as streams or batches and can be processed by a single writer (possibly in parallel). The approach is based on using functional data structures to support multiple versions, and an efficient solution to the Version Maintenance (VM) problem for acquiring, updating and releasing versions. Our solution to the VM problem is precise, safe and wait-free (PSWF). We experimentally validate our approach by applying it to balanced tree data structures for maintaining ordered maps. We test the transactional system using multiple algorithms for the VM problem, including our PSWF VM algorithm, and implementations with weaker guarantees based on epochs, hazard pointers, and read-copy-update. To evaluate the functional data structure for concurrency and multi-versioning, we implement batched updates for functional tree structures and compare the performance with state-of-the-art concurrent data structures for balanced trees. The experiments indicate our approach works well in practice over a broad set of criteria.