A transactional object calculus

A transaction defines a locus of computation that satisfies important concurrency and failure properties. These so-called ACID properties provide strong serialization guarantees that allow us to reason about concurrent and distributed programs in terms of higher-level units of computation (e.g., transactions) rather than lower-level data structures (e.g., mutual-exclusion locks). This paper presents a framework for specifying the semantics of a transactional facility integrated within a host programming language. The TFJ calculus, an object calculus derived from Featherweight Java, supports nested and multi-threaded transactions. We give a semantics to TFJ that is parametrized by the definition of the transactional mechanism that permits the study of different transaction models. We give two instantiations: one that defines transactions in terms of a versioning-based optimistic concurrency model, and the other which specifies transactions in terms of a pessimistic two-phase locking protocol, and present soundness and serializability properties for our semantics.

[1]  Roberto Bruni,et al.  Orchestrating Transactions in Join Calculus , 2002, CONCUR.

[2]  Malcolm P. Atkinson,et al.  A review of the rationale and architectures of PJama - a durable, flexible, evolvable and scalable orthogonally persistent programming platform , 2000, SMLI TR.

[3]  Richard J. Lipton Reduction: a new method of proving properties of systems of processes , 1975, POPL '75.

[4]  Xavier Leroy,et al.  Proceedings of the 31st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2004, Venice, Italy, January 14-16, 2004 , 2004, POPL.

[5]  Scott Nettles,et al.  Transactions for Java , 1998, Proceedings of the 1998 International Conference on Computer Languages (Cat. No.98CB36225).

[6]  Laurent Daynès,et al.  High-performance, space-efficient, automated object locking , 2001, Proceedings 17th International Conference on Data Engineering.

[7]  Irving L. Traiger,et al.  The notions of consistency and predicate locks in a database system , 1976, CACM.

[8]  David Jones High performance , 1989, Nature.

[9]  J. Gregory Morrisett,et al.  Composing first-class transactions , 1994, TOPL.

[10]  Nadia Busi,et al.  On the Serializability of Transactions in JavaSpaces , 2001, Electron. Notes Theor. Comput. Sci..

[11]  Andreas Reuter,et al.  Transaction Processing: Concepts and Techniques , 1992 .

[12]  Jan Vitek,et al.  A Semantic Framework for Designer Transactions , 2004, ESOP.

[13]  Luca Cardelli,et al.  Modern concurrency abstractions for C# , 2002, TOPL.

[14]  Jakob Rehof,et al.  Summarizing procedures in concurrent programs , 2004, POPL.

[15]  Dominic Duggan,et al.  Abstractions for Fault-Tolerant Global Computing , 2002, F-WAN@ICALP.

[16]  Laurent Daynès,et al.  Implementation of automated fine‐granularity locking in a persistent programming language , 2000, Softw. Pract. Exp..

[17]  Gul Agha,et al.  Research directions in concurrent object-oriented programming , 1993 .

[18]  Butler W. Lampson,et al.  Atomic Transactions , 1980, Advanced Course: Distributed Systems.

[19]  Laurent Daynès,et al.  Lightweight Flexible Isolation for Language-based Extensible Systems , 2002, VLDB.

[20]  Maurice Herlihy,et al.  Inheritance of synchronization and recovery properties in Avalon/C++ , 1988, Computer.

[21]  Lily B. Mummert,et al.  Camelot and Avalon: A Distributed Transaction Facility , 1991 .

[22]  Panos K. Chrysanthis,et al.  Synthesis of extended transaction models using ACTA , 1994, TODS.

[23]  E. B. Moss,et al.  Nested Transactions: An Approach to Reliable Distributed Computing , 1985 .

[24]  Philip Wadler,et al.  Featherweight Java: a minimal core calculus for Java and GJ , 2001, TOPL.

[25]  Rachid Guerraoui,et al.  An Equational Theory for Transactions , 2003, FSTTCS.

[26]  Barbara Liskov,et al.  Guardians and Actions: Linguistic Support for Robust, Distributed Programs , 1983, TOPL.

[27]  Malcolm P. Atkinson,et al.  First International Workshop on Persistence and Java , 1996 .

[28]  Satoshi Matsuoka,et al.  Analysis of inheritance anomaly in object-oriented concurrent programming languages , 1993 .