In this paper, we give an overview of the results of the CRAFT optimising compiler project (Fortran 90/HPF subset compilers). We start by describing the theoretical framework within which we designed program transformations for the optimization of inter- and intra-procedural data motion, as well as the optimizations for parallel loops; we then describe the implementation of the CRAFT compilers for Thinking Machines' CM-2 and CM-5. We report results from experiments on the Connection Machine CM-5, the IBM SP-2 and a network of UltraSparc workstations. The results demonstrate that these optimizations can achieve significant object code performance improvement. Copyright © 1999 John Wiley & Sons, Ltd.

In this paper, we sketch some techniques for using Java to improve the state-of-the-art in scalable collaboration management for scientific and engineering applications. We argue that flexibility, cost containment and support for large-scale collaboration must join raw performance as metrics for successful, scalable HPC software. Finally, we summarize our experience with large-scale Web-based collaboration, and describe some plans for future work. © 1997 John Wiley & Sons, Ltd.

No abstract available.

Massively parallel architectures, and the languages used to program them, are among both the most difficult and the most rapidly-changing subjects for compilation. This has created a demand for new compiler prototyping technologies that allow novel styles of compilation and optimization to be tested in a reasonable amount of time. Using formal specification techniques, we have produced a data-parallel Fortran-90 subset compiler for Thinking Machines' Connection Machine/2 and Connection Machine/5. The prototype produces code from initial Fortran-90 benchmarks demonstrating sustained performance superior to hand-coded *Lisp and competitive with Thinking Machines' CM Fortran compiler. This paper presents some new specification techniques necessary to construct competitive, easily retargetable prototype compilers. 1 Introduction Existing compilers for massively parallel machines have generally been constructed using traditional methods, combining generation from specification for a few su...

A method of generating parallel target code with explicit communication for massively parallel distributed-memory machines is presented. The source programs are shared-memory parallel programs with explicit control structures. The method extracts syntactic reference patterns from a program with shared address space, selects appropriate communication routines, places these routines in appropriate locations in the target program text and sets up correct conditions for invoking these routines. An explicit communication metric is used to guide the selection of data layout strategies.>

The authors address the problem of data distribution and communication synthesis in generating parallel programs targeted for massively parallel distributed-memory machines. The source programs can be sequential, functional, or parallel programs based on a shared-memory model. The approach is to analyze source program references and match syntactic reference patterns with appropriate aggregate communication routines which can be implemented efficiently on the target machine. An explicit communication metric is used to guide optimizations to reduce communication overhead. The target code with explicit communication is proven to be free from deadlock introduced by the compilation process. The techniques described are developed within the context of Crystal (functional language) though they can be applied to Fortran. The Crystal compiler generates C-code for an iPSC/2.>

The authors present a new dependence test which can detect disjoint regions of an iteration space. The test therefore reports accurate dependences for a class of conditional statements. The proposed algorithm can discover large-scale parallelism in cases where previous decision algorithms fail. The methods and algorithms for solving the subdomain dependence test are described. Also considered is the application of the subdomain dependence test to the problem of 'dependence cycle breaking' and the use of the subdomain dependence test in analyzing functional programs.>

This paper will focus on the issue of load balancing on a hypercube network of N processors. We will investigate a typical nearest neighbor balancing strategy - in which workloads among neighboring processors are averaged at discrete time steps. The computation model allows tasks, described by independent random variables, to be generated and terminated at all times.

A synthesis method for designing highly parallel algorithms in VLSI is presented. To illustrate the method, the familiar long multiplication algorithm for binary numbers is used. This algorithm is specified in the language Crystal, a very-high-level language for parallel processing. A total of 18 designs are derived from this specification. Each is optimal within its own class, which is characterized by a space-time map. The relative merits and tradeoffs of different designs are systematically compared and evaluated.>

A language Crystal and its compiler for parallel programming is presented. The goal of Crystal is to help programmers in seeking efficient parallel implementations of an algorithm, and managing the complexity that might arise in dealing with hundreds of thousands of autonomous parallel processes. In Crystal, a program consists of a system of recursion equations and is interpreted as a parallel system. Crystal views a large complex system as consisting of a hierarchy of parallel sub-systems, built upon a set of Crystal programs by composition and abstraction. There is no mention of explicit communications in a Crystal program. The Crystal compiler automatically incorporates pipelining into programs, and generates a parallel program that is optimal with respect to an algorithm. Each optimizing compiler, targeted for a particular machine, determines the appropriate granular size of parallelism and attains a balance between computations and communications. Based on the language, a unified theory for understanding and generating any systolic design has been devised and it constitues a part of the compiler.

In this paper, a design methodology for synthesizing efficient parallel algorithms and VLSI architectures is presented. A design process starts with a problem definition specified in the parallel programming language Crystal and is followed by a series of program transformations in Crystal, each aiming at optimizing the target design for a specific purpose. To illustrate the design methodology, a set of design methods for deriving systolic algorithms and architectures is given and the use of these methods in the design of a dynamic programming solver is described. The design methodology, together with this particular set of design methods, can be viewed as a general theory of systolic designs (or multidimensional pipelines). The fact that Crystal is a general purpose language for parallel programming allows new design methods and synthesis techniques, properties and theorems about problems in specific application domains, and new insights into any given problem to be integrated readily within the existing design framework.