Full HTML for

Basic foilset Computing on the Pragmatic Object Web

Given by Geoffrey C. Fox at EuroPar Invited Presentation on September 4 1998. Foils prepared September 13 1998
Outside Index Summary of Material

We discuss the Pragmatic Object Web (POW) and how to use it in the HPcc High Performance Commodity Computing based on POW with a hybrid multi-tier model
We describe metacomputing and parallel computing based on these concepts
We give examples of using WebFlow with Globus and show this gives natural integration of CORBA into HPCC
The use of HLA/RTI as control of a bunch of workstations is recommended

Table of Contents for full HTML of Computing on the Pragmatic Object Web

 Denote Foils where Image Critical
Denote Foils where HTML is sufficient
1 Computing on the Pragmatic Object Web
2 Abstract of Europar Pragmatic Object Web HPcc Presentation
3 Optimistic Scenario
4 The HPCC Dilemma and its Solution
5 What is Commodity Software
6 The Computing Pyramid
7 Server Side Java Distributed Objects Pragmatic Object Web Web-based Computing Computational Grids Coarse Grain Integration
8 Pragmatic Object Web Technology Model - I
9 Multi-Tier Client Server Service
10 Pragmatic Object Web Technology Model - II
11 Specifying Server Side Objects
12 Comparison of 2 3 and 4 Tier Models
13 Two ways of Implementing Data Objects
14 Today's Pragmatic Object Web: The Confusing Multi-Technology Real World Middleware Server Layer
15 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)
16 NPAC Concept: Summary of Pragmatic Object Web
17 NPAC Concept : HPcc High Performance commodity computing
18 What is the Architecture of Metaproblems Complex HPCC Applications
19 Structure(Architecture) of Applications - I
20 Structure(Architecture) of Applications - II
21 HPcc Hybrid Multi-Tier Architecture to obtain Commodity Functionality and High-Performance
22 Exploiting Multi-Tier Commodity Software Model
23 Three Possible Implementations of CFD CSM Linkage
24 Picture of JavaBean and JDK1.1 AWT Event Model
25 HPcc Prototype WebFlow and JWORB over GLOBUS
26 Gateway Building Blocks: JWORB WebFlow on GLOBUS
27 WebFlow WaveFilter Module
28 WebFlow + Globus Functional Architecture
29 WebFlow as front end for Globus in Alliance Quantum Chemistry Simulations
30 WebFlow over Globus for NCSA Alliance Quantum Chemistry Application View
31 WebFlow on Globus -- LMS at CEWES
32 What are JavaBeans I
33 What are JavaBeans II
34 Next Steps for HPcc using JavaBeans
35 Gateway Multi-Server Middleware System Architecture Linking Clients, HPCC, and Modern Enterprise Systems
36 Multi-Server Model
37 So in our WebWisdom Distance Education System
38 Database Architecture for WebWisdom
39 While for High Performance Computing
40 Multi-Server Gateway Tier
41 Multi Tier Gateway Architecture
42 What are General Capabilities in Gateway Tier?
43 What Particular Programs could run in Gateway Tier?
44 Distributed Modeling and Simulation RTI as more general MPI JWORB illustrates POW
45 Integration of DIS with Object Web Based Computing
46 Summary of NPAC's JWORB natural Building Block of the Gateway
47 JWORB - Java Web Object Request Broker
48 NPAC's Object Web RTI
49 JWORB based Object Web RTI
50 IIOP Performance for Java ORB's
51 Java IIOP Performance for Structures
52 C++ ORB Much Faster than Java!
53 HLA/RTI versus HPF/MPI
54 HLA/RTI at Top Management Level
55 Resource Management and Scheduling
56 HPcc for Parallel Computing
57 Parallel Computing v. Metacomputing
58 A Parallel Computer Viewed as a Single CORBA Object
59 Each Node of a Parallel Computer viewed as a Separate CORBA Object
60 Can HPcc Give High Performance if applied to each node of a parallel computer?
61 Hybrid Parallel Computing Model
62 Java as a Scientific Programming Language Sequential -- and various forms of Parallelism
63 Java and Parallelism?
64 Data Parallel HPJava: Motivation
65 HPJava Libraries
66 Distributed Array Syntax: HPJava Compared to HPF
67 Example: Red-black iteration
68 Preliminary HPJava Performance (outperforms Java due to libraries)
69 What should you do?

