Sandeep Hans

A programming language perspective on transactional memory consistency

Transactional memory (TM) has been hailed as a paradigm for simplifying concurrent programming. While several consistency conditions have been suggested for TM, they fall short of formalizing the intuitive semantics of atomic blocks, the interface through which a TM is used in a programming language. To close this gap, we formalize the intuitive expectations of a programmer as observational refinement between TM implementations: a concrete TM observationally refines an abstract one if every user-observable behavior of a program using the former can be reproduced if the program uses the latter. This allows the programmer to reason about the behavior of a program using the intuitive semantics formalized by the abstract TM; the observational refinement relation implies that the conclusions will carry over to the case when the program uses the concrete TM. We show that, for a particular programming language and notions of observable behavior, a variant of the well-known consistency condition of opacity is sufficient for observational refinement, and its restriction to complete histories is furthermore necessary. Our results suggest a new approach to evaluating and comparing TM consistency conditions. They can also reduce the effort of proving that a TM implements its programming language interface correctly, by only requiring its developer to show that it satisfies the corresponding consistency condition.

Safety of Deferred Update in Transactional Memory

Transactional memory allows the user to declare sequences of instructions as speculative transactions that can either commit or abort. If a transaction commits, it appears to be executed sequentially, so that the committed transactions constitute a correct sequential execution. If a transaction aborts, none of its instructions can affect other transactions. The popular criterion of opacity requires that the views of aborted transactions must also be consistent with the global sequential order constituted by committed ones. This is believed to be important, since inconsistencies observed by an aborted transaction may cause a fatal irrecoverable error or waste of the system in an infinite loop. Intuitively, an opaque implementation must ensure that no intermediate view a transaction obtains before it commits or aborts can be affected by a transaction that has not started committing yet, so called deferred-update semantics. In this paper, we intend to grasp this intuition formally. We propose a variant of opacity that explicitly requires the sequential order to respect the deferred-update semantics. Unlike opacity, our property also ensures that a serialization of a history implies serializations of its prefixes. Finally, we show that our property is equivalent to opacity if we assume that no two transactions commit identical values on the same variable, and present a counter-example for scenarios when the “unique-write” assumption does not hold.

Safety of Live Transactions in Transactional Memory: TMS is Necessary and Sufficient

One of the main challenges in stating the correctness of transactional memory (TM) systems is the need to provide guarantees on the system state observed by live transactions, i.e., those that have not yet committed or aborted. A TM correctness condition should be weak enough to allow flexibility in implementation, yet strong enough to disallow undesirable TM behavior, which can lead to run-time errors in live transactions. The latter feature is formalized by observational refinement between TM implementations, stating that properties of a program using a concrete TM implementation can be established by analyzing its behavior with an abstract TM, serving as a specification of the concrete one.

Towards Providing Data Validation as a Service

Data validation is one of the most important and, possibly, most under-valued task in an organization. Without clean data, an organization cannot employ sophisticated analysis and optimization tools to strive for excellence in operations, delivery or planning. Organizations have started to realize the value of data and its impact on their efficiency. Typically, they either develop in-house solutions or purchase industry standard solutions. In this work, we propose an alternative of data validation as a service offering. We argue that such a service would be a profitable proposition for both the parties, provider as well as consumer. We present a general framework to enable such an offering. We provide details on one such implementation that we carried to showcase the viability of such an approach. We propose multiple variants of the offering to handle privacy concerns of the consumer. Finally, we present a set of initial results comparing the different variants.

Provenance in Context of Hadoop as a Service (HaaS) - State of the Art and Research Directions

Hadoop as a service (HaaS), also known as Hadoop in the cloud, is a big data analytics framework that stores and analyzes data in the cloud using Hadoop/Spark. In this paper, we discuss the importance of providing provenance capabilities in context of Hadoop as a service (HaaS) framework. We first review the state of the art in provenance tracking in context of databases and work-flow processing, in context of cloud and in context of big data analytics frameworks like Hadoop and Spark. We next identify a number of provenance capabilities which have been developed in context of databases and workflow processing but the corresponding solutions have not been developed in context of Hadoop or Spark. We argue that developing these solutions is important so that a comprehensive provenance aware Hadoop as a Service (HaaS) can be provided on cloud. The paper ends by identifying some research challenges in developing these provenance capabilities.

Characterizing Transactional Memory Consistency Conditions Using Observational Refinement

Transactional memory (TM) facilitates the development of concurrent applications by letting a programmer designate certain code blocks as atomic. The common approach to stating TM correctness is through a consistency condition that restricts the possible TM executions. Unfortunately, existing consistency conditions fall short of formalizing the intuitive semantics of atomic blocks through which programmers use a TM. To close this gap, we formalize programmer expectations as observational refinement between TM implementations. This states that properties of a program using a concrete TM implementation can be established by analyzing its behavior with an abstract TM, serving as a specification of the concrete one. We show that a variant of Transactional Memory Specification (TMS), a TM consistency condition, is equivalent to observational refinement for a programming language where local variables are rolled back upon a transaction abort. We thereby establish that TMS is the weakest acceptable condition for this case. We then propose a new consistency condition, called Strong Transactional Memory Specification (STMS), and show that it is equivalent to observational refinement for a language where local variables are not rolled back upon aborts. Finally, we show that under certain natural assumptions on TM implementations, STMS is equivalent to a variant of a well-known condition of opacity. Our results suggest a new approach to evaluating TM consistency conditions and enable TM implementors and language designers to make better-informed decisions.

WTTM 2013, the fifth workshop on the theory of transactional memory

In conjunction with DISC 2013, the TransForm project (Marie Curie Initial Training Network) and EuroTM (COST Action IC1001) supported the 5th edition of the Workshop on the Theory of Transactional Memory (WTTM 2013). The objective of WTTM was to discuss new theoretical challenges and recent achievements in the area of transactional computing with emphasis on transactional memory. The workshop took place on October 14, 2013, in Jerusalem, Israel. This report is intended to give highlights of the problems discussed during the workshop.

Data validation for business continuity planning

In this paper we present a system and case study for business data validation in large organizations. The validated and consistent data provides the capability to handle outages and incidents in a more principled fashion and helps in business continuity. Typically, different business units employ separate systems to produce and store their data. The data owners choose their own technology for data base storage. It is a non-trivial task to keep the data consistent across business units in the organization. This non-availability of consistent data can lead to sub optimal planning during outages and organizations can incur huge financial costs. Traditional custom data validation system fetches the data from various data sources and flow it through the central validation system resulting in huge data transfer cost. Moreover, accommodating change in business rules is laborious process. Accommodating such changes in the system can lead to re-design and re-development of the system. This is a very costly and time consuming activity. In this paper, we employ a Metadata driven rule-based data validation system, which is domain independent, distributed, scalable and can easily accommodate changes in business requirements. We have deployed our system in real life settings. We present some of the results in this paper.