Konrad Siek

Brief announcement: towards a fully-articulated pessimistic distributed transactional memory

Transactional memory, an approach aiming to replace cumbersome locking mechanisms in concurrent systems, has become a popular research topic. But due to problems posed by irrevocable operations (e.g., system calls), the viability of pessimistic concurrency control for transactional memory systems is being explored, in lieu of the more typical optimistic approach. However, in a distributed setting, where partial transaction failures may happen, the inability of pessimistic transactional memories to roll back is a major shortcoming. Therefore, this paper presents a novel transactional memory concurrency control algorithm that is both fully pessimistic and rollback-capable.

A Formal Design of a Tool for Static Analysis of Upper Bounds on Object Calls in Java

This paper presents a formal design of a tool for statically establishing the upper bound on the number of executions of objects’ methods in a fragment of object-oriented code. The algorithm that our tool employs is a multi-pass interprocedural analysis consisting of data flow and region-based analyses. We describe the formalization of each of stage of the algorithm. This rigorous specification greatly aids the implementation of the tool by removing ambiguities of textual descriptions. There are many applications for information obtained through this method including reasoning about concurrent code, scheduling, code optimization, compositing services, etc. We concentrate on using upper bounds to instrument transactional code that uses a synchronization mechanism based on versioning, and therefore benefits from a priori knowledge about the usage of shared objects within each transaction. To this end we implement a precompiler for Java that analyzes transactions, and injects generated source code to initialize each transaction.

Atomic RMI: A Distributed Transactional Memory Framework

This paper presents Atomic RMI, a distributed transactional memory framework that supports the control flow model of execution. Atomic RMI extends Java RMI with distributed transactions that can run on many Java virtual machines located on different network nodes. Our system employs SVA, a fully-pessimistic concurrency control algorithm that provides exclusive access to shared objects and supports rollback and fault tolerance. SVA is capable of achieving a relatively high level of parallelism by interweaving transactions that access the same objects and by making transactions that do not share objects independent of one another. It also allows any operations within transactions, including irrevocable ones, like system calls, and provides an unobtrusive API. Our evaluation shows that in most cases Atomic RMI performs better than fine grained mutual-exclusion and read/write locking mechanisms. Atomic RMI also performs better than an optimistic transactional memory in environments with high contention and a high ratio of write operations, while being competitive otherwise.

Barcode Scanning from Mobile-Phone Camera Photos Delivered Via MMS: Case Study

Price comparison services are commonly available via WWW interface and they belong to the most popular web-sites because their functionality is highly valued by users. However, in dynamic action of shopping, customers equipped in mobile devices have no time and conditions for precise describing products on their mini screens of PDAs or mobile phones. An alternative request for information about prices and availability of a product encountered during shopping might be sent to price comparator through MMS channel in the form of photograph with products barcode. In the paper we describe a series of experiments using mobile phones for sending camera-made barcodes and deriving numerical equivalence for product ID. Experiments were conducted on a set of barcodes in ideal and real conditions using a library for software barcode scanning. Collected results show two main sources of difficulties in using such a system: human-related problems and technical issues described in the paper. A separate issue is availability of barcode id in product description stored in price comparator database.

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 has been initially proposed for nondistributed multiprocessor systems, but it is gaining popularity in distributed systems to synchronize tasks at large scales. Efficiency and scalability are often the key issues in TM research; thus, performance benchmarks are an important part of it. However, while standard TM benchmarks like the Stanford Transactional Applications for Multi‐Processing 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.

Proving opacity of transactional memory with early release

Abstract Transactional Memory (TM) is an alternative way of synchronizing concurrent accesses to shared memory by adopting the abstraction of transactions in place of low-level mechanisms like locks and barriers. TMs usually apply optimistic concurrency control to provide a universal and easy-to-use method of maintaining correctness. However, this approach performs a high number of aborts in high contention workloads, which can adversely affect performance. Optimistic TMs can cause problems when transactions contain irrevocable operations. Hence, pessimistic TMs were proposed to solve some of these problems. However, an important way of achieving efficiency in pessimistic TMs is to use early release. On the other hand, early release is seemingly at odds with opacity, the gold standard of TM safety properties, which does not allow transactions to make their state visible until they commit. In this paper we propose a proof technique that makes it possible to demonstrate that a TM with early release can be opaque as long as it prevents inconsistent views.

Having your cake and eating it too: combining strong and eventual consistency

Given the limitations imposed on distributed systems that are necessary to maintain strong consistency guarantees there is a growing interest in relaxed consistency models. Such models are often sufficient for particular applications, but allow more freedom to improve scalability and availability. Eventual consistency is a particularly useful approach, where the correct state spreads throughout the system over time, so that at any point any element of the system may be inconsistent, but all elements will eventually converge upon a consistent state. On the other hand relaxing properties may be unacceptable in the general case: a slightly stale shopping cart is one thing, but inconsistent payment processing is quite another. In this paper we try to balance strong and eventual consistency by proposing a general-purpose pessimistic distributed transactional memory that allows eventually consistent transactions to run alongside consistent ones. While the former maintain read-isolation (i.e., read from a consistent snapshot), they do not interfere with the latters safety properties. The relaxed-consistency transactions are later followed by their consistent counterpart so that the user view and global state eventually agree. Our contribution is to show that we can significantly relax synchronization (to the point of eliminating it completely from eventually consistent transactions) while retaining useful properties, but without imposing additional constraints about system architecture or data operations, common to other relaxed consistency approaches. All this, without affecting those transactions that execute in consistent mode.