The Potential of Java for High Performance

The Potential of Java for High Performance Applications M. Ashworth CLRC Daresbury Laboratory, Warrington WA4 4AD, UK Tel: +44-1925-603663 Fax: +44-1925-603634 [email protected]

Abstract Java has enjoyed a remarkable rise in popularity as the language of choice in a wide range of IT applications. High Performance and Data Intensive Computing has gone through a period of intense change as software environments have struggled to match the pace of developments in high performance hardware. There are now suggestions that Java may be able to meet the needs of the high performance community where other languages have failed. Java clearly has many advantages. In addition to being simple, object-oriented, portable, robust and extensible, its firm foundation on a thread-based execution model maps naturally onto parallel platforms. However, in most cases Java is much slower than traditional languages and there are specific features of the language which limit its performance. In this paper we review activities aimed at developing the potential of Java for use in high performance applications, both as a pure vehicle and as a component in multi-language environments. We conclude that although there is still some way to go before Java matures into a high-performance and fully functional language for technical and scientific applications, there is considerable benefit in using Java in a multi-language environment, in which Java is used for its portability and standardization and C, C++ and Fortran are used for their technical and scientific capabilities.

Keywords: Java, high-performance computing, parallel processing, distributed computing, cluster computing

1.

INTRODUCTION

High-Performance Computing (HPC), by which we mean large-scale scientific or data intensive computing, has gone through a period of great change as software environments have struggled to match the pace of developments in high performance hardware. Each new hardware innovation, vector processors, array processors, shared memory multi-processors, distributed memory parallel systems, cache-coherent systems, virtual shared memory, etc., has brought with it a new parallel programming model. Existing languages have evolved with the introduction of new features, such as compiler directives, message passing libraries, array syntax, etc., and new languages have been developed, e.g. Occam, attempting to express the parallel programming model in a powerful, flexible, succinct and platform-independent way. Despite many successes, it is apparent that no single solution has emerged which can completely meet the needs of software developers.

The Java language [15, 20] has attracted considerable interest in the popular and technical literature [1] and there are now suggestions that Java may be able to meet the needs of the HPC community where other languages have failed [21]. Java clearly has many advantages. In addition to being simple, object-oriented, portable, robust and extensible, its firm foundation on a threadbased execution model maps naturally onto parallel platforms. Java source is compiled to class files containing machine-independent byte-code, which is like machine code in form but is not specific to any particular hardware. In this form, the Java class file can be efficiently transmitted across a network from the server to a Java-enabled client where it is interpreted by the Java Virtual Machine (JVM). This means that a Java program can run without change on any machine for which a JVM has been written. Java is more efficient than other scripts, but, in most cases, it is slower than traditional languages, like C, C++ and Fortran. This is not a problem for Web applets, but severely limits Java’s efficacy for HPC. Specific developments have emerged to try to improve the performance of Java. On most platforms it is possible to compile Java class files with a Just-inTime (JIT) compiler. The byte codes are no longer directly interpreted, but firstly compiled on-thefly into machine code just before execution. Where strict platform independence is not required, native Java compilers, which compile directly to machine code, offer greatly improved performance. For example, the IBM High-Performance Compiler for Java (now part of the VisualAge for Java product), which generates native code for the RS6000 architecture [25]. However, even native compilers have difficulty matching the performance of traditional languages like C, C++ and Fortran, because there are specific features of Java which limit the possibilities for compiler optimization. In this paper we review activities aimed at developing the potential of Java as a language for high performance applications, including distributed and cluster computing, both in a pure form and as a component of multi-language environments.

2.

HIGH-PERFORMANCE JAVA

