Reusable Concurrent Data Types

This paper contributes to address the fundamental challenge of building Concurrent Data Types CDT that are reusable and scalable at the same time. We do so by proposing the abstraction of Polymorphic Transactions PT: a new programming abstraction that offers different compatible transactions that can run concurrently in the same application. We outline the commonality of the problem in various object-oriented languages and implement PT and a reusable package in Java. With PT, annotating sequential ADTs guarantee novice programmers to obtain an atomic and deadlock-free CDT and let an advanced programmer leverage the application semantics to get higher performance. We compare our polymorphic synchronization against transaction-based, lock-based and lock-free synchronizations on SPARC and x86-64 architectures and we integrate our methodology to a travel reservation benchmark. Although our reusable CDTs are sometimes less efficient than non-composable handcrafted CDTs from the JDK, they outperform all reusable Java CDTs.

[1]  Gul A. Agha,et al.  Concurrent object-oriented programming , 1993, CACM.

[2]  Bratin Saha,et al.  Open nesting in software transactional memory , 2007, PPOPP.

[3]  Maurice Herlihy,et al.  A methodology for implementing highly concurrent data objects , 1993, TOPL.

[4]  Maurice Herlihy,et al.  Linearizability: a correctness condition for concurrent objects , 1990, TOPL.

[5]  Kunle Olukotun,et al.  Transactional collection classes , 2007, PPOPP.

[6]  Pascal Felber,et al.  Atomic Boxes: Coordinated Exception Handling with Transactional Memory , 2011, ECOOP.

[7]  Kunle Olukotun,et al.  STAMP: Stanford Transactional Applications for Multi-Processing , 2008, 2008 IEEE International Symposium on Workload Characterization.

[8]  Cormac Flanagan,et al.  A type and effect system for atomicity , 2003, PLDI.

[9]  Adam Welc,et al.  Irrevocable transactions and their applications , 2008, SPAA '08.

[10]  Rudolf Bayer,et al.  Concurrency of operations on B-trees , 1994, Acta Informatica.

[11]  Bertrand Meyer,et al.  Reusability: The Case for Object-Oriented Design , 1987, IEEE Software.

[12]  HerlihyMaurice,et al.  A flexible framework for implementing software transactional memory , 2006 .

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

[14]  Maurice Herlihy,et al.  Transactional Memory: Architectural Support For Lock-free Data Structures , 1993, Proceedings of the 20th Annual International Symposium on Computer Architecture.

[15]  Rachid Guerraoui,et al.  Stretching transactional memory , 2009, PLDI '09.

[16]  Eran Yahav,et al.  Testing atomicity of composed concurrent operations , 2011, OOPSLA '11.

[17]  Maurice Herlihy,et al.  Software transactional memory for dynamic-sized data structures , 2003, PODC '03.

[18]  Milo M. K. Martin,et al.  Subtleties of transactional memory atomicity semantics , 2006, IEEE Computer Architecture Letters.

[19]  Aaron Turon.  Reagents: expressing and composing fine-grained concurrency , 2012, PLDI '12.

[20]  Marsha Chechik,et al.  The SCOOP Concurrency Model in Java-like Languages , 2009, CPA.

[21]  Maurice Herlihy,et al.  Transactional boosting: a methodology for highly-concurrent transactional objects , 2008, PPoPP.

[22]  Maurice Herlihy,et al.  Coarse-grained transactions , 2010, POPL '10.

[23]  Keir Fraser,et al.  A Practical Multi-word Compare-and-Swap Operation , 2002, DISC.

[24]  Maurice Herlihy,et al.  The art of multiprocessor programming , 2020, PODC '06.

[25]  Nir Shavit,et al.  Transactional Locking II , 2006, DISC.

[26]  Maurice Herlihy,et al.  A flexible framework for implementing software transactional memory , 2006, OOPSLA '06.

[27]  Stephen N. Freund,et al.  Types for atomicity: Static checking and inference for Java , 2008, TOPL.