Outside Index Summary of Material

HTML version of Basic Foils prepared September 13 1998

Foil 1 Computing on the Pragmatic Object Web

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Invited Talk at Europar Conference Sept 4 98
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/europowsept98
HTML version of Basic Foils prepared September 13 1998

Foil 2 Abstract of Europar Pragmatic Object Web HPcc Presentation

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
We discuss the Pragmatic Object Web (POW) and how to use it in the HPcc High Performance Commodity Computing based on POW with a hybrid multi-tier model
We describe metacomputing and parallel computing based on these concepts
We give examples of using WebFlow with Globus and show this gives natural integration of CORBA into HPCC
The use of HLA/RTI as control of a bunch of workstations is recommended
HTML version of Basic Foils prepared September 13 1998

Foil 3 Optimistic Scenario

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Java becomes a better Grande (HPCC) programming environment than Fortran and C++
High speed networks become pervasively deployed
Microsoft does not win -- some combination of IBM Sun Netscape (...) stops the advance of NT, COM, Internet Explorer, ChromeEffects ...
The Web remains a creative open environment
Supercomputers remain a small market but do not entirely disappear
Technical computing (on supercomputers and below) continues to be important but problems become complex with linked databases and linked multiple disciplines
HTML version of Basic Foils prepared September 13 1998

Foil 4 The HPCC Dilemma and its Solution

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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
  • HPCC applications are very complex and use essentially all computer capabilities and also have synchronization and performance constraints from HPCC
We have learnt to use commodity hardware either
  • partially as in Origin 2000/SP2 with consumer CPU's but custom network or
  • fully as in PC cluster with fast ethernet/ATM
Let us do the same with software and design systems with maximum possible commodity software basis
HTML version of Basic Foils prepared September 13 1998

Foil 5 What is Commodity Software

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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).
  • The standard interfaces are essential in that they allow modular (component based) software
We will "just" add high performance to this commodity distributed infrastructure
  • Respecting architecture of the object web, should allow us to naturally use improved software as it produced
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 September 13 1998

Foil 6 The Computing Pyramid

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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 September 13 1998

Foil 7 Server Side Java Distributed Objects Pragmatic Object Web Web-based Computing Computational Grids Coarse Grain Integration

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
HTML version of Basic Foils prepared September 13 1998

Foil 8 Pragmatic Object Web Technology Model - I

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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
Need to abstract entities (Web Pages, database entries, simulations) and services as objects with methods(interfaces)
  • CORBA .. XML is "just" CGI done right
COM(Microsoft) and CORBA(world) are competing cross platform and language object technologies
  • Every Netscape4 browser has a Visigenic ORB built in
Javabeans plus RMI and JINI is 100% pure Java distributed object technology
W3C says you should use XML which defines a better IDL and perhaps an object model -- certainly does for documents
How do we do this while technology is still changing rapidly!
HTML version of Basic Foils prepared September 13 1998

Foil 9 Multi-Tier Client Server Service

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Client Tier
Javabean Enterprise Javabean
Old and New Useful Backend Systems including MPP
Back-end Tier
Services
Middle Tier
Servers
HTML version of Basic Foils prepared September 13 1998

Foil 10 Pragmatic Object Web Technology Model - II

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Need to use mix of approaches -- choosing what is good and what will last
For example develop Web-based databases with Java objects using standard JDBC (Java Database Connectivity) interfaces
  • Oracle DB2 Informix Sybase, Lotus Notes, Object database confusion becomes an issue of performance/robustness NOT functionality
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
  • e.g. Java Blend is built on top of JDBC to use enterprise Javabeans to store Java Objects in relational databases