The Java programming language has the basic qualities needed for writing high-performance applications. However, since Java is relatively new, it lacks the extensive scientific software of other languages like C, C++ and Fortran. The main focus for activities in this area is the Java Grande Forum (JGF). “The Java Grande Forum believes that, more than any other language technology introduced thus far, Java has the greatest potential to deliver an attractive productive programming environment spanning the very broad range of tasks needed by the Grande Programmer” [21] The word “Grande” refers to an application of a large-scale nature where performance counts - the same sense in which we use the term HPC. The JGF is working towards a community consensus on actions which can be taken to improve the language and its environment and on the development of supporting infrastructure and standards. In a recent report [21] the JGF identifies a number of issues which are considered to be key to the suitability of Java for HPC applications, the most important of which fall into the categories of numerical issues and concurrency issues.

2.1

Numerical Issues

The JGF has focused on five critical areas where improvements to the Java language are needed: complex arithmetic, floating-point arithmetic, lightweight classes, multidimensional arrays and operator overloading.

2.1.1

Complex Arithmetic

Readability of scientific codes demands that complex numbers can be used in exactly the same way as integer or real values. The speed of computation should also not be compromised. Complex number classes can be implemented in Java on top of the existing primitive types, but the object overhead of complex methods makes them unacceptably inefficient. Readability and ease of code maintenance is much more difficult to attain if the syntax and semantics of complex is significantly different from that of the primitive types. Adding complex as a new primitive type in Java also has its problems: either the JVM would have to support the complex type directly, and fundamental changes to the JVM are to be avoided where possible, or complex would have to be translated into a pair of double values, leading to difficulties when complex numbers are passed into or returned from a method. A better solution is to extend Java so that new and arbitrary numeric types can be operated on conveniently and efficiently. This would have advantages not only for complex but also for other requirements such as interval arithmetic and extended precision.

2.1.2

Floating-point Arithmetic

The Java language, as currently defined, has very strict floating point semantics, which are intended to ensure precise reproducibility of results across a wide range of platforms, but which result in poor performance. For example, it is forbidden to use associativity to rearrange operations to make use of a processor’s combined multiply-add operation. The floating point requirements for HPC vary from application to application, but in most cases scientists and engineers need a dependable platform for program development when the stability of algorithms may be in question, and the ability subsequently to select optimizations which deliver the full performance of the floating point hardware. The proposals of the JGF allow for a strict floating point declaration, indicating that current Java semantics must be used, and one or more alternative options specifying that certain operations may be rearranged to assist performance optimization. There is still some debate on the issue of exactly how far optimizers should be allowed to go. Some have argued strongly in favour of allowing wide-ranging scope for optimizations, and others argue that the predictability of Java is one of its most important features which should not be compromised. For scientific computing it is also of key importance that Java adheres strictly to the IEEE 754 standard in its treatment of floating point exceptions [23].

2.1.3

Lightweight Classes

Lightweight classes are desirable to allow the creation of new Java objects. Many important features, including complex numbers, can be implemented as classes but would suffer from poor performance using normal Java classes. The issue here is how to implement lightweight classes without necessitating extensive changes to the JVM, reducing the likelihood of acceptance. The

recommended approach is to use the Java compiler to translate lightweight classes into normal JVM classes.

2.1.4

Multidimensional Arrays

Most HPC problems take the form of a computational representation of a physical or mathematical model involving multidimensional objects, and these are most commonly represented internally using multidimensional arrays. It is critical for performance that operations on multidimensional arrays are easily optimized by the compiler. Furthermore, it is common practice for the application developer to use a knowledge of how multidimensional arrays are stored in memory in order to write programs in a way which will assist the compiler in producing efficient code. e.g. by traversing an array in such a way as to maximize locality of reference. Java implements multidimensional arrays through arrays of arrays. At first sight this provides the required capability, but, unfortunately, arrays of arrays are more flexible than we require, allowing jagged arrays, in which not all rows have the same length, aliasing between rows and changes in shape. Whereas this flexibility is a valuable feature, it introduces a performance penalty, because the compiler has no information about possible shape changes and aliasing, and is forced into a conservative strategy, generating additional loads and stores. The JGF proposes an additional set of Java classes that implement immutable, rectangular multidimensional arrays with the same capabilities, and hopefully the same performance, as Fortran arrays. The array classes would also support array sections by analogy to Fortran 90.

