Transactional Programming Research Articles

Robustness against Read Committed for Transaction Templates with Functional Constraints

The popular isolation level Multiversion Read Committed (RC) trades some of the strong guarantees of serializability for increased transaction throughput. Sometimes, transaction workloads can be safely executed under RC obtaining serializability at the lower cost of RC. Such workloads are said to be robust against RC. Previous work has yielded a tractable procedure for deciding robustness against RC for workloads generated by transaction programs modeled as transaction templates. An important insight of that work is that, by more accurately modeling transaction programs, we are able to recognize larger sets of workloads as robust. In this work, we increase the modeling power of transaction templates by extending them with functional constraints, which are useful for capturing data dependencies like foreign keys. We show that the incorporation of functional constraints can identify more workloads as robust that otherwise would not be. Even though we establish that the robustness problem becomes undecidable in its most general form, we show that various restrictions on functional constraints lead to decidable and even tractable fragments that can be used to model and test for robustness against RC for realistic scenarios.

A new Instrument for Production Control: The Smart Order Concept

Production control is an essential component of a production system used to monitor and manage production orders. Centrally controlled production systems rely on basic data management, such as storing the bill of materials and required work schedules. Components of customer orders are added to generate the corresponding production orders. However, this type of production control can pose serious problems in case of unforeseen events such as machine failure or changing customer requirements during production. In such scenarios, costly and time-consuming re-scheduling becomes necessary, which endangers the company's competitive position and leads to data retention issues. This paper introduces a new method of production control based on the concept of smart orders. Smart orders use smart contracts for autonomous routing based on programmed information in the source code, enabling self-control through the production system. Smart contracts are transaction programs that work with ‘if-then logic”, allowing for partially flexible process schedules and reducing the need for human intervention. The smart order uses the functionalities of blockchain technology, such as security, transparency, and immutability, to ensure the integrity of production data. The paper concludes by presenting the expected value propositions of smart order-based production control on the production system. Depending on the production control system used, companies can integrate the results presented in this paper into their own blockchain implementation strategy.

Robustness against read committed for transaction templates

The isolation level Multiversion Read Committed (RC), offered by many database systems, is known to trade consistency for increased transaction throughput. Sometimes, transaction workloads can be safely executed under RC obtaining the perfect isolation of serializability at the lower cost of RC. To identify such cases, we introduce an expressive model of transaction programs to better reason about the serializability of transactional workloads. We develop tractable algorithms to decide whether any possible schedule of a workload executed under RC is serializable (referred to as the robustness problem). Our approach yields robust subsets that are larger than those identified by previous methods. We provide experimental evidence that workloads that are robust against RC can be evaluated faster under RC compared to stronger isolation levels. We discuss techniques for making workloads robust against RC by promoting selective read operations to updates. Depending on the scenario, the performance improvements can be considerable. Robustness testing and safely executing transactions under the lower isolation level RC can therefore provide a direct way to increase transaction throughput without changing DBMS internals.

Timestamp reassignment: taming transaction abort for serializable snapshot isolation

Serializable snapshot isolation (SSI) is a promising technique to exploit parallelism for multi-core databases. However, SSI suffers from excessive transaction aborts. Existing remedies have three drawbacks: 1) tracking prohibitively transitive dependencies; 2) aborting on every write-write conflict; and 3) requiring manual annotation on transaction programs. In this paper, we propose to suppress transaction aborts by reassigning timestamps. We combine static analysis with augmented query plan. In this way, we save both aborts caused by read-write and write-write conflicts, without tracking transitive dependency and annotating transaction programs. As such, our approach does not exhibit drawbacks of existing methods. Extensive experiments demonstrate the effectiveness and practicality of our approach.

Speech and language interventions for infants aged 0 to 2 years at high risk for cerebral palsy: a systematic review.

We evaluated the level of evidence of speech, language, and communication interventions for infants at high-risk for, or with a diagnosis of, cerebral palsy (CP) from 0 to 2 years old. We performed a systematic review of relevant terms. Articles were evaluated based on the level of methodological quality and evidence according to A Measurement Tool to Assess Systematic Reviews (AMSTAR) and Grading of Recommendations Assessment, Development and Evaluation (GRADE) guidelines. The search terms provided 17 publications consisting of speech or language interventions. There were no interventions in the high level of evidence category. The overall level of evidence was very low. Promising interventions included Responsivity and Prelinguistic Milieu Teaching and other parent-infant transaction frameworks. There are few evidence-based interventions addressing speech, language, and communication needs of infants and toddlers at high risk for CP, and none for infants diagnosed with CP. Recommendation guidelines include parent-infant transaction programs.

A DSL for modeling application-specific functionalities of business applications