Use CORBA to wrap existing applications
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 September 13 1998

Foil 11 Specifying Server Side Objects

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Documents -- URL
"General Programs including database invocations"
  • Old style Web -- CGI
  • New Style Web -- XML makes server side objects look like applets as far as invocation goes
  • CORBA and COM -- special "interface definition language" (IDL) defines invocation in C++ like syntax
  • RMI uses Java language as IDL language
HTML version of Basic Foils prepared September 13 1998

Foil 12 Comparison of 2 3 and 4 Tier Models

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Client
Middle Tiers
Back End
Thin Client
HTML version of Basic Foils prepared September 13 1998

Foil 13 Two ways of Implementing Data Objects

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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 September 13 1998

Foil 14 Today's Pragmatic Object Web: The Confusing Multi-Technology Real World Middleware Server Layer

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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 September 13 1998

Foil 15 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)

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
HTML version of Basic Foils prepared September 13 1998

Foil 16 NPAC Concept: Summary of Pragmatic Object Web

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
3-(or more)-tier architecture - Web browser front-ends, legacy (e.g. databases, HPC modules) backends; fat middleware
Use as appropriate the alternative / competing Middleware models:
  • Java RMI+ EJB (Enterprise Javabean) - single language solution by Sun
  • CORBA - all languages solution by OMG
  • COM - multi-language solution by Microsoft
  • WOM/XML - emergent solution by the Web Consortium
Each model has different tradeoffs (most elegant, powerful, fastest, simplest)
POW attempts to integrate various models and services in terms of multi-protocol middleware servers (JWORB)
  • Note Java is often the best language to build middleware whether this is Java or some other distributed object model
  • Most commercial Java activity is on Server not Client
HTML version of Basic Foils prepared September 13 1998

Foil 17 NPAC Concept : HPcc High Performance commodity computing

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Distributed Computing becomes a commodity highly functional environment (driven by Object Web Technologies)
Web/Commodity software (Pragmatic Object Web) - promising framework to build new HPcc (commodity computing) which can be applied to both metacomputing(computational grids), distributed simulation and parallel computing
Note HTTP CORBA IIOP Java RMI etc. is not necessarily High Performance layer -- they are linked middleware proxies controlling MPI as optimized "machine code"
HLA/RTI from distributed simulation community natural for coarse grain while PVM/MPI/HPF/.... natural for fine grain
Note logical progression below which is opposite to some other approaches
HTML version of Basic Foils prepared September 13 1998

Foil 18 What is the Architecture of Metaproblems Complex HPCC Applications

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
HTML version of Basic Foils prepared September 13 1998

Foil 19 Structure(Architecture) of Applications - I

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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
  • "10,000" separate programs (e.g. structures,CFD ..) used in design of aircraft
  • the various filters used in Khoros based image processing system
  • the ocean-atmosphere components in integrated climate simulation
  • The data-base or file system access of a data-intensive application
  • the objects in a distributed Forces Modeling Event Driven Simulation
HTML version of Basic Foils prepared September 13 1998

Foil 20 Structure(Architecture) of Applications - II

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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
  • modules are what HPF needs task parallelism for
  • Often modules are naturally distributed whereas parts of data parallel decomposition may need to be kept on tightly coupled MPP
Assume that primary goal of metacomputing system is to add to existing parallel computing environments, a higher level supporting module parallelism
  • Now if one takes a large CFD problem and divides into a few components, those "coarse grain data-parallel components" will be supported by computational grid technology
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 September 13 1998

Foil 21 HPcc Hybrid Multi-Tier Architecture to obtain Commodity Functionality and High-Performance

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Multidisciplinary application as an example
HTML version of Basic Foils prepared September 13 1998