2.1.5

Operator Overloading

Operator overloading is necessary to enable additional numeric types to be used in a way which is easy to develop, understand and maintain. Overloading allows the meaning of operators, such as plus, minus and multiply to depend on the type of their operands. Thus the addition of two complex numbers may be expressed as ‘a + b’ just as with any primitive type. Addition of two operands with user-defined type would usually have to be expressed using an explicit method such as ‘Complex.sum(a,b)’, but this would make scientific codes virtually unreadable. Some technique should be designed to allow overloading of the arithmetic, comparison, assignment and subscripting operators.

2.2

Concurrency Issues

The Java language has several built-in mechanisms which allow the parallelism inherent in scientific programs to be exploited. Threads and concurrency constructs are well-suited to shared memory computers, but not to large-scale distributed memory machines. Although sockets and the Remote Methods Invocation (RMI) interface allow network programming, they are too client/ server oriented to be suitable for SPMD (Single Program Multiple Data) scientific programming. Codes based on RMI would potentially underperform compared to platform-specific implementations of standard communication libraries like the Message Passing Interface (MPI). While promoting the activities in introducing the MPI model to Java, the JGF has also focused on improvements to the performance and capabilities of RMI as being key to exploiting Java for highperformance parallel and distributed computing. RMI provides the mechanism by which Java programs running in different JVMs may communicate by invoking methods remotely. Currently RMI is based on the client/server model and communicates over TCP/IP networks, which places

limitations on performance especially for closely coupled systems, such as distributed memory multi-processors and workstation clusters, commonly used for HPC applications. Many scientific applications have fine-grained parallelism and making fast remote method invocations with low latency and high bandwidth essential. It seems likely that in the near future developers will be able to choose between a number of communication models, including MPI and an improved RMI, in order to support the development of pure Java parallel and distributed applications.

2.3

Benchmarking

Another key activity of the JGF is to develop a Java benchmark suite for high performance applications. This will enable the community continuously to evaluate developments in the language and its execution environments and to feedback into the Java Grande process. Bull et al [11] have presented a framework and methodology for benchmarking Java Grande applications which aims to establish a standard approach within the community. An instrumentation Application Programming Interface (API) is presented, including timers and associated utilities, and the whole is invoked by extending the lowest class of the main hierarchy in the existing code and implementing (using ‘implements’) the benchmark interface. A number of serial benchmark codes have already been developed, including low-level benchmarks (including arithmetic operations, mathematical functions and the cost of a method call), kernels and applications. Parallel benchmarks are planned, but this leads to the problem area of which of the many possible parallel execution models to implement, e.g. threads, RMI or message-passing, and it is likely that multiple versions of parallel benchmarks using each of these mechanisms will have to be made available.

3.

MULTI-LANGUAGE ENVIRONMENTS

Java has clear benefits in terms of simplicity, portability and robustness, but it does not deliver the performance required for HPC, nor does it have a well-established collection of scientific libraries. C and Fortran do not have Java’s programming advantages, but they have proven execution speed on high-performance systems and there is a large repository of mathematical and scientific software. A winning formula would therefore appear to be to use each where its strengths lie: use Java for the structural parts of an application, and C and/or Fortran for the performance critical sections. For example, Java may be used as a wrapper to existing legacy code and existing native libraries. Tools now exist [18] for the automatic creation of Java interfaces to native libraries. This has been demonstrated in the case of the linear algebra software packages BLAS and LAPACK, as well as the Message Passing Interface library (MPI). Experiments using integer sort and matrix multiply parallel benchmarks in Fortran, C and Java, linked to native MPI and a native Fortran matrix multiply routine show that the Java-based code is highly efficient, and using IBM’s high-performance native Java compiler, execution times are found to be comparable with those attained using C and Fortran. In a distributed computing environment many developers now adopt a client/server model to application design. In this approach, the user interface is a Graphical user Interface (GUI) running on the user's workstation handling control tasks and other non-performance critical book-keeping activities (the client) while the high-performance kernel executes on the compute server. We can envisage a new type of multi-language, multi-paradigm programming environment for high-performance applications which makes use of innovative Web technologies and GUIs based on Java and provides a simple API, high performance through interfaces to native libraries, and a high level of portability and flexibility for large-scale applications.

