Integration of collaborative multi-discipline applications in high-performance metacomputing environments

Toan Nguyen, Christine Plumejeaud

Project SINUS
INRIA Rhône-Alpes
655, Av. de l’Europe
38334 Saint-Ismier Cedex

e-mail :

Phone : +33 4 76 61 52 40


Simulation and optimisation applications are a challenge to both numerical analycists and computer scientists. They involve a large variety of codes that result in high CPU loads on existing computer systems. Advances in both hardware and software, including massively parallel computers, PC-clusters and parallel programming languages somewhat alleviate current performance penalties. With the rising complexity of multi-discipline applications, and particularly simulation and optimisation problems, new advances in information technology are required to integrate smoothly high performance computing and complex application software. It is the claim of this paper that formal specification techniques, together with distributed integration platforms, provide a sound and efficient support for high performance distributed computing in metacomputing environments. On the one hand, formal specifications provide rigourous and provable approaches for complex applications definition and configuration. On the other hand, integration platforms provide standardised deployment and execution environments for coupling heterogeneous codes that are distributed on PC-clusters, NOW, LAN and WAN. This lays the grounds for sophisticated problem-solving environments supporting collaborative multi-discipline applications.

Key-words : collaborative applications, simulation, optimisation, code-coupling, formal specifications, process algebrae , distributed computing, parallel computing, metacomputing, CORBA.

1. Introduction

Simulation and optimisation applications, e.g., as used for digital mockups in aerospace design, raise important challenges to the computer science community [KEA99]. They require powerful and sophisticated computing environments, e.g., parallel computers, PC-clusters. They also require efficient communication software, e.g., message passing protocols [KES99].

Although these problems are not new, they have given rise to specific solutions that have become de-facto standard, e.g., MPI and PVM [MPI, PVM].

Simultaneously, computer science has provided interesting solutions to the problems of :

• formal specification of distributed and communicating systems

• standardized exchange and development environments for distributed applications

This paper explores the design and implementation of an integration platform which is a computerised environment dedicated to the specification, configuration, deployment and execution of collaborative multi-discipline optimisation applications. Such applications may invoke a variety of software components from various disciplines that are connected together to collaborate on common projects.

By collaborative applications, we mean applications involving distributed software, called here ‘tasks’, interacting dynamically in a controlled and formally provable way.

By specification, we mean the formal definition of the tasks’ interactions using an algebraic formalism, e.g., the SCCS process algebra [MIL83]. This includes the tasks’ data exchanges, as well as their synchronisation and control flow.

By configuration, we mean the mapping of the above tasks’ formal specfications to actual software components, hereafter called ‘modules’ or ‘codes’.

By deployment, we mean the allocation of the various modules to specific distributed hardware.

By execution, we mean the triggering of the various modules on the dedicated hardware, producing the applications’ results.

The paper is based on examples drawn from formal specification techniques for the definition of complex applications involving simultaneously different disciplines in aerospace design, e.g., aerodynamics using computional fluid dynamics and structural airframe design. It includes application deployment and execution, based on distributed object-oriented software and heterogeneous components programming for complex engineering design, i.e. CORBA.

This work led to the development of an integration platform called CAST (an acronym for " Collaborative Applications Specification Tool ") allowing the execution of test-cases for aerodynamic design in the aerospace industry. The platform is based on an high-level graphic user interface (Figure 2) allowing the formal specification of optimisation applications, based on the work of Milner’s process communication algebra SCCS [MIL83].

It is implemented on a network of workstations (NOW) and PC-clusters communicating through a CORBA object request broker [ORB98].

Current work includes the integration of parallel codes and the interface with existing commercial mathematical libraries.

This was developed in part for a european Esprit HPCN project, called " DECISION " : Integrated Optimisation Strategies for Increased Engineering Design Complexity .

In this paper, we use the terms ‘modules’ and ‘codes’ as synonyms to designate the applications’ run-time components. They implement what are refered to as the ‘tasks’, which are the applications’ high-level specification components. They are eventually mapped to the above run-time components during the configuration phase of the applications.

The paper is organised as follows. Section 2 is an overview of current specification approaches for distributed applications. Section 3 is an overview of multi-discipline optimisation problems. Section 4 is a detailed overview of the CAST integration platform developed for multi-discipline collaborative applcations, including example test-cases and future work. Section 5 is a comparison with similar approaches and projects. Section 6 is a conclusion.

2. Specifying distributed applications

2.1 Dataflow approaches

