Geoffrey Fox, Wojtek Furmanski, Tom Haupt
Programming tools that are simultaneously sustainable, highly functional, robust and easy to use have been hard to come by in the HPCC arena. This is partially due to the difficulty in developing sophisticated customized systems for what is a relatively small part of the worldwide computing enterprise. Thus we have developed a new strategy -- termed HPcc High Performance Commodity Computing -- which builds HPCC programming tools on top of the remarkable new software infrastructure being built for the commercial web and distributed object areas. This leverage of a huge industry investment naturally delivers tools with the desired properties with the one (albeit critical) exception that high performance is not guaranteed. Our approach automatically gives the user access to the full range of commercial capabilities (e.g. databases and compute servers), pervasive access from all platforms and natural incremental enhancement as the industry software juggernaut continues to deliver software systems of rapidly increasing power. We add high performance to commodity systems using a multi tier architecture with traditional HPCC technologies such as MPI and HPF supported as the backend of a middle tier of commodity web and object servers.
Our approach can be applied to both parallel and distributed computing environments but here we focus on the latter. This exploits the full power of our approach; has very few tools to date (as it is not the preserve of a particular hardware vendor) and is of importance to ASCI linking multiple laboratory and user machines together. We build on existing runtime and propose to use MPI and Globus at the high performance-messaging layer with POOMA as the base parallel object technology. Our approach is general and this choice will evolve as the needs of ASCI and trends in the HPCC community dictate.
We propose construction of a sequence of high level programming tools of increasing functionality and technical sophistication, incrementally deployed in ASCI Labs, and integrated as the ASCI WebFlow environment. We identify three milestones below corresponding roughly to each year of the proposal and each layer/tier of this 3-tier system. NPAC and its collaborators will test each layer and then we will incrementally deploy in ASCI whose evaluation will guide further evolutionary and revolutionary changes in the individual layers and the system integration. We can offer training courses (using if desired our novel distance training technology) in both the core tools and the underlying commodity technologies.
The first ASCI deliverable will be a Web based dataflow environment (similar in spirit to AVS and Khoros) WebFlow built using Java Applet front-ends, Java Web servers as middleware with a high performance backend built from Globus, MPI or POOMA. WebFlow can be considered as a high level visual interface to these key HPCC technologies.
In the second stage, we will upgrade the Javasoft Web servers (and associated servlets) to JWORB (Java Web Object Request Broker) servers, which will simultaneously support COM CORBA and HTTP (Web) protocols. JWORB embodies our vision of the "Pragmatic Object Web" with industry's impressive but still incomplete integration of web and distributed object technologies. NPAC has extensive experience in building powerful systems using this approach and based on this, we are writing a new book ("Building Distributed Systems on the Pragmatic Object Web"). We will finalize this as we use it in a class next semester and the book can be a key part of background for the proposed training we will offer in our tools. The JWORB based WebFlow allows natural integration of specialized PC (COM) and Industry standard CORBA distributed objects with the powerful Web dissemination model with technologies such as Java and VRML. This will give users an ability to link high performance localized (MPI, POOMA) or distributed (Globus) compute services with commodity relational and object databases. The system will also support commodity visualization, collaboration, session scripting, journaling and playback, and other important services that are typically lacking in the custom HPCC products. JWORB has been designed to support the military distributed simulation object standard HLA (High Level Architecture).
In the final stage of the project we will add a hierarchical visual mode using OMG's Uniform Modeling Language (UML) where one can expose the internals of a module and build visually in terms of finer grain parallel (e.g. POOMA) objects. Using our DARP (Data Analysis and Rapid Prototyping) techniques, we will also add high level utilities such as: user level scripting capability; support for both interpreted and compiled execution of modules; interactive rapid prototyping of simulation software; and run-time data analysis and computational steering. This powerful hierarchical framework will offer a common visual platform for design, development, testing, verification and runtime-compositional stages of the complex HPDC software process, and it will integrate visual and scripting prototyping techniques.
Our evolving ASCI WebFlow environment will be continuously tested and refined in the broad context of ASCI applications. We will start this deployment process in year 1 by providing visual HPDC support for POOMA coarse grain components and applications such as neutron transport, and we extended it in year 2 and 3 following the guidance of the ASCI Laboratories. We also intend to test our developed environment using new application software, which we will be building to support the GEM earthquake prediction computational toolkit. This application is of importance to DoE and involves currently Los Alamos and Livermore. Another metacomputing testing frameworks will be provided via our participation in the NCSA Alliance, Globus/GUSTO, and the DoD High Performance Modernization Program metacomputing testbeds.
Project Description
In this proposal, we address ASCI needs for high level programming environments and tools to support distance computing on heterogeneous distributed commodity platforms and high-speed networks, spanning all ASCI labs and facilities. Such High Performance Distributed Computing (HPDC) environments are inherently hard to build within the limited HPC budget lines. We therefore propose a paradigm shift towards HPcc - High Performance Commodity Computing - where HPDC is realized and it becomes feasible as a specialized high performance limit of modern scalable 3-tier enterprise computing environments.
*** Here is where a picture would be valuable to show tiers, which are probably NOT familiar to readers
More specifically, we propose here to develop ASCI WebFlow, that is, a scalable HPDC system that integrates:
This approach was not possible a few years ago when the enterprise computing was still mainly client-server (2 tier) and based on custom expensive solutions such as proprietary TP Monitors. The onset of the Web and the associated Intranets accelerated the development of scalable and open 3-tier standards such as CORBA, DCOM or Enterprise JavaBeans (EJB). We can therefore prototype now a dedicated and advanced and yet commercial quality HPDC system for ASCI applications by integrating open commodity standards for distributed enterprise computing with existing HPCC infrastructure, which is optimized for performance.
Dedicated visual programming systems such as AVS or Khoros are already successfully used and accelerating the software development process in the advanced visualization and image processing communities. We believe that WebFlow can offer a similar paradigm shift for the ASCI community by significant acceleration and quality improvement of the HPDC software process, which is currently largely based on low-level explicit message passing paradigm. Such optimized, algorithm-specific message passing codes become now natural candidates for individual coarse grain WebFlow modules where they can be further interconnected via high level universal dataflow channels. This allows Problem Solving Environments that can span and integrate multiple programming languages, paradigms, facilities, projects and labs. Note than unlike AVS and Khoros, ASCI WebFlow explicitly supports parallel modules and high performance interconnects.
The visual HPDC framework to be delivered by this project offers an intuitive Web browser based interface and a uniform point of interactive control for a variety of ASCI computational modules and applications, running at various labs on different platforms and networks. New applications can be composed dynamically from reusable components just by clicking on visual module icons, dragging them into the active WebFlow editor area, and linking by drawing the required connection lines. The modules are executed using Globus optimized components combined with the pervasive commodity services where native high performance versions are not available. For instance today one links Globus controlled MPI programs to WebFlow (Java connected) Windows NT and database executables. When Globus gets extended to full PC support, the default WebFlow implementation is replaced by the high performance code.
Individual modules will be typically represented by visualization, control, steering or collaboration applets, and the system will also offer visual monitoring, debugging and administration of the whole distributed applications and the underlying metacomputing resources. ASCI WebFlow will offer tools for easy conversion of existing (sequential, parallel or distributed) ASCI applications to visual modules via suitable CORBA, COM or JavaBeans based wrapper/proxy techniques. New applications, created within the ASCI WebFlow framework will likely follow a natural modular design in which one accumulates a comprehensive problem domain specific module library in the first phase of a project. Then one would explore the computational challenges of the project in a visual interactive mode, trying to compose the optimal solution of a problem in a sequence of on-the-fly trial applications. The scripting capabilities of WebFlow coupled with database support for session journaling will facilitate playback and reconstructing optimal designs discovered during such rapid prototyping sessions.
For the parallel object and module developers, we will also provide finer grain visual and scripted parallel software development tools using the new Uniform Modeling Language (UML), recently accepted as an OMG standard. UML offers a spectrum of diagrammatic techniques that allow one to address various stages of software process and several hierarchy layers of a complex software system. In this way, ASCI WebFlow will combine the features of UML based visual tools such as Rational Rose with both high performance and the proven value of visual programming environments such as Khoros and AVS.
Goals and Deliverables. Our technology goal is to build a high level user friendly commodity software based visual programming and runtime environment for HPDC that would evolve our current WebFlow prototype towards a production quality HPcc - High Performance Commodity Computing environment. We believe that such an ambitious and generic framework can be successfully built only when closely related to some specific large scale application domains which can provide specification requirements, testbeds and user feedback during the whole course of the system design, prototyping, development, testing and deployment.
We view ASCI program as a attractive application environment for HPcc due to its unique, clear mission and advanced computational challenges, opportunities and requirements. We therefore consider the detailed understanding of the ASCI computational and software integration needs as prerequisite for technology development components of this proposal and we put it as our first goal in the proposed R&D agenda. We already have good contacts with DoE Labs, both in the Defense (Los Alamos, Livermore) and the Research (Argonne) domains, and we intend to further strengthen these ties in the course of this proposed project (as discussed in Sec. 5).
Our proposed project follows an iterative and incremental software development process, given by the following two parallel and interacting tracks: 1) Iterative Deployment Track; and 2) Incremental Technology Development Track.
In the Technology Track, we will start with the current 3-tier based WebFlow prototype and we augment and extend the individual tiers by the latest/emergent technologies such as Globus in tier 3, CORBA/COM/EJB in tier 2, and UML in tier 1. The corresponding three tasks, addressing the individual tiers as listed above during the subsequent years of this 3-year project are described in detail in Section 3 below.
In parallel with the Technology Track, we will pursue the ASCI Deployment Track which starts in Year 1, continues throughout the project and is focused on delivering subsequent interactions of ASCI WebFlow to the ASCI community and on providing continuous feedback and requirement updates to the Technology Track. The ASCI application deployment is enhanced by working with the DoE and other researchers on the GEM earthquake prediction application development.
Each tier of our 3-tier system will be fully modular, encapsulated and ready to cooperate with other ASCI solutions for the neighboring tiers/layers. Such interoperability is expected to be natural, as many other systems available to ASCI, will surely follow the HPC + commodity based 3-tier software approach, already pioneered by HPcc. We expect that these efforts will converge around the common commodity standards such as CORBA/COM/JavaBeans and the HPCC standards being collected by the Globus Toolkit. Hence, the list of deliverables of this project includes four major items: three tiers/layers, described in the following sections and delivered as standalone self-contained macro-components, and the whole ASCI WebFlow system which includes and integrates all three layers as individual tiers of its 3-tier architecture.
Task Descriptions. Our planned interaction with ASCI activities, viewed as the critical information gathering component of this project, is discussed independently in Section 5, whereas here we concentrate on the technology tasks. The three tiers of our HPcc system for ASCI correspond to the following specific technology tasks of the proposed project, discussed in more detail in topics A, B, and C of this section:
We also discuss independently in topic D the deployment and integration task which extends during the whole course of the project:
Task A. WebFlow/Globus based Metacomputing Backend Our eventual technology goal is Object Web (Java/Web/CORBA/COM) based 3-tier visual scalable componentware framework for HPCC, with visual authoring support in tier 1, scalable componentware support in tier 2, and HPCC support in tier 3.
Based on DoE support, we already developed at NPAC an early and custom prototype of such a 3-tier system called WebFlow. WebFlow is based on a coarse grain dataflow paradigm (similar to AVS or Khoros models) and it offers visual interactive Web browser based interface for composing distributed computing (multi-server) or collaboratory (multi-client) applications as networks (or compute-webs) of Internet modules.
WebFlow front-end applet offers intuitive click-and-drag metaphor for instantiating middleware or backend modules, representing them as visual icons in the active editor area, and interconnecting them visually in the form of computational graphs, familiar for AVS or Khoros users. WebFlow middleware is given by a mesh of Java Web Servers with servlet based support for WebFlow Session, Module and Connection Management. WebFlow modules are specified as Java interfaces to computational Java classes or wrappers (module proxies) to backend services.
So far, we prototyped only a set of simple proof-of-the-concept backend modules testing various aspects of the system including:
The goal of the Year 1 ASCI WebFlow task is to implement the HPCC backend component of WebFlow by integrating it with the Globus metacomputing toolkit under development by Ian Foster at Argonne and collaborators from several national labs and universities. The integration of WebFlow and Globus seems to be a natural and useful match. Thus Globus is a relatively low-level metacomputing toolkit without many higher level frameworks available at the moment. On the other hand, WebFlow currently offers a satisfactory early prototype solution for Tier-1 (visual authoring) and Tier-2 (middleware wrapping/plumbing) components but it lacks an organized metacomputing backend in Tier 3.
The proposed WebFlow/Globus integration will be accomplished by developing new WebFlow Managers representing/wrapping base Globus services including the GRAM (Globus Resource Allocation Manager) and MDS (Metacomputing Directory Service). A natural WebFlow/Globus integration topology will include two parallel meshes of distributed modules: a control layer of WebFlow managed module proxies, and a high performance computation layer of Globus managed real modules. Visual activation of a WebFlow module icon in Tier 1 will correspond to creating its middleware proxy in WebFlow server, consulting Globus services for the best resource allocation schedule, instantiating the backend module, and returning the visual notification to the user. Several monitoring services in Tier 1 can be naturally constructed and experimented with by mapping Tier 3 Globus runtime services to suitable WebFlow managers in Tier 2 that receive real-time notifications from the backend modules and they in turn update graphics displays in the front-end monitoring applets. In ref. 8, we describe in detail how one can split messaging into control and data transfer functions and implement control at the tier-2 and data transfer where one really needs the high performance, at tier-3. We have successfully prototyped typed this using Java's listener model for events in a class (CPS714) project this semester.
In parallel with the technology task of WebFlow/Globus integration, we will identify in year 1 a set of ASCI applications (see Section 3D for current candidates) that are suitable for testing this concept and the resulting visual metacomputing toolkit. Since both Globus and WebFlow are already operational, we expect to receive significant feedback from the ASCI user community during the first year of the project which will help us to attack more advanced HPcc challenges in year 2 and 3.
Task B: JWORB - Object Web (Java/CORBA) based Middleware As discussed above, the middleware layer in the current WebFlow prototype is provided by a mesh of Java Web Servers (JWS) from JavaSoft. These are custom extended for the WebFlow purposes in terms of the servlet based Managers and Module interface specification. In fall'96 when the current WebFlow design decisions were made, JWS (at this time called Jeeves) was in a free software (competing with a similar system called Jigsaw by World-Wide Web Consortium) and the servlet API was expected to become part of the core Java/JDK. By early '97, JavaSoft changed their strategy and decided to turn JWS into a commercial product, now competing with Netscape Enterprise Server and Microsoft Internet Information Server. Meanwhile, we are witnessing a rapid onset of distributed object technologies such as CORBA, DCOM, RMI and EJB which might imply profound changes in the HTTP protocol evolution and the associated Web server engineering. Indeed, new activities such as DOM (Document Object Model) by W3C, ORBlets by Netscape/Visigenic and the corresponding Web outreach by OMG, seem to indicate the coming merger of Web and CORBA via Java towards "Object Web". Furthermore, the stateless and document-oriented HTTP can be viewed as just a special simple case of a more general, state-full and object-oriented IIOP (Internet Inter-ORB Protocol) used by CORBA, or/and the DCE-RPC protocol used by DCOM.
In view of these recent developments and dichotomies between various competing Object Web candidates (CORBA/DCOM/EJB), we decided to design and prototype a universal middleware server that would support and integrate several currently competing protocols. This provides a research prototype for the anticipated convergence of CORBA, DCOM and EJB technologies towards what we call 'Pragmatic Object Web' (POW).
Our POW server called JWORB (Java Web Object Request Broker) is being built in Java and it will initially act as an integrated HTTP and IIOP network server. Later on, we will also include DCE RPC support for DCOM and JRMP support for Java RMI. Unlike the current generation of full-blown (and hence huge and difficult to maintain) Java Web Servers such as Jeeves or Jigsaw, the HTTP component of JWORB is minimal. We expect several advanced Web services to be more efficiently expressed in terms of (already standardized, stabilized and commercialized) CORBA services - the latter to be enabled via the IIOP sector of the JWORB server. At the moment, the HTTP part of JWORB is operational and publicly available, and the IIOP part is under development, with the early prototype expected by April'98. We expect our JWORB to accelerate the adoption and dissemination of the Object Web standards by offering an open public domain integrated HTTP+IIOP development platform. Our adherence to Industry standards, implies we can incorporate commercial products as they become available, to replace some or all of the JWORB services.
After completing the base JWORB development, we will adapt it via a mixture of standard and suitably customized CORBA services to act as a middleware node server for an HPDC environment. One planned near term application domain acting as a testbed of our ideas and prototypes is DoD Modeling and Simulation where we are developing JWORB based HLA/RTI, called WebHLA, within the academic (PET) component of the DoD Modernization Program.
A natural application and adaptation of JWORB for the ASCI needs is to use it as a next generation WebFlow componentware-enabled middleware that would naturally interact both with the Web browsers in the front-end (using mainly HTTP) and with the CORBA-wrapped HPCC services in the back-end (using mainly IIOP). A promising model for ASCI WebFlow module (proxy) design is being provided by the Enterprise JavaBeans (EJB) architecture. As part of the year 2 Technology Track of this project we will complete the core JWORB development and we will build the EJB support as a CORBA service within JWORB, customized for WebFlow module management.
The resulting WebFlow middleware will be both self-contained as based on our JWORB and easily convertible to or/and naturally cooperating with commercial containers such as JWS, Oracle8, and Microsoft MTS.
It should be stressed that EJB/JWORB based WebFlow middleware cannot be realistically addressed in the year 1 of the project since the underlying technologies are just emerging and are not yet ready even for early prototyping. For example, the EJB specification was published by JavaSoft for the first public review only in Dec '97 and the final specification is expected by mid '98. Several other Object Web technologies relevant for the WebFlow/JWORB model are also still in the OMG standardization pipeline. Example emerging capabilities include CORBA Components, CORBA Scripting, Objects-by-Value, Workflow, Mobile Agents, UML and MOF. We are closely monitoring the formation of standards listed above and we are developing the specific WebFlow/JWORB technology development plan that assumes the availability of these specifications during the first year of the project. One advantage of planning on top of CORBA standards is OMG reliability.The whole standardization process including initial RFI (Requests for Information), followed by RFPs, followed by initial submissions and culminated by final submission and standard adoption are published on the Web. These come with precise deadlines which are being strictly adhered to and so they allow reliable technology planning for a year or two ahead.
Armed with the JWORB/EJB based middleware, we will revise in year 2 our WebFlow/Globus interface, prototyped in year 1, and we will augment it towards a more robust wrapper/proxy model based on CORBA binding techniques. Hence, year 2 WebFlow will deliver to ASCI users a suite of new, robust, multi-language and standard based techniques for wrapping HPCC software in the form of easily reusable and composable distributed objects, components and modules. Module developers will be now able to package their software as CORBA objects, CORBA servers, CORBA components, Enterprise JavaBeans or their containers or servers. Each of these wrapping techniques will fully cooperate with our EJB-in-JWORB middleware and will be also ready to be plugged-and-play in other emergent Java/CORBA containers conforming to the Object Web standards.
Our commodity standards based approach will allows us also to address interoperability with other metacomputing tools under development such as Legion which are based on custom distributed object models. The CORBA HPDC middleware developed in this ASCI project might in fact evolve towards a horizontal CORBA Facility for Metacomputing, to be eventually proposed to the OMG by the HPDC industry. In fact, we already have one example of such novel industry-government interaction mode, pursued by DMSO and aimed at promoting the HLA/RTI standard as a CORBA Facility for Interactive Modeling and Simulation.
We are also monitoring recent Microsoft activities which seem to indicate that DCOM is gaining momentum as a pragmatic platform for today's enterprise computing. Microsoft's claim is that, when restricted to the NT clusters, DCOM offers already today the 'total solution' for enterprise computing (and challenges the IBM mainframe market), whereas public DCOM ports to the UNIX platforms are becoming available as well and standardized by the Open Group (evolved from previous OSF). At the moment, CORBA and DCOM represent two extreme strategies with CORBA offering the 'right solution' which is still emerging while DCOM is already expanding its enterprise market share with a fully functional prototype of the complete system. One overlap area of both approaches is Java viewed by both models as the most convenient programming language for distributed objects and components. Hence, with our Java based JWORB we are conveniently positioned to address already today both the NT and UNIX platforms and to evolve together with CORBA and DCOM, seeking for and enforcing commonalties between both models.
Task C: UML based Visual Authoring Front-end Armed with the HPCC standards based Backend and the commodity standards based Middleware, we will concentrate in Year 3 on standardizing and fine-tuning for the ASCI needs the visual authoring framework in the Front-end. Our current visual metaphor in WebFlow is reflecting today's industry standards and best practice solutions, developed and tested by systems such as AVS and Khoros. Thus it is based on visual interactive graph editing with graph nodes representing modules/operations and graph links representing connections and dataflow channels. However, the new generation of client technologies such as JavaBeans or ActiveX admit several more elaborate and dynamic visual paradigms in which module icons are replaced by full-blown applets, OLE controls or other dynamic GUI widgets. Further, fixed type data channels are replaced by dynamic event/listener or consumer/producer or publisher/subscriber associations.
As part of a study of new visual programming standards, we have analyzed recently a suite of new tools appearing on the rapidly growing visual authoring market, including VisualStudio from JavaSoft, VisualAge from IBM, VisualCafe from Symantec, Rational Rose from Rational and VisualModeler from Microsoft. It appears that the visual componentware authoring products are still based on early custom models but there is already a promising stable standard initiative in the area of visual object-oriented design, represented by Uniform Modeling Language (UML).
UML is developed by an industry consortium led by Rational and supported by Microsoft, and was recently adopted as CORBA standard by OMG (together with the associated Meta Object Facility). Hence, we are witnessing here one distinctive example of a truly universal emerging standard candidate agreed upon by all major players. UML offers a broad spectrum of visual authoring graph topologies, adequate for various stages of the software process and representing diverse views of the modeling system such as use-case view, logical view, component view, concurrency view or deployment view.
The rich collection of UML graph topologies includes: use-case diagrams (for sketching initial customer requirements), class diagrams (with inter-class relationships such as inheritance or aggregation), object diagrams (with object methods and attributed), state diagrams (visualizing stateful objects are final state machines), sequence diagrams (exposing temporal aspects of object interactions), collaboration diagrams (exposing the spatial/topological aspects of object interactions), activity diagrams (representing the workflow and concurrency relations between object methods), component diagrams (with the actual software entities as nodes), deployment diagrams (with the physical hardware platforms as nodes).
UML is naturally extensible and it uses itself to provide formal specification of its syntax/notation, semantics and extension patterns in terms of a metamodel and meta-metamodel (related to OMG Meta Object Facility). Hence, there is a rigorous object-oriented formulation of all UML elements and their interactions, as well as extension objects that allow to further evolve the language and adapt it to specific computational domains.
UML specification is an open standard and it is already followed by the first generation commodity tools for advanced visual authoring such as Rational Rose from Rational (supporting the whole spectrum of modern programming languages) or VisualModeller from Microsoft (now available for VisualBasic Enterprise Editon). These tools are currently focused on fine grain object level visual software development and they offer 'round-trip engineering' support. Visual models can be converted into language specific code stubs/skeletons, and the full codes (both pre-existing and visually developed) can be reverse-engineered to expose their internal structure and to enable further editing in terms of UML graph topologies discussed above.
To our knowledge, current UML tools do not address yet the runtime visual authoring via coarse grain module composition as offered by WebFlow, but such dynamic extensions are natural in UML. We therefore propose to adopt UML as ASCI WebFlow tier 1 visual standard and to extend the language using its intrinsic mechanisms so that both the modeling/development time and simulation/runtime visual frameworks are supported within a uniform and consistent standard paradigm. In fact, current WebFlow model can be viewed as a runtime specialization of the UML activity diagrams - hence the dataflow model of WebFlow as derived from AVS/Khoros embeds naturally in UML and it gets reenforced by several other views and complementary graph topologies discussed above.
UML activity diagrams represent also the first step towards visual standards for parallel programming. The dataflow model itself (as in AVS) is based on the OR-gate synchronization (a module responds to data changes on any of its input channels). UML also adds AND-gate synchronization and some other visual parallel constructs (such as implicit iterator that implies concurrent replicas of a marked branch of the graph). The current early visual parallel processing support in UML is clearly driven by the SMP architectures. Some other previous efforts within the HPCC community such as HeNCE or CODE or more recently Cumulvs are addressing visual concurrency for shared memory massively parallel and distributed processing architectures. We believe that there are interesting research issues in reexamining these approaches from the UML standard perspective in search of new universal visual extension patterns that would allow one to express platform-independent concurrency in terms of suitable visual controls
The complex process of building HPDC software involves several natural hierarchy levels, starting from individual functions/methods, grouped into sequential and parallel objects, then packaged as single- or multi-server modules, and finally composed as local or distributed components towards metacomputing applications. Previous visual approaches addressed selected aspects of but we believe that none has succeeded yet in capturing the totality of this complex process. The unique position of UML is its proposed 'complete solution', realized in terms of a comprehensive set of views, diagrammatic techniques and graph topologies. In the context of ASCI WebFlow, it offers a promising common visual platform for (parallel) module developers and (distributed) module integrators. Each of these groups will adopt the most adequate techniques from the UML arsenal, while maintaining the interaction via overlapping topologies such as activity diagrams (that allow one to mix object-oriented, functional and concurrent processing perspectives).
Parallel module developers will be likely using class and object diagrams on a regular basis. They may also find useful the collaboratory diagrams which can be used.to visualize spatial collaboration of classes implementing a complex PDE stencil. The sequence or state diagrams could perhaps be useful to detect a deadlock via rigorous temporal or/and state analysis. Expression template programmers might also find useful the UML template notation and provide us with the specific extension requirements in this area to visually represent complex expression trees or to visualize/optimize the intermediate steps of the compiler parse tree.
Moving further down in the software hierarchy towards finer elements such as individual methods or the actual lines of the source code, we will provide direct customizable links from visual code icons to developer's favored code editors and debuggers. These could include vanilla public domain tools such as vi or emacs; commodity tools of growing popularity such as MS Visual Studio or Rational Rose; and specialized tools for high performance software prototyping such as our DARP package, so far tested in the HPF programming environment.
More generally, we will be working in year 3 of the project with various groups of ASCI WebFlow users to collect their comments, suggestions and requirements for the UML support in the WebFlow front-end. Based on this information, we will provide core UML support for parallel languages of relevance for ASCI (C++, HPC++, and HPF) as well as for parallel objects in frameworks such as POOMA. The WebFlow/UML frontend will be packaged as a Java/CORBA facility that can be used in a standalone mode as a visual parallel authoring toolkit for full-cycle and round-trip software engineering. It can also be offered as a parallel processing extension to commercial authoring tools such as Rational Rose, Visual Modeller and others to come over the next two years. These delivery possibilities will be refined in our discussions with ASCI users of our system.
Finally, we note that the 'round-trip engineering' requires language compiler front-ends and we intend to provide and use here our suite of parallel compiler front-ends developed by the Parallel Compiler Runtime Consortium led by NPAC.
Task D: Iterative/Incremental Deployment Plan In the previous 3 sections, we described 3 tiers of our proposed HPcc environment for HPDC ASCI applications. In parallel with these three focused tasks, addressed in three subsequent years of the project, we will also pursue the iterative deployment task, extending throughout the project. The deployment tasks starts in year 1 by bringing the WebFlow-over-Globus toolkit (see section 3A) to the ASCI users. It will assure ASCI: a) continuous operability and availability of the evolving WebFlow toolkit; b) continuous increase of functionality as specified in the individual tiers/tasks; c) backward compatibility after the subsequent system upgrades; d) modularity and encapsulation of the individual tiers/layers so that they can be reused and integrated independently with other ASCI systems; e) progressive integration of the individual tiers towards a complete ASCI WebFlow system for visual authoring and runtime control of HPDC applications across ASCI labs and facilities.
All steps listed above will be accomplished in the process of close interaction with selected systems and teams indicated to us by the ASCI program. Since we would like to work closely with the POOMA team, we illustrate the iterative deployment process on the example of planned WebFlow-POOMA interaction during the proposed project.
In year 1, we will deliver WebFlow-over-Globus package which will integrate POOMA/MPI with MPI-over-Nexus and hence provide metacomputing support for POOMA parallel objects. We will also analyze POOMA I/O as supported by DataConnect classes that handle run-time data transfer between POOMA objects and external modules. Thereby we will provide the corresponding dataflow channel/object abstraction in the WebFlow front-end. A set of year 1 POOMA/WebFlow applications would include real-time visualization and computational steering of POOMA/Globus meta-modules such as MC++ - a neutron transport Monte Carlo code built recently in POOMA. MC++, developed initially as a specific application, is we understand, now evolving towards a more generic Transport Physics Framework (TPF). TFP aims at providing libraries of plug-and-play components for various particle and material properties that would enable efficient exploration of alternative techniques and models in neutron transport studies. Hence, TFP appears as a promising candidate for ASCI WebFlow application/user domain where we start from generic visualization and steering support, and we evolve towards more ASCI-specific component libraries that can benefit from HPDC plug-and-play support offered by WebFlow.
In year 2, ASCCI WebFlow will receive new CORBA based middleware and we will work with POOMA developers on packaging POOMA as CORBA Facility for Particles and Fields Simulation. Such packaging would add value to POOMA by offering a natural linkage with other programming languages supported by COBRA (the current list includes C/C++, Java, Smalltalk, Ada, Cobol)..
In year 3, we will work with POOMA parallel class/component developers to understand their needs in the area of visual OO/componentware programming and to translate it into the requirements for the UML support in the WebFlow front-end. Examples include specific diagrammatic support for complex stencil or expression templates visual engineering. At the end of this process, we can envision a fully collaboratory engineering and runtime framework. Here parallel module engineers from the POOMA team and distributed module integrators from any ASCI team communicate and fine-tune their application components by sharing the suitable visual UML metaphors supported by the dynamic ASCI WebFlow front-end.
Relevance for ASCI The proposed project responds to several areas specified in the ASCI Level 2 Strategic Investigations and Software Research Opportunities, including: distance heterogeneous computing, data manipulation and visualization, scalable high-level programming tools, distributed object technologies, high level runtime constructs for the global data space, dynamic process scheduling and migration, problem solving environments. In particular, we are prototyping a novel approach to HPCC tools (namely construction on top of advanced commodity distributed computing systems) that could have fundamental importance in changing ASCI's current evaluation that tools are falling behind the project's needs.
We believe that our paradigm shift approach towards High Performance Commodity Computing and its specific implementation proposed here - ASCI WebFlow - will significantly accelerate and improve quality of the HPDC software development for ASCI. The highlights of our approach from the perspective of its relevance for ASCI mission include: a) uniform and intuitive point-and-click Web browser interface to numerous (possibly all) coarse grain heterogeneous computational resources of the ASCI program; b) high level visual intuitive programming tools that will accelerate productivity in the development of ASCI applications in the plug-and-play style in terms of standardized reusable components, coming from various labs and projects; c) Quality, standards based componentware design using the integrated experience of 700+ companies forming OMG from one side, and Microsoft's experience from their prototype DCOM deployment from the other side; d) Major software reuse and productivity boost based on publicly available commodity components (e.g. JavaVM or DCOM) e) Natural availability of commercial quality implementations of individual components when required (e.g. commercial ORBs, EJB servers, UML toolkits) f) WebFlow over Globus Metacomputing support to enforce wide area interoperability between individual ASCI labs and systems; g) CORBA/DCOM based multi-language support to assure smooth connectivity between Fortran, C/C++ and Java subsystems; h) UML based front-ends to support standards based visual collaboration between component developers and application integrators from various labs.
Planned Interaction with ASCI Activities We will continue our interactions with Los Alamos and Livermore as part of the GEM proposal planning. We will use these contacts as an opportunity for us to learn more about ASCI software components and user needs.
We will also continue our interaction with DoE research labs, especially Argonne where NPAC has working relation with Ian Foster and Rick Stevens via NCSA Team B projects.
We will also investigate similarities and differences between Globus and Legion metacomputing frameworks and we will address the uniform middleware interface in the form of a CORBA Metacomputing Facility.
We also intend to explore the technology transfer options for POOMA and other ASCI modules from DoE to DOD labs within the NPAC HPCMP/PET activities at various MSRCs.
As part of the proposed project, we will conduct research on other DoE software activities and their relevance for ASCI such as POET, Overture and other components of the DoE2000/ACTS/SciTL frameworks.
In particular, we will continue our collaboration with Dennis Gannon on HPC++/Tulip and their integration with CORBA/Java commodity componentware.
We also intend to interact with ASCI developers within several public national forums led by NPAC such as HPJava or GEM/NSF S&T, or involving NPAC participation such as NCSA Team B or HPCMP forums.
References
[1] D. Bhatia, V. Burzevski, M. Camuseva, G. C. Fox, W. Furmanski and G. Premchandran, "WebFlow - a visual programming paradigm for Web/Java based coarse grain distributed computing", Concurrency: Practice and Experience, Vol. 9 (6), pp. 555-577, June 1997. See also WebFlow Home Page at NPAC: http://osprey7.npac.syr.edu:1998/iwt98/products/webflow.
[2] R. Orfali and D. Harkey, Client/Server Programming with Java and CORBA, Wiley 1997.
[3] I. Foster and C. Kesselman, "Globus: A Metacomputing Infrastructure Toolkit", International Journal of Super computing Applications, 1997. See also Globus Home Page: http://www.globus.org.
[4] T. J. Williams, J.V.W. Reynders and W.F. Humphrey, "POOMA User Guide", Advanced Computing Laboratory in Los Alamos, April 1997. See also POOMA Home Page at Los Alamos: http://www.lanl.gov/pooma
[5] W. Gropp, E. Lusk and A. Skjellum, Using MPI: Portable Parallel Programming with the Message Passing Interface, MIT Press, 1995.
[6] A. Grimshaw and W. Wolf, "Legion - a view from 50,000 feet", in Proc. 5th IEEE Symp. on High Performance Distributed Computing, IEEE Computer Society Press, 1066, pp. 89-99.
[7] G. Fox, W. Furmanski and S. Pallickara, "Building Distributed Systems on the Pragmatic Object Web", book in progress, http://www.npac.syr.edu/users/shrideep/book/
[8] G. Fox and W. Furmanski, "HPcc as High Performance Commodity Computing", book chapter for the "Building National Grid" book by I. Foster and C. Kesselman, http://www.npac.syr.edu/users/gcf/HPcc/HPcc.html
[9] GEM Proposal Home Page http://www.npac.syr.edu/projects/gem
[10] WebHLA Home Page http://osprey7.npac.syr.edu:1998/iwt98/projects/webhla
[11] (J)WORB Project Home Page http://osprey7.npac.syr.edu:1998/iwt98/projects/worb
[12] TVR Project Home Page http://osprey7.npac.syr.edu:1998/iwt98/projects/tvr
[13] CORBA - OMG Home Page http://www.omg.org
[14] COM Home Page http://www.microsoft.com/com
[15] Enterprise JavaBeans http://java.sun.com/products/ejb/
[16] UML Home Page http://www.rational.com/uml
Project Team Describe experience of Fox Furmanski Haupt. So mention DoE C3P, CRPC, PCRC and "Java for Computational Science" effort. Describe WebFlow funded by DoE and extended via Rome Laboratory Mention pioneer courses prepare students and see book "Pragmatic Object Web" Can use one paragraph in my standard CV here and remove in CV section. CV location sent to you.
Computational Requirements At NPAC, we are expanding our modern SUN cluster which is an interesting mix of Ultra 2 based compute and database systems. This cluster (currently 8 ATM linked 2 processor Ultra2's) will become a Globus node. It is linked to an NT cluster running MPI and WebFlow which has 1 2 and 4 processor nodes.
Institutional Facilities Here say we will use NCSA and Globus (actually GUSTO) large scale capabilities. These probably include other DoE sites (find out).
Leverage WebFlow and DARP as input. We will be able to provide some leverage in this base technology development tasks coming from related NPAC projects such as: a) NCSA Alliance Team B where we deliver WebFlow for NCSA users and we explore its integration with Globus; b) DoD Modernization Program where we explore WebFlow for building visual simulation tools and Java/CORBA based Run-Time Infrastructure (RTI) within the new High Level Architecture (HLA) standard for Defence Modeling and Simulation; c) Industry outreach projects where we work both with IBM and with small business on CORBA based scalable collaboratory/televirtual environments.
Curriculum Vitae [1 page/person, 4-5 refs only]
Geofrey Charles Fox
gcf@nova.npac.syr.edu , http://www.npac.syr.edu,
Phone: (315) 443-2163, Fax: (315) 443-4741
Citizen Status: Permanent Resident Alien; Citizen of United Kingdom
Education:
B.A. in Mathematics from Cambridge Univ., Cambridge, England (1961-1964)
Ph.D. in Theoretical Physics from Cambridge University (1964-1967)
M.A. from Cambridge University (1968)
Professional Experience:
1990- Professor of Computer Science, Syracuse University
1990- Professor of Physics, Syracuse University
1990- Director of Northeast Parallel Architectures Center
1979-1990 Professor of Physics, California Inst. of Tech.
1986-1988 Associate Provost for Computing, California Inst. of Tech.
1983-1985 Dean for Educational Computing, California Inst. of Tech.
1981-1983 Executive Officer of Physics, California Inst. of Tech.
1974-1979 Associate Professor of Physics, California Inst. of Tech.
1971-1974 Assistant Professor of Physics, California Inst. of Tech.
1970-1971 Millikan Research Fellow in Theoretical Physics, Caltech
1970 Visiting Scientist (April-May), Brookhaven National Laboratory
1969-1970 Research Fellow at Peterhouse College, Cavendish Lab.,Cambridge
1968-1969 Research Scientist, Lawrence Berkeley Lab., Berkeley, Calif.
1967-1968 Member of School of Natural Science, Inst. for Advanced Study,
Princeton, New Jersey
Awards and Honors
Senior Wrangler, Part III Mathematics, Cambridge (1964)
Alfred P. Sloan Foundation Fellowship (1973-75)
Fellow of the American Physical Society (1990)
Journal Editorships
Principal: Concurrency: Practice and Experience (John Wiley, Inc.)
Physics and Computers (International Journal of Modern
Physics C - World Scientific)
Associate: Journal of Supercomputing,
Selected List of Publications - Geoffrey C. Fox
1. Fox, G.C., Johnson, M.A., Lyzenga, G.A., Otto, S.W., Salmon,
J.K., Walker, D.W., Solving Problems on Concurrent Processors, Vol. 1,
Prentice-Hall, Inc. 1988; Vol. 2, 1990.
2. Fox, G. C., Messina, P., Williams, R., Parallel Computing
Works!, Morgan Kaufmann, San Mateo Ca, 1994.
3. Fox G.C., Furmanski W., "Computing on the Web,New Approaches
to Parallel Processing,Petaop and Exaop Performance in the Year 2007
IEEE Internet Computing 39-46 March/April 1997
4. Fox G.C., Podgorny M, Cheng G. et al., "Web Technologies for
Collaborative Visualization and Simulation",
SIAM Parallel Processing Conference, March 1997
5. Fox G.C., Dincer K.,"Using Java and JavaScript in the Virtual
Programming Laboratory: A Web-Based Parallel Programming Environment"
Special Issue on Java, Concurrency:Practice and Experience 9:6 485-508, 1997.
Summary of Interests
See: http://www.npac.syr.edu
Fox is an internationally recognized expert in the use of parallel
architectures and the development of concurrent software and
algorithms. His activities include high performance Java and Fortran
compilers and their runtime support. Fox has established a community
activity to investigate value of Java in large scale networked
computing. He is also a leading proponent for the development of
computational science as an academic discipline and a scientific
method. He has established at Syracuse University both graduate and
undergraduate programs which cover both simulation and information
technologies. All course have been made available on the Web and his
research includes HPCC technology to support education at both K-12 and
University level. His research on parallel computing has focused on
development and use of this technology to solve large scale
computational problems with recent application foci including numerical
relativity, earthquake prediction and financial modeling. Fox directs
InfoMall, which is focused on accelerating the introduction of high
speed communications and parallel computing into New York State
industry and developing the corresponding software and systems
industry. Much of this activity is in educational area where Fox is
leading developments of new K-12 curricula material built using VRML,
Java and other new technology. A recent set of activities center on Web
collaboration technology and its application to synchronous distance
education
Wojtek Furmanski
Wojtek Furmanski is Research Professor of Physics and Chief Technologist of NPAC. In his Theoretical Physics PhD and the following postdoctoral research, conducted in Cracow Poland, CERN Geneva, DESY Hamburg, Orsay Paris and Caltech, he developed diagrammatic techniques for systematic analysis of scaling violation in QCD beyond leading order and performed the first complete calculation for the two loop parton densities. This work is now a standard reference in high energy physics. At Caltech, he joined the Caltech Concurrent Computation Program and he conducted research on optimal collective communication algorithms for parallel machines. He was also a member of the Computation and Neural Systems (CNS) program at Caltech where he conducted multidisciplinary research on use of neural networks for load balancing parallel computation, on use of parallel processing for neurophysiological simulations of cortex and on multigrid algorithms for early vision. He also started at Caltech the development of the MOVIE (Multitasking Object-oriented Visual Interactive Environment) System, used for the GIS (terrain image understanding) applications for the U.S. Army and as the backend support for High Performance Fortran Interpreter. Current work pursued by Furmanski and his research group IWT (Interactive Web Technologies) at the Northeast Parallel Architectures Center and the CASE Center at Syracuse University is focused on integrating previous MOVIE ideas with the current Web/commodity technologies and developing a next generation environment for multi-server and multi-user scalable interactive Internet services called HyperWorld. The first set of prototypes in this area, WebTools developed in '94 are being now productized and new prototypes are under development in the area of Web/Java/CORBA/COM based distributed computing (WebVM, WebFlow, JWORB), collaboratory (WebSpace), wargaming (WebHLA), televirtuality (TVR) and telemedicine (CareWeb). Furmanski also founded recently a Web/commodity software development company - Translet, Inc. - currently focused on custom community network environments or HyperWorld instances for distance education, telemedicine and Internet gaming. Address: Wojtek Furmanski Research Professor, Department of Physics Chief Technologist, NPAC President, Translet, Inc. 201 Physics Building, Syracuse University Syracuse, NY 13244--1130 (315) 443--3891, furm@npac.syr.edu Education: PhD, 1978, Theoretical Physics, Jagellonian University, Cracow, Poland. Habilitation, 1981, Theoretical Physics, Jagellonian University, Cracow, Poland Employment: President, Translet, Inc., 1996 -- NPAC Chief Technologist, Syracuse University, 1996 -- Research Professor in Physics, Syracuse University, 1990 -- Member of Professional Staff, Caltech Concurrent Computation Program, 1986 --- 1990. Senior Research Fellow, Caltech, High Energy Physics, 1983 --- 1986. CRNS Research Fellow, Orsay University, LPTHE, Paris, France, 1982 --- 1983. Scientific Associate, CERN/TH and Geneva University, Geneva, Switzerland, 1981 --- 1982. Assistant Professor, Jagellonian University, Cracow, Poland, 1979 --- 1981. Scientific Associate, CERN/TH, Geneva, Switzerland, 1978 --- 1979. Assistant, Theoretical Physics, Jagellonian University, Cracow, Poland. Selected Publications W. Furmanski and R. Petronzio, "Lepton-hadron processes beyond leading order in Quantum Chromodynamics", Zeit. Phys. C11--293, 1982. G. C. Fox and W. Furmanski, "The physical structure of concurrent problems and concurrent computers", Phil. Trans. R. Soc. Lond. A, Vol. 326, 411 (1988), also in Scientific Applications of Multiprocessors, edited by R. J. Elliot and C. A. R. Hoare, Prentice Hall (1988), 55. M.E.Nelson, W. Furmanski and J.Bower, "Simulating Neurons and Networks on Parallel Computers", in Methods in Neural Modeling: From Synapses to Networks, edited by C. Koch and I. Segev, MIT Press, Cambridge (1989), 397--437. W. Furmanski, "MOVIE --- Multitasking Object-oriented Visual Interactive Environment", in Fox, G.C., Messina, P., Williams, R., editors, Parallel Computing Works, Morgan and Kaufman 1993. Furmanski, W., "Supercomputing and VR Networking", paper presented at the Meckler Conference Virtual Reality '93, San Jose, CA, May 19--21, 1993. D. Bhatia, V. Burzevski, M. Camuseva, G. C. Fox, W. Furmanski and G. Premchandran, "WebFlow - a visual programming paradigm for Web/Java based coarse grain distributed computing", Concurrency: Practice and Experience, Vol. 9 (6), pp. 555-577, June 1997.
Tom Haupt