Atwood et al [2] have evaluated the role of Java as a component in the development environment in the case of a CFD code. The code solves the transonic small disturbance equation for simulation of inviscid steady transonic flow over slender bodies. Several programming models were evaluated for ease of implementation, portability and performance. The approaches were as follows: 1) 2) 3)

4)

pure Java, in which the entire solver was written as a stand-alone Java application; Java with C using JNI, in which the iterative solver was coded in C and integrated with Java code using JNI, the Java Native Interface; Java client/server approach using RMI, in which a client program accepts user parameters via a GUI and sends them to a remote solver running on a server machine, with client/server interaction being performed using RMI; Java with C using JNI and RMI, in which approaches 2 and 3 are combined.

It was found that, although limited in capabilities, the development process was convenient and powerful, but would benefit from additional support for interface design. In addition to supplying input parameters, the GUI was used to examine the effectiveness of Java for post-processing. Whereas Java’s graphical capabilities were found to be excellent for two-dimensional representations, full visualization of the three-dimensional flow fields was not straight-forward. Performance measurements showed that the optimized solver written in C was twenty-five times faster than interpreted Java and six times faster than JIT-compiled Java, emphasizing the potential benefits of adopting a multi-language approach.

4.

JAVA, HPC AND THE WORLD-WIDE WEB

The World-Wide Web was conceived as a means of accessing information and that is still its major function, but it is increasingly evolving towards a means of providing and accessing services. Likewise, networking, both local-area and wide-area, is no longer about providing connectivity, but about providing services. The client-server based model of distributed computing is growing beyond the simple file-server and compute-server concepts to encompass a global Web-based metacomputer. Most Internet resources today present data as pages written in HTML format, a document mark-up language which allows simple text formatting, access to data in various forms (image, audio, video, etc.), and, crucially as this gives the Web its web-like structure, hypertext links to other pages. Limited services, such as email forms, database searches etc., are provided using the Common Gateway Interface (CGI), which allows an incoming client to execute programs made available on the server. A major sea change is happening on the Internet, due in no small part to the emergence of Java. Java has been designed from the start to facilitate the provision of services over the Internet. The main difference from CGI, is that Java applets (small Java applications embedded in Web pages) execute not on the server but on the client, enabling applications to make better use of low bandwidth communications. When a Java-enabled client accesses a Java applet, the Java class file is downloaded and runs on the client's own hardware using their JVM. The capabilities of Java are growing rapidly and a wide range of class libraries and toolkits for Web access, thread-based computing and GUIs are now freely available. Although the popular image of the Web has been purely as a global information provider, this has not been its only manifestation. Increasingly, organisations are setting up an Intranet - a corporate Web server providing information and services which are targeted at, and indeed are only accessible by, people within the organisation, or a part of it. The Intranet may contain information for

staff ranging from accounts to telephone directories and from minutes of meetings to the date of the Christmas dinner. Furthermore, in an industrial research and development environment, for example, the Intranet may enable access for everyone in a group or department to the technical designs and specifications of a new product together with the project specifications, modification records, test procedures, test results, marketing information etc. Communications between, as well as within, organisations are also benefiting from Web-based technology. The Extranet, a restricted, secure Web linking a group of organisations with common business interests, is emerging as a valuable way to improve communications, streamline operations and deliver greater cost-effectiveness to a range of business activities. It is in this environment that we see major benefits arising from integrating Java with traditional high-performance programming environments using the client/server model. This vision emphasises the strengths of each component: Java allows easy access to Web-based computing and facilitates the construction of GUIs; traditional languages such as C, C++ and Fortran allow applications best to exploit high-performance hardware.

