Pursuing Laziness for Efficient Implementation of Modern Multithreaded Languages

Modern multithreaded languages are expected to support advanced features such as thread identification for Java-style locks and dynamically-scoped synchronization coupled with exception handling. However, supporting these features has been considered to degrade the effectiveness of existing efficient implementation techniques for fine-grained fork/join multithreaded languages, e.g., lazy task creation. This paper proposes efficient implementation techniques for an extended Java language OPA with the above advanced features. Our portable implementation in C achieves good performance by pursuing ‘laziness’ not only for task creation but also stealable continuation creation, thread ID allocation, and synchronizer creation.

[1]  Takayasu Ito,et al.  Parallel Symbolic Languages and Systems , 1996, Lecture Notes in Computer Science.

[2]  Marc Feeley,et al.  Lazy Remote Procedure Call and its Implementation in a Parallel Variant of C , 1995, PSLS.

[3]  Xingbin Zhang,et al.  A Hybrid Execution Model for Fine-Grained Languages on Distributed Memory Multicomputers , 1995, Proceedings of the IEEE/ACM SC95 Conference.

[4]  Masahiro Yasugi.  Hierarchically Structured Synchronization and Exception Handling in Parallel Languages using Dynamic Scope , 1999 .

[5]  Marc Feeley.  Polling efficiently on stock hardware , 1993, FPCA '93.

[6]  Robert H. Halstead,et al.  MULTILISP: a language for concurrent symbolic computation , 1985, TOPL.

[7]  D. I. Bevan,et al.  Distributed Garbage Collection Using Reference Counting , 1987, PARLE.

[8]  Kazuo Taki,et al.  Eliminating bottlenecks on parallel systems using adaptive objects , 1998, Proceedings. 1998 International Conference on Parallel Architectures and Compilation Techniques (Cat. No.98EX192).

[9]  Gregory V. Wilson,et al.  Parallel Programming Using C , 1996 .

[10]  Volker Strumpen,et al.  Indolent Closure Creation , 1998 .

[11]  Matteo Frigo,et al.  The implementation of the Cilk-5 multithreaded language , 1998, PLDI.

[12]  Brad Calder,et al.  Leapfrogging: a portable technique for implementing efficient futures , 1993, PPOPP '93.

[13]  Eric S. Roberts,et al.  WorkCrews: An abstraction for controlling parallelism , 2005, International Journal of Parallel Programming.

[14]  Akinori Yonezawa,et al.  StackThreads/MP: integrating futures into calling standards , 1999, PPoPP '99.

[15]  Doug Lea,et al.  Concurrent programming in Java - design principles and patterns , 1996, Java series.

[16]  Takayasu Ito,et al.  Parallel Symbolic Computing: Languages, Systems, and Applications , 1992, Lecture Notes in Computer Science.

[17]  Dennis Gannon,et al.  Proceedings of the ACM 2000 conference on Java Grande , 2000 .

[18]  A. J. Nijman,et al.  PARLE Parallel Architectures and Languages Europe , 1987, Lecture Notes in Computer Science.

[19]  Marc Feeley,et al.  A Message Passing Implementation of Lazy Task Creation , 1992, Parallel Symbolic Computing.

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

[21]  Robert H. Halstead,et al.  Lazy task creation: a technique for increasing the granularity of parallel programs , 1990, IEEE Trans. Parallel Distributed Syst..