It is increasingly the case in high-performance parallel applications that interaction with an external computing environment is necessary for a computational problem's solution. Certainly, this has always been true from the point of view of file I/O for reading program input data and writing computation output results, and traditional state-based debugging tools have always had interaction with a halted program as a fundamental feature. However, these interface examples are rudimentary relative to the support required for application programs to access higher-level external services (e.g., databases, visualization systems[1], and distributed resources) and to allow external access to the application's state (e.g., for program state display or computational steering[2]). Although such support can be developed on an ad-hoc basis for each application, a general approach to the problem of parallel program interaction is preferred. In particular, high-level parallel languages require an approach that is portable with language implementations and that can accommodate language-level interaction with external applications and tools.
The notion of program interaction support has long been a concern in the distributed computing and software engineering domains where interactions are either out of necessity or are the basis for improved application design. In a high-performance computing context, program interaction typically implies a performance loss. However, the development of interaction support, when required, will become more problematic as the sophistication of the application and the parallel computing environment increases. For this reason, the inclusion of interaction support early in the design and development of a parallel language system can lead to an integrated solution where external access to a parallel program will be natural and convenient, and where performance concerns, when they arise, can be addressed within the particular computing environment. In this paper, we describe the design approach used to implement parallel program interaction support in a parallel object-oriented language system. The unique aspect of this research work is the use of the language itself and its associated compiler resources for generating the interaction infrastructure. The remainder of the introduction describes the features of the interaction system and the language platform where it was developed. More details of the architecture and implementation are given in the following sections. Several examples are then briefly described, followed by future directions and conclusions.