5.

DISTRIBUTED-, CLUSTER- AND META- COMPUTING

With the recent availability of high-performance low-cost networking components, it is now becoming practical and cost-effective to assemble a network of workstations and/or PCs into a single distributed-memory computing resource [29]. Applications running on workstation clusters built-up over local area networks can make use of the high percentage of idle time on under-utilized desktop machines. Beowulf class systems are emerging as dedicated systems built on particularly cost-effective PC technology [7]. The rapid growth in the number of computers connected to the Web has led many researchers to consider the potential of using a number of connected, but otherwise unrelated, systems as a single heterogeneous computational resource. For suitable applications, which have large granularity, a high degree of parallelism and low sensitivity to communications latency, such metacomputers can form a practical, viable and scientifically useful resource. One feasibility study used over 800 workstations distributed across five continents [12]. This wide variety of solutions is described under a range of names: distributed computing; cluster computing; metacomputing etc.

5.1

Adapting Existing Environments for Java

The majority of HPC applications on distributed memory systems are implemented using message-passing programming using Parallel Virtual Machine (PVM) or the Message Passing Interface (MPI). PVM contains the virtual machine capabilities required for meta-computing. MPI is a more recent development and offers greater performance through the widespread availability of vendor optimized libraries. The MPI_Connect project [14] aims to provide the interoperability between MPI programs running on distributed systems required for distributed applications. There has been a number of efforts to provide the facilities required to enable these existing message-passing environments to be used in conjunction with Java. There are two possible approaches: either provide an interface between Java and the existing native libraries; or produce a pure Java class library based on the concepts of the original methodology and staying as close as possible to the original interface to minimize the learning process for the new software.

JPVM [16] adopts the latter approach in the case of PVM, providing a Java library with an interface close to the original C and Fortran specification, but with enhancements consistent with Java programming styles and which exploit Java’s additional capabilities. At the same time, JPVM adds new features, such as thread safety and communications between threads, in addition to processto-process. The performance cost of primitive operations is high and a parallel matrix multiplication benchmark shows poor speed-up for all but the largest problem size. Despite its inappropriateness for communications intensive applications, the author argues that the additional costs associated with a Java-based system do not outweigh the benefits of the added features, portability and programming flexibility afforded by Java. As described above, MPI can be called from Java using automatically generated Java bindings to native MPI libraries [18]. The Java Grande Forum have published a draft Java binding for MPI [22]. A pure Java implementation of MPI, MPIJ, based upon the existing C++ interface, is available as part of the Distributed Object Group Metacomputing Architecture (DOGMA) [26]. Performance of MPIJ has been shown to be as good as other message-passing libraries on Windows NT systems, but further high-performance benchmarks are to be encouraged.

5.2

New environments

A host of new environments are emerging in which Java is used as a key technology in enabling the efficient use of distributed computing resources as an infrastructure for parallel computing. Baratloo et al [6] introduce the Charlotte system, which supports parallel programming in Java and enables parallel tasks to be distributed using the virtual machine model. Utilizing the Web as a parallel metacomputer introduces new challenges. Charlotte addresses the issues of the programming model, the dynamic execution environment, including fault tolerance and dynamic load balancing, heterogeneity, portability and security. It is implemented as a set of Java classes and includes distributed memory objects which form the foundation of a distributed shared memory system. The application programmer specifies parallelism explicitly by including a number of parallel steps within their Java code, designating the number of instances of which classes are to run concurrently. Performance was evaluated using the Ising model simulating magnetism on a three-dimensional lattice. A number of experiments were conducted which demonstrate good parallel speed-up of up to 14.5 on 16 Ethernet connected Pentium Pro machines, and proved Charlotte’s load balancing and fault tolerance capabilities. No comparisons were made between Java and other languages. Charlotte is impeded by the restrictions inherent in the Java applet security model. For example, the master is required to run on a machine running a Web server, in order that slave applets are able to establish a direct communications channel. In addition the current implementation requires manual input of the URL location. KnittingFactory [4, 5] is a more advanced development from the same authors which has been designed to address these problems. The IceT project [19] aims to combine Internet programming techniques with established and evolving distributed computing paradigms, such as PVM, including, but not limited to, the features provided by Java. An IceT environment comprises a set of processes executing in unison across multiple hosts and multiple networks, and sharing information using IceT’s message-passing infrastructure. By using the platform-independent nature of Java, processes can be freely migrated and executed on different architectures within the resource pool, whereas previously, using PVM, the user had to compile the program individually for each distinct architecture. IceT supports the use of native languages, and preliminary investigations have shown that a combination of distributed computational processes written in C and supported by the IceT framework, can give performance competitive with the equivalent PVM implementation.

