My first computer.

It must have been September of 1970 when I left home and travelled to Tucson, Arizona. Soon after I arrived, I signed up for SIE 78, a one-unit Fortran course. I remember asking another student (at the University of Arizona). What the heck is FORTRAN? They told me it was a computer course, and I wanted a one-unit course to fill my schedule up to 19 units, so I added it to my program.

At that time there were 2 computers on campus. The CDC 6400 which served the entire campus, and a little Univac over in the math department. The intriguing aspect of the Univac was that people who used it (once certified), signed up for time slots, then actually entered the room where it was and touched it! The CDC on the other hand was sequestered in a huge room and was served by an elite order of priests (the operators). Folks like myself got to touch a keypunch, then handed the resulting card deck to a person behind a counter.

The architecture of the CDC 6400 series.

The 6400 was eventually replaced by the 6600, and then the 7600 came along. They all were members of a closely related family. See the little book, "Assembly Language Programming for the Control Data 6000 Series" by Ralph Grishman, Algorithmics Press, 1972. Virtually all of the following information comes from that book.

The 6600 was first shipped in 1965, and was the most powerful computer of its time. There were also models 6200, 6400, 6500, and 6700 in the family. The 7600 began shipping in 1969 and was 5-6 times faster than the 6600.

The 6600 could do an integer add in 300 ns, a floating point add in 400 ns, and a floating point multiply in 1000 ns. It also had independent execution units, so it could do two multiplications, an addition, and a floating add in parallel.

The 6400 did an integer add in 600 ns, and took 5700 ns to do a floating point multiply.

The 7600 did the integer add in 55 ns, and the multiply in 137.5 ns.

The memory of the 6600 was typicall 131,072 words, built out of ferrite cores. Smaller memories of 32,768, or 65,536 words were also shipped. The full memory system cost on the order of one million dollars. 7600 only shipped with the smaller memories. These words were 60 bits, and a single word could potentially hold more than one instruction.

(It was a word addressed machine, and 17 bits addresses 131,072 words.) Read memory access time was 500 ns, write access was 1000 ns. Memory was arranged in 32 banks and several of these could run in parallel to allow on the order of 10 million reads or writes each second. The 7600 was faster, reads took 137.5 ns, writes took 275 ns.

The machines had a 60 bit word, and instructions could be 15, 30, or 60 bits in size.

The cpu had 8 each of 3 types of registers: A, X, and B registers. The X registers were 60 bits and were used for computation. The A registers held addresses and were 18 bits in size. The B registers were also 18 bits in size and could be called index registers.

The A and X registers had a unique coupling (with the exception of A0 and X0) A1 thru A5 were used to read memory. You placed an address into A1 and the memory word at that address was fetched into X1. A6 and A7 were similarly used to write. You placed an address into A6 and the contents of X6 was stored into the memory word at that address. Knowing all this, you can comprehend the dedication to Grishman's book, which reads:

This book is dedicated to A6 and A7, without which none of the results in this book could have been saved.

The B registers were on their own, the only unusual things was that the B0 register had an immutable value of zero.

There were 64 op codes (the instructions had a 6-bit opcode field). One op code was divided into 8 instructions, so there were actually 71 instructions. All very RISC-like and very much ahead of its time. All memory accesses were load/store via the A/X register arrangement.

30 bit instructions typically included an 18 bit constant. 15 bit instructions were mostly register to register.

Octal representation was the order of the day. The 15 bit machine noop (used all the time to fill up a 60 bit word that had just a 30 bit and a 15 bit instruction), was 46000. A 15 bit instruction was represented by 5 octal digits. A 60 bit word was 20 octal digits.

Characters were represented by 6-bit "display code" and 10 of these characters fit into a word. ASCII was unheard of. Individual characters were accessed by shifting and masking. These computers were built for computing, not information processing!!

A lot more could be said, but this pretty much gives a picture of the machine. The first several years of my professional life were spent programming these machines in Fortran and assembly language before I moved on to the DEC-20 and then other machines.