. We describe high-level language constructs for specifying parallel programs and show how they may be used to provide modular specification of communication, synchronization and placement. The high-level constructs are translated into actors which provide flexible low-level primitives for interconnecting distributed components and efficient execution on concurrent computers. We argue that our linguistic constructs allow parallel program specifications that are easier to reason about and efficient to implement. 1. Introduction Current methods for programming parallel computers involve very low-level mechanisms which allow efficient execution only on particular architectures. In order to raise the level of abstraction at which programs are specified, a number of requirements must be met by high-level languages for parallel computing. Specifically, in order for high-level parallel languages to be practical they must: ffl provide constructs which abstract over the coordination structure...

Abstract not found

Actors are a model of concurrent objects which unify synchronization and data abstraction boundaries. Because they hide details of parallel execution and present an abstract view of the computation, actors provide a promising building block for easy-to-use parallel programming systems. However, the practical success of the concurrent object model requires two conditions be satisfied. Flexible communication abstractions and their efficient implementations are the necessary conditions for the success of actors. This thesis studies how to support communication between actors efficiently. First, we discuss communication patterns commonly arising in many parallel applications in the context of an experimental actor-based language, THAL. The language provides as communication abstractions concurrent call/return communication, delegation, broadcast, and local synchronization constraints. The thesis shows how the abstractions are efficiently implemented on stock-hardware distributed memory mul...

: MPI is gaining acceptance as a standard for message-passing in high-performance computing, due to its powerful and flexible support of various communication styles. However, the complexity of its API poses significant software overhead, and as a result, applicability of MPI has been restricted to rather regular, coarse-grained computations. Our OMPI (Optimizing MPI) system removes much of the excess overhead by employing partial evaluation techniques, which exploit static information of MPI calls. Because partial evaluation alone is insufficient, we also utilize template functions for further optimization. To validate the effectiveness for our OMPI system, we performed baseline as well as more extensive benchmarks on a set of application cores with different communication characteristics, on the 64-node Fujitsu AP1000 MPP. Benchmarks show that OMPI improves execution efficiency by as much as factor of two for communication-intensive application core with minimal code increase. It a...

Abstract not found

In this paper we present performance results of several irregular parallel algorithms implemented using a high-level actor language and its runtime kernel. The problems studied require dynamic computation of the placement of objects and may create load imbalance as the computation proceeds thereby requiring dynamic load balancing. We express the algorithms as fine grained computation, which allows us to rearrange objects in various ways and to compose the same algorithm with different partitioning and distribution strategies (PDS's). The PDS's are implemented for specific data structures or algorithm structures and are reusable for different parallel algorithms. We demonstrate how our methodology provides portability of algorithm specification, reusability and ease of expressibility without significantly sacrificing efficiency. 1 Introduction In parallel computing, the set of operations and the partial order in which they may be carried out define an ideal algorithm [10]. This ideal ...

In scalable concurrent architectures, the performance of a parallel algorithm depends on the resource management policies used. Such policies determine, for example, how data is partitioned and distributed and how processes are scheduled. In particular, the performance of a parallel algorithm obtained by using a particular policy can be affected by increasing the size of the architecture or the input. In order to support scalability, we are developing a methodology for modular specification of partitioning and distribution strategies (PDS's). As a consequence, a PDS may be changed without modifying the code specifying the logic of a parallel algorithm. We illustrate our methodology for parallel algorithms that use dynamic data structures. 1 Introduction In parallel computing, the set of operations and the partial order in which they may be carried out define an ideal algorithm [25]. We use Actors, a form of concurrent objects, to specify ideal algorithms. Actors naturally express an i...

: Id is an architecture-independent, general-purpose parallel programming language that has evolved and been in use for a number of years. Id does not have a sequential core; rather, it is implicitly parallel, with the programmer introducing sequencing explicitly only if necessary. Id is a mostly-functional language, in the family of non-strict functional languages with a HindleyMilner static type system. Unlike other non-strict functional languages, it uses lenient, not lazy evaluation, for reasons of parallelism, as well as to give meaning to non-functional constructs. The non-functional constructs come in two layers: I-structures (which preserve determinacy, but not referential transparency, and are closely related to logic variables), and M-structures, which are side-effects with implicit synchronization. The layers are distinguished by syntax and types, so that it is possible for an implementation to force a program to be within a desired layer (e.g., purely functional)....

Recent progress in implementations of object-oriented concurrent programming languages on highly-parallel processors makes it feasible to construct large-scale parallel applications having complicated structures. Such applications can not exhibit good performance without dynamic resource management (e.g., load-balancing and object scheduling) tailored to the characteristics of the applications and/or machine architectures. Since dynamic resource management systems are usually intertwined with the language implementation, modification/extension of the management systems requires complicated programming in the low-level language. Reflective systems can provide abstractions to modify/extend the implementation-level facilities within the application-level language. This study proposes a reflective architecture of an object-oriented concurrent language for highly-parallel processors to provide resource management systems for parallel applications. To make our architecture practical, much at...

Abstract not found