Javelin [13] uses Java-enabled Web technology to implement an infrastructure for world-wide distributed, parallel computing. The Javelin architecture links client processes seeking resources to hosts processes offering resources via a number of broker processes that coordinate supply and demand. Clients register their requirements with the brokers. Hosts register their capabilities. The brokers assign tasks and act as a communication channel. Roles are not fixed and a machine may serve as a host when it is idle, and later change to a client when tasks arise. For simplicity, the implementation uses existing Web technology, such as Web browsers and Java applets, however as such, performance is limited by that of the underlying JVM. Javelin is claimed to be fully scalable up to tens of thousands of hosts, but the performance demonstration, obtaining good speed-up results for a parallel ray tracing algorithm and a prime number search, was carried out using just nine systems, one a 64 processor Meiko CS-2. Visper [28] is a development environment which simplifies the development and testing of parallel programs by enabling a modular and object-oriented approach supported by a Web-enabled GUI. The environment consists of a single console program and a daemon program running on each participating system, both of which are stand-alone, multi-threaded Java applications. User programs are written in Java using a new MPI-like message-passing library called VComms and are then executed in parallel using the Visper console. It appears to provide many of the capabilities in a Java environment that were available previously using HeNCE [8] and XPVM [24] with C or Fortran. There are many further examples of promising and imaginative projects for Java-based distributed computing [3, 9, 10, 17, 27]

6.

CONCLUSIONS

The viability of Java as a programming language for the HPC community is yet to be established. Pure Java applications can not yet rival traditional languages for performance, nor is it feasible in most cases to jettison the existing code-base in favour of Java. Java is, however, rapidly becoming a key enabling component in a wide range of network computing environments which can be used as a foundation for distributed HPC applications. Development teams should be clear where the benefits of Java lie. Java is a highly portable language. Its “Write once, run anywhere” philosophy makes it ideal for network and Web-based computing and for the construction of interfaces, both graphical interfaces with users and interfaces with other software packages, such as databases. Java does not have a well established set of scientific library bindings, nor does it deliver the fast execution speed required for HPC. We believe that the immediate future of Java as a language for the HPC community lies in its use in a multi-language environment, in which Java is used for its portability and standardization and C, C++ and Fortran are used for their technical and scientific capabilities. Whether Java will mature into a truly high-performance and fully functional language for technical and scientific applications is still open to debate. Clearly the potential is there and considerable efforts are being made in that direction. With the maturing of compilation technology, high-performance applications written in Java will doubtlessly appear. However, it is unlikely that large numbers of programmers will be rushing to rewrite applications in Java. The practical solution is rather to re-use legacy code as server processes to Java clients or as shared libraries with Java wrappers.

7.

REFERENCES

