Message-passing program development by ensemble

Abstract

We present Ensemble, a message-passing implementation methodology, applied to PVM. Ensemble overcomes problems and complexities in developing applications in messagepassing environments (MPE). Applications are specified by scripts, which represent Process Communication Graphs (PCG) annotated with information specific for an MPE, and by reusable executable components. A loader program interprets the scripts and composes applications from reusable components. MotivationThe design and implementation of parallel message passing applications (MPA) have been recognized as demanding tasks. PVM [5] and MPI [6] Message Passing Environments (MPE) have improved the situation, as they permit the implementation of applications independently of the underlying architecture, but the step from application design to implementation remains, in general, a demanding task. The implementation does not only require the programming of sequential code solving a problem or providing a service, but also requires the explicit programming of process management, e.g. process creation, process topologies and their mapping onto the architecture. As MPEs differ significantly in the way they manage processes, message passing program implementation presents a number of difficulties. MPEs impose on application implementation their own structure to such a degree, that implementations of the same application design (even a simple ring topology) on different MPEs, using the same language for the sequential computations, look very different. The implementation difficulty does not depend only on the complexity of the design, but also on the particular MPE used. Some applications are more easily implemented on some MPEs than on others. For example, a general tree topology is easy to implement on PVM, but difficult on MPI. The difficulty arises from the process management model each MPE uses. Often, the original application design is obscured in the implementation by the required process management programming. Consequently, implementation requires special techniques and skills, different for each MPE. There are no methodologies for implementing applications on PVM or MPI. Programmers have to implement relying on their experience, quite often in an ad hoc way, developing programs that are difficult to debug, extend and modify. Important aspects of parallel programming, such as scalability, reusability are often neglected. Scalability is programmed only when the design has some regularity, as expressed by some function; the degree of difficulty for programming scalability also depends on the MPE used. Reusability of executables is limited as process management (creation, topology, mapping, etc.) is encoded in them; processes are programmed to operate in a fixed topology of known processes. We have developed a message passing program implementation methodology, called Ensemble, for overcoming the above problems. The original design is maintained in the implementation, programs implementing the same designs in different MPEs look similar, are easily ...

Modular MPI and PVM Components

“…"atm [2,6] sends to ocn [1,2] in context X". No execution overhead is introduced, as envelope bindings are done at compile time.We currently develop a new composition environment, which manages components, executables, etc as grid resources and study formal support for compatibility and composition.Our future plans are to re-engineer SPMD programs as modular components; also to address dynamically configurable applications by modifying EnvArgs during execution.…”

“…Each component is required to run separately as SPMD, but also may be coupled together for solving the climate model. atmP [2,6] atmP [2,8] atmP [2,7] atmP [3,7] atmP [3,6] atmP [3,8] …”

“…In the Ensemble methodology [1,2,3,4] message passing (MP) applications are designed and built by composing modular MP components. We have developed tools for: designing and implementing separate components; designing topologies; specifying allocation resources; generating composition directives.…”

“…Previous Ensemble implementations [1,2,3] were aiming at developing abstract component code capable of running on any API (PVM, MPI, Parix). Consequently program components could only use a limited, semantically common, subset of routines (e.g.…”

Associating composition of Petri net specifications with application designs in GRADE

“…However, this approach had the disadvantage that GRAPNEL code of processes could not be reused through different application. To overcome this problem, w e have decided to follow the concept of re-usable program components similarly to that of Ensemble methodology [1] [4] [5]. In this way, the programmer can create and use processes individually as reusable program components which can be embedded into various applications using different inter connection schemes.…”