Dataflow modeling has been used for a long time in business processing, process modeling and requirements engineering [DAT]. It is used primarily to specify the input and output data for specific tasks which are connected together in a time-scalable diagram.

Underlying this approach is however a strong programming philosophy, e.g., IRIS EXPLORER [NAG98], and a lack of formal foundations, with the notable exception of Petri-Nets [PET].

Its origins dates back to the seventies, when the distributed computing research was in its infancy. Therefore, the dataflow approach does not provide a natural way for the specification and control of distributed applications.

2.2 Workflow approaches

Workflow approaches have been used extensively for business process modeling, e.g., document processing [WOR, DOC, AND98]. A number of commercial products are available. They are based on this approach and provide a reliable environment that can be deployed in distributed computer environments. They are making their way into the engineering market, e.g. CODINE [THO99], but usually lack theoretical basis.

The main drawback of this approach is that, like most data-flow approaches, they lack sound theoretical foundations.

However, they usually take into account from the start data and application distribution on local and wide area networks (LAN, WAN).

2.3 Formal approaches : process algebras, specification systems

Simultaneously with the workflow approaches, theoretical work has been conducted for system’s software process specification, including communicating processes (CSP, SCCS [MIL83]).

This layed the basis for the formal specification of communicating systems, in particular message handling and communication protocols.

The confluence or converging or merging of the formal specification approaches with the workflow approaches laid interesting paths to specify, configure, deploy and execute distributed applications.

With the help of communication standards and software configuration and execution standards, e.g. CORBA, all the basic bricks are now at hand to build effective distributed complex applications.

3. Specifying multi-discipline optimisation applications

3.1 Optimisation problems

Modeling physics problems with numerical methods requires good approximation methods. These approaches may incur high CPU loads for even simple problems, e.g., several hours CPU-time for 2-D airflow calculation in CFD, even on powerful workstations.

Optimisation approaches tend to accelerate convergence using specific mathematical methods. Of particular interest are currently the genetic and parallel algorithms approach [MAR98]. Genetic algorithms for example allow faster convergence because candidate solutions can be generated and processed in parallel, e.g., on CPU clusters. They are however less robust than sequential method.

A particular test-case will illustrate the following sections.

It consists in the shape optimisation for an airfoil in stationary aerodynamic conditions. The goal is to reduce the shock-wave induced drag.

Thus, two algorithms are involved. One, which computes the airflow around the airfoil, the other which optimises the airfoil’s shape.

The entry data are the airfoil shape (RAE2612), its angle of attack (2 degrees), the airflow speed (Mach 0.84) and the number of optmisation steps (100).

This problem is solved in several hours on an entry level SUN Sparc workstation running the Solaris 2.6 operating system.

Considering these CPU loads, it is clear that engineers in design bureaus seek better performance. Two approaches are currently explored :

• faster computers

• faster algorithms

The first approach is divided in turn in three ways : • faster CPUs

• parallel computers

• clusters of tightly connected CPUs

The second approach (faster algorithms) is currently based : • on genetic algorithms, where candidate solutions are randomly generated, then selected, crossed-over and merged [MAR98]

• parallel algorithms, where specific statements may be used to control grouping and the spawning of sub-processes, e.g., using MPI.

The importance of speed limitations in solution convergence cannot be over emphasised, because simulation applications such as digital mockups for aerospace design is the focus of many aircraft manufacturers in a fierce competing market.

Design bureaus therefore tend to integrate multiple discipline problem-solving techniques in their simulations, e.g., coupling aerodynamics, electromagnetics and structural design.

This is detailed in the next section (Section 3.2).

3.2 Coupled optimisation problems

Coupled optimisation problems are part of multi-discipline integrated engineering.

Their importance comes from the expected design to market time reduction and in the expected reduction in the design cycles through shorter trial and error cycles.

Coupled optimisation problems can be examplified by the aerodynamics-structure coupled optimisation in aircraft wing design. Whereas specific optimisation in the structural CSM field is well understood, as it is in CFD for aerodynamics, their coupling requires carefull attention.

It is of first importance to characterize precisely where and when should both optimisations interfere. However, this is not an obvious task because most optimiser codes have been developed independently, with no particular constraint on program cooperation. This is even the case when a solver and optimisers are coupled, because it is not often obvious how to structure the program’s main loop : should the optimiser or the solver be the master program ?

An open question for coupled optimisation problems, as well as general code-coupling environments, is the data interface between modules. It is generally the case that each module has a specific data storage and format, e.g., mesh formats. They may not all be compatible. They may also overlap in some areas. Data compatibility between codes is therefore an issue.

