Abstract.
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.
This research is supported in part by the 21st century COE program.
This is a preview of subscription content, log in via an institution.
Buying options
Tax calculation will be finalised at checkout
Purchases are for personal use only
Learn about institutional subscriptionsPreview
Unable to display preview. Download preview PDF.
References
Yasugi, M., Taki, K.: An object-oriented language for parallel processing its design and implementation. In: IPSJ SIG Notes 96-PRO-8(SWoPP 1996), vol. 96, pp. 157–162 (1996) (in Japanese)
Yasugi, M., Eguchi, S., Taki, K.: Eliminating bottlenecks on parallel systems using adaptive objects. In: Proc. of International Conference on Parallel Architectures and Compilation Techniques, Paris, France, pp. 80–87 (1998)
Yasugi, M.: Hierarchically structured synchronization and exception handling in parallel languages using dynamic scope. In: Proc. of International Workshop on Parallel and Distributed Computing for Symbolic and Irregular Applications (1999)
Yasugi, M., Umatani, S., Kamada, T., Tabata, Y., Ito, T., Komiya, T., Yuasa, T.: Code generation techniques for an object-oriented parallel language OPA. IPSJ Transactions on Programming 42, 1–13 (2001) (in Japanese)
Supercomputing Technologies Group: Cilk 5.3.2 Reference Manual. Massachusetts Institute of Technology, Laboratory for Computer Science, Cambridge, Massachusetts, USA (2001)
Frigo, M., Leiserson, C.E., Randall, K.H.: The implementation of the Cilk-5 multithreaded language. In: ACM SIGPLAN Notices (PLDI 1998), vol. 33, pp. 212–223 (1998)
Feeley, M.: Lazy remote procedure call and its implementation in a parallel variant of C. In: Queinnec, C., Halstead Jr., R.H., Ito, T. (eds.) PSLS 1995. LNCS, vol. 1068, pp. 3–21. Springer, Heidelberg (1996)
Vandevoorde, M.T., Roberts, E.S.: WorkCrews: An abstraction for controlling parallelism. International Journal of Parallel Programming 17, 347–366 (1988)
Chandra, R., Gupta, A., Hennessy, J.L.: COOL. In: Wilson, G.V., Lu, P. (eds.) Parallel Programming Using C++, The MIT Press, Cambridge (1996)
Taura, K., Tabata, K., Yonezawa, A.: StackThreads/MP: Integrating futures into calling standards. In: Proceedings of ACM SIGPLAN Symposium on Principles & Practice of Parallel Programming (PPoPP), pp. 60–71 (1999)
Wagner, D.B., Calder, B.G.: Leapfrogging: A portable technique for implementing efficient futures. In: Proceedings of Principles and Practice of Parallel Programming (PPoPP 1993), pp. 208–217 (1993)
Plevyak, J., Karamcheti, V., Zhang, X., Chien, A.A.: A hybrid execution model for fine-grained languages on distributed memory multicomputers. In: Proceedings of the 1995 conference on Supercomputing (CD-ROM), p. 41. ACM Press, New York (1995)
Bevan, D.I.: Distributed garbage collection using reference counting. In: de Bakker, J.W., Nijman, A.J., Treleaven, P.C. (eds.) PARLE 1987. LNCS, vol. 259, pp. 176–187. Springer, Heidelberg (1987)
Mohr, E., Kranz, D.A., Halstead, J. R.H.: Lazy task creation: A technique for increasing the granularity of parallel programs. IEEE Transactions on Parallel and Distributed Systems 2, 264–280 (1991)
Halstead Jr., R.H.: Multilisp: a language for concurrent symbolic computation. ACM Transactions on Programming Languages and Systems (TOPLAS) 7, 501–538 (1985)
Feeley, M.: A message passing implementation of lazy task creation. In: Halstead Jr., R.H., Ito, T. (eds.) US/Japan WS 1992. LNCS, vol. 748, pp. 94–107. Springer, Heidelberg (1993)
Feeley, M.: Polling efficiently on stock hardware. In: Proc. of Conference on Functional Programming Languages and Computer Architecture, pp. 179–190 (1993)
Lea, D.: A Java fork/join framework. In: Proceedings of the ACM 2000 conference on Java Grande, pp. 36–43. ACM Press, New York (2000)
Lea, D.: Concurrent Programming in Java: Design Principles and Patterns, 2nd edn. Addison Wesley, Reading (1999)
Strumpen, V.: Indolent closure creation. Technical Report MIT-LCS-TM-580, MIT (1998)
Author information
Authors and Affiliations
Editor information
Editors and Affiliations
Rights and permissions
Copyright information
© 2003 Springer-Verlag Berlin Heidelberg
About this paper
Cite this paper
Umatani, S., Yasugi, M., Komiya, T., Yuasa, T. (2003). Pursuing Laziness for Efficient Implementation of Modern Multithreaded Languages. In: Veidenbaum, A., Joe, K., Amano, H., Aiso, H. (eds) High Performance Computing. ISHPC 2003. Lecture Notes in Computer Science, vol 2858. Springer, Berlin, Heidelberg. https://doi.org/10.1007/978-3-540-39707-6_13
Download citation
DOI: https://doi.org/10.1007/978-3-540-39707-6_13
Publisher Name: Springer, Berlin, Heidelberg
Print ISBN: 978-3-540-20359-9
Online ISBN: 978-3-540-39707-6
eBook Packages: Springer Book Archive