Multigrid convergence rates degenerate on, problems with stretched grids or anisotropic operators, unless one uses line or plane relaxation. For three dimensional problems, only plane relaxation suffices, in general. While line and plane relaxation algorithms are efficient on sequential machines, they are quite awkward and inefficient on parallel machines. This paper presents a new multigrid algorithm, based on the use of multiple coarse grids, that eliminates the need for line or plane relaxation in anisotropic problems. We develop this algorithm, andextend the standard multigrid theory to establish rapid convergence for this class of algorithms. The new algorithm uses only point relaxation, allowing easy and cfficient parallel implementation, yet achieves robustness and convergence rates comparable to line and plane relaxation multigrid algorithms.The algorithm described here is a variant of Mulder's multigrid algorithm [5] for hyperbolic problems. The latter uses multiple coarse grids to achieve robustness, but is unsuitable for elliptic problems, since its V-cycle convergence rate goes to one as the number of levels increases. The new algorithm combi nes the contributions from the multiple coarse grids via a local "switch," based on the strength of the discrete operator in each coordinate direction. This improvement allows us to show that the V-cycle convergence rate is uniformly bounded away from one, on model anisotropic problems. Moreover, the new algorithm can be combined with the idea of concurrent iteration on all multigrid levels to yield a highly parallel algorithm for strongly anlisotrol)ic problems.

Data parallel languages, such as High Performance Fortran, can be successfully applied to a wide range of numerical applications.However, many advanced scientific and engineering applications are multidisciplinary and heterogeneous in nature, and thus do not fit well into the data parallel paradigm. In this paper we present Opus, a language designed to fill this gap. The central concept of Opus is a mechanism called ShareD Abstractions (SDA). An SDA can be used as a computation server, i.e., a locus of computational activity, or as a data repository for sharing data between asynchronous tasks. SDAs can be internally data parallel, providing support for the integration of data and task parallelism as well as nested task parallelism. They can thus be used to express multidisciplinary applications in a natural and efficient way. In this paper we describe the features of the language through a series of examples and give an overview of the runtime support required to implement these concepts in parallel and distributed environments.

Programming nonshared memory systems is more difficult than programming shared memory systems, since there is no support for shared data structures. Current programming languages for distributed memory architectures force the user to decompose aU data structures into separate pieces, with each piece "owned" by one of the processors in the machine, and with all communication explicitly specified by low-level message-passing primitives. This paper presents a new programming environment for distributed memory architectures, providing a global name space and allowing direct access to remote parts of data values. In order to retain efficiency, we provide a system of annotations allowing the user to retain control over aspects of the program critical to performance, such as data distributions and load balancing. This paper describes the analysis and program transformations required to implement this environment, and shows the efficiency of the resulting code with an example program tested on an NCUBE hypercube.

No abstract

We have recently introduced Opus, a set of Fortran language extensions that provide shared data abstractions (SDAs) as a mechanism for communication and synchronization among coarse-grain data parallel tasks. In this paper, we discuss the design and implementation issues of the runtime system necessary to support SDAs, and outline the underlying requzrements for such a runtzme system. W e explore the feasibility of this approach by implementing a prototype of the runtrme system. We give prelimznary results of the prototype on the Intel Paragon, outline the current status of the project, and discuss future plans.