Multiversion Concurrency with Bounded Delay and Precise Garbage Collection

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 structure 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. * This paper is the full version of a paper published in the ACM Symposium on Parallelism in Algorithms and Architectures (SPAA), 2019. The conference version of this paper [10] can be found at https://doi.org/10.1145/3323165.3323185.1 Throughout we use "transaction" to mean the traditional sense of a sequence of instructions that appear to take place atomically at some point during their execution (strictly serializable) [51], and not to mean a specific implementation technique such as transactional memory. arXiv:1803.08617v3 [cs.DC] 15 May 2019Read Transaction 1 v = acquire(k); 2 user_code(v); 3 // response 4 versions = release(k); 5 for (v in versions) collect(v); Write Transaction1 v = acquire(k); 2 newv = user_code(v); 3 flag = set(newv); 4 // response if successful---update visible here 5 versions = release(k); 6 for (v in versions) collect(v); 7 if (!flag) collect(newv) and retry or abort

Technical Report: Bundling Linked Data Structures for Linearizable Range Queries

“…Multi-version concurrency control (MVCC), widely used in database management systems, relies on timestamps to coordinate concurrent accesses. Many different implementations exist [7,8,32,34,39]; all rely on a multiversioned data repository where each shared object stores a list of versions, and each version is tagged with a creation timestamp. Transactions then read the versions of objects that are consistent with their execution.…”

Implementing parallel and concurrent tree structures

“…However, concurrent updates would result in two separate versions. To guarantee serializability, additional techniques are required, such as version melding in Hyder [15], flat-combining [10] or other batching-or combining-based approaches [3,4,16] that avoids concurrent writes.…”

“…PAM uses path-copying with a single writer. It is however, possible to batch updates and run them in parallel [4]. In many cases, using batching based on the bulk operations with path-copying can be more efficient than using concurrent data structures.…”

“…For PAM, we control the batching latency within 50ms, which is approximately the typical network latency, and thus is less likely to dominate the cost. More details can be found in [4]. For all the tested workloads of mixed reads and writes, PAM with batching shows better performance than all the other concurrent data structures, especially for read-heavy workloads.…”

Bundled References: An Abstraction for Highly-Concurrent Linearizable Range Queries

“…It is widely used in database management systems. Many different implementations exist [6,7,26,28,33]; all rely on a multiversioned data repository where each shared object stores a list of versions, and each version is tagged with a creation timestamp. Transactions then read the versions of objects that are consistent with their execution.…”