[28]  Michael F. Spear,et al.  NOrec: streamlining STM by abolishing ownership records , 2010, PPoPP '10.

[29]  Roman Manevich,et al.  JANUS: exploiting parallelism via hindsight , 2012, PLDI '12.

[30]  Rachid Guerraoui,et al.  On the correctness of transactional memory , 2008, PPoPP.

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

[32]  Keir Fraser,et al.  Language support for lightweight transactions , 2014, SIGP.

[33]  Nir Shavit,et al.  Software transactional memory , 1995, PODC '95.

[34]  Maged M. Michael,et al.  Simple, fast, and practical non-blocking and blocking concurrent queue algorithms , 1996, PODC '96.

[35]  Ajitha Rajan,et al.  Requirements Coverage as an Adequacy Measure for Conformance Testing , 2008, ICFEM.

[36]  J. Eliot B. Moss.  Open Nested Transactions: Semantics and Support , 2006 .

[37]  Akinori Yonezawa,et al.  Linguistic supports for development of distributed organizational information systems in object-oriented concurrent computation frameworks , 1991, COCS '91.

[38]  Torvald Riegel,et al.  Time-Based Software Transactional Memory , 2010, IEEE Transactions on Parallel and Distributed Systems.

[39]  Yu Lin,et al.  CHECK-THEN-ACT Misuse of Java Concurrent Collections , 2013, 2013 IEEE Sixth International Conference on Software Testing, Verification and Validation.

[40]  HerlihyMaurice.  A methodology for implementing highly concurrent data objects , 1993 .

[41]  Michael L. Scott,et al.  Compiler aided manual speculation for high performance concurrent data structures , 2013, PPoPP '13.

[42]  William N. Scherer,et al.  Advanced contention management for dynamic software transactional memory , 2005, PODC '05.

[43]  Keshav Pingali,et al.  Optimistic parallelism requires abstractions , 2009, CACM.

[44]  Bertrand Meyer,et al.  Systematic concurrent object-oriented programming , 1993, CACM.

[45]  Torvald Riegel,et al.  A Lazy Snapshot Algorithm with Eager Validation , 2006, DISC.

[46]  George C. Necula,et al.  Specifying and checking semantic atomicity for multithreaded programs , 2011, ASPLOS XVI.

[47]  Maged M. Michael,et al.  Implementing and Exploiting Inevitability in Software Transactional Memory , 2008, 2008 37th International Conference on Parallel Processing.

[48]  Scott D. Stoller,et al.  Runtime analysis of atomicity for multithreaded programs , 2006, IEEE Transactions on Software Engineering.

[49]  David F. Bacon,et al.  Guava: a dialect of Java without data races , 2000, OOPSLA '00.

[50]  Rachid Guerraoui,et al.  Democratizing transactional programming , 2014, CACM.

[51]  Sebastian Burckhardt,et al.  CheckFence: checking consistency of concurrent data types on relaxed memory models , 2007, PLDI '07.

[52]  Eran Yahav,et al.  Concurrent libraries with foresight , 2013, PLDI.

[53]  Kunle Olukotun,et al.  The Atomos transactional programming language , 2006, PLDI '06.

[54]  Kunle Olukotun,et al.  Transactional Execution of Java Programs , 2005 .

[55]  Keshav Pingali,et al.  Exploiting the commutativity lattice , 2011, PLDI '11.

[56]  Idit Keidar,et al.  On maintaining multiple versions in STM , 2010, PODC.

[57]  João P. Cachopo,et al.  Versioned boxes as the basis for memory transactions , 2006, Sci. Comput. Program..

[58]  Simon L. Peyton Jones,et al.  Composable memory transactions , 2005, CACM.

[59]  Bertrand Meyer,et al.  A Modular Scheme for Deadlock Prevention in an Object-Oriented Programming Model , 2010, ICFEM.

[60]  Andrew D. Gordon,et al.  Maintaining Database Integrity with Refinement Types , 2011, ECOOP.