Virtual Machine Support for Many-Core Architectures: Decoupling Abstract from Concrete Concurrency Models

The upcoming many-core architectures require software developers to exploit concurrency to utilize available computational power. Today's high-level language virtual machines (VMs), which are a cornerstone of software development, do not provide sufficient abstraction for concurrency concepts. We analyze concrete and abstract concurrency models and identify the challenges they impose for VMs. To provide sufficient concurrency support in VMs, we propose to integrate concurrency operations into VM instruction sets. Since there will always be VMs optimized for special purposes, our goal is to develop a methodology to design instruction sets with concurrency support. Therefore, we also propose a list of trade-offs that have to be investigated to advise the design of such instruction sets. As a first experiment, we implemented one instruction set extension for shared memory and one for non-shared memory concurrency. From our experimental results, we derived a list of requirements for a full-grown experimental environment for further research.

[1]  Henry Hoffmann,et al.  On-Chip Interconnection Architecture of the Tile Processor , 2007, IEEE Micro.

[2]  Bradley C. Kuszmaul,et al.  Cilk: an efficient multithreaded runtime system , 1995, PPOPP '95.

[3]  Radha Jagadeesan,et al.  A theory of memory models , 2007, PPOPP.

[4]  Albert Noll,et al.  Optimization strategies for a java virtual machine interpreter on the cell broadband engine , 2008, CF '08.

[5]  Wolfgang De Meuter,et al.  Linguistic symbiosis between actors and threads , 2007, ICDL '07.

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

[7]  Uwe Kastens,et al.  Feedback driven instruction-set extension , 2004, LCTES '04.

[8]  Michael M. Swift,et al.  Pathological Interaction of Locks with Transactional Memory , 2008 .

[9]  Joe Armstrong,et al.  Concurrent programming in ERLANG , 1993 .

[10]  Jonathan S. Shapiro,et al.  Concurrency among strangers: programming in E as plan coordination , 2005 .

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

[12]  Michael Gschwind,et al.  Cell GC: using the cell synergistic processor as a garbage collection coprocessor , 2008, VEE '08.

[13]  Bratin Saha,et al.  McRT-STM: a high performance software transactional memory system for a multi-core runtime , 2006, PPoPP '06.

[14]  Cho-Li Wang,et al.  JESSICA2: a distributed Java Virtual Machine with transparent thread migration support , 2002, Proceedings. IEEE International Conference on Cluster Computing.

[15]  Giovanni De Micheli,et al.  Automatic instruction set extension and utilization for embedded processors , 2003, Proceedings IEEE International Conference on Application-Specific Systems, Architectures, and Processors. ASAP 2003.

[16]  Milo M. K. Martin,et al.  Unrestricted Transactional Memory: Supporting I/O and System Calls Within Transactions , 2006 .

[17]  Eric Dean Tribble,et al.  Concurrency Among Strangers , 2005, TGC.

[18]  Daniel A. Brokenshire,et al.  Introduction to the Cell Broadband Engine Architecture , 2007, IBM J. Res. Dev..

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

[20]  James Gosling,et al.  The Java Language Specification, 3rd Edition , 2005 .

[21]  Martin Odersky,et al.  Actors That Unify Threads and Events , 2007, COORDINATION.

[22]  Chung-Kwong Yuen,et al.  A survey of implementations of concurrent, parallel and distributed Smalltalk , 1993, SIGP.

[23]  Edward T. Grochowski,et al.  Larrabee: A many-Core x86 architecture for visual computing , 2008, 2008 IEEE Hot Chips 20 Symposium (HCS).

[24]  David M. Ungar,et al.  Hosting an object heap on manycore hardware: an exploration , 2009, DLS '09.

[25]  Suresh Jagannathan,et al.  A Uniform Transactional Execution Environment for Java , 2008, ECOOP.

[26]  David Gregg,et al.  Optimizing indirect branch prediction accuracy in virtual machine interpreters , 2003, PLDI '03.

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

[28]  John A. Trono,et al.  Further comments on "A Correct and Unrestrictive Implementation of General Semaphores" , 2000, OPSR.

[29]  Stefan Marr,et al.  Intermediate language design of high-level language virtual machines: towards comprehensive concurrency support , 2009, VMIL '09.

[30]  No License,et al.  Intel ® 64 and IA-32 Architectures Software Developer ’ s Manual Volume 3 A : System Programming Guide , Part 1 , 2006 .

[31]  Charles E. Leiserson,et al.  Programming with exceptions in JCilk , 2006, Sci. Comput. Program..

[32]  Andreas Krall,et al.  Instruction Scheduling for Complex Pipelines , 1992, CC.

[33]  Xu Wang,et al.  A Quantitative Study of the On-Chip Network and Memory Hierarchy Design for Many-Core Processor , 2008, 2008 14th IEEE International Conference on Parallel and Distributed Systems.

[34]  Carl Hewitt,et al.  A Universal Modular ACTOR Formalism for Artificial Intelligence , 1973, IJCAI.

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

[36]  Michael Haupt,et al.  Towards an actor-based concurrent machine model , 2009, ICOOOLPS@ECOOP.

[37]  Virendra J. Marathe,et al.  Design tradeoffs in modern software transactional memory systems , 2004 .

[38]  Mark D. Hill,et al.  Cache coherence techniques for multicore processors , 2008 .

[39]  Ramesh Sankaranarayana,et al.  DESIGNING A DISTRIBUTED JVM ON A CLUSTER , 2003 .

[40]  Michael Franz,et al.  A Tree-Based Alternative to Java Byte-Codes , 1999, International Journal of Parallel Programming.

[41]  José M. Piquer.  Indirect distributed garbage collection: handling object migration , 1996, TOPL.

[42]  D. M. Hutton,et al.  The Art of Multiprocessor Programming , 2008 .

[43]  Gul A. Agha,et al.  Actor frameworks for the JVM platform: a comparative analysis , 2009, PPPJ '09.

[44]  C. A. R. Hoare,et al.  Communicating sequential processes , 1978, CACM.

[45]  Doug Lea,et al.  A Java fork/join framework , 2000, JAVA '00.

[46]  Bobby Bodenheimer,et al.  Synthesis and evaluation of linear motion transitions , 2008, TOGS.

[47]  Alan Mycroft,et al.  Kilim: Isolation-Typed Actors for Java , 2008, ECOOP.

[48]  Albert Noll,et al.  CellVM: A Homogeneous Virtual Machine Runtime System for a Heterogeneous Single-Chip Multiprocessor , 2008 .