Foil 22 Exploiting Multi-Tier Commodity Software Model

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Essential idea is consider a three tier model
  • Top tier is the client (in "Network Computer" based 4 tier architectures this becomes 2 tiers)
  • Second tier are servers coordinated by commodity technologies such as the Web and CORBA and communicating via HTTP(Web), IIOP(CORBA), RMI or custom Java sockets.
  • Use middle tier component/container model -- Enterprise Javabeans
  • Third tier are services such as databases, MPP's
Preserve the first two tiers as a high functionality commodity information processing system and confine HPCC to the third (lowest) tier.
  • MPI becomes the high performance "machine code" for message passing which you use if HTTP, IIOP or RMI have insufficient performance
HTML version of Basic Foils prepared September 13 1998

Foil 23 Three Possible Implementations of CFD CSM Linkage

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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
Can switch at each mpi_init or at each MPI message
HTML version of Basic Foils prepared September 13 1998

Foil 24 Picture of JavaBean and JDK1.1 AWT Event Model

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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
(proxy)
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 at middle or backend tier
1)Register Observers with Listener
HTML version of Basic Foils prepared September 13 1998

Foil 25 HPcc Prototype WebFlow and JWORB over GLOBUS

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
NPAC Project illustrating multi tier Gateway incorporating Java Applet Program Composition at Client
DMSO HLA/RTI Compliance (FMS,IMT)
CORBA COM Java Web Interoperable Gateway GLOBUS High Performance Backend inherits Gateway Services: Collaboration, Distributed Objects, Databases, Visualization .....
HTML version of Basic Foils prepared September 13 1998

Foil 26 Gateway Building Blocks: JWORB WebFlow on GLOBUS

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Client (Tier 1): Java Graph Editor for Webflow linked to interpreted debugger (DARP), Java Visualizer SciVis
  • In four tier model, these Java tools would run on Java Web Server with pure HTML client
Middle Tier 2: Network of JWORB or Java Servers running on Gateway Tier linking to CORBA COM and HTTP(Internet)
  • Java Servlet wraps non Java Application (Apache Java Server) or CORBA handles any language
Back-end Tier 3: Simple MPI or Globus (or similar) where available and where necessary
Next foils show
  • Pure Gateway Tier: WebFlow system with simple Java Image filters
  • Customized "database" solution for NCSA Alliance Grand Challenge in Quantum Monte Carlo
  • LMS Landscape Modeling System linking multiple (possibly parallel) simulation modules with diverse data from the Internet
HTML version of Basic Foils prepared September 13 1998

Foil 27 WebFlow WaveFilter Module

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Original Image
Output Image
Some of
Available Image Filters
CLIENT Visual DataFlow
Interface
SERVER Processes Filters
HTML version of Basic Foils prepared September 13 1998

Foil 28 WebFlow + Globus Functional Architecture

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
HTML version of Basic Foils prepared September 13 1998

Foil 29 WebFlow as front end for Globus in Alliance Quantum Chemistry Simulations

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Client Tier
IIOP High Functionality
Middle Tier
Future Globus
Globus
Future Parallel I/O
HTML version of Basic Foils prepared September 13 1998

Foil 30 WebFlow over Globus for NCSA Alliance Quantum Chemistry Application View

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
HTML version of Basic Foils prepared September 13 1998

Foil 31 WebFlow on Globus -- LMS at CEWES

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
WebFlow
server
WebFlow
server
WebFlow
server
EDYS
CASC2D
Data Retrieval
High Performance SubSystem
CASC2D
proxy
IIOP
Web Browser
Data Wizard
WMS interface
Toolbar
HTTP
WMS
File Transfer
File Transfer
GLOBUS
Internet
WebFlow modules
(back-end)
WebFlow
middle-tier
WebFlow applet
(front-end)
HTML version of Basic Foils prepared September 13 1998

Foil 32 What are JavaBeans I

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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
  • This is exactly the ideas we used to get high performance separating control and data transfer
One expects Javabeans to become the CORBA component interface
HTML version of Basic Foils prepared September 13 1998

Foil 33 What are JavaBeans II

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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
  • We will see this as next step for WebFlow
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
  • Hiding of properties which can only be accessed by methods (which must have special names)
  • Display of these properties (as given by methods)
