James M. Boyle

The TAMPR program transformation system: simplifying the development of numerical software

Writing correct numerical software is a complex, demanding, and, at times, even a boring, task. In this chapter, we describe an approach to constructing software—program specification and transformation—and allied tools that can help not only to ensure the correctness of numerical computations but also automate much of the drudge-work involved in preparing such software. This approach to software construction holds out the exciting prospect of enabling the numerical analyst or specialist in scientific computing to concentrate on correctly capturing the problem to be solved, while delegating the details of programming the software and adapting it to specialized computing environments to automated tools.

A practical functional program for the CRAY X-MP

One can have all the advantages of functional programming – correctness, clarity, simplicity, and flexibility – without any sacrifice in performance, even for a scientifically significant computation on a supercomputer. Therefore, why use Fortran? We demonstrate parity – equality of speed and storage use – between a program generated automatically from a functional specification and a program written by hand in the procedural style. To our knowledge, this demonstration of parity is the first for a program that solves a scientifically significant problem – quasi-linear hyperbolic partial differential equations – on a scientifically interesting supercomputer – the CRAY X-MP. We use pure Lisp, including higher-order functions, to express the functional specification for the PDE solver. We designed this specification for maximal clarity and flexibility, rather than for efficiency. Nevertheless, we obtain a highly efficient program to solve the PDEs: automated program transformations put back the missing efficiency as they produce an executable Fortran program from the specification. The generated Fortran program vectorizes on the CRAY X-MP and runs about 4% faster than a handwritten Fortran program for the same problem. We describe the problem and the specification, and some of the problem-domain-specific and hardware-specific transformations that we use to obtain the high-efficiency program.

The automated transformation of abstract specifications of numerical algorithms into efficient array processor implementations

Abstract We present a set of program transformations which are applied automatically to convert abstract functional specifications of numerical algorithms into efficient implementations tailored to the AMT DAP array processor. The transformations are based upon a formal algebra of a functional array form, which provides a functional model of the array operations supported by the DAP programming language. The transformations are shown to be complete. We present specifications and derivations of two example algorithms: an algorithm for computing eigensystems and an algorithm for solving systems of linear equations. For the former, we compare the execution performance of the implementation derived by transformation with the performance of an independent, manually constructed implementation; the efficiency of the derived implementation matches that of the manually constructed implementation.

Proving refinement transformations for deriving high-assurance software

The construction of a high-assurance system requires some evidence, ideally a proof, that the system as implemented will behave as required. Direct proofs of implementations do not scale up well as systems become more complex and therefore are of limited value. In recent years, refinement-based approaches have been investigated as a means to manage the complexity inherent in the verification process. In a refinement-based approach, a high-level specification is converted into an implementation through a number of refinement steps. The hope is that the proofs of the individual refinement steps will be easier than a direct proof of the implementation. However, if stepwise refinement is performed manually, the number of steps is severly limited, implying that the size of each step is large. If refinement steps are large, then proofs of their correctness will not be much easier than a direct proof of the implementation. We describe an approach to refinement-based software development that is based on automatic application of refinements, expressed as program transformations. This automation has the desirable effect that the refinement steps can be extremely small and, thus, easy to prove correct. We give an overview of the TAMPR transformation system that we use for automated refinement. We then focus on some aspects of the semantic framework that we have been developing to enable proofs that TAMPR transformations are correctness preserving. With this framework proofs of correctness for transformations can be obtained with the assistance of an automated reasoning system.

The Construction of Numerical Mathematical Software for the AMT DAP by Program Transformation

We have shown that it is possible mechanically to produce a highly efficient implementation tailored for execution on the AMT DAP 510 of a high-level functional specification. The functional specification is not biased in ways that would permit its efficient execution on a particular machine architecture, but is expressed in a way that gives a clear statement of the algorithm. Indeed, the functional specification may be used as the starting point for producing implementations tailored for execution on other machines (and will be used in this way in future investigations).

Using knowledge-based transformations to reverse-engineer COBOL programs

We describe a program restructuring tool under development. The tool is constructed using program transformations executed by the TAMPR program transformation system. We discuss the knowledge embodied in the transformations and how they restructure an example COBOL program developed in the mid-1970s. While the tool needs to be extended further to produce a robust commercial product, early use for restructuring COBOL programs demonstrates the power and flexibility of this transformational approach.

Lisp to Fortran—Program Transformation Applied

You have written a moderately large applicative Lisp program (3200 lines, 56 functions). It is thoroughly debugged and has been in use for several years. You have received numerous requests for the system of which the program is a part. You have decided to make that system available as part of a larger package for which Fortran has been chosen as the transportable implementation language. The program must run compiled in order for its use to be practical. What do you do?

Transformations to Restructure and Re–engineer COBOL Programs

In this paper we describe a COBOL-program restructuring tool currently under development. The tool is constructed using program transformations executed by the TAMPR program transformation system. We discuss the COBOL knowledge embodied in the transformations and how they restructure an example COBOL program developed in the mid–1970s. While the tool is not yet a robust commercial product, early use for restructuring COBOL programs demonstrates the power and flexibility of this transformation–based approach.

A Family of Data-Parallel Derivations

A good programmer attempts to minimize architecture-specific detail when writing a sequential implementation of an algorithm. Such good programming practice makes it possible to transport the implementation to other hardware architectures and thus minimize programmer effort. Indeed, high-level programming languages attempt to hide the detail required by particular machine architectures and thus make it easier to construct programs and transport them. When using traditional methods to implement an algorithm for an advanced parallel architecture, the programmer faces the dilemma of

Perceptual basis for reactive teleoperation

To improve task performance in partially structured environments, enhancements to teleoperation have been proposed by introducing autonomous behaviors. Such autonomy is implemented based on a reactive robotic architecture, where reactive motor agents that directly couple sensory inputs and motor actions become the building blocks. To this end, a perceptual basis for the motor agents is presented in this paper. The perceptual basis consists of perceptual agents that extract environmental information from a structured light vision system and provide action-oriented perception for the corresponding motor agents. Rather than performing general scene reconstruction, a perceptual agent directly provides the motion reference for the motor behavior. Various sensory mechanisms - sensor fission, fusion, and fashion - become basic building blocks of the perception process. Since perception is a process deeply intertwined with the motor actions, active perception may also incorporate motor behaviors as an integral perceptual process.