3.3 Distributed multi-discipline problems

Advances in engineering design makes possible the cooperation of multiple disciplines. However, interactions among various fields are still subject to adequate synchronisation rules between the participants and the consensus on appropriate data exchange formalisms. This is usually known as groupware [AND98]. It requires advanced technology for the coordination of the various agents involved in the projects (human or machine). It also requires sohpisticated negociation and communication software, as well as powerful and versatile data and knowledge modeling formalisms.

All of which are similar to the worries of part of the distributed computing field.

In fact, optimisation results can have such impacts on the simulation processes (and vice-versa) that a smart coupling can have drastic gains on project schedule for the design bureaus.

With the advent of specialised (Intranet) and general purpose computer networks (Internet), distributed computation in large-scale problems and CPU-intensive applications are factors that can contribute to better overall performance in problem solving.

Ranging from WAN to LAN, NOW and PC clusters, a variety of hardware and software configurations are now available that allow the distribution of the applications’ components.

A favorite target applicaton is here the set of applications involving multiple discipline which might collaborate through high-bandwith network to integrate their results from different locations and merge them in a single project site.

The remainder of this paper focuses on multi-discipline optimisation problems involving distributed computations on WAN, LAN, NOW and PC clusters.

4. Distributed integration platforms

4.1 Integration platforms

Research in operating systems has emphasised the advantages of software components for distributed computing [BAL98]. They allow the definition, deployment and execution of distributed applications formed by various heterogenous software modules which are not necessarily designed initially to cooperate. Further, they can reside on heterogeneous platforms provided that they communicate through a common hardware or software medium.

The advent of the object-oriented programming technology has also stressed the feasibility of a common open software environment for distributed applications.

The software modules are considered as components that can be dynamically plugged into a distributed execution platform. This requires some form of wrapping of the modules to interface the platform in a common standardised way. This is implemented in CORBA using the IDL definitions of the module interfaces.

Among the advantages of this approach is the ability to operate heterogeneous software in a unified way on heterogeneous hardware. This is an add-on to modularity exemplified by object-oriented languages and software development.

Further, it allows the decoupling of the software interface from their implementations. Thus dynamic changes in the software implementations are possible without impacting on the other applications’ components using them.

This approach is behind the current trend in distributed computing, examplified by the OMG, where components can be dynamically plugged into the distributed execution environment.

The requirements for this approach to be implemented is the ability to define an adequate formalism for data exchage and component synchronisation. This uses the remote synchronous method invocation in CORBA for instance, or more sophisticated multi-threaded request processing. It also uses interface repositories to store and publish objects that can be remotely accessed.

It must be emphasised here that the main forward step permitted by object-oriented approaches to distributed computing is the transparent use of distributed software par the casual users and experts users of the design applications.

Figure 1. CAST : plugging-in solvers and optimisers.

The idiosyncracies of the data and module distribution is left to the software developers. This is in constrast with dedicated standards that are used for parallel programming, e.g., MPI. Here, the developers must code inside the modules the grouping and spawning of the executing processes. The actual code is therefore mixed with distribution statements.

This is not the case with environments where modularity and transparent distribution is supported, e.g., CORBA. There, the users’ code can be used as is, without any modification. This is examplified in the following sections by the airfoil optimisation example, where the CFD solver and shape optimiser are used unmodified through the CAST platform using CORBA.

Therefore, using specialised communication standards like MPI implies that the applications’ developers code them inside the user modules.

But using general purpose communication standards like CORBA only implies that the systems’ developers program the interface of the users’ code to CORBA, not the applications’ developers. This is done without any modifications of the users’ code.

4.2 A Distributed integration platform for multi-discipline collaborative applications

4.2.1 Principles

CAST is an integration platform designed to fulfill the requirements of distributed optimisation applications in complex engineering design projects.

Example applications are industrial projects in the aerospace industry, in particular concerning multi-discipline optimisation, e.g., coupled aerodynamics, structure, acoustics and electromagnetics optimisation.

The target user population includes project managers and engineers that are experts in their particular domain, i.e., electromagnetics, aerodynamics. They are well aware of computer technology, but not necessarily experts in formal process specifications, theoretical computational mathematics, nor object-oriented, CORBA and components programming.

This constrains the integration platform to provide a high-level user interface, with no exotic idiosyncracies related to process algebras and distributed computing.

The fundamentals of the platform are therefore :

