The humble index register was crucial to the development of high-level languages.
On January 15, 1962, IBM announced its model 7094 mainframe. The 7094 was the fastest, most powerful computer of the second generation of computers. Among the improvements offered by the 7094 were an operating cycle of 2 microseconds and the ability to execute two instructions per storage cycle. Because it was the supercomputer of its age, the 7094 was used by NASA to control the flight operations of the Gemini and the Mercury space flights. In fact, a 7094 was kept as a standby during the first Apollo missions. Because the 7090 series of mainframes were the first to disassociate data channels and the hardware to which the cable was attached, thereby permitting both I/O interrupts and the simultaneous execution of I/O and storage instructions, the 7094 was used by MIT’s Project MAC for the world’s first time sharing system.
There was something else that the 7094 did that is often lost in the hype: it maximized the use of index registers. An index register is a specialized circuit (or register) found in the central processor that is used most often to process an array. The need to scroll through a table or an array of data was so obvious to the original programmers that the first index register was implemented in the University of Manchester’s Mark I in 1949.
Throughout the first and most of the second generation of mainframes, computer hardware designers assumed that main storage was slow and unstable. Accordingly, the only storage operations that these machines supported were fetch and save. In other words, neither computations nor transformations were performed on stored data. In the von Neumann model of computer architecture, program instructions were executed by the processor. As directed by the stored program, the processor would fetch a field of data and place it into a register within the processor itself.
It was within the processor or the Arithmetic Logical Unit (ALU) that the calculation or data manipulation happened. Once the operation was finished, the changed or calculated field of data was sent back to main storage. These register-to-register operations were much faster and more secure than they would have been if performed in the vacuum tubes that made up storage for the first generation of mainframes.
Within the processor, the absolute address of the next instruction to be executed was kept in a register, as was the absolute address of its data field. Without an index register, the absolute addresses of the next row or table entry had to be computed before the fields could be accessed.
Consider the following FORTRAN statement:
PERCNT is an array with a length of 101. The individual elements of PERCNT are addressed in FORTRAN with subscripts, so the tenth element can be designated with a subscript as PERCNT (9). The subscript is implemented by using an index register. Indeed, without index registers higher-level languages like FORTRAN and COBOL would not have been developed.
The IBM 7094 brought all of these elements together. It delivered either three or seven index registers, it ran the FORTRAN Operating System, and it ran like the wind. Later generations of mainframes, most directly IBM’s System 360, supported general-purpose registers. Any general-purpose register could be used as an index or used for register-to-register computations or data transformations. Sometime when you’ve nothing better to do, perform an internet search on Zilog’s first Z80 processor. When you locate the chip’s specifications, you’ll find the index register—the programmer’s best friend.
It began almost fifty years ago—and that’s when it happened.
Dan Wohlbruck has over 30 years of experience with computers, with over 25 years of business and project management experience in the life and health insurance industry. He has written articles for a variety of trade magazines and websites. He is currently hard at work on a book on the history of data processing.