HTML version of Basic Foils prepared September 13 1998

Foil 34 Next Steps for HPcc using JavaBeans

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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 September 13 1998

Foil 35 Gateway Multi-Server Middleware System Architecture Linking Clients, HPCC, and Modern Enterprise Systems

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
HTML version of Basic Foils prepared September 13 1998

Foil 36 Multi-Server Model

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Clients and their servers
Middle Tier Custom Servers
Back End Servers and
their services
HTML version of Basic Foils prepared September 13 1998

Foil 37 So in our WebWisdom Distance Education System

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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 Collaboration Servers 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
  • middle tier servers include speech to text converters (for deaf) and text to speech converters (for blind) etc.
HTML version of Basic Foils prepared September 13 1998

Foil 38 Database Architecture for WebWisdom

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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 September 13 1998

Foil 39 While for High Performance Computing

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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)
  • One runs 10,000 separate programs to design a modern aircraft which must be scheduled and linked .....
All linked to collaborative information systems in a sea of middle tier servers(as on following page) to support design, crisis management, multi-disciplinary research
HTML version of Basic Foils prepared September 13 1998

Foil 40 Multi-Server Gateway Tier

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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 September 13 1998

Foil 41 Multi Tier Gateway Architecture

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
High Performance Computing and Communication Tier
Clients
Gateway Systems
Globus
IIOP
RMI
HTTP
HTML version of Basic Foils prepared September 13 1998

Foil 42 What are General Capabilities in Gateway Tier?

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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
  • Uses agents to determine optimal execution platform
  • Accounting, Security, Compiling Interface, Seamless Tools Interface, global data and file system interface
Resource management of heterogeneous MPP backend (linked to seamless interface)
Database and Object Brokers; Network servers like Netsolve
Collaboration Servers including Habanero, Tango, Lotus Notes ...
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 September 13 1998

Foil 43 What Particular Programs could run in Gateway Tier?

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
The 90% of users who only need HPCC occasionally
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
JINI Java Resource Registration and Discovery Service
HTML version of Basic Foils prepared September 13 1998

Foil 44 Distributed Modeling and Simulation RTI as more general MPI JWORB illustrates POW

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
HTML version of Basic Foils prepared September 13 1998

Foil 45 Integration of DIS with Object Web Based Computing

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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 use a common framework for both distributed (event driven) simulations and classic time stepped parallel computing
HTML version of Basic Foils prepared September 13 1998

Foil 46 Summary of NPAC's JWORB natural Building Block of the Gateway

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
JWORB - Java Web Object Request Broker - multi-protocol middleware network server (HTTP + IIOP + DCE RPC + RMI transport)
Current prototype integrates HTTP and IIOP i.e. acts as Web Server and CORBA Broker
  • HTTP Services built in terms of CORBA services
  • Gives you immediately web interfaces to CORBA
  • CORBA supports applications in any language
Next step: add DCE RPC support to include Microsoft COM
JWORB - our trial implementation of Pragmatic Object Web
First non DMSO implementation of RTI -- HLA (distributed event driven simulation) Runtime at 5% cost(!)
HTML version of Basic Foils prepared September 13 1998

Foil 47 JWORB - Java Web Object Request Broker

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
HTML version of Basic Foils prepared September 13 1998

Foil 48 NPAC's Object Web RTI

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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 September 13 1998

Foil 49 JWORB based Object Web RTI

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
HTML version of Basic Foils prepared September 13 1998

Foil 50 IIOP Performance for Java ORB's

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
JacORB
JWORB
ORBIX
RMI
Variable Size Integer Arrays
HTML version of Basic Foils prepared September 13 1998

Foil 51 Java IIOP Performance for Structures

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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 September 13 1998

Foil 52 C++ ORB Much Faster than Java!

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Arrays of Integers C++ about 20 times faster than Java
RMI (Fastest Java) omniORB (C++)
HTML version of Basic Foils prepared September 13 1998

