20. – 25. August 2000, Dagstuhl Seminar 00341
High Performance Computing and Java
S. Flynn-Hummel (IBM Watson), V. Getov (Univ. Westminster, London-Harrow), F. Irigoin (Paris), Ch. Lengauer (Passau)
Die Dagstuhl-Stiftung erhielt eine Spende von:
Auskunft zu diesem Dagstuhl Seminar erteilt
The object-oriented programming language Java aspires to become a modern version of C++ and has rapidly captured people's attention, largely because of its features for interactive and Internet programming. One advantage of Java over C++ is that it includes mechanisms for parallelism and coordination, which makes it a natural language for distributed computing.
The immense expectations in Java have spawned numerous efforts to extend its applicability. One example is the inclusion of ideas of functional programming in the Java derivative Pizza; one of the features offered by Pizza is the template, which is similar to the skeleton in parallel programming (see seminars 9708 and 99171). Another example is Titanium, which includes features to facilitate SPMD-style parallel programming.
High performance computing (HPC) has also been a field of high hopes since the growth of a parallel computer market in the last decade. However, parallel languages and parallelizing compilers have not lived up to expectations in target code efficiency. This is due in part to the rapid changes in parallel architectures and to current limitations of compilation technology. To date, the most popular style of parallel programming has been at a comparatively low level: with an imperative language like Fortran or C and with MPI directives for communication. Hundreds of explicitly parallel programs have been derived this way. The goal must be to make parallel programming less cumbersome.
The seminar's charter is to explore where concepts pursued by Java, like object orientation and threads, just-in-time compilation, virtual machines, etc. can play a useful r4le in high performance computing. Threads and remote method invocation require more efficient context management and communication protocols. Just-in-time compilation for a high performance virtual machine would enhance the portability of HPC codes and holds promises for more flexibility in well-targeted code optimization.
In its present form, Java is clearly not well suited for HPC -- but it should be. One aim of the seminar is to help work out guidelines and recommendations to make it so. The Java Grande Forum, a consortium of universities, companies and research laboratories was formed in early 1998 for this purpose. Numerous workshops and conferences on this topic have been announced and held since. This seminar is different in that it strives to bring together, in balance, Java fans and skeptics in order to enable a more encompassing, critical assessment. Java will serve as a point of reference but will not be the only language considered.
Central questions to be discussed include:
- How suitable are Java threads for high performance computing? Can they be made more light-weight?
- Can object-oriented features enhance the portability of performance?
- How can efficient communication be added to Java?
- What should be the division of labor between static (compile-time), just-in-time, and dynamic (run-time) optimization/parallelization?
- Can a virtual machine play a useful r4le in high performance computing? How can the performance/scalability of the Java Virtual Machine be improved? How well does the Java numerics model facilitate the development of portable high performance codes?
- What lessons can be learned from the Java standardization process?
- Where is parallel programming still helpful in achieving high performance?
A section of maximally three papers on work presented at this seminar is planned for the Nov. 2001 issue of the Communications of the ACM (http://www.acm.org/cacm/)