[1] M. Ashworth, “New Language on the Block: Java for High-Performance Computing?”, ERCIM News, Number 36, 23-24, 1999. [2] C.A. Atwood, R.P. Garg and D. DeRyke, “A Prototype Computational Fluid Dynamics Case Study in Java”, in Proceedings of the ACM 1997 Workshop on Java for Science and Engineering Computation, Las Vegas, 21 June 1997, 8 pp., http://wwww.npac.syr.edu/users/gcf/03/javaforcse/ acmspecissue/latestpapers.html. [3] J.E. Baldeschwieler, R.D. Blumofe and E.A. Brewer, “ATLAS: An Infrastructure for Global Computing”, Proceedings of the 1996 SIGOPS European Workshop: Systems Support for Worldwide Applications, Connemara, Ireland, September 1996, http://www.tns.lcs.mit.edu/~djw/library/ sigops96/index.html. [4] A. Baratloo, M. Karaul, H. Karl and Z.M. Kedem, “An Infrastructure for Network Computing with Java Applets”, Proceedings of the ACM Workshop on Java for High Performance Network Computing, Stanford University, 1998, 10 pp., http://www.cs.nyu.edu/baratloo/html/publications.html. [5] A. Baratloo, M. Karaul, H. Karl and Z.M. Kedem, “KnittingFactory: An Infrastructure for Distributed Web Applications”, Technical Report TR 1997-748, Department of Computer Science, New York University, New York, NY, November 1997, http://www.cs.nyu.edu/baratloo/html/publications.html. [6] A. Baratloo, M. Karaul, Z.M. Kedem and P. Wyckoff, “Charlotte: Metacomputing on the Web”, in Proceedings of the 9th International Conference on Parallel and Distributed Computing Systems, Dijon, France, September 1996, 21 pp., http://www.cs.nyu.edu/baratlo/html/publications.html. [7] P. Beaugendre, T. Priol, G. Alleon and D. Delaveux, “A Client/Server Approach for HPC Applications within a Networking Environment”, in High-Performance Computing and Networking, eds. P. Sloot, M. Bubak and B. Hertzberger, Springer, 518-525, 1998. [8] A. Beguelin, J. J. Dongarra, G. A. Geist, R. Manchek, and V. S. Sunderam, “Graphical development tools for network-based concurrent supercomputing”, in Proceedings of Supercomputing 91, Albuquerque, New Mexico, 18th-22nd November, 435-444, 1991. [9] D. Bhatia, V. Burzevski, M. Camuseva, G.C. Fox, W. Furmanski and G. Premchandran, “WebFlow - A Visual Programming Paradigm for Web/Java Based Coarse Grain Distributed Computing”, Concurrency: Practice& Experience, Vol. 9, No. 6, 555-577, June 1997, http:// www.npac.syr.edu/techreports/html/0750/abs-0787.html. [10] T. Brecht, H. Sandhu, M. Shan and J. Talbot, “ParaWeb: Towards World-Wide Supercomputing”, Proceedings of the 1996 SIGOPS European Workshop: Systems Support for Worldwide Applications, Connemara, Ireland, September 1996, http://www.tns.lcs.mit.edu/~djw/library/ sigops96/index.html. [11] J.M. Bull, L.A. Smith, M.D. Westhead, D.S. Henty and R.A. Davey, “A Methodology for Benchmarking Java Grande Applications”, 1999, Edinburgh Parallel Computing Centre Technical Report EPCC-TR99-01, 7 pp., http://www.epcc.ed.ac.uk/t3d/documents/techreports. [12] C.H. Cap, “Massive Parallelism with Workstation Clusters -- Challenge or Nonsense” in Proceedings of the High Performance Computing and Networking Conference HPCN ‘94 Europe, Munich 1994, Springer LNCS 797, 42--52, 1994, http://www.tec.informatik.uni-rostock.de/IuK/ publications/index.html.

