A survey of support for structured communication in concurrency control models

The two standard models used for communication in concurrent programs, shared memory and message passing, have been the focus of much debate for a long time. Still, we believe the main issue at stake should not be the choice between these models, but rather how to ensure that communication is structured, i.e., it occurs only in syntactically restricted code regions. In this survey, we explore concurrency control models and evaluate how their characteristics contribute positively or negatively to the support for structured communication. We focus the evaluation on three properties: reasonability, which is the main property we are interested in and determines how easily programmers can reason about a concurrent program's execution; performance, which determines whether there are any distinct features which can prevent or facilitate efficient implementations; and composability, which determines whether a model offers constructs that can be used as building blocks for coarser-grained, or higher-level, concurrency abstractions.

[1]  Maurice Herlihy,et al.  Virtualizing transactional memory , 2005, 32nd International Symposium on Computer Architecture (ISCA'05).

[2]  Tobin J. Lehman,et al.  T Spaces : The Next Wave , 2004 .

[3]  Per Brinch Hansen,et al.  Monitors and concurrent Pascal: a personal history , 1993, HOPL-II.

[4]  Alan Chalmers,et al.  A Comparison of Linda Implementations in Java , 2000 .

[5]  Gregory R. Andrews,et al.  Paradigms for process interaction in distributed programs , 1991, CSUR.

[6]  John K. Ousterhout,et al.  Why Threads Are A Bad Idea , 2013 .

[7]  Martin Odersky,et al.  An Overview of the Scala Programming Language , 2004 .

[8]  Jan-Willem Maessen,et al.  Towards a Safer Interaction with Transactional Memory by Tracking Object Visibility , 2005 .

[9]  Jim Gray,et al.  The Transaction Concept: Virtues and Limitations (Invited Paper) , 1981, VLDB.

[10]  Amy L. Murphy,et al.  TeenyLIME: transiently shared tuple space middleware for wireless sensor networks , 2006, MidSens '06.

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

[12]  Nicholas Carriero,et al.  Linda in context , 1989, CACM.

[13]  Simon L. Peyton Jones,et al.  Concurrent Haskell , 1996, POPL '96.

[14]  Peter A. Buhr,et al.  Monitor classification , 1995, CSUR.

[15]  James R. Larus,et al.  Transactional Memory, 2nd edition , 2010, Transactional Memory.

[16]  Konstantinos Sagonas,et al.  Heap architectures for concurrent languages using message passing , 2002, MSP/ISMM.

[17]  Peter A. Buhr,et al.  Implicit-signal monitors , 2005, TOPL.

[18]  Gul A. Agha,et al.  ACTORS - a model of concurrent computation in distributed systems , 1985, MIT Press series in artificial intelligence.

[19]  James Leslie Keedy.  On structuring operating systems with monitors , 1979, OPSR.

[20]  Roy H. Campbell,et al.  The specification of process synchronization by path expressions , 1974, Symposium on Operating Systems.

[21]  James Noble,et al.  Ownership types for flexible alias protection , 1998, OOPSLA '98.

[22]  Per Brinch Hansen.  An outline of a course on operating system principles , 2002 .

[23]  William N. Scherer,et al.  Composability for Application-Specific Transactional Optimizations , 2010 .

[24]  Erik Poll,et al.  Immutable Objects in Java , 2006 .

[25]  Michael D. Ernst,et al.  Object and reference immutability using Java generics , 2007, ESEC-FSE '07.

[26]  Jonathan L. Schilling.  Dynamically-valued constants: an underused language feature , 1995, SIGP.

[27]  Maurice Herlihy.  Technical perspectiveHighly concurrent data structures , 2009, CACM.

[28]  Peter H. Welch,et al.  Communicating Process Architectures 2012 , 2000 .

[29]  Nicholas Carriero,et al.  Applications experience with Linda , 1988, PPoPP 1988.

[30]  Per Brinch Hansen,et al.  Java's insecure parallelism , 1999, SIGP.

[31]  Hans-Juergen Boehm,et al.  HP Laboratories , 2006 .

[32]  James R. Goodman,et al.  Transactional lock-free execution of lock-based programs , 2002, ASPLOS X.

[33]  Amy L. Murphy,et al.  TinyLIME: bridging mobile and sensor networks through middleware , 2005, Third IEEE International Conference on Pervasive Computing and Communications.

[34]  Vivek Sarkar,et al.  Immutability specification and its applications: Research Articles , 2005 .

[35]  Nicholas Carriero,et al.  Coordination languages and their significance , 1992, CACM.

[36]  Antony L. Hosking,et al.  Nested transactional memory: Model and architecture sketches , 2006, Sci. Comput. Program..

[37]  Bruce K. Haddon.  Nested monitor calls , 1977, OPSR.

[38]  George Wells.  Coordination Languages: Back to the Future with Linda , 2005 .

[39]  Martin C. Rinard,et al.  ACM Conference on Object-Oriented Programming, Systems, Languages and Applications (OOPSLA), November 2002 Ownership Types for Safe Programming: Preventing Data Races and Deadlocks , 2022 .

[40]  Timothy L. Harris.  Language constructs for transactional memory , 2009, POPL '09.

[41]  Martin Odersky,et al.  Event-Based Programming Without Inversion of Control , 2006, JMLC.

[42]  P. Brinch-Hansen,et al.  The programming language Concurrent Pascal , 1975 .

[43]  Rachid Guerraoui,et al.  Concurrency and distribution in object-oriented programming , 1998, CSUR.

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

[45]  Leszek Kotulski.  About the semantic nested monitor calls , 1987, SIGP.

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

[47]  Adam Welc,et al.  Safe nondeterminism in a deterministic-by-default parallel language , 2011, POPL '11.

[48]  Joe L. Armstrong.  The development of Erlang , 1997, ICFP '97.

[49]  Edsger W. Dijkstra,et al.  The structure of the “THE”-multiprogramming system , 1968, CACM.

[50]  Hans-J. Boehm.  Transactional memory should be an implementation technique, not a programming interface , 2009 .

[51]  Nicholas Carriero,et al.  Applications experience with Linda , 1988, PPEALS '88.

[52]  Hsien-Hsin S. Lee,et al.  Kicking the tires of software transactional memory: why the going gets tough , 2008, SPAA '08.

[53]  Amy L. Murphy,et al.  LIME: Linda meets mobility , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[54]  Eduard Ayguadé,et al.  QuakeTM: parallelizing a complex sequential application using transactional memory , 2009, ICS.

[55]  Maged M. Michael.  Hazard pointers: safe memory reclamation for lock-free objects , 2004, IEEE Transactions on Parallel and Distributed Systems.

[56]  Ken Arnold,et al.  JavaSpaces¿ Principles, Patterns, and Practice , 1999 .

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

[58]  Edsger W. Dijkstra,et al.  Guarded commands, nondeterminacy and formal derivation of programs , 1975, Commun. ACM.

[59]  Per Brinch Hansen.  A Programming Methodology for Operating System Design , 1974, IFIP Congress.

[60]  Alan Chalmers,et al.  Linda implementations in Java for concurrent systems: Research Articles , 2004 .

[61]  James R. Larus,et al.  Software and the Concurrency Revolution , 2005, ACM Queue.

[62]  Gregory R. Andrews,et al.  Concepts and Notations for Concurrent Programming , 1983, CSUR.

[63]  Andrew Birrell,et al.  Implementing Remote procedure calls , 1983, SOSP '83.

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

[65]  Per Brinch Hansen,et al.  The Origin of Concurrent Programming: From Semaphores to Remote Procedure Calls , 2013 .

[66]  Vivek Sarkar,et al.  Concurrent Collections Programming Model , 2010, Encyclopedia of Parallel Computing.

[67]  Per Brinch Hansen,et al.  Operating System Principles , 1973 .

[68]  Michael D. Ernst,et al.  A practical type system and language for reference immutability , 2004, OOPSLA '04.

[69]  John Tang Boyland,et al.  Capabilities for Sharing: A Generalisation of Uniqueness and Read-Only , 2001, ECOOP.

[70]  Edward A. Lee.  The problem with threads , 2006, Computer.

[71]  James R. Larus,et al.  Transactional memory , 2008, CACM.

[72]  Erik Poll,et al.  Type-based Object Immutability with Flexible Initialization - extended version , 2009 .

[73]  Alexander Aiken,et al.  A theory of type qualifiers , 1999, PLDI '99.

[74]  Per Brinch Hansen,et al.  Concurrent Programming Concepts , 1973, CSUR.

[75]  Kenneth P. Birman,et al.  Exploiting virtual synchrony in distributed systems , 1987, SOSP '87.

[76]  Rachid Guerraoui,et al.  Why STM can be more than a research toy , 2011, Commun. ACM.

[77]  Vivek Sarkar,et al.  Immutability specification and its applications , 2002, JGI '02.

[78]  Edward A. Lee.  Disciplined Message Passing , 2009 .

[79]  Maged M. Michael,et al.  Software Transactional Memory: Why Is It Only a Research Toy? , 2008, ACM Queue.

[80]  George Wells.  New and improved: Linda in Java , 2006, Sci. Comput. Program..

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

[82]  Andy Oram,et al.  Beautiful Code: Leading Programmers Explain How They Think (Theory in Practice (O'Reilly)) , 2007 .

[83]  Erik Poll,et al.  Immutable Objects for a Java-Like Language , 2007, ESOP.

[84]  Benjamin C. Pierce,et al.  Types and programming languages: the next generation , 2003, 18th Annual IEEE Symposium of Logic in Computer Science, 2003. Proceedings..

[85]  Mark Moir,et al.  Hybrid transactional memory , 2006, ASPLOS XII.

[86]  Alan Chalmers,et al.  Linda implementations in Java for concurrent systems , 2004, Concurr. Pract. Exp..

[87]  Mateo Valero Cortés,et al.  Hybrid transactional memory to accelerate safe lock-based transactions , 2008 .

[88]  George Clifford Wells,et al.  A programmable matching engine for application development in Linda , 2001 .

[89]  Joep L. W. Kessels.  An alternative to event queues for synchronization in monitors , 1977, CACM.

[90]  Per Brinch Hansen,et al.  Structured multiprogramming , 1972, CACM.

[91]  Roberto Ierusalimschy,et al.  Revisiting coroutines , 2009, TOPL.

[92]  Charles Antony Richard Hoare.  Towards a theory of parallel programming , 2002 .

[93]  Sergei Gorlatch,et al.  Send-receive considered harmful: Myths and realities of message passing , 2004, TOPL.

[94]  C. A. R. Hoare,et al.  Monitors: an operating system structuring concept , 1974, CACM.

[95]  John H. Howard.  Signaling in monitors , 1976, ICSE '76.

[96]  Sarita V. Adve,et al.  Parallel programming must be deterministic by default , 2009 .

[97]  Walter Bright,et al.  The D Programming Language , 2010 .

[98]  David Lorge Parnas.  The non-problem of nested monitor calls , 1978, OPSR.

[99]  Dan Grossman,et al.  The transactional memory / garbage collection analogy , 2007, OOPSLA.

[100]  Christina Freytag,et al.  Using Mpi Portable Parallel Programming With The Message Passing Interface , 2016 .

[101]  Henri E. Bal,et al.  Programming languages for distributed computing systems , 1989, CSUR.

[102]  Message P Forum,et al.  MPI: A Message-Passing Interface Standard , 1994 .

[103]  Andrew M. Lister.  The problem of nested monitor calls , 1977, OPSR.

[104]  Joe Armstrong,et al.  Programming Erlang: Software for a Concurrent World , 1993 .

[105]  Eric A. Brewer,et al.  USENIX Association Proceedings of HotOS IX : The 9 th Workshop on Hot Topics in Operating Systems , 2003 .

[106]  Nir Shavit,et al.  Understanding Tradeoffs in Software Transactional Memory , 2007, International Symposium on Code Generation and Optimization (CGO'07).

[107]  Roger M. Needham,et al.  On the duality of operating system structures , 1979, OPSR.

[108]  Horst D. Wettstein.  The problem of nested monitor calls revisited , 1978, OPSR.

[109]  Robert Ennals.  Software Transactional Memory Should Not Be Obstruction-Free , 2005 .

[110]  Per Brinch Hansen,et al.  The invention of concurrent programming , 2002 .

[111]  Maurice Herlihy,et al.  Nonblocking memory management support for dynamic-sized data structures , 2005, TOCS.

[112]  David Gelernter,et al.  Generative communication in Linda , 1985, TOPL.

[113]  Maurice Herlihy,et al.  Wait-free synchronization , 1991, TOPL.

[114]  Hans-Juergen Boehm,et al.  You don't know jack about shared variables or memory models , 2011, Commun. ACM.