The Intel Concurrent File System (CFS) for the iPSC/2 hypercube is one of the first production file systems to utilize the declustering of large files across numbers of disks to improve I/O performance. The CFS also makes use of dedicated I/O nodes, operating asynchronously, which provide file caching and prefetching. Processing of I/O requests is distributed between the compute node that initiates the request and the I/O nodes that service the request. The effects of the various design decisions in the Intel CFS are difficult to determine without measurements of an actual system. We present performance measurements of the CFS for a hypercube with 32 compute nodes and four I/0 nodes (four disks). Measurement of read/write rates for one compute node to one I/O node, one compute node to multiple I/O nodes, and multiple compute nodes to multiple I/O nodes form the basis for the study. Additional measurements show the effects of different buffer sizes, caching, prefetching, and file preallocation on system performance.

The January 1989 report of the ACM Task Force on the Core of Computer Science (COCS) presents a critique of the traditional computer science introductory curriculum and suggests a radically different alternative: a three-semester survey course of the whole of the field.This paper presents an overview and critique of the COCS report and suggests an alternative vision of how to upgrade the CSI course.The alternative is based on an evolution from the current CSl to a course with more depth and rigor, and with a sense of history, but without broadening the focus beyond the traditional topics of algorithms, data structures, software methodology and a single high-level programming language.A new text serves as an "existence proof" of the viability of the approach.

A new approach is described to the teaching of introductory computer programming and computer science (the CS1 course). The approach is based on a new view of what “programming” is fundamentally about. The central feature of the approach is the teaching of skills in program analysis along with the traditional emphasis on skills in program synthesis. The approach was class tested in an earlier version in 1986, and the difficulties encountered in the class test led to two supporting changes in the course content: (1) data structures are introduced at the beginning of the course, and (2) the concept of program state is introduced as a key element in understanding programs.

A large array is an array whose storage is distributed among primary and secondary storage and whose processing may be distributed among several tasks in a distributed system. This paper presents a semantic model (set of language concepts) for representing large arrays in a distributed system in such a way that the performance realities inherent in the distributed storage and processing can be adequately represented. An implementation of the large array concept as an ADA package (abstract data type) is described, as well as a particular tailoring of the concept for the NASA Finite Element Machine. An example application program using the package is also described.

The control computation for a loop in a program is that part of the program concerned with the initialization, incrementation, and testing of the variables that determine the flow of control into, through, and out of the loop. The elements of loop control computations are idenified and their role in structuring our understanding of loops is analyzed. It is argued, through examples drawn from a Pascal compiler, that the intelligibility of a loop is closely tied to the accessibility and intelligibility of the loop control computation. It is further argued, from an analysis of all the loops in this compiler, that most loop control computations fail in a few standard patterns, mostly concerned with the sequential processing of elements of data structures. In light of these results, common loop control statements are critiqued. It appears that better loop control structures than the while, repeat-until, and similar statement structures are possible and desirable, and some proposals for better structures are given.

The analysis of the relation between the structure of a program and the function that it computes requires a decomposition of the program into its components. Traditionally this decomposition has been based on the common division of a program into subprograms, and ultimately into statements, expressions and individual variables and constants. In this paper an alternative decomposition is proposed that is based on the decomposition of a program into a set of kernel elements, those program elements that participate in the direct computation of the outputs of the program, and a set of control elements, those elements that participate in the determination of the execution path. The kernel-control decomposition of a program leads to a series of progressively more abstract program representations, each of which has both theoretical and practical interest. The separation of control structure from kernel and the three abstract models presented here, which are based on this decomposition, are particularly valuable in the analysis and optimization of program control structures. This research summary outlines the major results, which will be reported in full in a journal article.