The platform supports the definition, configuration, deployment and execution of multi-discipline applications distributed over NOW, LAN, WAN and PC clusters.

They are formed by collaborating modules which may run on heterogeneous computers. The modules may be implemented using various programming languages and they dynamically exchange data.

They are synchronised by user-specified plans which include sequences, embedded and interleaved loops, and fork operators. These synchronisation operators are components of a process algebra which is primarily based on Milner’s SCCS algebra [MIL83].

This provides a sound and theoretical background on which to rely in order to formally specify, prove and verify the application processes.

Figure 2. CAST : the user interface.

For instance, the formal specification of the above HBCGA (Hybrid Binary Coded Genetic Algorithm) example produces the following SCCS formula :


where BCGA, FUN, HYBRID and the various INIT modules are connected by the loop operator, depicted by ‘=>’, the sequence operator ‘ :’ and the choice operator ‘+’. Other operators are available, including the synchronisation of tasks ‘&’ and the parallelisation operator ‘/’.

Note that this example involves two embedded loops and two interleaved loops.

The SCCS formula is produced automatically by CAST 2.0 from the application’s graphic specification. It is used internally to generate the adequate distributed execution structure.

Note that the target end-users are never required to know the SCCS or any process algebra. The integration platform provides a high-level icon-based interface to the users which can invoke simulation, verification, configuration, deployment and execution tools (Figure 2).

Further, the platform fully supports the integration of distributed modules over heterogeneous networks of computers. It provides a transparent disributed execution environment that complies with the CORBA 2.0 specification from the OMG [OMG98].

As a bonus to potential customers, the platform supports as well the coupling of non-CORBA compliant modules with CORBA-compliant modules altogether.

This is a contributing factor for a smooth transition from existing software and mathematics libraries to state-of-the-art distributed software technology. It clearly preserves the users investments in specialised software, allowing seemless upgrades to recent computer technology while fertilising older investments.

Hardware configurations are uniformly supported, i.e., workstations, PC-clusters and computers connected through NOW, LAN, WAN are transparently supported through the definition of execution locations for the user modules.

4.2.2 Specification of complex applications

The benefit gained from using process algebras to define the user applications is twofold :

Although the last point is not yet implemented, it is foreseen that the introduction of verification and reduction algorithms will permit a significant gain in the integration of complex distributed applications involving a large number of modules.

Several verification techniques based on formal algebras and specification languages are already available and currently in use by the designers of real-time software and comunication protocols (LOTOS, CADP, etc). They invoke model-checking algorithms, observer techniques, which can significantly reduce the run-time errors caused by improper specifications. Their implementation in the CAST integration platform seems quite simple.

4.2.3 Implementation First phase

A demonstrator was developed during a first six months phase (April-October 1998).This preliminary Corba-compliant integration platform was demonstrated during the second DECISION project review in Sophia-Antipolis, October 1998. It relied on the ILU object request broker (ORB) from Xerox and the OLAN distributed application configuration environment [BAL98].

ILU has interesting features, including interfaces with a variety of programming languages, e.g., C, C++, Lisp, Java, Python. But inherent limitations (e.g., no interface repositories, no multi-threading) and performance penalties lead however to the replacement of these software. Second phase

The replacement by the Orbacus ORB [ORB98] from Object-Oriented Concepts, Inc. (Figure 4), a fully Corba-compliant ORB, started in November 1998. Orbacus permits a seamless integration with the C++ and Java languages. This made possible the fast implementation of the Corba version of CAST on Unix workstations.

The prototype was demonstrated in April 1999. A contributing factor was the C++ language chosen for the implementation of CAST. Based on these grounds, the upgrade to an extensive Corba-compliant integration platform, named CAST 2.0, was therefore straightforward.

The current CAST prototype is consequently a full Corba 2.0-compliant integration platorm which allows the plug-in of wrapped modules (Figure 3).

It uses the features of the CORBA standard as laid in the version 2.0 OMG specifications.

Figure 3. CAST : a full CORBA compliant integration platform.

The IDL interface definition language is used to define the user modules interfaces and generate their wrappers, stubs and skeletons. It is compiled and generates the C++ corresponding classes which are automatically included in the server and client of the CAST platform.

On the demonstrator, for the sake of simplicity, ease of maintenance and performance, no usage was made of the dynamic invocation interface and dynamic interface repository in Corba. This limited the first Corba version of CAST 2.0 to execute only existing user modules.

Figure 4. Wing shape optimisation : induced drag reduction in high-speed cruise configuration (Isomach curves).

