Robert W. Numrich

Co-array Fortran for parallel programming

Co-Array Fortran, formerly known as F--, is a small extension of Fortran 95 for parallel processing. A Co-Array Fortran program is interpreted as if it were replicated a number of times and all copies were executed asynchronously. Each copy has its own set of data objects and is termed an image. The array syntax of Fortran 95 is extended with additional trailing subscripts in square brackets to give a clear and straightforward representation of any access to data that is spread across images.References without square brackets are to local data, so code that can run independently is uncluttered. Only where there are square brackets, or where there is a procedure call and the procedure contains square brackets, is communication between images involved.There are intrinsic procedures to synchronize images, return the number of images, and return the index of the current image.We introduce the extension; give examples to illustrate how clear, powerful, and flexible it can be; and provide a technical definition.

Improving performance via mini-applications.

Application performance is determined by a combination of many choices: hardware platform, runtime environment, languages and compilers used, algorithm choice and implementation, and more. In this complicated environment, we find that the use of mini-applications - small self-contained proxies for real applications - is an excellent approach for rapidly exploring the parameter space of all these choices. Furthermore, use of mini-applications enriches the interaction between application, library and computer system developers by providing explicit functioning software and concrete performance results that lead to detailed, focused discussions of design trade-offs, algorithm choices and runtime performance issues. In this paper we discuss a collection of mini-applications and demonstrate how we use them to analyze and improve application performance on new and future computer platforms.

Measurement of Communication Rates on the Cray T3D Interprocessor Network

We measure communication rates for the Cray T3D interprocessor network. First we design experiments with no contention on the network to establish the achievable fraction of the peak hardware rate. Then we increase the contention with a sequence of experiments designed to measure the robustness of the network. We analyze the results in terms of the Hockney parameters, r∞ and n1/2.

Writing a Multigrid Solver Using Co-array Fortran

Co-Array Fortran, known previously as F−-, is an extension to Fortran 95 that combines elegance of expression with simplicity of implementation to give an efficient parallel programming language. We illustrate its power and efficiency with a multigrid solver for Poisson’s equation in three dimensions. We examine the effect of latency and bandwidth for the co-array version compared with an equivalent MPI version on two machines, the SGI/CRAY ORIGIN 2000 and the CRAY-T3E.

F--: A Parallel Extension to Cray Fortran

F-- is a parallel extension to Cray Fortran 77 for distributed memory computers. It adds exactly one new symbol to the language, a vertical line that separates two sets of indices. The first set contains the coordinates for data in a local data grid. The second set contains the coordinates for processors in a global processor grid. A statement such as x(i,j)=y(i,j| p,q) generates a load from remote address y(i,j) in the data grid on processor (p,q) followed by a store to local address x(i,j) in the local data grid. F-- syntax requires an explicit statement of the relationship between data layout and processor layout. It assumes that good performance on a distributed memory computer requires the programmer to understand and to exploit data locality. Programmers use the F-- syntax only when it is needed. 0therwise all data are local and all code is local. Compiler and library developers concentrate on generating well-optimized local code.

Co-arrays in the next Fortran Standard

The WG5 committee, at its meeting in Delft, May 2005, decided to include co-arrays in the next Fortran Standard. A Fortran program containing co-arrays is interpreted as if it were replicated a fixed number of times and all copies were executed asynchronously. Each copy has its own set of data objects and is called an image. The array syntax of Fortran is extended with additional trailing subscripts in square brackets to give a clear and straightforward representation of access to data on other images. References without square brackets are to local data, so code that can run independently is uncluttered. Any occurrence of square brackets is a warning about communication between images. The additional syntax requires support in the compiler, but it has been designed to be easy to implement and to give the compiler scope both to apply its optimizations within each image and to optimize the communication between images. The extension includes execution control statements for synchronizing images and intrinsic procedures to return the number of images, to return the index of the current image, and to perform collective operations. The paper does not attempt to describe the full details of the feature as it now appears in the draft of the new standard. Instead, we describe a subset and demonstrate the use of this subset with examples.

A metric space for productivity measurement in software development

We define a metric space to measure the contributions of individual programmers to a software development project. It allows us to measure the distance between the contributions of two different programmers as well as the absolute contribution of each individual programmer. Our metric is based on an action function that provides a picture of how one programmers approach differs from another at each instance of time during the project. We apply our metric to data we collected from students taking a course in parallel programming. We display the pictures for two students who showed approximately equal contributions but who followed very different paths through the course.

A metric space for computer programs and the principle of computational least action

Abstract We define a normed metric space for computer programs and derive from it the Principle of Computational Least Action. In our model, programs follow trajectories determined by Newton’s equation of motion in an abstract computational phase space and generate computational action as they evolve. A program’s action norm is the L1-norm of its action function, and its distance from other programs is the distance derived from the action norm. The Principle of Computational Least Action states the goal of performance optimization as finding the program with the smallest action norm. We illustrate this principle by analyzing a simple program.

Parallel numerical algorithms based on tensor notation and Co-Array Fortran syntax

Co-Array Fortran represents a correspondence between tensor notation and an extended Fortran array syntax. It uses normal Fortran array indices to point to data in local memory and adds co-array indices to point to data in remote memory. By writing algorithms according to the rules of tensor algebra, the programmer can transcribe a parallel algorithm directly into co-array syntax and can experiment with alternative communication patterns with full confidence that the algorithm is correct. Data communication is transparent in the notation itself and the syntax allows compilers to exploit low-latency hardware so that application codes scale well to large numbers of processors. Co-array syntax, combined with the object-oriented features of Fortran 90, is a powerful tool for designing and writing parallel algorithms. It raises the level of abstraction with little or no loss of performance.

Performance Metrics Based on Computational Action

We propose a new performance metric based on computational action. We examine work as it evolves in time and compute computational action as the integral of the work function over time. We compare the action generated at less than full power with the action that could have been generated at full power. We claim that the goal of performance optimization is to minimize lost, or wasted, action. We calculate our metric for some computers in the Top500 list (http://www.top500.org) and propose a new ranking based on least action wasted. When work is a function of the resources applied, we use the classical techniques of the calculus of variations to minimize wasted action. From the result of this exercise, we calculate productivity as the ratio of work produced to resources used.