[13] B.O. Christiansen, P. Cappello, M.F. Ionescu, M.O. Neary, K.E. Schauser, and D. Wu, “Javelin: Internet-Based Parallel Computing Using Java”, Concurrency: Practice & Experience, Vol.9, No. 11, November 1997, http://www.cs.ucsb.edu/~danielw/Papers/publications.html. [14] G.E. Fagg and K.S. London, “MPI Interconnection and Control”, Technical Report TR98-42, Major Shared Resource Center, U.S. Army Corps of Engineers Waterways Experiment Station, Vicksburg, Missippissi, 17 pp., http://www.wes.hpc.mil/pet/CEWES/CEWES_reports.html. [15] N. Fawcett and T. Ridge, “Java - A Practical Guide”, ISBN 07506 3344 1, Butterworth-Heinemann, 1997. [16] A. Ferrari, “JPVM: Network Parallel Computing in Java”, Technical Report CS-97-29, Department of Computer Science, University of Virginia, Charlottesville, Virginia, USA, 8th December 1997, 8 pp., http://www.cs.virginia.edu/~ajf2j/jpvm.html. [17] I. Foster, G. K. Thiruvathukal and S. Tuecke, Technologies for Ubiquitous Supercomputing: A Java Interface to the Nexus Communication System, Concurrency: Practice & Experience, Special Issue, G. C. Fox (ed.), June 1997, http://www-fp.mcs.anl.gov/~foster/papers.html. [18] V. Getov, S.F. Hummel and S. Mintchev, “High-Performance Parallel Programming in Java: Exploiting Native Libraries”, Concurrency: Practice & Experience, Vol. 10, 863-872, 1998. [19] P.A. Gray and V.S. Sunderam, “IceT: Distributed Computing and Java”, Concurrency: Practice & Experience, Vol. 9, No. 11, 1997, http://www.mathcs.emory.edu/icet/. [20] A. van Hoff, S. Shaio and O. Starbuck, “Hooked on Java: creating hot Web sites with Java applets”, ISBN 0-201-48837-X, Addison-Wesley, 1996. [21] Java Grande Forum, “Making Java Work for High-End Computing”, Java Grande Forum Panel, Supercomputing 1998, Orlando, Florida, 13 November 1998, 52 pp., http://www.javagrande.org/reports.htm. [22] Java Grande Forum, “MPI for Java: Position Document and Draft API Specification”, Technical Report JGF-TR-03, November 1998, 79 pp., http://www.javagrande.org/reports.htm. [23] W. Kahan and J.D. Darcy, “How Java’s Floating-Point Hurts Everybody Everywhere”, Proceedings of the ACM Workshop on Java for High Performance Network Computing, Stanford University, 1998, http://www.cs.berkeley.edu/~wkahan/JAVAhurt.pdf [24] J.A. Kohl and G.A. Geist, “XPVM 1.0 User's Guide”, ORNL/TM-12981, Oak Ridge National Laboratory, Tennessee, November 1996, 45 pp., http://www.netlib.org/pvm3/xpvm/index.html. [25] J.E. Moreira, S.P. Midkiff and M. Gupta, “From Flop to MegaFlops: Java for Technical Computing”, IBM Research Report IBM RC21166, IBM T.J. Watson Research Center, 22 pp., 1998. [26] MPIJ Web site, http://notch.cs.byu.edu/DOGMA/online_docs/docs/mpij/MPIJ.html. [27] M. Philippsen and M. Zenger, “JavaParty - Transparent Remote Objects in Java”, Concurrency: Practice & Experience, Vol. 9, No. 11, 1125-1242, 1997, http://wwwipd.ira.uka.de/JavaParty/docs/index.html. [28] N. Stankovic and K. Zhang, “Java and Parallel Processing on the Internet”, in Proceedings of the First International Workshop on Web Engineering, Brisbane, 14th April 1998,6 pp., http:// btwebsh.macarthur.uws.edu.au/san/webe98/proceedings.htm. [29] J.B. Weissman, “Gallop: The Benefits of Wide-Area Computing for Parallel Processing”, Journal of Parallel and Distributed Computing, 54 (2), 183-205, 1998, http://ringer.cs.utsa.edu/ ~jon/pub.html.