Communication performance is a critical aspect of the performance of many high-performance systems. Indeed, a distinguishing feature between distributed and high-performance parallel computation is the bandwidth and latency of communication. In this section, we present an example of how high-performance communication mechanisms can be integrated into a commodity three-tier computing system.
The example we consider is a multidisciplinary simulation. As
discussed in Chapter 
, multidisciplinary applications
typically involve the linkage of two or more modules--say,
computational fluid dynamics and structures applications--into=20
a single simulation. We can assume that simulation components
are individually parallel.
As an initial approach, one could view the linkage between components sequentially, with the middle tier coordinating the movement of data from one simulation component to the other at every step in the simulation. If higher performance is required, one may need to link the components directly, using a high-performance communication mechanism such as the Message Passing Interface (MPI) []. The connections between modules can be set up by a middle-tier service (such as WebFlow or JavaBeans); then, two third-tier modules can communicate to one another without intervention of the middle-tier service. Control flow returns to the middle tier when the simulation is complete.
A third possibility is to keep the control function within the middle tier, setting up high-performance connections between the two modules and initiating data transfer at every step in the simulation. Unlike the first scenario we considered, the actual transfer of data between modules would take place using the high-performance interface, not through the middle tier. This alternative preserves the advantages of both approaches, using the commodity protocols and services of the three-tier architecture for all user-visible control functions while exploiting the performance of high-performance software only where necessary.
A key element of this example is the structure of the middle-tier
service. One approach would be to use JavaBeans (see
Chapter ) as the vehicle for integrating the
individual simulation components. In the JavaBeans model, there is a
separation of control (handshake) and implementation. This separation
makes it possible to create JavaBeans ``lister objects'' that reside
in the middle tier and act as a bridge between a source and sink of
data. The lister object can decide whether high performance is
necessary or possible and invoke the specialized high-performance
layer. As discussed above, this approach can be used to advantage in
runtime compilation and resource management, with execution schedules
and control logic in the middle tier and high-performance
communication libraries implementing the determined data movement.
This approach can also be used to provide parallel I/O and
high-performance CORBA.