December 1972 - Vol. 15 No. 12
Features
Dynamic partitioning for array languages
The classical process of partitioning an array into subarrays is extended to a more useful array language operation. Various modes of partitioning are defined for different types of arrays, so that subarrays may vary over the original array in a nearly arbitrary manner. These definitions are motivated with several realistic examples to illustrate the value of partitioning for array languages.
Of general interest is the data structure for partitioning. This consists of dynamic tree structures which are used to derive and maintain the array control information. These are described in sufficient detail to be of value in the design of other array languages. The description presented in this paper is implemented in a new array language, OL/2, currently under development at the University of Illinois.
Index ranges for matrix calculi
The paper describes a scheme for symbolic manipulation of index expressions which arise as a by-product of the symbolic manipulation of expressions in the matrix calculi described by the authors in a previous paper. This scheme attempts program optimization by transforming the original algorithm rather than the machine code.
The goal is to automatically generate code for handling the tedious address calculations necessitated by complicated data structures. The paper is therefore preoccupied with “indexing by position.” The relationship of “indexing by name” and “indexing by position” is discussed.
A method for incrementally compiling languages with nested statement structure
A method of incremental compilation is presented which applies especially to programming languages in which statements can be nested (such as Algol and PL/I). The method permits editing of the source language using a general purpose text editor, and incremental processing of changes without frequent recompilation of entire routines. The essential points of the method are: (1) the syntax of the language is restricted insofar as which constructs may occur on lines; (2) an internal data structure (called the skeleton) is maintained to represent the statement structure; (3) the recompilation is partially batched in the sense that recompilation of modified lines does not occur until the last of a set of editing commands has been received; and (4) the parsing and compilation are factored into two parts, that done on individual lines and that done globally to handle the relationships between the lines.
Weighted increment linear search for scatter tables
A new linear search for hash tables whose increment step is a function of the key being addressed is presented. Comparisons with known methods are given, in terms of efficiency and computation complexity. In particular, the new method applies to tables of size n = 2r. It allows full table searching, and practically eliminates primary clustering at a very low cost.
A comparison of multivariate normal generators
Three methods for generating outcomes on multivariate normal random vectors with a specified variance-covariance matrix are presented. A comparison is made to determine which method requires the least computer execution time and memory space when utilizing the IBM 360/67. All methods use as a basis a standard Gaussian random number generator. Results of the comparison indicate that the method based on triangular factorization of the covariance matrix generally requires less memory space and computer time than the other two methods.
A new method for the solution of the Cauchy problem for parabolic equations
partial differential equations. When the equations are defined in unbounded domains, as in the initial value (Cauchy) problem, the solution of the integral equation by the method of successive approximation has inherent advantages over other methods. Error bounds for the method are of order h3/2 and h7/2 (h is the increment size) depending on the finite difference approximations involved.
On the criteria to be used in decomposing systems into modules
This paper discusses modularization as a mechanism for improving the flexibility and comprehensibility of a system while allowing the shortening of its development time. The effectiveness of a “modularization” is dependent upon the criteria used in dividing the system into modules. A system design problem is presented and both a conventional and unconventional decomposition are described. It is shown that the unconventional decompositions have distinct advantages for the goals outlined. The criteria used in arriving at the decompositions are discussed. The unconventional decomposition, if implemented with the conventional assumption that a module consists of one or more subroutines, will be less efficient in most cases. An alternative approach to implementation which does not have this effect is sketched.
Levels of language for portable software
An increasing amount of software is being implemented in a portable form. A popular way of accomplishing this is to encode the software in a specially designed machine-independent language and then to map this language, often using a macro processor, into the assembly language of each desired object machine. The design of the machine-independent language is the key factor in this operation. This paper discusses the relative merits of pitching this language at a high level or a low level, and presents some comparative results.
Trace-driven modeling and analysis of CPU scheduling in a multiprogramming system
Microscopic level job stream data obtained in a production environment by an event-driven software probe is used to drive a model of a multiprogramming computer system. The CPU scheduling algorithm of the model is systematically varied. This technique, called trace-driven modeling, provides an accurate replica of a production environment for the testing of variations in the system. At the same time alterations in scheduling methods can be easily carried out in a controlled way with cause and effects relationships being isolated. The scheduling methods tested included the best possible and worst possible methods, the traditional methods of multiprogramming theory, round-robin, first-come-first-served, etc., and dynamic predictors. The relative and absolute performances of these scheduling methods are given. It is concluded that a successful CPU scheduling method must be preemptive and must prevent a given job from holding the CPU for too long a period.