Models have been widely used in the information system development process. Models are not just means for system analysis and documentation. They may be also transformed into system implementation, primarily program code. Generated program code of screen forms and transaction programs mainly implements generic functionalities that can be expressed by simple retrieval, insertion, update, or deletion operations over database records. Besides the program code of generic functionalities, each application usually includes program code for specific business logic that represents application-specific functionalities, which may include complex calculations, as well as a series of database operations. There is a lack of domain-specific and tool-supported techniques for specification of such application-specific functionalities at the level of platform-independent models (PIMs). In this paper, we propose an approach and a domain-specific language (DSL), named IIS⁎CFuncLang, aimed at enabling a complete specification of application-specific functionalities at the PIM level. We have developed algorithms for transformation of IIS⁎CFuncLang specifications into executable program code, such as PL/SQL program code. In order to support specification of application-specific functionalities using IIS⁎CFuncLang, we have also developed appropriate tree-based and textual editors. The language, editors, and the transformations are embedded into a Model-Driven Software Development tool, named Integrated Information Systems CASE (IIS⁎Case). IIS⁎Case supports platform-independent design and automated prototyping of information systems, which allows us to verify and test our approach in practice.

Democratizing transactional programming

Control transactions without compromising their simplicity for the sake of expressiveness, application concurrency, or performance.

Relaxed Concurrency Control in Software Transactional Memory

Some of today's TM systems implement the two-phase-locking (2PL) algorithm which aborts transactions every time a conflict occurs. 2PL is a simple algorithm that provides fast transactional operations. However, it limits concurrency in benchmarks with high contention because it increases the rate of aborts. We propose the use of a more relaxed concurrency control algorithm to provide better concurrency. This algorithm is based on the conflict-serializability (CS) model. Unlike 2PL, it allows some transactions to commit successfully even when they make conflicting accesses. We implement this algorithm in a STM system and evaluate its performance on 16 cores using standard benchmarks. Our evaluation shows that the algorithm improves the performance of applications with long transactions and high abort rates. Throughput is improved by up to 2.99 times despite the overheads of testing for CS at runtime. These improvements come with little additional implementation complexity and require no changes to the transactional programming model. We also propose an adaptive approach that switches between 2PL and CS to mitigate the overhead in applications that have low abort rates.

An abort-aware model of transactional programming

There has been a lot of recent research on transaction-based concurrent programming, aimed at offering an easier concurrent programming paradigm that enables programmers to better exploit the parallelism of modern multi-processor machines, such as multi-core microprocessors. We introduce Transactional State Machines (TSMs) as an abstract finite-data model of transactional shared-memory concurrent programs. TSMs are a variant of concurrent boolean programs (or concurrent extended recursive state machines) augmented with additional constructs for specifying potentially nested transactions. Namely, some procedures (or code segments) can be marked as transactions and are meant to be executed “atomically”, and there are also explicit commit and abort operations for transactions. The TSM model is non-blocking and allows interleaved executions where multiple processes can simultaneously be executing inside transactions. It also allows nested transactions, transactions which may never terminate, and transactions which may be aborted explicitly, or aborted automatically by the run-time environment due to memory conflicts. We show that concurrent executions of TSMs satisfy a correctness criterion closely related to serializability, which we call stutter-serializability, with respect to shared memory. We initiate a study of model checking problems for TSMs. Model checking arbitrary TSMs is easily seen to be undecidable, but we show it is decidable in the following case: when recursion is exclusively used inside transactions in all (but one) of the processes, we show that model checking such TSMs against all stutter-invariant ω-regular properties of shared memory is decidable.

Transactional memory, linking theory and practice

Transactional memory appears promising for democratizing concurrent programming. Its potential lies in producing code that is extensible as atomicity is preserved under composition of transactions. This new abstraction raises several challenges such as the compliance of transactions with alternative synchronization techniques of legacy code and memory consistency models that favor transactional programming. The objective of the Second Workshop on the Theory of Transactional Memory was to discuss new theoretical challenges and recent achievements in the context of transactional computing. We report on some of the issues raised during this workshop.

Performance effects of corporate divestiture programs

