Fortran 8x Research Articles

Data parallel computers and the Forall statement

The array constructs of Fortran 90 (formerly called Fortran 8x) map naturally onto SIMD architectures, such as that of the Connection Machine computer system, that support a data parallel programming style. The Forall statement, an extension to Fortran 90 allowing for the expression of simultaneous execution of certain do loop bodies, enhances this natural fit. A Fortran 90 compiler for data parallel machines is naturally extended to handle the Forall statement. We describe the data structures and algorithms used to effect this extension and present some examples of source code fragments and the target operations generated for them.

The calculus of context relations

We present the theory of context relations. Context relations are a method for incremental semantic analysis in language-specific editors, which is able to handle incomplete program fragments. The algorithm is generated from the definition of a language's static semantics and is based on inference rules and order-sorted unification. The paper presents the underlying mathematical theory, optimal incremental analysis algorithms, handling of user-defined polymorphism and overloading, and implementation issues. It is intended as the concluding report on a by now mature concept, which has successfully been used to generate efficient incremental type inferencers for languages like ADA and Fortran 8x.

Molecular Dynamics on the Connection Machine using Fortran

Abstract A new algorithm for molecular dynamics on the Connection Machine is presented and compared to an algorithm known from literature. The algorithms have been in implemented in CM Fortran 8x. Their performances, measured in CPU time, are compared and discussed for the simple Lennard-Jones system and for a liquid charged particle system. The implementation and performance of the Ewald sum, used for the charged particle system, is presented and discussed. The new algorithm is suitable for use with a cut off radius. Other advantages of the algorithm are discussed.

The Fortran (not the foresight) Saga: the light and the dark

Week by week we read about corporate battles for shares in a market, be it hardware, software or services, about takeover manoeuvrings and buyouts, about rival consortia seeking to dominate areas like Unix or networking. Yet these ongoing stories, hard though they may sometimes be to follow, have the complexity of a Ladybird book, compared with the long-running saga of the Fortran 8X standard.

EVA: an explicit vector language

Fortran is the main language used on supercomputer today. Indeed, all supercomputers compilers have extensions, providing language features for explicit vector handling, to Fortran 77. These extensions are different on each machine and their functions are limited. Even with the next standard Fortran 8x, vector syntax is incomplete. EVA is an explicit vector language with powerful vector handling tools. Taking into account the billion of dollars invested in productive Fortran 77 programs, EVA has been designed keeping in mind Fortran and C interface facilities.

Parallel algorithms for SIMD computers

Parallel Algorithms that manipulate multi-dimensional arrays on two-dimensional SIMD processor arrays are described here. The definition of these algorithms, which will be called COMPRESS and EXPAND is taken from APL and FORTRAN 8X. These algorithms have already been studied under the constraint that the number of elements is equal to the number processing elements. In the algorithms presented here these restrictions are lifted. Therefore the application of these algorithms contributes to transforming array languages into more general use languages.

Book Review: Fortran 8x Explained, Revised Edition, by Michael Metcalf and John Reid. (Oxford University Press, New York 1989)

In the normal course of events, a language is born, evolves, textbooks crafted, standards hammered out, and textbooks revised.

From the editor

1. Distribution of the Fortran draft. In our last episode (dated August 1989), we told you that we were unable to get permission to distribute the May 1989 Fortran 8X draft as an issue of Fortran Forum. Then, some time around the middle of December, you got a copy in the mail. What happened?

Aftran: Array Fortran programming language

Widespread use of vector pipeline supercomputers is restricted due to the machine-dependent task of vectorization. Though automatic vectorizers can be used to produce machine-dependent vectorized code from Fortran 77 code, algorithms and structures have to be carefully designed to allow efficient vectorization. An alternative approach is to write explicity vectorized programs in a language such as Fortran 8x with vector or array instructions. However, we anticipate that it will be a long time before Fortran 8x compilers are widely available. An ongoing project at the Supercomputer Computations Research Institute (SCRI) and Computer Science Department of FSU has defined the language Aftran, which adds much of the array processing capabilities of Fortran 8x [1] to Fortran 77. This paper discusses the features, design and implementation of this prototype for Fortran 77 target transformations.

Fortran 8X draft

Standard Programming Language Fortran. This standard specifies the form and establishes the interpretation of programs expressed in the Fortran language. It consists of the specification of the language Fortran. No subsets are specified in this standard. The previous standard, commonly known as "FORTRAN 77", is entirely contained within this standard, known as "Fortran 8x". Therefore, any standard-conforming FORTRAN 77 program is standard conforming under this standard. New features can be compatibly incorporated into such programs, with any exceptions clearly indicated in the text of this standard.

The comparison and selection of programming languages for high energy physics applications

In this paper a comparison is presented of programming languages in the context of high energy physics software applications. The evaluation method used was specifically devised to address the issues of particular importance to HEP applications, not just the technical features of the languages considered. The candidate languages evaluated were Ada, C, FORTRAN 77, FORTRAN 8x, Pascal and PL/I. Some conclusions are drawn and recommendations made regarding the role of FORTRAN and other programming languages in the current and future development of HEP software.

Recent progress in fortran standardization