Foil 53 HLA/RTI versus HPF/MPI

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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 September 13 1998

Foil 54 HLA/RTI at Top Management Level

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Resource Management typically breaks down into either
  • a) Scheduling of largely independent jobs
  • b) Optimized data placement in a data parallel entity
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
  • Enterprise computing has Transaction Monitors
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 September 13 1998

Foil 55 Resource Management and Scheduling

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
HLA/RTI come with
Declaration Management corresponds to publication and subscription model of matching services and needs
  • Natural (agent-based) computing model on web
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 September 13 1998

Foil 56 HPcc for Parallel Computing

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Provides uniform access to metacomputing and parallel computing built on sustainable commodity technologies
HTML version of Basic Foils prepared September 13 1998

Foil 57 Parallel Computing v. Metacomputing

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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 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
  • or as a collection of tier 2 objects -- one per node
Both are interesting
  • As a single object provides a CORBA like facility of invoking as a distributed object
  • As one object per node, can use HPcc to provide node level programming environment
HTML version of Basic Foils prepared September 13 1998

Foil 58 A Parallel Computer Viewed as a Single CORBA Object

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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 September 13 1998

Foil 59 Each Node of a Parallel Computer viewed as a Separate CORBA Object

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
HTML version of Basic Foils prepared September 13 1998

Foil 60 Can HPcc Give High Performance if applied to each node of a parallel computer?

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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 September 13 1998

Foil 61 Hybrid Parallel Computing Model

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Backend Parallel Computing Nodes running Classic HPCC -- MPI becomes Globus to use distributed resources
Middle Control Tier -- JWORB runs on all Nodes
Use separation of control and data transfer
to support RTI(IIOP) on control layer and MPI
on fast transport layer simultaneously
HTML version of Basic Foils prepared September 13 1998

Foil 62 Java as a Scientific Programming Language Sequential -- and various forms of Parallelism

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Note Java will have similar performance to Fortran
a)when Industry compilers mature b)if Sun accepts Java Grande recommendations
HTML version of Basic Foils prepared September 13 1998

Foil 63 Java and Parallelism?

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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 and we have described how to use this in HPcc
"Data Parallel" languages features are NOT in Java and have to be added extending ideas from HPF and HPC++ etc
  • e.g. NPAC's HPJava translates 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
  • In Web use, allows one to process Image in one thread, HTML page in another etc.
  • threads Can be used to do more general parallel computing but only on shared memory computers
HTML version of Basic Foils prepared September 13 1998

Foil 64 Data Parallel HPJava: Motivation

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
Data parallelism important in High Performance scientific computing.
Java must use same ideas as HPF HPC++ but details of language and experience can suggest a different implementation
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.
  • Can be applied to Fortran C++ Java
  • Explicitly MIMD control flow.
  • Ease of HPF Arrays; power of MPI; HPJava uses best language ....
HTML version of Basic Foils prepared September 13 1998

Foil 65 HPJava Libraries

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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 September 13 1998

Foil 66 Distributed Array Syntax: HPJava Compared to HPF

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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 September 13 1998

Foil 67 Example: Red-black iteration

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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 September 13 1998

Foil 68 Preliminary HPJava Performance (outperforms Java due to libraries)

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
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
HTML version of Basic Foils prepared September 13 1998

Foil 69 What should you do?

From Computing on the Pragmatic Object Web EuroPar Invited Presentation -- September 4 1998. *
Full HTML Index
As a program manager or user of scientific computers
  • Only support or use sustainable high quality software built on commodity base to community standards
  • Insist on Java Grande compliance in RFP's
  • monitor Java carefully to see when and if becomes language of choice
As researchers, think of some better ideas aiming 5-10 years from now
All of us -- defend the free world from Microsoft
© Northeast Parallel Architectures Center, Syracuse University, npac@npac.syr.edu

If you have any comments about this server, send e-mail to webmaster@npac.syr.edu.

Page produced by wwwfoil on Sun Sep 13 1998