This paper presents Fortran D, a version of Fortran enhanced with data decomposition specifications. It is designed to support two fundamental stages of writing a data-parallel program: problem mapping using sophisticated array alignments, and machine mapping through a rich set of data distribution functions. We believe that Fortran D provides a simple machine-independent programming model for most numerical computations. We intend to evaluate its usefulness for both programmers and advanced compilers on a variety of parallel architectures.

Fortran M is a small set of extensions to Fortran 77 that supports a modular approach to the design of message-passing programs. It has the following features. (1) Modularity. Programs are constructed by using explicitly-declared communication channels to plug together program modules called processes. A process can encapsulate common data, subprocesses, and internal communication. (2) Safety. Operations on channels are restricted so as to guarantee deterministic execution, even in dynamic computations that create and delete processes and channels. Channels are typed, so a compiler can check for correct usage. (3) Architecture Independence. The mapping of processes to processors can be specified with respect to a virtual computer with size and shape different from that of the target computer. Mapping is specified by annotations that influence performance but not correctness. (4) Efficiency. Fortran M can be compiled efficiently for uniprocessors, sharedmemory computers, distributed-m...

Because of the complexity and variety of parallel architectures, an efficient machine-independent parallel programming model is needed to make parallel computing truly usable for scientific programmers. We believe that Fortran D, a version of Fortran enhanced with data decomposition specifications, can provide such a programming model. This paper presents the design of a prototype Fortran D compiler for the iPSC/860, a MIMD distributed-memory machine. Issues addressed include data decomposition analysis, guard introduction, communications generation and optimization, program transformations, and storage assignment. A test suite of scientific programs will be used to evaluate the effectiveness of both the compiler technology and programming model for the Fortran D compiler.

A fundamental principle in program design is to isolate difficult or changeable design decisions. Application of this principle to parallel programs requires identification of decisions that are difficult or subject to change, and the development of techniques for hiding these decisions. We experiment with three complex applications, and identify mapping, communication, and scheduling as areas in which decisions are particularly problematic. We develop computational abstractions that hide such decisions, and show that these abstractions can be used to develop elegant solutions to programming problems. In particular, they allow us to encode common structures, such as transforms, reductions, and meshes, as software cells and templates that can reused in different applications. An important characteristic of these structures is that they do not incorporate mapping, communication, or scheduling decisions: these aspects of the design are specified separately, when composing existing structures to form applications. This separation of concerns allows the same cells and templates to be reused in different contexts.

A rather recent approach in programming parallel and distributed systems is that of coordination models and languages. Coordination programming enjoys a number of advantages such as being able to express different software architectures and abstract interaction protocols, supporting multilinguality reusability and programming-in-the-large, etc. However, most of the proposed models and languages are data-driven in the sense that changes in the behaviour of the formalism are triggered by detecting the presence of data values. In addition, more often than not, the formalism does not clearly separate the computation components from other related components, namely (and primarily) communication ones but also synchronisation components, etc. In this paper we use a coordination model (IWIM) and language (MANIFOLD) which are control-driven in the sense that the formalism's change of behaviour is triggered by means of raising events. We illustrate the main features of this new formalism and we ...

Shared Prolog is a language for symbolic computing that combines distributed coordination based on a shared dataspace with sequential symbolic computation based on logic programming. Shared Prolog includes a concept of logically shared dataspace, thus introducing in parallel logic programming a coordination model different from the stream-based communication model of Flat Concurrent Prolog and Strand. We demonstrate how Shared Prolog can be used for expressing a number of different parallel symbolic computing schemata such as: pipeline, divide et impera, and distributed problem solving. We also discuss a number of topics in implementing such a programming model.

Run-time work distribution in parallel programming systems is usually accomplished through the use of dynamic scheduling heuristics. Their sensitivity to run-time information such as global work-load, task granularity, data dependencies, locality of information, among others, is essential when trying to optimize performance. Adaptive schedulers that base their decisions on feed-back from the system are therefore of special importance. We have developed and used a general purpose parallel programming system, the pSystem, that also served as a test-bed environment on which we have experimented and studied the performance of distinct scheduling heuristics. Currently, we have two versions of the system: one based on Unix processes; and the other on Solaris threads. Threads (particularly user-level threads) are usually associated with low execution overheads, since they require minimal interaction with the operating system kernel. This suggests that lower grain parallelism may be more effectively exploited with a thread-based parallel programming system. Performance analysis of both implementations over a set of well known benchmarks, with various schedulers, shows that threads scale better under higher system loads and/or when the granularity of the tasks being executed is below a given threshold value. This paper starts with a description of the design and implementation of the pSystem computational model, followed by a detailed description of several experiments and the analysis of their results. ©1997 John Wiley & Sons, Ltd. KEY WORDS: parallelism; scheduling; parallel programming environments; performance analysis

This paper proposes a parallel programming notation and a method of reasoning about programs with the following characteristics: 1. Parallel Composition The notation provides different forms of interfaces between processes; the more restrictive the interface, the simpler the proofs of process composition. A flexible interface is that of cooperating processes with a shared address space; proofs of programs that use this interface are based on non-interference [OG76] and temporal logic [Pnu81, CM88, Lam91]. We also propose more restrictive interfaces and specifications that allow us to use the following specificationconjunction rule: the strongest specification of a parallel composition of processes is the conjunction of the strongest specifications of its components. This rule is helpful in deriving parallel programs. 2. Determinism A process that does not use certain primitives of the notation is guaranteed to be deterministic. Programmers who wish to prove that their programs are d...

A coordination style programming language, Multran, and its temporal logic semantics are proposed. Multran uses Linda-like tuple space to coordinate concurrent transactions, which could be written in any language as long as they satisfy their pre-conditions and post-conditions. It has an intuitional presentation and enjoys a temporal logic semantics for program verification. A Multran program can be executed in a parallel, sequential, or distributed manner based on available resources, and its correctness can be reasoned about by temporal logic. In particular, temporal logic can be used to reason about the safety and liveness properties of Multran programs. 1. Introduction Multran (Multiset transformation and transactions), a high-level parallel programming language based on multiset transformation and transaction programming paradigm, and its temporal logic semantics are proposed. Multiset, or bag, is a set except that it may have multiple occurrences of its elements. A transaction ...

Two parallel languages and their associated programming systems are reviewed and evaluated. Both Strand and PCN are designed to facilitate parallel program development by providing an expressive high-level notation; by integrating tools for debugging, performance analysis, etc.; and by providing portability across different parallel computers. Both provide explicit parallel constructs and use singleassignment variables as an abstraction for communication and synchronization. They support a compositional approach to program design, in which programs composed from simpler components inherit the properties of these components. Strand, developed in 1988, is a first-generation system specialized for symbolic applications. PCN, developed in 1990, is a second-generation system that supports both symbolic and numeric computing. Both systems are available on a range of parallel computers, have been widely distributed, and are in use in many applications. This article summarizes their principal ...