There is not now nor will there be a single software paradigm that applies to all parallel applications. The previous chapters have shown one surprising fact. At least 90% of all scientific and engineering computations can be supported by loosely synchronous message-passing systems, such as CrOS (Express) at a low level and data-parallel languages such as High Performance Fortran at a higher and somewhat less general level. The following chapters contain several different software approaches that sometimes are alternatives for synchronous and loosely synchronous problems, and sometimes are designed to tackle more general applications.
Figures 3.11(a) and 3.11(b) illustrate two compound problem architectures-one of which the battle management simulation of Figure 3.11(b) is discussed in detail in Sections 18.3 and 18.4. MOVIE, discussed in Chapter 17, and the more ad hoc heterogeneous software approach described in Section 18.3 are designed as ``software glue'' to integrate many disparate interconnected modules. Each module may itself be data-parallel. The application of Figure 3.11(b) involves signal processing, for which data parallelism is natural, and linking of satellites, for which a message-passing system is natural. The integration needed in Figure 3.11(a) is of different modules of a complex design and simulation environment-such as that for a new aircraft or automobile described in Chapter 19. We redraw the application of Figure 3.11(a) in Figure 15.1 to indicate that one can view the software infrastructure in this case as forming a software ``bus'' or backbone into which one can ``plug'' application modules. This software integration naturally involves an interplay between parallel and distributed computing. This is graphically shown in Figure 15.2, which redisplays Figures 3.10 and 3.11(a) to better indicate the analogy between a software network (bus) and a heterogeneous computer network. The concept of metacomputer has been coined to describe the integration of a heterogeneous computer network to perform as a single system. Thus, we can term the systems in Chapter 17 and Section 18.3 as metasoftware systems, and so on, software for implementing metaproblems on metacomputers.
Figure 15.1: General Software Structure for Multidisciplinary Analysis and
Design
Figure: The Mapping of Heterogeneous Problems onto Heterogeneous
Computer Systems combining Figure 3.10 and
Figure 3.11(a).
The discussion in Chapter 16 shows how different starting points can lead to similar results. Express, discussed in Chapter 5, can be viewed as a flexible (asynchronous) evolution of the original (loosely) synchronous CrOS message-passing system. Zipcode, described in Chapter 16, starts with a basic asynchronous model but builds on top of it the structure necessary to efficiently represent loosely synchronous and synchronous problems.
MOOSE, described in the following section, was in some sense a dead
end, but the lessons learned helped the evolution of our later
software as described in Chapter 5. MOOSE was designed to
replace CrOS but users found it unnecessarily powerful for the
relatively simple (loosely) synchronous problems being tackled by
C
P at the time.
The Time Warp operating system described briefly in Section 15.3
is an important software approach to the very difficult asynchronous
event-driven simulations described in Section 14.1. The
simulations described in Section 18.3 also used this
software approach combined in a heterogeneous environment with our fast,
loosely synchronous system CrOS. This illustrates the need for and
effectiveness of software designed to support a focussed subclass of
problems. The evolution of software support for asynchronous problems
would seem to need a classification with the complete asynchronous
class divided into subclasses for which one can separately generate
appropriate support. The discussions of Sections 14.2,
14.3, 15.2, 15.3, and 18.3 represent
C
P's contributions to this isolation of subclasses with their
needed software. Chapters 16 and 17 represent a
somewhat different approach in developing general software frameworks
which can be tailored to each problem class.