Automatic transformation of high-level object-oriented specifications into parallel programs

doi:10.1016/0167-8191(89)90074-4

Parallel Computing

Volume 10, Issue 1, March 1989, Pages 15-28

https://doi.org/10.1016/0167-8191(89)90074-4 Get rights and content

Abstract

The basic principles and the overall design of the automatic transformation system SUSPENSE (SUprenum SPEcification tool for Numerical SoftwareE), which transforms specifications into parallel programs, are presented.

The system supports a high-level specification language for partial differetial equations (PDEs) and related areas in numerical analysis. The language offers facilities to describe and manipulate numerical objects such as vectors, matrices, domains, grids etc. on a high level of abstraction. Sequential algorithms can be formulated by means of general iterators which describe (in contrast to procedural programming languages) only partial orders on objects. Parallelism is obtained in a domain-specific way by splitting numerical objects such as grids, vectors etc. into segments which will be processed in parallel.

The target language for the transformation system is the parallel FORTRAN dialect SUPRENUM-FORTRAN. This language is under development as a part of the German supercomputer project SUPRENUM.

Algorithms written and transformed in SUSPENSE are tailored to the parallel SUPRENUM machine which consists of up to 256 processors with local memory only and message-based communication.

SUSPENSE demonstrates that well-known theoretical concepts from computer science such as high-level specifications, design by ‘stepwise refinement’ etc., work well in the field of numerical analysis and the generation of parallel programs.

References (32)

E Best
Adaequacy of path programs
K Kennedy et al.
An introduction to the set theoretical language SETL
J. Comput. Math. Appl.
(1975)
W Rönsch et al.
A linear algebra package for a local memory multiprocessor: Problems, proposals and solutions
Parallel Comput.
(1988)
K.R Apt et al.
A proof system for CSP
ACM Trans. Programming Languages and Systems
(1980)
American National Programming Language FORTRAN
(1978)
American National Standard for Information Systems Programming Language FORTRAN
Draft S8
(1987)
D.R Barstow
Domain-specific automatic programming
IEEE Trans. Software Engng
(1985)
F.L Bauer
P.M Behr et al.
The German supercomputer architecture — Rationale and concepts
C Beierle et al.
A software development environment integrating specification and programming languages

D.G Bobrow et al.

An overview of KRL

Cognitive Sci.

(1977)

R.M Burstall et al.

An informal introduction ro specifications using CLEAR

E.W Dijkstra

Guarded commands, nondeterminacy and formal derivation of programs

Comm. ACM

(1975)

E Ehses et al.

MIMD-Fortran, GMD-Report

(1986)

J.A Goguen et al.

An introduction to OBJ: a language for writing and testing formal algebraic program specifications

J.A Goguen et al.

An initial algebra approach to the specification, correctness and implementation of abstract data types

Cited by (9)

Kranc: a Mathematica package to generate numerical codes for tensorial evolution equations
2006, Computer Physics Communications
Citation Excerpt :
While the first approach avoids mixing of technologies, the second approach uses specialized technologies to deal with parts of the problem. For previous work on generating code from high-level problem descriptions see also Refs. [3–8]. We decided to adopt the second strategy for the following reasons.
We present a suite of Mathematica-based computer-algebra packages, termed “Kranc”, which comprise a toolbox to convert certain (tensorial) systems of partial differential evolution equations to parallelized C or Fortran code for solving initial boundary value problems. Kranc can be used as a “rapid prototyping” system for physicists or mathematicians handling very complicated systems of partial differential equations, but through integration into the Cactus computational toolkit we can also produce efficient parallelized production codes. Our work is motivated by the field of numerical relativity, where Kranc is used as a research tool by the authors. In this paper we describe the design and implementation of both the Mathematica packages and the resulting code, we discuss some example applications, and provide results on the performance of an example numerical code for the Einstein equations.
Title of program: Kranc
Catalogue identifier: ADXS_v1_0
Program summary URL: http://cpc.cs.qub.ac.uk/summaries/ADXS_v1_0
Program obtainable from: CPC Program Library, Queen's University of Belfast, N. Ireland
Distribution format: tar.gz
Computer for which the program is designed and others on which it has been tested: General computers which run Mathematica (for code generation) and Cactus (for numerical simulations), tested under Linux
Programming language used: Mathematica, C, Fortran 90
Memory required to execute with typical data: This depends on the number of variables and gridsize, the included ADM example requires 4308 KB
Has the code been vectorized or parallelized: The code is parallelized based on the Cactus framework.
Number of bytes in distributed program, including test data, etc.: 1 578 142
Number of lines in distributed program, including test data, etc.: 11 711
Nature of physical problem: Solution of partial differential equations in three space dimensions, which are formulated as an initial value problem. In particular, the program is geared towards handling very complex tensorial equations as they appear, e.g., in numerical relativity. The worked out examples comprise the Klein–Gordon equations, the Maxwell equations, and the ADM formulation of the Einstein equations.
Method of solution: The method of numerical solution is finite differencing and method of lines time integration, the numerical code is generated through a high level Mathematica interface.
Restrictions on the complexity of the program: Typical numerical relativity applications will contain up to several dozen evolution variables and thousands of source terms, Cactus applications have shown scaling up to several thousand processors and grid sizes exceeding 500³.
Typical running time: This depends on the number of variables and the grid size: the included ADM example takes approximately 100 seconds on a 1600 MHz Intel Pentium M processor.
Unusual features of the program: based on Mathematica and Cactus
Programming for exascale computers
2013, Computing in Science and Engineering
C Parallelizing Pre-processor for Flosolver Mk3
1998, Journal of the Institution of Engineers (India), Part CP: Computer Engineering Division
Abstract level parallelization of finite difference methods
1997, Scientific Programming
Code generation in ALPAL using symbolic techniques
1992, Proceedings of the International Symposium on Symbolic and Algebraic Computation, ISSAC
How symbolic computation boosts productivity in the simulation of partial differential equations
1991, Journal of Scientific Computing

View all citing articles on Scopus

^☆: The work described in this report is being carried out as part of the German Supercomputer project SUPRENUM and is funded by the Federal Ministry for Research and Technology, Fed. Rep. Germany, under grant number ITR8502D0. The authors assume all responsibility for the contents of this report.

View full text

Automatic transformation of high-level object-oriented specifications into parallel programs☆

Abstract

J. Comput. Math. Appl.

Parallel Comput.

A proof system for CSP

ACM Trans. Programming Languages and Systems

American National Programming Language FORTRAN

American National Standard for Information Systems Programming Language FORTRAN

Draft S8

Domain-specific automatic programming

IEEE Trans. Software Engng

The German supercomputer architecture — Rationale and concepts

A software development environment integrating specification and programming languages