The fortunes of Fortran have changed markedly over the last two years. An increasingly gloomy outlook for the new standard, Fortran 8x, culminated in a complete impasse in the summer of 1988. The deadlock was broken as the result of firm action by the international community and X3J3's positive response to that pressure. In this paper, the consequent changes which have been made to the draft standard since last autumn will be outlined.

A Vector Algorithm for Lattice Gas Hydrodynamics

A code implementing a cellular automaton for simu lating fluid flows is presented in the style of Fortran 8X. Major data structures and the boundary characteristics are represented by bit vectors, resulting in efficient use of memory. Use of vector-length, bitwise operations yields significant speedup. The code is equally applicable to other vector supercomputers that support the full range of boolean operations.

Semantic extension possibilities in the proposed new fortran

AbstractThe next revision of the standard Fortran language, commonly referred to as Fortran 8x, has now been published, at least in draft form. It is therefore possible for some of its new features to be investigated and the type of programming that can be expected when implementations appear to be explored. This paper looks at the scope provided by the proposed new features for 'semantic extension' of the language. The capability is illustrated by way of example code which could provide an extended‐precision numeric facility if implemented. The new linguistic constructs that permit this type of approach to software provision are described as they are used.

Computer sciences for geophysicists. Part IX: the reliability of software, geophysical or otherwise

I expect some of you are still wondering what happened to the article in this series on graphics, devices, standards usage and so on. I still am. I suppose I ought to come clean and admit the real problem, which is not so much indolence on my part as the essentially ephemeral nature of graphics standards. It seems as though these standards possess a fifth force of nature to accompany weak, strong, electromagnetic and gravitational forces. This force is the political force. In essence, it works like this. Different graphics committees come together, exchange a DISON, an elementary particle of unbelievable mass which carries a Draft International Standard, no charm and little agreement. Having done this, the exchangers then diverge as rapidly as possible, often exceeding the speed at which free food and drinks disappear at Icebreakers. Thus it is with three-dimensional (3D) graphics (and FORTRAN 8X). After the various international organizations came together fleetingly like mayflies on a balmy day producing GKS, the Graphical Kemel System for two-dimensional (2D) graphics, they have now set off in opposite directions to produce Draft Standards for 3D which are almost but not quite, completely dissimilar. If you wish to keep up with things, the current protagonists are PHIGS (look it up) and GKS 3D. Coupled with other standards which seem to be vying for attention, such as CGI, (Computer Graphics Interface), which is a NQTS (Not Quite The Same) standard, I have temporarily given up and clutch at GKS 2D as a rock in an otherwise uneasy ocean. The very best thing you can do with graphics standards seems to be nothing as yet unless you are brave and rich enough to go it alone. The real subject I would like to address here is one which is rapidly assuming great importance to everybody involved in the use of software. This is the subject of reliability.

An optimizing precompiler for finite-difference computations on a vector computer

This paper is concerned with techniques for translating array expressions, as found in FORTRAN 8X, into very efficient vector expressions on a machine in which long vectors are needed for high performance. It describes the application of these techniques in a precompiler for the CYBER 205 which requires a vector length of 1000 to achieve 90% of the asymptotic speed. The precompiler does not vectorize FORTRAN 77 DO loops, instead it vectorizes and optimizes programs written in the explicit array syntax of the proposed FORTRAN standard (FORTRAN 8X). The optimization of the vector code is intended to be most effective for algorithms commonly used in finite-difference approximations of partial differential equations. Finite-difference schemes frequently evaluate the same expression over the interior of a multidimensional rectangular array. In these computations the precompiler is able to vectorize arithmetic operations over the entire array, rather than over individual dimensions, thus generating relatively long vectors. This vectorization is done, whenever possible, without using expensive gather operations. When gather operations must be used the precompiler attempts to minimize them by making one gather serve for several operands through the use of masks and offsets.

Fortran 8x Explained

First Page

Edward Reid:some comments on Fortran 8X

During the public review period on Fortran 8X, I submitted rather extensive comments (totalling about 31 pages) which are obviously too long for full publication in Fortran Forum. I have summarized some parts of the comments that may be of interest to Forum readers.

A review and analysis of Fortran 8x

The ANSI Standards Subcommittee X3J3 on Fortran has recently completed a draft proposed standard for the Fortran programming language. The draft proposed standard, known informally as Fortran 8x, is a revision of the current standard X3.9-1978, known informally as Fortran 77. This report is a review of Fortran 8x and consists of a series of six articles. The first article gives a general overview of Fortran 8x. The next three articles give brief discussions of the array facilities; the enhanced numeric facilities; and user-defined data types, procedure interfaces, and the new program unit called a module. The fifth article provides a brief analysis of the controversial issues discussed by X3J3 (including both the accepted and rejected facilities for Fortran 8x). The sixth article gives a brief comparison with Ada. The report concludes with a summary giving information on how and where to express opinions of the draft proposed standard.

More on Fortran 8X pointer proposals

Here is a program that I wrote to test the proposals of Burch, Schonfelder, et al for adding pointers to Fortran 8X. I read a comment by Steven O. Siegfried of Saint Paul MN that "it's tough to build a binary tree with implicit [de]referencing", and I wanted to see what the problems were.