PurposeThe paper aims at extending extant research on sources of divestiture gains by suggesting a novel program‐based perspective on divestitures and analyzing the performance of program divestitures in comparison to single “stand‐alone” divestitures.Design/methodology/approachBased on event study methodology, the authors analyze the abnormal returns of 160 divestiture announcements within the global insurance industry between 1998 and 2007. In contrast to prior research which relied on ex post statistical clustering to identify transaction programs, ad hoc corporate press releases issued with the divestiture announcements are used to categorize program divestitures.FindingsEmpirical results suggest that program divestitures generate higher abnormal returns than stand‐alone divestitures. Further analyses into the sources for these higher gains, however, do not provide support for experience effects as significant explanatory factors. Instead, results suggest that the scheduling of divestitures significantly impacts announcement returns.Research limitations/implicationsThe scope and single industry setting of the study suggest future cross‐industry research on the influence of divestiture program characteristics on divestiture performance and the conditions under which these programs improve divestiture performance.Practical implicationsManagers are advised to refrain from piecemeal divestiture behavior lacking clear strategic focus. Instead, they are encouraged to bundle their divestitures as part of a divestiture program with a clear strategic intent and shared business logic.Originality/valueWhile prior research on divestitures has treated divestitures as isolated events, the paper directs attention towards the analysis of divestiture programs. Further, experience and timing effects, which have been widely absent from prior divestiture studies, are considered.

Is transactional programming actually easier?

Chip multi-processors (CMPs) have become ubiquitous, while tools that ease concurrent programming have not. The promise of increased performance for all applications through ever more parallel hardware requires good tools for concurrent programming, especially for average programmers. Transactional memory (TM) has enjoyed recent interest as a tool that can help programmers program concurrently. The transactional memory (TM) research community is heavily invested in the claim that programming with transactional memory is easier than alternatives (like locks), but evidence for or against the veracity of this claim is scant. In this paper, we describe a user-study in which 237 undergraduate students in an operating systems course implement the same programs using coarse and fine-grain locks, monitors, and transactions. We surveyed the students after the assignment, and examined their code to determine the types and frequency of programming errors for each synchronization technique. Inexperienced programmers found baroque syntax a barrier to entry for transactional programming. On average, subjective evaluation showed that students found transactions harder to use than coarse-grain locks, but slightly easier to use than fine-grained locks. Detailed examination of synchronization errors in the students' code tells a rather different story. Overwhelmingly, the number and types of programming errors the students made was much lower for transactions than for locks. On a similar programming problem, over 70% of students made errors with fine-grained locking, while less than 10% made errors with transactions.

Design and implementation of transactional constructs for C/C++

This paper presents a software transactional memory system that introduces first-class C++ language constructs for transactional programming. We describe new C++ language extensions, a production-quality optimizing C++ compiler that translates and optimizes these extensions, and a high-performance STM runtime library. The transactional language constructs support C++ language features including classes, inheritance, virtual functions, exception handling, and templates. The compiler automatically instruments the program for transactional execution and optimizes TM overheads. The runtime library implements multiple execution modes and implements a novel STM algorithm that supports both optimistic and pessimistic concurrency control. The runtime switches a transaction's execution mode dynamically to improve performance and to handle calls to precompiled functions and I/O libraries. We present experimental results on 8 cores (two quad-core CPUs) running a set of 20 non-trivial parallel programs. Our measurements show that our system scales well as the numbers of cores increases and that our compiler and runtime optimizations improve scalability.

Introduction

In recent years, multiprocessors have emerged as the architecture of choice at the chip level to help ride Moore's law and continue exploiting the exponential growth in transistors while maintaining acceptable power consumption levels and complexity. Unfortunately, parallel software has not made it to the mainstream, making technologies to help facilitate parallel software development and programming for commodity chips critical to the sustained growth in IT infrastructure and industry. Transactional programming is emerging as a promising approach to help mitigate many of the difficulties associated with conventional synchronization and coordination mechanisms in parallel programs.

A flexible framework for implementing software transactional memory

We describe DSTM2, a Java™ software library that provides a flexible framework for implementing object-based software transactional memory (STM). The library uses transactional factories to transform sequential (unsynchronized) classes into atomic (transactionally synchronized) ones, providing a substantial improvement over the awkward programming interface of our previous DSTM library. Furthermore, researchers can experiment with alternative STM mechanisms by providing their own factories. We demonstrate this flexibility by presenting two factories: one that uses essentially the same mechanisms as the original DSTM (with some enhancements),and another that uses a completely different approach.Because DSTM2 is packaged as a Java library, a wide range of programmers can easily try it out, and the community can begin to gain experience with transactional programming. Furthermore, researchers will be able to use the body of transactional programs that arises from this community experience to test and evaluate different STM mechanisms simply by supplying new transactional factories. We believe that this flexible approach will help to build consensus about the best ways to implement transactions, and will avoid the premature "lock-in" that may arise if STM mechanisms are baked into compilers before such experimentation is done.

The Atomos transactional programming language