Extensions to the platform have since been implemented to support the dynamic plug-in of solvers and optimisers to the platform. This uses the full dynamic creation and invocation capabilties of the CORBA object-request broker.

It is clear that the configuration, deployment and execution of the optimisation applications remain unchanged for the end-users and the project managers in both cases (Figure 3). Third phase

The last development phase started in January 2000. Its goal was to allow the integration of parallel codes and execution on remote PC clusters over high-speed wide-area networks. By the end of year 2000, this was operational concerning the execution of parallel codes on PC clusters.

Therefore users can now define distributed simulation and optimisation applications that involve sequential and parallel codes that cooperate. The codes run on parallel computers, NOW and PC clusters that are distributed over wide area networks. The last step which is currently being tested involves communication on high-speed Gigabits/sec networks. The transport layer is currently provided by the VTHD network from France Telecom Research, CNET and INRIA [VTH].

Interfacing existing codes that involve MPI statements with CORBA was a challenge. Various work has already been carried out concerning the integration of parallel codes in distributed computing environments and was of invaluable help for this matter. Our implementation uses the notion of " parallel CORBA objects " developed in PACO by the PARIS project at IRISA [PAR99]. Basically, a parallel CORBA object is a collection of similar objects running in parallel on a PC cluster for example. They are managed by a particular server object which interfaces with the remote clients. The parallelism is therefore transparent to the end user. This provides for the seemless integration of parallel codes, written in Fortran using MPI for example, up to the interface of the code with the parallel CORBA objects. PACO is itself built on the MICO object-request broker [MIC]. MICO has therefore become the new ORB layer used by CAST since September 2000.

