arXiv subjects

Konrad Siek

Publications and source records attributed to Konrad Siek.

5 recordsLinked to original sources

arXiv2021

Userfault Objects: Transparent Programmable Memory

The Userfault Object (UFO) framework explores avenues of cooperating with the operating system to use memory in non-traditional ways. We implement a framework that employs the Linux kernel's userfault mechanism to fill the contents of runtime objects on demand. When an object's memory is accessed the framework executes a user-defined function that generates a slice of the object. The back-end can generate data from thin air, calculate it from a formula, or retrieve it from persistent storage, the network, or other sources (with or without post-processing). UFOs follow the memory layout of standard runtime objects, so they can be introspected and written to safely. The framework manages the loading and unloading of object segments to ensure that memory is reclaimed as needed and data is never lost. This allows the UFO framework to implement larger-than-memory data structures that never materialize into memory in full. Implementing objects as UFOs also impacts performance, since overhead of populating memory is amortized by loading entire pages of data at a time. The host runtime can also rely on direct memory accesses into userfault object obviating the need for a special dispatch mechanism. We provide a proof-of-concept implementation of the UFO framework for the R language.

cs.PL↗

arXiv2017

The Optimal Pessimistic Transactional Memory Algorithm

Transactional Memory (TM) is an approach aiming to simplify concurrent programming by automating synchronization while maintaining efficiency. TM usually employs the optimistic concurrency control approach, which relies on transactions aborting and restarting if conflicts occur. However, an aborted transaction can still leave some effects in the system that cannot be cleaned up, if irrevocable operations are present within its code. The pessimistic approach eliminates that problem, since it relies on deferring operations in case of conflict rather than aborting, but hitherto pessimistic TMs suffered from low parallelism due to the need of serializing transactions. In this paper, we aim to introduce OptSVA, a pessimistic TM concurrency control algorithm that ensures a high level of parallelism through a battery of far-reaching optimizations including early release, asynchronous execution, and the extensive use of buffering.

cs.DC↗

arXiv2016

Atomic RMI 2: Highly Parallel Pessimistic Distributed Transactional Memory

Distributed Transactional Memory (DTM) is an emerging approach to distributed synchronization based on the application of the transaction abstraction to distributed computation. DTM comes in several system models, but the control flow model (CF) is particularly powerful, since it allows transactions to delegate computation to remote nodes as well as access shared data. However, there are no existing CF DTM systems that perform on par with state-of-the-art systems operating in other models. Hence, we introduce a CF DTM synchronization algorithm, OptSVA-CF. It supports fine-grained pessimistic concurrency control, so it avoids aborts, and thus avoids problems with irrevocable operations. Furthermore, it uses early release and asynchrony to parallelize concurrent transactions to a high degree, while retaining strong safety properties. We implement it as Atomic RMI 2, in effect producing a CF DTM system that, as our evaluation shows, can outperform a state-of-the-art non-CF DTM such as HyFlow2.

cs.DC↗

arXiv2016

Helenos: A Realistic Benchmark for Distributed Transactional Memory

Transactional Memory (TM) is an approach to concurrency control that aims to make writing parallel programs both effective and simple. The approach is started in non-distributed multiprocessor systems, but is gaining popularity in distributed systems to synchronize tasks at large scales. Efficiency and scalability are often the key issues in TM research, so performance benchmarks are an important part of it. However, while standard TM benchmarks like the STAMP suite and STMBench7 are available and widely accepted, they do not translate well into distributed systems. Hence, the set of benchmarks usable with distributed TM systems is very limited, and must be padded with microbenchmarks, whose simplicity and artificial nature often makes them uninformative or misleading. Therefore, this paper introduces Helenos, a realistic, complex, and comprehensive distributed TM benchmark based on the problem of the Facebook inbox, an application of the Cassandra distributed store.

cs.DC↗

arXiv2016

Last-use Opacity: A Strong Safety Property for Transactional Memory with Early Release Support

Transaction Memory (TM) is a concurrency control abstraction that allows the programmer to specify blocks of code to be executed atomically as transactions. However, since transactional code can contain just about any operation attention must be paid to the state of shared variables at any given time. E.g., contrary to a database transaction, if a TM transaction reads a stale value it may execute dangerous operations, like attempt to divide by zero, access an illegal memory address, or enter an infinite loop. Thus serializability is insufficient, and stronger safety properties are required in TM, which regulate what values can be read, even by transactions that abort. Hence, a number of TM safety properties were developed, including opacity, and TMS1 and TMS2. However, such strong properties preclude using early release as a technique for optimizing TM, because they virtually forbid reading from live transactions. On the other hand, properties that do allow early release are either not strong enough to prevent any of the problems mentioned above (recoverability), or add additional conditions on transactions with early release that limit their applicability (elastic opacity, live opacity, virtual world consistency). This paper introduces last-use opacity, a new TM safety property that is meant to be a compromise between strong properties like opacity and serializability. The property eliminates all but a small class of inconsistent views and poses no stringent conditions on transactions. For illustration, we present a last-use opaque TM algorithm and show that it satisfies the new safety property.

cs.DC↗