PARDIS: Programmer-level abstractions for metacomputing

Abstract

The potential offered by metacomputing is hard to realize due to the complexity of programming geographically distributed applications spanning different software systems. This paper describes PARDIS, a system designed to address this challenge, based on ideas underlying the Common Object Request Broker Architecture (CORBA), a successful industry standard. PARDIS is a distributed environment in which objects representing data-parallel computations, called Single Program Multiple Data (SPMD) objects, as well as non-parallel objects present in parallel programs, can interact with each other across platforms and software systems. Each of these objects represents a small encapsulated application and can be used as a building block in the construction of powerful distributed metaapplications. The objects interact through interfaces specified in the Interface Definition Language (IDL), which allows the programmer to integrate within one metaapplication component implemented using different software systems. Further, support for non-blocking interactions between objects allows PARDIS to build concurrent distributed scenarios.

Introduction

Due to recent technical innovations, networking technologies have reached performance levels acceptable for supercomputing and have enabled a new class of high-performance applications which are able to exploit the heterogeneity of diverse software systems and geographically distributed resources. The advantages that these metacomputing environments [1], [2] offer are enormous, however, they are seldom realized due to the difficulty of building such systems. Up to now metacomputing applications have usually been developed in an ad hoc fashion, trying to explicitly combine different communication libraries and developing special-case tools [3]. Systems constructed in this way usually require extensive modifications to the original application code in order to integrate it into a metacomputing environment and result in software which is complex, and difficult to debug and maintain. This problem gives rise to the need for a general-purpose metacomputing environment which would provide abstractions suitable for easy and efficient coupling of high-performance scientific applications.

In order to fulfill these requirements, reduce the complexity, and accelerate the process of developing these applications, such system should implement application-level interaction of heterogeneous, parallel components in a distributed environment. That is, it should allow the programmer to build metaapplications from independently developed and tested components which once implemented can be reused as building blocks in many scenarios. In order to achieve this, such system must be able to define interactive interfaces to components which will hide enough to free the programmer from the necessity to understand the implementation details of any particular component, and at the same time be flexible enough to define the components accurately and enable efficient interaction with them. Hiding implementation details should also allow combining components developed using different software systems and in this way enable metaapplications to exploit heterogeneity of their components. Further, the system should provide an elegant and flexible way of handling remote interactions to ensure interoperability with remote components.

In the field of distributed computing a similar set of problems has been addressed by DCOM [4] and the Common Object Request Broker Architecture (CORBA) [5], which has successfully built an infrastructure supporting the integration of heterogeneous distributed applications within one system. However, the abstractions implemented in CORBA are not always efficient or suitable for parallel computing; for example they create sequential bottlenecks in interactions with data-parallel applications. In this paper we will describe PARDIS, a system which employs the ideas introduced in CORBA to suit the needs of PARallel DIStributed objects.

PARDIS builds on CORBA in that it allows the programmer to construct metaapplications using independently developed heterogeneous components interacting through interfaces specified in an Interface Definition Language (IDL) common to all components. Using interfaces defined in this way the components can be plugged into a reusable infrastructure capable of combining remote or local components into metaapplications. The fact that the combining infrastructure is reusable, and that the objects need only to provide an interface in order to use it (no need to modify implementation), allows metaapplications to be easily put together and taken apart, and their components to be reused in building other metaapplications. PARDIS modifies the set of abstractions implemented in CORBA by introducing Single Program Multiple Data (SPMD) objects representing data-parallel computations, and distributed sequences representing the notion of distributed data in a parallel program. Further, PARDIS accommodates the need for concurrency in high-performance applications by allowing non-blocking invocations, and, aside from a general-purpose solution suitable for all data-parallel systems provides direct interoperability with two existing data-parallel libraries: POOMA [6] and HPC++ PSTL [7].

We will begin to discuss PARDIS by describing in detail its architecture, implementation and the ways in which a programmer can interface it. We will move on to evaluate the main abstraction introduced in PARDIS: SPMD objects, and finally give a few concrete examples of how PARDIS can be used to construct metaapplications.