Given by Geoffrey C. Fox at NIST Information Technology Laboratory Washington DC on January 22 98. Foils prepared 21 January 98
Outside Index
Summary of Material
We discuss role of commodity (Web) technologies in future high performance computing environments |
We describe how a network of Web/CORBA/COM servers architecture can naturally support both parallel and distributed computing while |
We describe applications to both metacomputing, and parallel computing and suggest this approach can provide attractive user environments leveraging the huge commodity investment |
We suggest critical importance of CORBA and component based software in HPCC -- Javabeans seem very important |
We describe role of collaboration technology in linking computers with people |
We describe use of Java as a general coding language for scientific and engineering computation |
This approach unifies distributed event driven simulations with classic massively parallel time stepped computations |
Outside Index
Summary of Material
Geoffrey Fox |
Syracuse University |
NPAC |
111 College Place Syracuse NY 13244 4100 |
3154432163 |
We discuss role of commodity (Web) technologies in future high performance computing environments |
We describe how a network of Web/CORBA/COM servers architecture can naturally support both parallel and distributed computing while |
We describe applications to both metacomputing, and parallel computing and suggest this approach can provide attractive user environments leveraging the huge commodity investment |
We suggest critical importance of CORBA and component based software in HPCC -- Javabeans seem very important |
We describe role of collaboration technology in linking computers with people |
We describe use of Java as a general coding language for scientific and engineering computation |
This approach unifies distributed event driven simulations with classic massively parallel time stepped computations |
15 Ph.D. level Researchers and 5 at masters level |
About 20 funded students, others "volunteers" |
Local and International Collaborators
|
State of the Art Practical Computational facilities focused on high quality information subsystems and networks
|
Theme is leading edge computer science and its applications of relevance to real world for academia, business and community |
Basic Information Technology -- Databases, Corba, Web, Collaboration, Networking |
Healthcare/Human Computer Interfaces -- "Center for Really Neat Research" -- work with disabled users |
Education Technology -- TANGO, Video Servers WebWisdom etc. |
High Performance Computing and Communication Research -- Programming Environments and Applications and links of HPCC to Web and distributed object (CORBA)Technology |
InfoMall Technology Transfer
|
InfoMall MidHudson supports technology in MidHudson (exIBMers)
|
Education Delivery
|
Bottom of Pyramid has 1000 times dollar value and compute power of best supercomputer (tip of pyramid) but supercomputer has high performance network to support close synchronization needed by classic parallel algorithms |
Use of |
Web Technologies |
is naturally a |
HPCC has developed good research ideas but cannot implement them as solving computing's hardest problem with 1 percent of the funding
|
We have learnt to use commodity hardware either
|
Let us do the same with software and design systems with maximum possible commodity software basis |
The world is building a wonderful distributed computing (information processing) environment using Web (dissemination) and distributed object (CORBA COM) technologies |
This includes Java, Web-linked databases and the essential standards such as HTML(documents), VRML(3D objects), JDBC (Java database connectivity).
|
We will "just" add high performance to this commodity distributed infrastructure
|
The alternative strategy starts with HPCC technologies (such as MPI,HPF) and adds links to commodity world. This approach does not easily track evolution of commodity systems and so has large maintenance costs |
Visual Basic/C++/J++ and ActiveX or Beanboxes with Javabeans give visual approach to software objects
|
Enterprise Javabeans and COM are extending this to distributed computing |
Using Web technologies for grid and building modules out of (whatever Javabeans/COM evolves to) allows one to deliver to user HPCC programming environments with comparable friendliness to those in PC world |
At present, JavaBeans technology is focused on component programming within a single Java VM. |
Within the Sun philosophy of '100% Java', distributed Beans can be developed using RMI interconnect. However, the rest of the industry tries to protect their C++ investments while converting to Java. |
Hence, in parallel with JavaBeans development, the Web industry explores now the linkage of Java with CORBA based distributed object technologies which offer an full C++/Java interoperability. |
CORBA supports cross-language remote object invocation as well as IIOP (Internet Inter-ORB Protocol) based interoperability between object brokers from various vendors. |
Of particular interest are Java based ORBs or ORBlets which can be downloaded as applets to enable CORBA capabilities also at the client/browser side. |
An alternative, offered by Netscape, is a resident ORB support in all browser and server products. |
Java based ORBs will soon turn the Web, so far acting as a largely passive document publishing framework, into a powerful dynamic world-wide distributed object-based computing environment. |
The current incoherent but highly creative Web will merge with distributed object technology in a multi-tier client-server-service architecture with Java based combined Web-ORB's |
COM(Microsoft) and CORBA(world) are competing cross platform and language object technologies
|
Need to abstract entities (Web Pages, simulations) and services as objects with methods(interfaces) |
How do we do this while infrastructure still being designed! |
One can anticipate this by building systems in terms of Javabeans e.g. develop Web-based databases with Javabeans using standard JDBC (Java Database Connectivity) interfaces |
Design and Use Java Framework for Computing which will become a "CORBA facility"
|
By definition, Object Web software is and will even more so, be the "best" software ever built because it has the largest market and greatest leverage of investment dollars
|
On should build upwards from the "democratic Web"
|
This allows you to both deliver your application to the general public (when required) and leverage best software |
Essential idea is consider a three tier model
|
Preserve the first two tiers as a high functionality commodity information processing system and confine HPCC to the third (lowest) tier.
|
Middle Tier |
Basic Web Server |
Custom Web Server |
TP Server |
Business Transaction Management |
You Write Software |
at Client and Server |
Old and New Useful Backend Software |
W is Web Server |
PD Parallel Database |
DC Distributed Computer |
PC Parallel Computer |
O Object Broker |
N Network Server e.g. Netsolve |
T Collaboratory Server |
Clients |
Middle Layer (Server Tier) |
Third Backend Tier |
1)One can "just" use Object Web technologies as a software infrastructure for building parallel, distributed or sequential computing environments which can have a very different architecture from the Web
|
2)Harness the power of the Web as a computer -- use up the idle cycles on the WebTV's in every home -- typically a Web Client based system
|
3)One can view the Object Web as a distributed information system with modest performance and build a metacomputing system with the Web architecture
|
Larry Smarr and NCSA Collaboration have stressed analogy of deployment of computer/communication technology with impact that electrical and transportation grids had
|
The transportation system was built using lessons from and feed up/down from Sports cars, Cadillacs, Model T's, Ford Escorts etc. |
Computational Grid will be shaped by and shape all 5 classes of applications on previous foil
|
A highish end computational grid will in some sense (to be disagreed on) be influenced by and influence the "Object Web" which is here defined as "mass-market"/business IntraNet (low to low) use of Internet/distributed Information Systems |
Applications are metaproblems with a mix of module and data parallelism |
Modules are decomposed into parts (data parallelism) and composed hierarchically into full applications.They can be the
|
Modules are "natural" message-parallel components of problem and tend to have less stringent latency and bandwidth requirements than those needed to link data-parallel components
|
Assume that primary goal of metacomputing system is to add to existing parallel computing environments, a higher level supporting module parallelism
|
It is natural to base on either a network of Web Clients or Web Servers
|
Web Client Models Include SuperWeb (Javelin) from UCSB and are well illustrated by the January 1997 hotwired article "Suck your Mips". |
Greater functionality but less power and pervasiveness is a pure Web Server model as proposed by NPAC
|
Note total compute power in all Web "clients" is about 100 times that in all Central Supercomputers |
Object Web Software provides a high functionality but modest performance distributed computing (Metacomputing) environment based on either Web (soon to be CORBA IIOP and HTTP/Java Socket) Servers or Clients |
Here we will explore an architecture using servers for control as higher functionality than clients although currently less broadly deployed
|
Object Web Only addresses Integration of already decomposed parts!
|
1:User View: Interoperable Web Interface accessing services through Java Compute Services Framework |
2:Network of Java Servers provide distributed services with databases, compute engines, collaboratories, object brokers, instruments
|
Back end "Number Crunchers" linked either by communication at level 2 (slowish but easy) or at level 3 (high performance but more work) |
Compute processes linked either to servers or together by MPI if parallel |
Java Servers |
As a first step, implement multi-module systems with each module linked via Java Servers
|
Where necessary "escape" down to classic HPCC technologies for data transport keeping control at server level
|
This seems very convenient in JDK 1.1 "event model" which is mechanism used by Javabeans to communicate
|
1)Simple Server Approach 2)Classic HPCC Approach |
3)Hybrid Approach with control at server and |
data transfer at |
HPCC level |
4)Invoke High Performance Message Transfer between Observers and Sources specified in Message Event |
Server Tier |
Data Source |
Data Sink (Observers) |
5)Actual Data Transfer |
High Performance Tier |
2)Prepare |
Message Event in Source Control |
1)Register Observers with Listener |
Here are some examples of using our approach where large scale industry investment in Web technology appears to add significant value to metacomputing systems built with Web architecture
|
Multidisciplinary and Computational Steering Applications
|
Visual and Interpreted Programming Environments
|
Technologies to get High Performance CORBA |
Integration with Forces Modeling (Distributed Event driven Simulation) |
Integration with Networked enabled servers such as NEOS and Netsolve
|
Original Image |
Output Image |
Some of |
Available Image Filters |
Visual DataFlow |
Interface |
Original Image |
Output Image |
Some of |
Available Image Filters |
Visual DataFlow |
Interface |
Bunch of Filters and Displays |
defined in |
Java Graph editor and |
running on grid of Java Servers |
Original Image |
Simulation |
Basic Display |
Image Filter |
is another |
module |
Output Display after Filter |
Runs as a |
parallel |
module |
using |
Java Server |
host |
Note Java also integrates compiled and interpreted approaches and so leads to more convenient programming environments
|
JavaScript is a fully interpreted language but not really Java |
Applets are half-way between traditional compiled and interpreted approaches |
Web "systems" can behave like Interpreters with interactive commands at client (gives Web version of MATLAB) |
Web Client |
including |
Java Applets |
Web Server |
Java/Fortran/C++ |
Application Backend |
Client |
Middle Tier |
Backend Tier |
e.g. Java |
e.g. HPF |
SciVis Java |
Scientific |
Visualization |
A screen dump from a Scivis Session |
HPcc can be applied to either parallel or high-performance distributed computing (aka metacomputing) |
In metacomputing, HPcc fills a void as few if any high level tools |
In parallel computing, HPcc provides uniform and perhaps more attractive sustainable user environment |
Can view a parallel computer either as a single tier 2 object
|
Both are interesting
|
This is classic host-node computing model |
Host is logically distinct but can be on same machine as a "node" |
YES! If one uses the same separation between control and data transfer explained for metacomputing case |
Build a "bridge" that accepts MPI HTTP or CORBA invocation but invokes either the powerful slow CORBA mechanism or the nifty optimized MPI |
Why address nodes as CORBA? -- so you can build applications uniformly so they can access nodes and servers around the world in same message passing style |
Why address nodes with MPI? -- so you can get code that executes very fast! |
Why address nodes with HTTP? -- so you can get advantages of CORBA today as Web Servers dominate! |
The "Host" is logically a separate Corba object but could of course be instantiated on the same computer as one or more of the nodes. Using the protocol bridge of fig. 15, one could address objects using Corba with local parallel computing nodes invoking MPI and remote accesses using Corba where its functionality (access to very many services) is valuable. |
From HPcc as High Performance Commodity Components |
This allows MPI (or equivalently Nexus, Globus or PVM) and commodity technologies to coexist with a seamless user interface. |
From HPcc as High Performance Commodity Components |
DoD modeling community is currently evolving towards the HLA(High level Architecture) framework with the RTI (Run Time Infrastructure) based communication bus. |
The goal of HLA/RTI is to enhance interoperability across more diverse simulators than in the DIS realm, ranging from real-time to time-stepped to event-driven paradigms. |
HLA defines a set of rules governing how simulators (federates) interact with each others. Federates describe their objects via Object Model Template (OMT) and agree on a common Federation Object Model (FOM). |
The overall HLA/RTI model is strongly influenced by the CORBA architecture and in fact the current prototype development is indeed CORBA based. |
We suggest that next step is to combine CORBA2 (Initial HLA/RTI is CORBA1) with NPS prototype ideas to give a fully object and Web integrated event driven simulation environment. |
Java3D is natural visualization environment in this scenario |
They are Java's implementation of "component-based" visual programming |
This modern software engineering technique produces a new approach to libraries which become a "software component infrastructure(SCI)" |
There is a visual interface to discovery of and setting of values of and information about parameters used in a particular software component |
JavaBeans uses the event model of JDK1.1 to communicate between components
|
One expects Javabeans to become the CORBA component interface |
The visual interface allows inspection of and implementation of both individual beans and their linkage . This visual construction of linkage allows one to form nontrivial programs with multiple communicating components
|
Apart from the event mechanism which is a communication/linkage mechanism, ComponentWare (and JavaBeans in particular) "just" give a set of universal rules (needed for interoperability) for rather uncontroversial (albeit good) object-oriented and visual programming practices
|
Currently WebFlow uses a Java Server and manipulates Java applications which can be frontends with native methods to Fortran C or C++ routines |
Change Java Server to JWORB -- server integrating HTTP and IIOP (Web and CORBA) |
Change Java Applications to JavaBeans |
Change linkage in WebFlow to respect JavaBean conventions |
Then we get HPComponentware |
And using our multitier model high performance CORBA |
WebFlow is HPCC version of a |
Typical Visual Interface for JavaBeans |
Java (with visual interfaces i.e. JavaBeans) is natural tier 2 language
|
Linking this to tier 3 "classic applications" gives rise to JavaBean wrappers for existing applications |
These can be used in HPcc and commodity environments |
Naturally become CORBA distributed objects and so can be remotely executed and documented (via CORBA trader or yellow pages service) |
Classic Application |
Fortran C C++ |
JavaBean Wrapper |
Tier 2 |
Tier 1 |
Tier 3 |
IIOP HTTP RMI |
We present the proposed process of integrating HPCC and Enterprise Computing technologies on 2-dimensional 3x3 chart, exposing the evolution of user and system perspectives on new computing technologies. |
On the (vertical) system/complexity axis, we start from PC desktop and we evolve towards distributed and finally HPCC computing. |
On the (horizontal) user/simplicity axis, we start from objects and we evolve towards reusable components and finally their visual development and runtime environments. |
The first row on our char represents the already established PC technologies exemplified by systems such as Visual C++/J++, VBScript, Borland Delphi, Visual Cafe etc. |
The second row corresponds to the emergent Object Web based Enterprise Computing that integrates Java/JavaBeans based component technologies with CORBA based distributed objects. |
Finally, the third row represents our proposed HPCC extensions of these technologies in terms of HP-CORBA based HP-Components. |
Now consider how to make the Object Web High performance. |
In the object domain we propose the extension HP-CORBA of the CORBA model for the HPCC domain by developing a minimal high performance ORB on top of MPI/Nexus. |
Such HP-ORBlets, residing in the individual nodes of a parallel system (either as network daemons or as runtime libraries) would allow one to hide explicit message passing calls in terms of higher level more user-friendly remote object invocations.
|
HP-ORBlets would focus on high performance data/method communication support, whereas the lower bandwidth control communication would be passed to and handled by the full functionality lower performance commercial ORBs in the CORBA bus in the middleware layer. |
The split between data and control communication would be fully transparent at the program's level, i.e. both parallel object developers and integrators would be offered a uniform CORBA object based programming model.
|
Two major advantages of the proposed approach are:
|
The following figure illustrates a possible CORBA-HPCC integration framework ( HPCORBA ) |
Each node of a parallel machine runs a lightweight (e.g. Nexus based ) ORBlet which enables both local and remote object services. |
Coming CORBA3/MOM based messaging and object-by-value frameworks adapted to provide high-performance (e.g. MPI based) object-oriented (IIOP based) inter-node communication. |
Parallel Computation graphs are represented by Interface Definition Language (IDL) in a language independent way and optimized by parallel compiler technologies. |
Specific language bindings would result in HPF, HPC++ or HPJava implementations. |
This framework provides interoperability with the emergent Object Web software industry and offers an elegant solution for scalable parallel I/O ( linking HPCORBA with Oracle CORBA ) |
Tier 1 |
Tier 2 IIOP |
Tier 3 Globus |
High Performance Messaging |
High Functionality Messaging |
HPCC can learn from success of standards in Web arena
|
MPI is a successful standard of this type but |
HPF took too long -- especially to implement -- as standard too complex.
|
CORBA suggests we set up HPcc as a HPCC facility |
Java suggests we set up some HPCC frameworks to define client/server interfaces; Java scientific libraries etc. |
WorkFlow |
ORB |
System Management |
HPcc ? |
.............. |
Trader |
Security |
.......... |
Naming |
Persistence |
Oil & Gas |
DMSO Modeling and Simulation |
Imagery |
Banking |
Manufacturing |
...... |
...... |
Services |
Horizontal Facilities |
Vertical |
Facilities |
Standard Interfaces |
i.e. Frameworks |
Numerical Computing Framework
|
Computing Services Framework
|
High Performance Framework
|
Distributed Computing Framework
|
Distributed Simulation Framework
|
Java Calls (mainly Interfaces and not methods) to capabilities expressed in implementation neutral form |
Drivers convert these general calls to vendor specific implementation of service |
Java code can either be all on client (2-tier) or on client and middle tier (3 tier) |
e.g. JDBC is a universal interface to all relational databases |
Adoption of this JDBC implies that vendor specific solutions (such as Oracle's PL/SQL) are immediately less attractive
|
Note database business is larger than simulation business
|
These are too many suggested computing frameworks and probably several are rather controversial as there is no agreed model of the use of Java in Computing
|
The most promising for early consideration are |
1) The Numerical Computing Framework which is essentially use of Java in Computational Science and Engineering |
Very important to get agreement on areas that affect JavaVM and the Java Language as these are getting harder to change
|
2) The Computing Services Framework which we give more detail on. |
Enables development of Web Interfaces to run a given job on any computer compliant with this framework just as JDBC gives a universal interface to any relational database
|
The Computing Services Framework allows vendors to compete on either User Front End (GUI) or back end services with the JavaCS framework providing universal linkage |
The framework is implemented at the backend as a set of drivers which map generic Java Interfaces to particular software (e.g. a compiler) on particular machines. |
Requires agreement by "suitable interested parties" on
|
http://www.sis.port.ac.uk/~mab/Computing-FrameWork/ |
Is CORBA (viewing system as a collection of objects) useful |
Compiling, Executing, Specification of features needed for execution optimization
|
Accounting -- use Web commerce technology? |
Security (especially hard in metacomputing as link several different management policies)
|
Sharing, Accessing and Storing into File Systems |
Data and Performance Visualization Interface (how applets access server side information) |
Performance measurement and recording (cf: Pablo SDDF) |
Interfaces for Programming Tools
|
Libraries including names in Math class and
|
Module linkage model for metaproblems (multidisciplinary applications) as in Javabeans sufficient? |
An Applet based system using LiveConnect and plugin with Netscape3 and Signed Applets with Netscape4 |
Supports general shared event model of collaboration where it can share applications in Java, JavaScript, C, VRML, C++ (Open Inventor)
|
Has conventional general tools
|
Developed for command and control |
Most extensively used in education -- especially for course between Syracuse and Jackson State
|
From Tango - A Java/WWW-Based Internet Collaborative Software System part of NPAC Overview May 1997 |
TANGOsim |
Basic |
Replicated Applications |
1)Virtual Users 2)Customized Views |
TANGO Java |
Collaboratory |
Server |
HTTP |
Server |
MultiMedia Mail |
C2 Commander |
Chat |
VTC |
Event Driven |
Simulation |
Engine |
C2 Radar Officer |
3D GIS |
Scripting |
Language |
C2 Weather Officer |
Message Routing |
SW/Data Distrib. |
Other |
Collaborators |
MultiMedia Mail |
Chat |
Simulation |
Engine Controller |
All Clients |
Typical Clients |
Feb 97 Demonstration of Tango |
From Tango Project for CEWES Collaborative Tool Meeting |
TANGO links people and shared applications such as chat board, audio video conferencing, visualizations, shared white board, common AUTOCAD design and related tools |
CFD |
TANGO Server |
Database |
Object Broker |
MPP |
Structures |
MPP |
Engineer |
+ core |
services |
Visualization e.g.CAVE |
Shared AutoCAD |
Engineer |
+ core |
services |
This combines TANGO for collaboration with WebFlow to link server side applications |
If necessary WebFlow would support high performance inter-module communication as in structures-CFD Linkage example but it would always implement control and this allows TANGO integration with server side computation
|
WebFlow communication model is a dynamic dataflow |
Of course other server side compute models are possible and in general need (web-linked) data bases, file systems, object brokers etc., |
WebFlow supports dataflow model where user must supply routines to process input of data that drives module and output of data for other modules |
TANGO supports shared state and user supplies routines that read or write either
|
Can be done for applications like AUTOCAD as vendor supplies necessary API |
CFD |
Structures |
It must be competitive with best available collaborative tools and so its multi-language interface allows us to interface to other systems with Tango supplying Integrated Session Control
|
Basic model is that of a room which is a group of people getting together for a class
|
Each room supports a collection of shared objects chosen by teacher/students/administrator |
Tango supports (more than) enough (over 40) applications and our next step is to evaluate, improve and make robust release |
Core Collaboration Capabilities
|
Office and Authoring Tools
|
General Virtual University Applications
|
Special Virtual University Applications
|
From Tango - A Java/WWW-Based Internet Collaborative Software System part of NPAC Overview May 1997 |
Have some fun with Multi-player games
|
"Other" Applications
|
Java for User Interfaces and MetaComputing is natural from its design! |
Java for your favourite Conjugate Gradient routine (etc.) is less obvious ..... |
Java likely to be a dominant language as will be learnt and used by a broad group of users
|
Java may replace C++ as major system building language
|
Clearly Java can easily replace Fortran as a Scientific Computing Language as can be compiled as efficiently and has much better software engineering (object) and graphics (web) capabilities
|
Java can unify classic science and engineering computations with more qualitative macroscopic "distributed simulation and modelling" arena which is critical in military and to some extent industry |
Key question is performance of Java |
Note Web Software can be run on High Performance IntraNets such as Iway so hardware need NOT be a problem! |
Java is currently semi-interpreted and (as in Linpack online benchmark) is about 50 times slower than good C or Fortran |
Java --> (javac)--> Downloadable Universal Bytecodes --> (Java Interpreter) |
--> Native Machine Code
|
However Language can be efficiently compiled with "native compilers" |
Java ----> (native compiler) |
---> Native (for Particular Machine) Code |
Lots of Interesting Compiler issues for both compiled and scripted Java |
My SGI INDY gets .54 Megaflops for Java 100 by 100 Linpack |
It has 200 Mhz R4400 and current Netlib benchmark for this chip is 32 mflops for optimized Fortran |
For better resolution see JPEG Version |
see http://www.netlib.org/benchmark/linpackjava/ |
Note Just in Time Compilers are giving a factor of 10 from June 96 Measurements! |
see http://www.netlib.org/benchmark/linpackjava/ |
Syracuse and Las Vegas Workshops saw no serious problem to High Performance Java on sequential or Shared Memory Machines |
Some restrictions are needed in programming model
|
For instance, Avoid Complicated Exception handlers in areas compilers need to optimize! |
Should be able to get comparable performance on compiled Java C and Fortran starting with either Java Language or JavaVM bytecodes |
The Interpreted (Applet) JavaVM mode would always be slower than compiled Java/C/Fortran -- perhaps by a factor of two with best technology |
One can use "native classes" which is just a predownloaded library of optimized runtime routines which can be high performance compiled Java, C, C++, Fortran, HPF etc. modules invoked by interpreted or compiled Java
|
Use Native Classes selectively for
|
1)Classic solution of large scale PDE or Particle dynamics problem
|
2)Modest Grain size Functional Parallelism as seen in overlap of communication and computation in a node process of a parallel implementation.
|
3)Object parallelism seen in Distributed Simulation where "world" modelled (typically by event driven simulation) as set of interacting macroscopic (larger than grid points) objects
|
4)MetaProblems consisting of several large grain functionally distinct components such as
|
Java: 1) Not Supported, 2) is Thread mechanism, 3) is Java Objects or Applets, 4) is JavaBeans or equivalent |
Fortran: 1)is supported in HPF, 2--4) are not supported |
The Web integration of Java gives it excellent "network" classes and support for message passing. |
Thus "Java plus message passing" form of parallel computing is actually somewhat easier than in Fortran or C. |
Coarse grain parallelism very natural in Java |
"Data Parallel" languages features are NOT in Java and have to be added (as a translator) of HPJava to Java+Messaging just as HPF translates to Fortran plus message passing |
Java has built in "threads" and a given Java Program can run multiple threads at a time
|
Can be used to do more general parallel computing but only on shared memory computers
|
Combine threads on a shared memory machine with message passing between distinct distributed memories |
"Distributed" or "Virtual" Shared memory does support the JavaVM as hardware gives illusion of shared memory to JavaVM |
Message Passing |
Message Passing |
Java Wrappers (native classes or Server socket connections) around existing data parallel Fortran or C++ |
Native Java and MPI
|
Data Parallel Extensions of Java
|
Java threads for data parallelism on SMP's |