This dissertation shows a new approach to writing object-oriented parallel programs based on design patterns, frameworks, and multiple layers of abstraction.

This report describes PVMGraph, a graphical programming environment to support the design and implementation of parallel applications. PVMGraph offers a simple but yet expressive graphical representation for the components of a parallel application and assists the user in manipulating these components. PVMGraph also allows the evaluation of the application design and implementation. Although, PVMGraph graphical representation is general, its semantics is directed to PVM applications. This means that each graphical object is associated with a PVM/C segment of code. The description of PVMGraph is divided into two main parts: the design graphical representation (external view) and the implementation (textual) representation (internal view). The external view consists of an abstract view of components of a parallel application design, that is; the processes, their interfaces (behavioural description) and their interactions which are represented graphically. The internal view consists of th...

The concept of design patterns has been extensively studied and applied in the context of object-oriented software design. Similar ideas are being explored in other areas of computing as well. Over the past several years, researchers have been experimenting with the feasibility of employing design-patterns related concepts in the parallel computing domain. In the past, several pattern-based systems have been developed with the intention to facilitate faster parallel application development through the use of pre-implemented and reusable components that are based on frequently used parallel computing design patterns. However, most of these systems face several serious limitations such as limited flexibility, zero extensibility, and ad hoc nature of their components. Lack of flexibility in a parallel programming system limits a programmer to using only the high-level components provided by the system. Lack of extensibility here refers to the fact that most of the existing patternbased parallel programming systems come with a set of pre-built patterns integrated into the system. However, the system provides no obvious way of increasing the repertoire of patterns when need arises. Also, most of these systems do not offer

Parallel programming environments provide a way for programmers to reap the benefits of parallelism, while reducing the effort required to create parallel applications. The CO2P3S parallel programming system is one such tool that uses a pattern-based approach to express concurrency. Using the Cowichan Problems, we demonstrate that CO2P3S contains a rich set of parallel patterns for implementing a wide variety of applications running on shared-memory or distributed-memory hardware. An example of these parallel patterns, the Search-Tree pattern, is described and it is shown how the pattern was used to solve the Fifteen Puzzle problem. Code metrics and performance results are presented for the Cowichan applications to show the usability of the CO2P3S system and its ability to reduce programming effort, while producing programs with reasonable performance.

Module Cm: A Concrete Module Instantiation of Concrete Modules as collection of processes Step 3 Step 2: Add Application Code Step 3: Instantiate FIGURE X.1. Relationships between a parallel architectural skeleton, an abstract module and a module a skeleton by specifying the parameters associated with the attributes, as needed by the application at hand. Figure X.1 approximately illustrates the various phases of application development using parallel architectural skeletons. As shown in the figure, di#erent extensions of the same skeleton can result in somewhat di#erent abstract parallel computing modules (abbreviated as an abstract module). An abstract module is yet to be filled in with application code. Once an abstract module is supplied with application code, it results in a concrete parallel computing module (abbreviated as a concrete module or simply a module). A parallel application is a systematic collection of mutually interacting, instantiated modules.

The advantages of pattern-bas programming have been well-documented in the sequential literature. However patterns have yet to make their way into mains tream parallel computing, even though several research tools support them. There are two criticals hortcomings of pattern (or template) based systems for parallel programming: lack of extensibility and performance. The patterns supported by a tool are typically limited in number or scope, thereby narrowing the applicability of a given system. As well, patterns usually offer generic solutions, which incur additional runtime overhead that impacts performance. This paper describes our approach for addressing these problems in the CO2P3S parallel programming system. CO2P3S supports multiple levels of abstraction, allowing the user to design an application with high-level patterns, but move to lower levels of abstraction for performance tuning. Patterns are implemented as parameterized templates allowing the user the ability to customize the pattern to meet their needs. CO2P3S generates code that is specific to the pattern/parameter combinations elected by the user. The MetaCO2P3S tool addresses extensibility by giving us the ability to design and add new pattern templates to CO2P3S. Since the pattern templates are stored in a system-independent format, they are suitable for storing in a repository to be shared throughout the user community. The CO2P3S/MetaCO2P3S combination is unique in the parallel computing world.

Most of the methods proposed for the development of high-performance systems (HPS) do not balance the software and performance engineering activities. This paper presents a method for the development of HPS which promotes the production of well-engineered, highly parallel programs the design decisions of which are also guided by their impact on performance. The method follows strong software engineering principles such as modularity, and the use of formal methods to support verification and transformation. From the point of view of performance engineering the method supports the use of prototypes for performance prediction at early stages of the development. Much of the method is language and hardware independent, and the paper illustrates the application of the method to the development of occam programs running on transputers. 1

In this paper, we introduce SPM (Software-built Parallel Machines), a model to create software based virtual parallel machines. With SPM, an application developer simply selects all the required virtual parallel machines from the repository and implements the intended parallel algorithms directly without any need of complex mappings, as if the required processor interconnections are readily available. In addition, we present an implementation of the SPM model, which provides a systematic way to design new virtual machines. Our experiments show that the applications developed using the SPM model and tools give excellent performance, as compared to the applications developed using a generic communication library, such as MPI.

For almost a decade we have been working at developing and using template-based models for coarse-grained parallel computing. Our initial system, FrameWorks, was positively received but had a number of shortcomings. The Enterprise parallel programming environment evolved out of this work, and now, after several years of experience with the system, its shortcomings are becoming evident. This paper outlines our experiences in developing and using the two parallel programming systems. Many of our observations are relevant to other parallel programming systems, even though they may be based on different assumptions. Although template-base models have the potential for simplifying the complexities of parallel programming, they have yet to realize these expectations for high-performance applications. 1 Introduction Along with the growing interest in parallel and distributed computing, there has been a corresponding increase in the development of models, tools and systems for parallel progra...

This paper presents the P-RIO environment which offers high level, but straightforward, concepts for parallel and distributed programming. A simple software construction methodology makes most of the useful object oriented programming technology properties available, facilitating modularity and code reuse. This methodology promotes a clear separation of the individual sequential computation components from the interconnection structure used for the interaction between these components. The mapping of concepts associated to the software construction methodology to graphical representations is immediate. P-RIO includes a graphical programming tool, has a modular construction, is highly portable, and provides runtime support mechanisms for parallel programs, in architectures composed of heterogeneous computing nodes. Keywords: Distributed and parallel computing, object oriented programming, code reuse, graphical programming. Introduction Parallel and distributed architectures are essenti...