Atomos is the first programming language with implicit transactions, strong atomicity, and a scalable multiprocessor implementation. Atomos is derived from Java, but replaces its synchronization and conditional waiting constructs with simpler transactional alternatives.The Atomos watch statement allows programmers to specify fine-grained watch sets used with the Atomos retry conditional waiting statement for efficient transactional conflict-driven wakeup even in transactional memory systems with a limited number of transactional contexts. Atomos supports open-nested transactions , which are necessary for building both scalable application programs and virtual machine implementations.The implementation of the Atomos scheduler demonstrates the use of open nesting within the virtual machine and introduces the concept of transactional memory violation handlers that allow programs to recover from data dependency violations without rolling back.Atomos programming examples are given to demonstrate the usefulness of transactional programming primitives. Atomos and Java are compared through the use of several benchmarks. The results demonstrate both the improvements in parallel programming ease and parallel program performance provided by Atomos.

Generating XML based specifications of information systems

This paper outlines a methodology for designing information systems based on XML. The methodology uses XML DTDs to define the design standards, and the structure and constraints of the design specifications. The result of the design process is a set of valid XML documents that are the specifications of transaction programs and applications of the information system. At the start of a design process, the methodology uses a CASE tool to map user requirements into initial XML specifications. Final design specifications are produced by a sequence of XSL transformations of the initial XML specifications. A key feature of the methodology is that it produces a platform independent design of an information system. To enable an early feedback from users, the methodology uses further XSL transformations that produce an executable prototype of the information system in the Java programming environment.

Enhancing software reliability with speculative threads

This paper advocates the use of a monitor-and-recover programming paradigm to enhance the reliability of software, and proposes an architectural design that allows software and hardware to cooperate in making this paradigm more efficient and easier to program.We propose that programmers write monitoring functions assuming simple sequential execution semantics. Our architecture speeds up the computation by executing the monitoring functions speculatively in parallel with the main computation. For recovery, programmers can define fine-grain transactions whose side effects, including all register modifications and memory writes, can either be committed or aborted under program control. Transactions are implemented efficiently by treating them as speculative threads.Our experimental results suggest that monitored execution is more amenable to parallelization than regular program execution. Code monitoring is sped up by a factor of 1.5 by exploiting single-thread instruction-level parallelism, and by an additional factor of 1.6 using thread-level speculation. This results in an overall improvement of 2.5 times and a sustained 5.4 instructions-per-cycle performance. A monitored execution that used to be 2.5 times slower executes with a degradation of only 12% when compared to the performance on the baseline machine. We also show that the concept of fine-grain transactional programming is useful in catching buffer overrun errors through a number of real-life examples.

Enhancing software reliability with speculative threads

This paper advocates the use of a monitor-and-recover programming paradigm to enhance the reliability of software, and proposes an architectural design that allows software and hardware to cooperate in making this paradigm more efficient and easier to program.We propose that programmers write monitoring functions assuming simple sequential execution semantics. Our architecture speeds up the computation by executing the monitoring functions speculatively in parallel with the main computation. For recovery, programmers can define fine-grain transactions whose side effects, including all register modifications and memory writes, can either be committed or aborted under program control. Transactions are implemented efficiently by treating them as speculative threads.Our experimental results suggest that monitored execution is more amenable to parallelization than regular program execution. Code monitoring is sped up by a factor of 1.5 by exploiting single-thread instruction-level parallelism, and by an additional factor of 1.6 using thread-level speculation. This results in an overall improvement of 2.5 times and a sustained 5.4 instructions-per-cycle performance. A monitored execution that used to be 2.5 times slower executes with a degradation of only 12% when compared to the performance on the baseline machine. We also show that the concept of fine-grain transactional programming is useful in catching buffer overrun errors through a number of real-life examples.

Enhancing software reliability with speculative threads

This paper advocates the use of a monitor-and-recover programming paradigm to enhance the reliability of software, and proposes an architectural design that allows software and hardware to cooperate in making this paradigm more efficient and easier to program.We propose that programmers write monitoring functions assuming simple sequential execution semantics. Our architecture speeds up the computation by executing the monitoring functions speculatively in parallel with the main computation. For recovery, programmers can define fine-grain transactions whose side effects, including all register modifications and memory writes, can either be committed or aborted under program control. Transactions are implemented efficiently by treating them as speculative threads.Our experimental results suggest that monitored execution is more amenable to parallelization than regular program execution. Code monitoring is sped up by a factor of 1.5 by exploiting single-thread instruction-level parallelism, and by an additional factor of 1.6 using thread-level speculation. This results in an overall improvement of 2.5 times and a sustained 5.4 instructions-per-cycle performance. A monitored execution that used to be 2.5 times slower executes with a degradation of only 12% when compared to the performance on the baseline machine. We also show that the concept of fine-grain transactional programming is useful in catching buffer overrun errors through a number of real-life examples.