The 2D wing shape optimisation example given in the previous section ( was run on a PC cluster using a parallel version of the genetic algorithm written in Fortran using MPI statements. It was made compliant with CORBA using PACO. It was run as a set of servers and a CAST client on the network. In the last implementation, there are two servers, one which is dedicated to the genetic optimisation algorithm, and the other which is dedicated to the CFD and mesh calculations.

Performance is of course in par with the parallel execution of the code on multiple processors. Figures given below provide some performance data (Table 1). The rows in the table concern parallel optimisation code executed on an entry-level mono-processor Unix workstation (node called Ships) and on PC-cluster configurations of 4 up to 40 processors. The cluster is located at INRIA Rhône-Alpes in Grenoble. Each node in the PC-cluster is a Pentium III bi-processor running Linux at 733 MHz. CPU times are in seconds.

# procs
CPU (s)

Table 1. Performance data for 2D wing shape optimisation on PC-clusters.

The next step which is to end by July 2001 involves the execution of simulation applications involving parallel visualisation software and aerodynamic optimisation of airfoils using workstations and PC clusters distributed over several sites at INRIA Rennes, INRIA Sophia-Antipolis and INRIA Rhône-Alpes.

This will provide a large scale problem –solving environment including remote and collaborative execution of parallel codes and on-line visualisation software.

4.2.4 Interface with existing software libraries

As a result of the meetings amongst the DECISION project partners, other developments have been carried out, including :

the development of the DEEP integration platform for the DECISION project

The first item includes the definition and delivery of the CAST " Specifier ", which is a stand-alone software that can be interfaced with Iris Explorer (see Section 2). It is part of the original CAST prototype platform. It does not include the module execution component of the original software, nor its communication interface. Its purpose is to :

The second item includes the integration in CAST (Corba version 2.0) of " corbatised " optimisers from JyU (see Section 3). Interface with mathematical libraries

The interface between CAST and Iris Explorer is intended for the development of the integration platform in the DECISION project.

Because CAST uses a task-flow approach, whereas Iris Explorer uses a dataflow approach, it is necessary to define a common interface for the communication between the two software (Figure 1).

A particular component has been developed in CAST to produce a file that is a linear representation of the task graphs specified by the users.

It is triggered by a command which is available to the users in the main window menu.

These graphs include the specification of the input and output parameters of the various tasks defined by the users. The interface between CAST and Iris Explorer is an ASCII text file that describes, for each task in the task graph, all the input and output parameters, including their type, name, input port and output port..

The file includes these parameter specifications which are straightforwardly interpreted by an Iris Explorer script written by NAG in their proprietary SKM programming language to produce the corresponding module maps. The file generator, developed by INRIA Rhône-Alpes, was released in February 1999. Coupling CORBA and non-CORBA codes

The current version of the CAST 2.0 platform allows the simultaneous integration of both Corba and non-Corba modules (Figure 7). This uses the notion of " group server " which allows the wrapping of several non-CORBA codes simultaneously by a single wrapper.

This is in contrast with the full CORBA compliant approach used above for the CORBA-compliant modules which uses the standard " module wrapper " approach. There, each CORBA module has its own specific wrapper for interface with the CORBA layer and invocation by the remote clients.

In fact the first tests for the new CAST 2.0 prototype were run using a non-Corba version of the BCGA optimiser and wrapped (i.e., Corba-compliant) analytical functions.

It was implemented in both C++ and Java on the server side for the assessment of both implementation options. Performance tests showed a foreseeable order of magnitude penalty against Java. This doesn’t appear however as a shortcoming, first because the C++ language is widely disseminated and standardised. Second because, for portability reasons, this JAVA implementation of the " group server " was retained for the integration of future non-CORBA modules.

Figure 5. Multi-airfoil lift optimisation in landing configuration (Isomach curves).

This simultaneous integration of both Corba and non-Corba compliant modules is clearly a factor contributing to the smooth transition from existing optimisation libraries and computing environments, to more up-to-date integration platforms, while preserving the legacy software.

As decided during the previous project reviews, a cooperation has been started with the University of Jyvaskyla (JyU) to produce a demonstrator for the Corba version of the CAST 2.0 prototype platform, including wrapped optimisers from JyU.

In this direction, JyU has developed a wrapped version of the PBNCBN optimiser. Analytical functions are used in lieu of specific solvers. Consistent with the development of the Corba version of CAST 2.0 (see Section 4), the wrapper are implemented in the C++ language.

The CORBA demonstrator includes the following modules (Figure 3) :

Figure 6. Wrapping several codes with a group server.

All the communication between the client and between the optimisation modules, i.e., NIMBUS, PBEXPE and PBNCBN is through the CORBA layer. This does not include the call to NAG’s QP module.

This is made possible by the unique ability of the CAST 2.0 integration platform to support code-coupling for Corba-compliant and non-Corba compliant modules simultaneously.

4.2.8 Future work

Future developments of CAST 2.0 include :

The first item includes the implemetation of an interface with existing tools supporting formal process verification. Packages including such tools already exist and should be a significant step forward in the support of sophisticated process development for complex optimisation applications. Although their process model may differ from the task-flow approach used here, e.g., binary graphs models, as well as the format for their input data and implementation language, e.g., LOTOS, the outcome of this coupling is clearly a bonus to complex applications definitions.

The last point is dedicated to the sometimes constraining task of wrapping existing codes for compliance with the CORBA specifications. Although this task is somewhat of secondary importance here because CAST 2.0 supports the coupling of both non-CORBA and CORBA compliant modules, it is our opinion that next generation codes should be developed with distributed integration in mind.

In this context, wrapping codes automatically could significantly reduce the task of integrating user modules in a state-of-the-art CORBA integration platform such as CAST 2.0. It is therefore our intent to develop an automatic wrapper generator that will make use of generic wrapper templates that cover a broad class of application codes..

5. Comparison with other approaches and projects

Whether they are called integration platforms, code-coupling or problem-solving environments, prototypes and infrastructures are being developed by various projects which are currently investigating the field of high-performance computing, concerning particularly simulation and optimisation applications.

Environmental science, aerospace, shipbuilding and automotive industries, as well as visualisation software for satellite and biomedical imaging are first candidates for such high-performance computing environments.

Most approaches are dedicated to specific niches in particular domains, e.g., airframe optimisation. Among the critical issues adressed are the software interoperability and integration, as well as the data interfaces, e.g. grid compatibility issues.

The latter problem is not adressed in this paper. We focus in the following paragraph on recent and ongoing projects dealing with software integration in distributed computing environments, mainly in European projects.

This partial overview of current and recent projects shows that none of them deals specifically with the formal specification of complex applications as does the CAST integration platform.

Therefore, even if several prototypes make use of a CORBA layer as a communication and synchonisation framework, none of them include both a high-level application specifications approach coupled with an object-oriented distributed computing environment a la CORBA.

Further, none of them explicitly deals with the transparent coupling of CORBA-compliant and non-CORBA codes simultaneously. This seems to us of outmost importance if we are to deal with the existing software libraries. CAST can thus guarantee a smooth transition from existing numerical libraries and mathematical software to state-of-the-art integration platfroms.

Further, a number of large projects do not make use of the CORBA dynamic invocation facilities [SPI99], e.g., the dynamic invocation interface (DII) and the dynamic repository interface (DRI). If this limitation seems reasonable in well defined and routine applications, it is very restrictive in optimisation applications where the number and variety of the optimisation modules made available to the users give them the opportunity to dynamically switch among modules at run-time.

This is one concern in the DECISION project [DEC98]. This can only be implemented in platforms where the various modules all share the same interface (which is unrealistic) if the static use of CORBA is chosen. Otherwise, the platform must provide another reference level, i.e., formal specifications independent from the modules definitions.

This is implemented by the specification level in CAST where the formal specifications provide an easy way to define the applications in terms of logical and hierarchically decomposable tasks. Therefore, module switching is only a matter of changing the run-time modules reference. This is made without any modification to the high-level specification of the applications.

This in turn allows the invocation of remote modules transparently, as well as the switching between modules which are not located on the same site.

Finally, it does not appear that the above-mentioned projects used from the start an object-oriented approach for the design and implementation of their integration platform and problem-solving environment. This approach is known to guarantee scalability, functional extensibility, modularity, maintainability and inter-operability. The CAST integration platform was designed with these objectives in mind and is implemented in C ++. Parts of the " group server " interface with existing codes is implemented in JAVA for obvious portability reasons as well (Section This led to a very compact and easily maintainable code, which was developed in a four man x years effort and tested against mono and multi-airfoil optimisation examples involving genetic algorithms (Figure 5).

6. Conclusion

Complex engineering projects call for a variety of disciplines which must interact to ensure the overall project goals in a timely and effective manner.

The number of different expertises required may incur cascading impacts on many parts of the projects, even if they involve only local minor changes. This is particularly true in aerospace design, where the consistency of the systems and airframe design are essential for the project release.

These complex interactions require sound and provable specifications. This calls for formal specification techniques, e.g., process algebras.

Further, the variety of the disciplines involved require sophisticated computational tools. These might be connected in large corporate locations through distributed networks of computers throughout the world. Therefore, distributed computation techniques are required to minimise the latency of results integration. This can be solved by using distributed object-oriented software development techniques, e.g., CORBA.

This paper presents a software integration platform called CAST that combines both techniques of formal specifications and distributed object-oriented development, for the specification, configuration, deployment and execution of complex engineering applications in a unified and operational way.

The platform has been developed on Unix workstations connected by a NOW that communicate through a commercial CORBA object request broker.

The target user population includes project managers and engineers that are expert in their particular domain, e.g., aerodynamics, electromagnetics.

The application tasks and their interactions are transparently mapped to distributed software components. They are implemented using object-oriented programming techniques. The actual user modules may include simultaneously non object-oriented code, e.g., Fortran subroutines, as well fully object-oriented software, e.g., C++. In this case, CAST takes automatically into account the diversity of the interfaces and parameters for the various modules.

The CAST integration platform also offers a high-level graphics interface for the specification of complex multi-discipline applications, thus making the formal algebraic and theoretical background on which it is based, as well as the technicalities of distributed computing, totally transparent to the end-users.

Also, an interesting feature in CAST is that it supports the coupling of CORBA and non-CORBA modules simultaneously. This provides for a smooth transition from existing application software and mathematical libraries to state-of-the-art integration platforms and metacomputing environments. It is also expected that this will permit the connection to third party environments that support widely accepted communication standards and exchange protocols, e.g., CORBA.

Although metacomputing has focused much attention and efforts in the last few years, large scale applications, including CPU and graphics intensive applications that require large amounts of computing ressources are still demanding easy to use high-performance problem-solving environments. Examples of such applications include the co-simulation of electronic chips in the CADNET project and multidiscipline aircraft simulation for the Digital Dynamic Aircraft approach in the AMAZE project. Indeed, the design environments required now by aircraft manufacturers will include CFD, CSM, acoustics and electromagnetics simulation and optimisation, ranging from the initial CAD outlines up to the dynamic behavior of the airframe and systems under operating constraints. This will put an unprecedented load on hardware and software resources in problem-solving environments.

Still lacking specific features, e.g., load balancing, guaranteed QoS and security, the CAST integration platform provides however the functionalities that make it a good candidate for basic building blocks towards high-performance metacomputing environments dedicated to collaborative multi-discipline applications.

The software documentation, including the software specifications and the CAST user’s manual, is available on-line at :


The authors wish to thank Jacques Periaux from Dassault-Aviation, as well as Alain Dervieux and Jean-Antoine Desideri from the SINUS project at INRIA Sophia-Antipolis, for their strong support and helpful advice.

This work was partly supported by the EEC Esprit Program, through the HPCN " DECISION " project: " Integrated Optimisation Strategies for Increased Engineering Design Complexity ". The partners of this project were Dassault-Aviation (F), INRIA (F), NAG Ltd (G.B), the University of Jyvaskyla (Finland), Nokka-Tume (Finland) and Messet-VTT (Finland).

Nathalie Marco, from the SINUS  project at INRIA Sophia-Antipolis, provided the optimisation test-cases used in this work. The authors wish also to thank Jerôme Blachon for his invaluable help in the design and implementation of CAST, and Thierry Priol, Christophe Rene and Eric Lemoine from the PARIS project at IRISA for their help in making PACO available for CAST.

Part of this project is funded by INRIA through ARC " Couplage " and by the French RNRT program, through the VTHD project, in cooperation with Stephane Lanteri at INRIA Sophia-Antipolis.


[ALL99] G. Alleon. " The JACO3 project ". Soft-IT Workshop " Next generation of interoperable simulation environments based on CORBA ", INRIA-ONERA-Simulog. June 1999.

[AND98] ANDREOLI J.M., et al. The coordination technology area at XRCE Grenoble : research in support of distributed cooperative work. Xerox Research Center Europe. Research Report. 1998.

[BAL98] BALTER R., et al. Architecturing and configuring distributed applications with OLAN. Proc. IFIP Int’l. Conf. Distributed Systems platforms. Middleware ’98. Lake District. September 1998.

[BLA99] J. Blachon, T. Nguyen " DECISION prototype integration platform : CAST CORBA prototype ". Soft-IT Workshop " Next generation of interoperable simulation environments based on CORBA ", INRIA-ONERA-Simulog. June 1999.

[COR99] T. Cornu. " The SOFT_IT project ". Soft-IT Workshop " Next generation of interoperable simulation environments based on CORBA ", INRIA-ONERA-Simulog. June 1999.




[GIR99] S. Girona " Metacomputing tools for stochastic analysis : Promenvir " European Research Conference " Advanced environments and tools for high performance computing " Problem-solving environments : infrastructure and prototypes. San Feliu de Guixols, Spain, June 1999.

[ILU98] XEROX ILU Reference manual. 1998.

[KEA99] A. Keane. " The creation of a multi-analysis wing design environment ". European Research Conference " Advanced environments and tools for high performance computing " Problem-solving environments : infrastructure and prototypes. San Feliu de Guixols, Spain, June 1999.

[KES99] C. Kesslman. Globus and metacomputing infrastructure. European Research Conference " Advanced environments and tools for high performance computing " Problem-solving environments : infrastructure and prototypes. San Feliu de Guixols, Spain, June 1999.

[MAR98] MARCO N., LANTERI S. A two-level parallelization strategy for genetic algorithms applied to shape optimum design. Research Report no. 3463. INRIA. July 1998.


[MIL83] MILNER R. Calculi for synchrony and asynchrony. Theoretical computer science. Vol. 25, no. 3. July 1983.


[MUR99] J. Murphy. " The JULIUS project ". Soft-IT Workshop " Next generation of interoperable simulation environments based on CORBA ", INRIA-ONERA-Simulog. June 1999.

[NAG98] NAG Ltd. Iris Explorer. Reference Manual. 1998.

[OMG98] Object Management Group. The Common Object Request Broker : architecture and specification. Revision 2.2. Object Management Group. Document 98-03-11.

[ORB98] Object-Oriented Concepts, Inc. ORBacus for C++ and Java. Version 3.1.1. Object-Oriented Concepts, Inc. 1998.

[PAR99] Th. Priol. Avant-projet PARIS " Programmation des systemes paralleles et distribues pour le simulation numerique distribuee ". INRIA. May 1999. [PET]


[SPI99] D. Spicer " FRONTIER : an environment for industrial multi-objective optimisation " European Research Conference " Advanced environments and tools for high performance computing " Problem-solving environments : infrastructure and prototypes. San Feliu de Guixols, Spain, June 1999.


[STR99] M. Strietzel. " The TENT project ". Soft-IT Workshop " Next generation of interoperable simulation environments based on CORBA ", INRIA-ONERA-Simulog. June 1999.

[THO99] C. Thole. " Autobench : developement of a PSE for the automotive industry " European Research Conference " Advanced environments and tools for high performance computing " Problem-solving environments : infrastructure and prototypes. San Feliu de Guixols, Spain, June 1999.