Full HTML for
Given by Geoffrey C. Fox at NPACI Summer Institute on Parallel Computing on August 21 98. Foils prepared August 15 98
Outside Index
Summary of Material
We discuss the different ways Java can be used in a computational science programming environment
|
| We describe the implied metaproblem and metacomputer architecture |
| We relate Java to CORBA and COM distributed object models |
|
We describe Java Grande Forum
|
Denote Foils where Image Critical
Denote Foils where Image has important information
Denote Foils where HTML is sufficient
Java Grande Role of Java in Large Scale Computations
Abstract of NPACI Java Grande Presentation
The 3 Roles of Java
Synergy of Parallel Computing and Web Internetics as Unifying Principle
Why is Java Worth Looking at?
Java Grande Forum Motivation and Activities
What is Java Grande?
What is Goal of Java Grande Forum?
Activities of the Java Grande Forum I
Gosling on Operator Overloading
Activities of the Java Grande Forum II
Server Side Java Distributed Objects Pragmatic Object Web Web-based Computing Computational Grids Coarse Grain Integration
The HPCC Dilemma and its Solution
What is Commodity Software
The Computing Pyramid
Implications of the Computing Pyramid
NPAC Concepts: Pragmatic Object Web
An Object Web-based 3-Tier Computing System
Pragmatic Object Web Technology Model - I
Pragmatic Object Web Technology Model - II
NPAC Concepts : HPcc High Performance commodity computing
Basic HPcc Strategy
Three Roles of Object Web Technologies in Computing
What is the Architecture of Metaproblems Complex HPCC Applications
Structure(Architecture) of Applications - I
Structure(Architecture) of Applications - II
Issues and Examples of Pragmatic Object Web
Today's Pragmatic Object Web: The Confusing Multi-Technology Real World Middleware Server Layer
Different Choices -- Client Server Service
Todays Complex World will evolve to something like the pure CORBA Architecture for a distributed Information System (There are similar COM and Javabean /RMI Versions)
Specifying Server Side Objects
Comparison of 2 3 and 4 Tier Models
Two ways of Implementing Data Objects
Gateway System Architecture Linking Clients, HPCC, and Modern Enterprise Systems
Multi-Server Model
So in our WebWisdom Distance Education System
Database Architecture for WebWisdom
Role of Collaboratory Systems
Architecture of Tango used in JSU Distance Education
Java as a Server Building Technology
While for High Performance Computing
Multi-Server Scenario
Multi Tier Gateway Architecture
What are General Capabilities in Gateway Tier?
What Particular Programs could run in Gateway Tier?
HPcc Prototype Implementation WebFlow and JWORB
Exploiting Multi-Tier Commodity Software Model
Three Possible Implementations of CFD CSM Linkage
Picture of JavaBean and JDK1.1 AWT Event Model
Visual Programming WebFlow, DARP on GLOBUS
WebFlow WaveFilter Module
WebFlow + Globus Functional Architecture
WebFlow 3 Tier Architecture with High Performance Globus and High Functionality IIOP Gateway Layer Services
WebFlow SC'97 Demo
WebFlow over Globus at NCSA Application View
What are JavaBeans I
What are JavaBeans II
Next Steps for HPcc using JavaBeans
Minimal Web based Multidisciplinary Application
Comparison of Application Integration Communication/Linkage Models
Distributed Modeling and Simulation RTI as more general MPI JWORB illustrates POW
Integration of DIS with Object Web Based Computing
Summary of NPAC's JWORB
JWORB - Java Web Object Request Broker
NPAC's Object Web RTI
JWORB based Object Web RTI
IIOP Performance for Java ORB's
Java IIOP Performance for Structures
C++ ORB Much Faster than Java!
HLA/RTI versus HPF/MPI
HLA/RTI at Top Management Level
Architecture of HLA/RTI Services
HLA/RTI Management Structure
Resource Management and Scheduling
Java Seamless Computing Framework
What/Why is a Framework?
JDBC Software Architecture
Proposed Java Computing Services Framework
Possible Services in a Java Computing Framework - I
Possible Services in a Java Computing Framework - II
Java as a Scientific Programming Language Sequential -- Parallel Interpreted -- Compiled
Java and Parallelism?
"Pure" Java Model For Parallelism
Java -- Interpreters and Compilers
Hierarchy of Software Levels
Parallel Computing v. Metacomputing
A Parallel Computer Viewed as a Single CORBA Object
Each Node of a Parallel Computer viewed as a Separate CORBA Object
Can HPcc Give High Performance if applied to each node of a parallel computer?
A Message or Protocol Optimization Bridge
MPI Java + Message Passing
NPAC mpiJava: A Java Interface to MPI
mpiJava Class Hierarchy
Shared Memory mpiJava Performance
Distributed Memory mpiJava Performance
Data Parallel HPJava: Motivations
HPJava Libraries
Distributed Array Syntax: HPJava Compared to HPF
Example: Red-black iteration
Preliminary HPJava Performance (outperforms Java due to libraries)
Outside Index
Summary of Material
HTML version of Basic Foils prepared August 15 98 
Full HTML Index
| NPACI Summer Institute August 21 1998 |
| Geoffrey Fox |
| Northeast Parallel Architectures Center |
| Syracuse University |
| 111 College Place |
| Syracuse NY |
| gcf@npac.syr.edu |
| http://www.javagrande.org |
| http://www.npac.syr.edu/users/gcf/hpjavanpaci |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
We discuss the different ways Java can be used in a computational science programming environment
|
| We describe the implied metaproblem and metacomputer architecture |
| We relate Java to CORBA and COM distributed object models |
|
We describe Java Grande Forum
|
HTML version of Basic Foils prepared August 15 98 
Full HTML Index
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| The two forms of Large Scale Computing Scale Computer for Scale Users in Proportion Power User to number of computers |
| Parallel Commodity Distributed Computers Information Systems Technology <--------------- Internetics Technologies ---------------> |
| Parallel Computer Distributed Computer |
| HPF MPI HPJava HTML VRML |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
The Java Language has several good design features
|
| Java has a very good set of libraries covering everything from commerce, multimedia, images to math functions (under development at http://math.nist.gov/javanumerics) |
| Java has best available electronic and paper training and support resources |
| Java is rapidly getting best integrated program development environments |
| Java naturally integrated with network and universal machine supports powerful "write once-run anywhere" model |
| There is a large and growing trained labor force |
| Can we exploit this in computational science? |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| http://www.javagrande.org |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Use of Java for: |
| High Performance Network Computing |
| Scientific and Engineering Computation |
| (Distributed) Modeling and Simulation |
| Parallel and Distributed Computing |
| Data Intensive Computing |
| Communication and Computing Intensive Commercial and Academic Applications |
| HPCC Computational Grids ........ |
| Very difficult to find a "conventional name" that doesn't get misunderstood by some community! |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Java has potential to be a better environment for "Grande application development" than any previous languages such as Fortran and C++ |
| The Forum Goal is to develop community consensus and recommendations for either changes to Java or establishment of standards (frameworks) for "Grande" libraries and services |
| These Language changes or frameworks are designed to realize "best ever Grande programming environment" |
| First Meeting Mar 1 Palo Alto at Java 98 -- 200 Attendees set Agenda -- 30 permanent people and further meetings May 9-10, Aug 6-7 |
| Public Discussion SC98 Orlando November 13 (3 hour panel) |
| http://www.npac.syr.edu/projects/javaforcse |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Two major working groups promoting standards and community actions |
Numerics: Java as a language for mathematics led by Ron Boisvert and Roldan Pozo from NIST
|
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Java Grande 98 Feb 28 98 |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
Distributed and Parallel Computing led by Dennis Gannon and Denis Caromel (INRIA, France)
|
| Development of Grande Application benchmarks |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
HTML version of Basic Foils prepared August 15 98
Full HTML Index
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 |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| 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 |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Bottom of Pyramid has 100 times dollar value and 1000 times compute power of best supercomputer |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Web Software MUST be cheaper and better than MPP software as factor of 100 more money invested! |
| Therefore natural strategy is to get parallel computing environment by adding synchronization of parallel algorithms to loosely coupled Web distributed computing model |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| 3-(or more)-tier architecture - Web browser front-ends, legacy (e.g. databases, HPC modules) backends; fat (1+tier) middleware |
Alternative / competing Middleware models:
|
| Each model has different tradeoffs |
| POW attempts at integrating various models and services in terms of multi-protocol middleware servers (JWORB) |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Middle Server Tier |
| Basic HTTP/CGI Web Server |
| Java Web Server |
| Transaction Processing Server |
| Business Transaction Management |
| Javabean |
| Enterprise Javabean |
| Old and New Useful Backend Software |
| Object Broker |
| Back-end Tier |
| The Services |
| Client |
| Front-end Tier |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Basic Vision: 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, database entries, simulations) and services as objects with methods(interfaces)
|
| How do we do this while infrastructure still being designed! |
| Major Commercial Java Activity today is on Server NOT Client |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
One can anticipate this by building systems in terms of Java objects e.g. develop Web-based databases with Java objects using standard JDBC (Java Database Connectivity) interfaces
|
Even better use (Enterprise) Javabeans which are Java's (middle tier) or client componentware offering visual interfaces, containers (here they are consistent with CORBA standard) and standard software engineering interfacing rules
|
| Confused? Read "Building Distributed Systems on the Pragmatic Object Web" -- Book of class I teach to CS/CE students at Syracuse http://www.npac.syr.edu/users/shrideep/book |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Distributed Computing becomes a commodity article (driven by Web Technologies) |
| Market niches for orthodox MPP style HPC are shrinking |
| NT clusters become a viable and more cost effective alternative to classic high performance systems |
| HLA/RTI from distributed simulation community natural for coarse grain while MPI/HPF/.... Natural for fine grain -- must integrate which we claim can be done using a multi tier architecture |
| Web/Commodity software (Pragmatic Object Web) - promising base to build new HPcc (commodity computing) |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| HPcc is High Performance commodity computing |
Encapsulate services (from databases to instruments to MPP's) as middle tier distributed objects using an approach that will evolve to COM/CORBA in future but is deployable today
|
Establish Java Frameworks and Equivalent CORBA Facilities
|
| This already gives you an approach to seamless access and a framework for composing complex metaproblems by linking programs together or programs to databases |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
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
|
HTML version of Basic Foils prepared August 15 98
Full HTML Index
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| 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
|
HTML version of Basic Foils prepared August 15 98
Full HTML Index
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
|
| Use Java/Distributed Object Technology for modules -- note Java to growing extent used to write servers for CORBA and COM object systems |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| 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 |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| (Business) Logic can be a client, Middleware Server or specialized service layer |
| Choices in distributed object (database record is "just" a distributed object) specification |
| Different transport protocols |
| Client |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Documents -- URL |
"General Programs including database invocations"
|
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Client |
| Middle Tiers |
| Back End |
| Thin Client |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Old way: Use an Object Database |
| Current Approach: Use a Relational Database and business logic in EJB |
| Object Database |
| Application using data objects |
| Backend relational database such as Oracle |
| Enterprise Javabean mapping user object to backend persistent data model |
| Application using data objects |
| Middle Tier |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Clients and their servers |
| Middle Tier Custom Servers |
| Back End Servers and |
| their services |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| The backend servers would include CORBA objects from Educom's IMS projects; Video servers and Oracle database defined curricula pages from NPAC |
| The front end servers would include distributed students with mirror sites to get performance |
In the middle tier, we have JDBC query processing and XML servlet parsers mapping original data in optimal fashion to match needs of student -- choosing from pure HTML or Interactive Java Whiteboard views of a given object
|
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Educational Objects i.e. |
| Data Defining Content of Curricula Pages |
| Server side |
| Java(JDBC) or |
| LiveWire |
| Metadata |
| Web Server |
| Conventional HTML Pages |
| Dynamically Generated |
| Including XML syntax Dublin Core (IMS) |
| Web Browser |
| XML Templates Defining How educational data stored in Pages |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Systems like Tango or Habanero built around Java Servers integrate a group of multiple clients as a "Service" at the middle Java Server level |
| Building systems in this way automatically includes "people in the loop" -- Computational Steering, Education, Multidisciplinary collaborative design |
| Group of collaborating clients |
| and client applications |
| Database |
| Object Broker |
| MPP |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| NPAC Web Server |
| JSU Web Server |
| JSU Tango Server |
| ... |
| Audio Video Conferencing Chat Rooms etc. |
| Address at JSU of Curriculum Page |
| Teacher's View of Curriculum Page |
| Student's View of Curriculum Page |
| Participants at JSU |
| Teacher/Lecturer at NPAC |
| Java Server |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
Tango uses a server written as a Java application
|
| 100% maintenance free and Industry-strength stability |
Platform-independent
|
Java for Servers is dominant industry (including Microsoft) development as supports thin clients which are preferred as
|
HTML version of Basic Foils prepared August 15 98
Full HTML Index
We have multiple supercomputers in the backend -- one doing CFD simulation of airflow; another structural analysis while in more detail you have linear algebra servers (Netsolve); Optimization servers (NEOS); image processing filters(Khoros);databases (NCSA Biology workbench); visualization systems(AVS, CAVEs)
|
| All linked to collaborative information systems in a sea of middle tier servers(as on previous page) to support design, crisis management, multi-disciplinary research |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Database |
| Matrix Solver |
| Optimization Service |
| MPP |
| MPP |
| Parallel DB Proxy |
| NEOS Control Optimization |
| Origin 2000 Proxy |
| NetSolve Linear Alg. Server |
| IBM SP2 Proxy |
| Gateway Control |
| Agent-based Choice of Compute Engine |
| Multidisciplinary Control (WebFlow) |
| Data Analysis Server |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| High Performance Computing and Communication Tier |
| Clients |
| Gateway Systems |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
Seamless Interface -- an Enterprise Javabean which processes input from user's Java Applet interface and maps user generic commands to those on specific machine
|
| Resource management of heterogeneous MPP backend (linked to seamless interface) |
| Database and Object Brokers |
| Collaboration Servers including Tango, Lotus Notes and other commercial systems |
| Visualization Servers |
| "Business Logic" to map user data view (e.g. objects) to persistent store (e.g. Oracle database) and simulation engine (MPP) preferred format |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Most of a Command and Control Application |
| Several FMS and IMT Applications |
| Some I/O Intensive applications |
| High value services with modest computational needs e.g. grid generation and other pre-processing, data manipulation and other post-processing |
| Video Servers for Training |
| Design and Planning Tools |
| "Glue" for Multidisciplinary Interactions |
| Control of metacomputing applications |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| NPAC Specific work |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
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.
|
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| 1)Simple Server Approach 2)Classic HPCC Approach |
| Data and Control |
| CFD |
| Structures |
| Data Only |
| CFD Server |
| Structures Server |
| Control |
| Only |
| 3)Hybrid Approach with control at server and |
| data transfer at |
| HPCC level |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| 4)Invoke High Performance Message Transfer between Observers and Sources specified in Message Event |
| 3)Source Callbacks Listener with Message Event |
| Listener |
| Source Control |
| 1)Register Listeners |
| with Master Source |
| 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 |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
Client (Tier 1): Java Graph Editor for Webflow or interpreted debugger (DARP) linked to Java Visualizer SciVis
|
| Middle Tier 2: Network of Java Servers linking UNIX and Windows NT systems with "all" services |
| Back-end Tier 3: Globus where available. In early 98, this is high performance UNIX system links with no databases and no NT |
| Note this is a good high performance I/O architecture whether file system, CORBA or database based |
Next foils show
|
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Original Image |
| Output Image |
| Some of |
| Available Image Filters |
| Visual DataFlow |
| Interface |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Client Tier |
| IIOP High Functionality |
| Middle Tier |
| Future Globus |
| Globus |
| Future Parallel I/O |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
HTML version of Basic Foils prepared August 15 98
Full HTML Index
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| 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 |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
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
|
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Currently WebFlow uses a Java Server and manipulates Java applications which can be front ends 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 and non-Java apps to CORBA objects |
| Change linkage in WebFlow to respect JavaBean event mechanism |
| Then we get HPComponentware |
| And using our multi-tier model high performance CORBA |
| WebFlow is HPCC version of a |
| Typical Visual Interface for JavaBeans |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| This combines TANGO for collaboration with WebFlow to link server side applications |
If necessary WebFlow could support high performance inter-module communication as in structures-CFD Linkage example but it would always implement control at middle tier 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., |
| On client one can share tools such as CAD systems like CATIA or AUTOCAD so Tango interfaces with API to these system and drives "slaves" from state extracted from linkage to master. |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| WebFlow supports dataflow model in middle tier 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
|
| One can write Tango linkage for applications like AUTOCAD as vendor supplies necessary API |
| CFD |
| Structures |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| DoD modeling and simulation (FMS,IMT) 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. |
| Building HPCC on the Object Web implies that we can a common framework for both distributed (event driven) simulations and classic time stepped parallel computing |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| JWORB - Java Web Object Request Broker - multi-protocol middleware network server (HTTP + IIOP + DCE RPC + RTP + ..) |
| Current prototype integrates HTTP+IIOP i.e. acts as Web Server and CORBA Broker |
| Next step: add DCE RPC support to include Microsoft COM |
| JWORB - our trial implementation of Pragmatic Object Web |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Implements DMSO RTI as JWORB service with 2 major CORBA objects: RTI Ambassador and Federate Ambassador |
| Offers natural Web interfaces to HLA simulations via HTTP or IIOP channels |
| Natural support for human-in-the-loop (Web surfers join WebHLA federation and can collaborate as WebHLA federates) |
| Attractive model for High Level Metacomputing |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| JacORB |
| JWORB |
| ORBIX |
| RMI |
| Variable Size Integer Arrays |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Java ORBs Transferring |
| variable size Array of Structures |
| (RMI slowed by serialization) |
| RMI |
| JacORB |
| ORBIX, JWORB |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Arrays of Integers C++ about 20 times faster than Java |
| RMI (Fastest Java) omniORB (C++) |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| We can support any given paradigm at either high functionality (web server) or high performance (backend) level |
| HPCC Messaging could be a Java/RMI middle tier MPI or Nexus/Optimized Machine specific MPI at backend |
| JWORB supports CORBA based RTI already and we can bridge to high performance event driven simulation systems like SPEEDES at the high performance backend layer |
| However most problems can be thought of a set of coarse grain entities which are internally data parallel but the coarse grain structure is "functional" parallelism |
| So HLA/RTI is especially natural as tier 2 management level of these coarse entities |
| Entities can be time synchronized simulations and use MPI(HPF?) at either middle or back end tier or in fact as in DMSO simulations a federate running a custom discrete event simulation |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
Resource Management typically breaks down into either
|
So a) is all at middle tier and should use commodity solutions -- there are many queuing systems such as Condor, Codine, LSF which we can "wrap" and Microsoft does not yet have a fully scalable commodity solution
|
| So it is still embryonic but we suggest adopting the HLA/RTI framework as this supports job placement, interdependencies (time management) and hierarchical systems of federations --> federates |
| Optimized data placement has been largely solved as a mathematical problem by HPCC but not packaged broadly. Our suggestion suggests how to invoke as backend support for a commodity service |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| So we have a hierarchy of entities Federation --> Federates --> Objects where can have many tiers in each category |
| A Federation could be the set of all jobs to be run on a particular site |
| A Federate could be a job consisting of multiple possibly shared objects |
| Objects are just data structures in HLA -- you send interaction events instead of invoking methods |
| These aspects are organized by Federation, Object and Ownership management services |
| We can classify both jobs and computers as separate federations |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
Declaration Management corresponds to publication and subscription model of matching services and needs
|
| Time Management corresponds to scheduling of sequenced events in discrete event simulations -- it will allow support generally dependencies in jobs -- the CAVE visualization system must be used after simulation |
| Data management is classic "load-balancing" problem of parallel computing where you map objects optimally to computers to minimize communication cost and load imbalance |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Allows Universal Access to all computers from the same Java Applet Front End |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| 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 (Java Database Connectivity) is a universal interface to all relational databases |
Adoption of this JDBC implies that vendor specific solutions are immediately less attractive
|
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Java applications |
| JDBC API |
| JDBC Driver manager |
| JDBC API |
| JDBC Driver API |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
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
|
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| http://www.sis.port.ac.uk/~mab/Computing-FrameWork/ |
| Abstract ideas developed in Globus Condor and Legion for a harder problem (metacomputing) and developed for seamless problem by Sweb (Cornell) WebSubmit (NIST) or UNICORE (Europe) |
Compiling, Executing, Specification of features needed for execution optimization
|
| Accounting -- use Web commerce technology? |
Authenication, Security (especially hard in metacomputing as link several different management policies)
|
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| 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
|
Generalizes to Resource Discovery, Allocation and Scheduling
|
| Module linkage model for metaproblems (multidisciplinary applications) as in Javabeans sufficient? |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Note Java will have same performance as Fortran |
| a)when Industry compilers mature b)if Sun accepts Java Grande recommendations |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| 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 NPAC's 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
|
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| 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 |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
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 |
| Web Client |
| including |
| Java Applets |
| Web Server |
| Java Application Backend |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Numerical Objects in (C++/Fortran/C/Java) |
| Expose the Coarse Grain Parallelism |
| Expose All Levels of Memory Hierarchy |
| a) Pure Script (Interpreted) |
| c) High Level Language but Optimized Compilation |
| d) Machine Optimized RunTime |
| b) Semi- Interpreted |
| a la Applets |
| Memory Levels in High |
| Performance CPU |
| Nodes of Parallel/ Distributed System |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| HPcc ideas 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
|
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| This is classic host-node computing model |
| Host is logically distinct but can be on same machine as a "node" |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| 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! |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Note this mechanism is higher performance but less powerful than the JWORB Server tier multi-protocol integration |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Naturally one can implement an MPI linkage for Java and this has been implemented by NPAC (mpiJava) Mississippi State and Westminister College (London) |
| There is no formal definition of Java binding to MPI ad there are some areas of uncertainity |
| Westminister version automatically links C version of MPI to Java Native Interface (JNI) |
| NPAC version "optimizes" Java link based on C++ MPI standard noting Java does not support "memory sequence" but with serialization could allow transfer of objects http://www.npac.syr.edu/projects/pcrc/mpiJava |
| MSU version goes one step further with a version even more tuned to Java |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Fully featured Java interface to MPI 1.1 |
| Object-oriented API based on MPI 2 standard C++ interface |
| Initial implementation through JNI to native MPI |
| Comprehensive test suite translated from IBM MPI suite |
| Available for Solaris, Windows NT and other platforms |
| Example mpiJava Call: |
| MPI.COMM_WORLD.Send(message, 0, message.length, MPI.CHAR, 1, 99) ; |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| mpiJava Performance |
| C versus Java(J) |
| WMPI PC with NT MPICH Sun Solaris |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| mpiJava Performance |
| C versus Java(J) |
| WMPI PC with NT MPICH Sun Solaris |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Data parallelism important in High Performance scientific computing. |
| High level HPF programming model attractive, but implementations problematic and base language is Fortran! |
| HPspmd model: Distributed array syntax, plus high-level class library bindings for communication and arithmetic on arrays. |
| Explicitly MIMD control flow. |
| Ease of HPF Arrays; power of MPI; uses best language .... |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| In HPJava model, all communications go through explicit calls to user-level libraries, initially: |
| Adlib: regular collective operations |
| MPI: low-level message passing |
| Later, add interfaces to other libraries, eg |
| Global Arrays: 1-sided access to remote data |
| CHAOS: irregular collective operations |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| HPJava |
| Procs p = new Procs1(4) ; |
| Range x = new BlockRange(100,p.dim(0)); |
| float [[,*]] a = |
| new float [[x, 100]] on p ; |
| float [[]] b = new float [[x]] on p ; |
| HPF |
| !HPF$ PROCESSOR P(4) |
| !HPF$ DISTRIBUTE T(BLOCK) ONTO P |
| REAL A(100,100) |
| !HPF$ ALIGN A(:,*) WITH T(:) |
| REAL B(100) |
| !HPF$ ALIGN B(:) WITH T(:) |
HTML version of Basic Foils prepared August 15 98 
Full HTML Index
| Procs p = new Procs2(NP, NP) ; |
| on(p) { |
| Range x = new BlockRange(N, p.dim(0), 1) ; // ghost width 1 |
| Range y = new BlockRange(N, p.dim(1), 1) ; // ... |
| float [[,]] u = new float [[x, y]] ; |
| for(int parity = 0 ; parity < 2 ; parity++) { // red and black |
| Adlib.writeHalo(u, widths) ; // Communicate Ghost Cells |
| overall(i = x [1 : N - 2]) |
| overall(j = y [1 + (x.idx(i) + parity) % 2 : N - 2 : 2]) |
| u [i, j] = 0.25 * (u [i - 1, j] + u [i + 1, j] + |
| u [i, j - 1] + u [i, j + 1]) ; |
| } |
| } |
HTML version of Basic Foils prepared August 15 98
Full HTML Index
| Hand translated Jacobi iteration (HPJava to Java). |
| Compared with sequential Java, C++ and Fortran (-O optimization level). |
| JDK 1.2Beta, JNI to Adlib, MPICH, Ultrasparc cluster |