Component Architectures for High Performance, Distributed Meta-Computing.

Dennis Gannon, Dept. of Computer Science, Indiana University (


The design of the current generation of desktop software technology differs from past generations in one fundamental way. The new paradigm states that applications should be built by composing "off the shelf" components, much the same way that hardware designers build systems from integrated circuits. Furthermore, these components may be distributed across a wide area network of compute and data servers. Components are defined by the public interfaces that specify function as well as the protocols with which they may use to communicate other components. An application program in this model becomes a dynamic network of communicating objects. This basic distributed object design philosophy is having a profound impact on all aspects of information processing technology. We are already seeing a shift in the software industry toward investment in software components and away from hand-crafted, stand-along applications. And, within the industry, a technology war is being waged over the design of the component composition architecture.

High performance computing will not be immune from this paradigm shift. More specifically, as our current and future Internet continues to scale in both size and bandwidth, it is not unrealistic to think about applications that might incorporate 10,000 active components that are distributed over that many compute hosts. Furthermore, pressure from the desktop software industry will compel us to integrate the applications that run on supercomputer systems into distributed problem solving environments that use object technology. Metacomputing systems consisting of MPP servers, advanced, networked instruments, database servers and gigabit networks will require a robust and scalable object model that support high performance application design.

In this position paper, we describe the important characteristics of high performance, "Metacomputing" applications that arise in large scale science and engineering computation. We will then describe the limitations of some of the current component architectures based on CORBA, ActiveX, and Java Beans/Studio when applied to this class of problem. We conclude with a series of suggestions for building a more robust component model that will scale to the application described here.

Three Application Scenarios for High Performance Computing.

Example 1. Distributed Algorithm Design

Component architectures have been in use in the scientific programming community for about seven years. In most cases, these systems have been used for specialized tasks such as composing scientific tools from algorithmic components. One of the best examples is AVS and NAG Explorer. Designed to simplify the process of building scientific visualization applications, AVS and Explorer use a component model to allow users to compose the the visualization systems from components that included image analysis tools, filters and geometric transformations, and rendering modules. These early systems allowed a limited form of distributed computation, but were primarily limited by their closed architecture and their lack of an object model flexible enough to include user defined data types as part of the message stream.   A more modern approach to image analysis and visualization component architectures can be seen in the Utah SciRun system and the SoftLSI prototype from Fujitsu.

The Linear System Analyzer (LSA) designed by Bramley, et. al. is one such experimental component architecture. LSA was built to simplify the process of solving large sparse systems of linear equations. While many may consider the task of solving matrix equations to be a "solved problem", nothing could be further from the truth. This job remains one of the most difficult problems in most large scale scientific simulation. Bramley observed that the problem can be decomposed into the following steps

LSA provides a library of components that implement these steps in the solution process. By connecting a matrix analysis component to a preconditioner which is connected to an iterative solver and a solution extractor, the user can build a custom solver for the problem at hand. The components can be linked together to form a single library which can be added to a larger application. However, it may be the case the the best solver may be located on a specific remote parallel machine, or the problem is so large that it can only be done on a remote machine with a very large memory. Consequently, LSA allows components to be placed on remote machines by assigning a host IP address to that component. The underlying component container architecture works with the grid scheduler to make sure that the component is initialized and running at that location.

Requirements imposed on the component system.

The LSA and other distributed algorithm systems impose special requirements that are not part of the conventional desktop software component model.

Example 2. Tele-Immersive Collaborative Design

Consider the following problem. A car company uses collaborative design to reduce costs and time in new product design. For each new car, there is a master design database at the main factory and each subcontractor maintains a separate design database with details about the components they supply. Some of the information in the subcontractor database is proprietary and does not appear in the master design database. However it possible for the master design database to extract any required performance information from the subcontract by means of simple RPC transactions. These performance responses can be used to drive a simulation of the car that runs on a remote supercomputer at the company headquarters. The simulation results can be transmitted to Tele-Immersive (T-I) systems such as a CAVE or Immersadesk at the main facility and at the subcontractors over a high bandwidth network. What is displayed in the T-I environment is the car responding to a virtual environment under the control of the T-I users.

Suppose the designers want to see the effect of changing the engine design on the car handling performance. The main designers ask engine builder to update their database with a different model of the engine. A virtual mountain road scenario is loaded into the T-I environments and is used to drive the simulation. The designers interactively experiment with the handling characteristics of the simulated vehicle. The components of the system are

Requirements imposed on the component system.

The most important aspect of this application is the dependence upon managing bandwidth so that real-time performance is possible. This is made more complex by the need to manage many different types of data streams between components. Currently real-time CORBA implementations are being investigated in the research community \cite{schmidt}, but the standard implementations of CORBA, DCOM (ActiveX) and Java communication mechanisms would be insufficient for this application. The object architecture must provide a mechanism where performance constraints and QoS mechanisms can be associated with the logical data paths between component ports.

In addition, support in the object model for multi-cast communication is very important. While it is likely we will see extensions of Java RMI to multi-cast, it is not part of the CORBA or ActiveX model.

Example 3. The Digital Sky Survey

The Digital Sky Survey project illustrates a different set of distributed object examples. The survey will consist of multiple databases consisting of many billions of meta-data objects that each describe some visible object such as a star or galaxy. Each of these meta-data objects is linked to a digital image in the archival system, and the collection of meta-data objects is organized as relational database. In addition to a reference to the image object in the archive, each of the meta-data objects contains basic reference information and a list of data extraction methods that can be applied to the image object.

A scientist at some remote location may decide to search for all galaxies that exhibit some important set of properties. Some of the properties may relate to information stored as part of the meta-data but some of it may require an analysis of stored images. Formulated as a database query, the request is sent to the database. The set of objects that satisfy the conditions associated with the meta-data can be extracted. Then for each of these objects, a request can be sent to the data archive to apply the remaining tests to the images. This is a data parallel operation that results in a references to the subset of galaxies that satisfy all conditions. It may also be the case that the result of this query must be used as part of a second query submitted to another remote sky survey repository. This may involve the transmission of a large stream of data from the first repository host to the second.

The components of the solution process are the relational databases and the repositories. To set up a complex analysis of the data two or more components may need to be connected by a high bandwidth link. The information that is communicated between components consist of image objects, object references, meta-data information and relational data base queries.

Requirements imposed on the component system.

While many of the problems associated to this application can be found in the previous two, there are also some unique features to this problem.

The first of these involves the extensive use of database technology. While there is a Java database interface standard, it may not scale to the problems described here. In particular, the interaction between the object relational database and image archive require the implementation of the data-parallel remote method invocation described above.

The second problem is related to the communication that must take between components with parallel implementations. The existing commercial technologies would require that a single logical channel would be implemented as a single network stream connection. However, if both components have parallel implementations, then it may be possible to implement the communication as a set of parallel communication streams. Pardis, a parallel implementation and extension of CORBA, is one example system that supports this feature. Pardis demonstrates that it is possible to significantly improve the utilization of network bandwidth by providing parallel streams to implement remote method calls.

Component Systems and Object Technology

Object oriented software design principles are only the first step in building the next generation of metacomputing applications. As the desktop software industry has learned, it is also necessary to define what it means for an instance of an object class to become a component in a distributed system. A precise definition of component depends upon the environment in which the component is used. This environment defines the component architecture which prescribes the required features that a component must support so that the may be composed into functioning applications.

The way in which a component presents a visual interface (if it has one) and responds to events and communicates with other components is defined by the component architecture. The three most important commercial component architectures are Microsoft ActiveX, OMG's CORBA/OpenDoc and Java Beans and Java Studio. However, because our interest is metacomputing systems and not graphical user interfaces, we will focus here on the aspects of component systems that describe the composition and communication behavior of most component architectures.

There are two common models of component integration

In addition to this data stream style communication that takes place between object ports, there are two other standard forms of communication that components systems use. The Java Bean and Java Studio systems from Sun follow this model very closely.. Other commercial systems that are based on this architecture include AVS and its descendent NAG Explorer which are used to build visualization tools from components. Unfortunately, Explorer has a very limited and inflexible type system which limits it extensibility to larger distributed applications. The CORBA based OpenDoc system uses a similar object model.

The final piece of a component system architecture that distinguishes it from other types software infrastructures is the concept of a component container framework. The container is the application that runs on the users workstation that is used to select components, connect them together and respond to many of the event messages. The container uses the control interface of each component to discover its properties and initialize it.

Microsoft Internet Explorer is an example of a component container for ActiveX. Java Studio provides a graphical user interface for composing and connecting component that is very similar to the layout system used by Explorer and other component breadboards. We shall return to more of the technical requirements for high performance components and container frameworks later in this chapter.

Component Framework Requirements for Grid Applications

To accomplish the task of building component based, high performance application, we must solve certain additional problems. First, the objects in the framework need to know about each other in order to be able to transmit the data and member function messages as indicated. For example, the CAD database may be located in one city and the flow simulation may be running on a parallel processing system in another location. Furthermore, the visualization system may be an immersive environment like a CAVE in another facility. Also, some objects may be persistent such as the design data base, while other objects, such as the grid generation filter, may exist only for the duration of our computation.

One solution would be to use a visual programming system that allows a user to draw the application component graph. NAG Explorer uses this technique. The LSA example described above and Java Studio also use this graphical model Unfortunately NAG's type system is not very rich and it is not clear that graphical composition tools will scale to the networks of more than a few dozen objects. We would also like to describe networks that are dynamic and are able to incorporate new component resources ``on the fly'' as they are discovered.

Systems like Explorer and the current SciRun used a fixed type system. However, most distributed object systems allow arbitrary user defined types to be transmitted over the channels between components. A system must know how to transmit application specific objects over the network. This is called the {\em serialization} problem and a solution to it requires a protocol for packing and unpacking the components of data structures so that they may be reliably transmitted between different computer architectures in a heterogeneous environment. The traditional solution is to use an Interface Definition Language (IDL) to describe the types of the objects being transmitted. IDL is a simple C++ like language for describing structures and interfaces. It was first used in the DCE infrastructure. The DCE IDL was adopted and extended for use in Microsoft DCOM and CORBA. The CORBA extension is the most complete and it is used as the foundation of the specification of the entire CORBA system. Java RMI, on the other hand, is a strictly Java-to-Java communication model, so Java serves as its own IDL. However, there is now a Java-to-HPC++ link that uses a combination of IDL and Java RMI, and JavaSoft has agreed to re-implement RMI so that it runs over the CORBA communication protocol known as IIOP.

One of the most persistent problems with the existing commercial technologies is the poor performance of serialization and communication. The Java Remote Method Invocation (RMI) provides the most sophisticated serialization model, but the performance is several orders of magnitude below the requirements of the Grid applications described above.

The Agile Objects project at the University of Illinois is exploring techniques for high performance implementation of component object standard interfaces and protocols which focus on lowering the cost of crossing component boundaries (lower invocation overhead) and reducing the latency of a remote procedure call (lower invocation latency). In particular, these efforts are focusing on DCOM and Java RMI invocation mechanisms and build on technologies from the Illinois Concert runtime which executes RPC and message calls in 10 to 20 microseconds within a cluster of workstations. In addition, the WUSL real-time CORBA work and the Indiana JAVA RMI-Nexus projects are addressing the same problem in the case of heterogeneous environments.

Most good object oriented systems must also include central mechanisms for the following additional problems.

In the proceeding pages we have attempted to outline many of the technical problems that are associated with extending contemporary component and distributed object technology to the applications that will run on the emerging high performance meta computing grid. While the challenges are great, they are not insurmountable. With a coordinated effort, it should be possible to build an application-level framework for a distributed component architecture that will be suitable for these applications and also interoperate with the emerging standards for desktop software. However, without true interoperability, there is little hope that a substantial software industry will emerge from the high end of scientific and engineering problem solving.