The IBM 701 computer was one of IBM’s first commercially available computers. Here are a few facts about the 701:
- The 701 was introduced in 1953.
- IBM sold only 30 units.
- It used approximately 4,000 tubes.
- Memory was stored on 72 CRT tubes called Williams Tubes with a total capacity of 2,048 words.
- The word size was 36 bits wide.
- The CPU contained two programmer accessible registers: Accumulator, multiplier/quotient register.
There were two types of electronic switches in the early 1950’s: The relay and the vacuum tube. Relays were unreliable, mechanical, noisy, power-hungry and slow. Tubes were unreliable and power-hungry. Compared to the relay, tubes were fast. One of the limitations on how big and complex a computer could be in those days, was determined by the reliability of the tube. Tubes had a failure rate of 0.3 percent per 1000 hours (in the late 40’s, early 50’s). That means, that in 1,000 hours of use, 0.3 percent of the tubes will fail. That’s pretty good if you’re talking about a dozen tubes. At that failure rate, the 701 would fail at an average of less than one hour (0.3 x 4,000 tubes = 1,200 units per 1,000 hours) assuming an even distribution of failures.
Tubes use higher voltage levels than semiconductors and that means a lot more heat and more power usage. It also means that tubes are much slower than semiconductors. By today’s standards, tubes are incredible slow. Most tube circuit times were measured in microseconds instead of nanoseconds. A typical add instruction on the IBM 701 took 60 microseconds to complete.
The main memory was composed of Williams tubes. These are small CRT tubes that stored data by exploiting the delay time that it took phosphor to fade. Instead of using the visible properties of phosphor to store data, a secondary emission effect can occur by increasing the beam to a threshold causing a charge to occur. A thin conducting plate is mounted to the front of the CRT. When the beam hits a point where the phosphor is already lit up, no charge is induced on the plate. This is a read as a one. When the beam hits a place where there was no lit phosphor, a current will flow indicating a zero. The read operation causes the bit to overwritten as a one, so the data must be re-written as it is read. Wiki has an entire article on the Williams tube: Williams tube wiki. Here’s an example of the dot pattern on a Williams tube:
By National Institute of Standards and Technology – National Institute of Standards and Technology, Public Domain
The tubes that were used for memory storage didn’t have visible phosphor, therefore a technician could plug in a phosphor tube in parallel and see the image as picture above for troubleshooting purposes.
Williams tube memory was called electrostatic storage and it had an access time of 12 microseconds. Each tube stored 1,024 bits of data data for one bit of the data bus. To form a parallel data bus, 36 tubes together represented the full data path for 1,024 words of data. The data is stored on the tube in 32 columns by 32 rows. If you count the columns and rows in the tube pictured above, you’ll see that it is storing 16 by 16, representing a total of 256 bits of data. The system came with 72 tubes total for a memory size of 2,048 words of memory. Since the word size is 36 bits wide, 2,048 words is equal to 9,216 bytes of storage.
Here’s a photo of one drawer containing two Williams tubes:
Williams tubes used electromagnets to steer the electron beam to an xy point on the screen. What this means is that the entire assembly must be carefully shielded to prevent stray magnetic fields from redirecting the beam. In the picture above you can see the black shielding around each of the long tubes to prevent interference between the two tubes.
In order to address the data from the tube, the addressing circuitry would control the x and y magnets to steer to the correct dot, then read or write the dot. If you want to learn more about the circuitry that drives an electrostatic memory unit, you can download the schematics in PDF here.
One type of semiconductor was used in this machine and that was the Germanium diode. The 701 used at total of 13,000 germanium diodes.
The CPU or Analytical Control Unit could perform 33 calculator operations as shown in this diagram:
Here is the block diagram of the 701:
Instructions are read from the electrostatic storage into the memory register where it is directed to the instruction register. Data that is sent to external devices must go through the multiplier/quotient register. Data read from external devices (i.e. tape, drum or card reader) is loaded into the multiplier/quotient register. As you can see from the block diagram, there is a switch that feeds inputs from the tape, drum, card reader or the electrostatic memory. This is a physical switch on the front panel of the computer. The computer operator would change the switch position to the desired input before starting the machine. Here’s a photo of the front panel, you can see the round switch near the lower left (click to zoom):
By Dan – Flickr: IBM 701, CC BY 2.0
The front panel also has switches and lights for each of the registers so the operator could manually input binary into the accumulator or enter a starting address (instruction counter). Notice how the data width of this computer is wider than the address width. Only 12 bits are needed to address all 2,048 words of memory. If you look closely, you’ll also notice that the lights are grouped in octal sets (3 lights per group). The operator can key in data that is written as octal numbers (0-7) without trying to look at a 12-bit number of ones and zeros. The switches for entering data are grouped gray and white in octal groupings as well.
There is a front panel control to increment the machine cycle. An operator or technician could troubleshoot a problem by executing one machine cycle at a time with one press of the button per machine cycle. For a multiply instruction the operator could push the button 38 times to complete the operation or examine the partial result as each cycle was completed. The machine also came with diagnostic programs that could be run to quickly identify a physical problem with the machine. A set of 16 manuals was provided to assist the installation, maintenance, operation and programming of the 701. The computer operator normally only operated the start, stop and reset controls as well as the input and output selectors on the machine. The instruction counter and register controls are normally used by a technician to troubleshoot problems.
The CPU was constructed using a modular technique. Each module or “Pluggable Unit” had a complete circuit on it and could be replaced all at once by a technician. The units looked like this:
Image from Pintrest (Explore Vacuum Tube, IBM, and more!)
Each of these units are aligned together into one large block:
(By Bitsavers, IBM 701)
Notice how all the tubes face the front of the machine. One of the first things to burn out on a tube is the heating element. By facing the tubes toward the front, a technician can quickly identify any burned out tubes and replace them. If all tubes are glowing, then the technician will need to run diagnostics and try to limit down which tube or tubes are not working. Another reason to design the modules to face all tubes forward, is that the technician can grab a tube and pull it out of it’s socket to put it into a tube tester and determine which tube really is bad.
My experience with tubes date back to the late ’70s when people wanted to “fix” an old TV set (usually a TV that was built in the early 60s). I would look for an unlit tube, read the tube number off the side and run down to the electronics shop to buy a new one. If that failed, then my next troubleshooting step was to pull all the tubes (after the TV cooled off), put them in a box and run up to the electronics store where they had a tube tester (they wanted to sell new tubes, so they provided a self-help tester right at their store). I would plug my tube into the tester, flip through the index pages for the tube type being tested. Then adjust the controls according to the instructions and push the test button. If the tube was bad, then I bought a new one. Other components such as diodes, resisters, capacitors rarely went bad. Those would be the next thing on the troubleshooting list after all the tubes were determined to be good. One other note about troubleshooting tubes: The tube tester had a meter that would be read to determine what the testing current flow was. The manual had a range of acceptable values (minimum and maximum values). The values were based on the tube manufacturer’s specifications. For some devices, the tube would not work, even though it was within manufacturer specifications. We referred to tubes like this as a “weak” tube (in other words it might not be able to pass as much current as needed by the circuit). So a determination would have to be made to replace the tube.
Here’s an example of the type of tube tester I remember using:
All cabinets were designed to be no larger than necessary to be able to transport up an elevator and fit through a normal sized office door (see: Buchholz IBM 701 System Design, Page 1285 Construction and Design Details). The entire system was divided into separate cabinets for this very purpose. Cables would be run through the floor to connect cabinets together, much like the wiring in modern server rooms.
The 701 could be configured with a drum storage unit and a tape storage unit. The IBM 731 storage unit contained two physical drums organized as four logical drums able to store 2,048 full words of information each (for a total of 8,192 words, equal to 82,000 decimal digits). Each logical drum reads and writes 36 bits in a row. The drum spins at a rate of 2,929 RPM with a density of 50 bits to the inch. There are 2,048 bits around the drum for each track. Seek time could take up to 1,280 microseconds. The storage capacity was intentionally designed to match the capacity of the electrostatic memory. This was used to read all memory onto a drum or read a drum into the electrostatic memory.
The primary input device for the 701 was the punch card reader. Computers in the 50’s were designed as batch machines. It cost a lot of money to run a computer room and it is more economical to batch jobs so the computer was processing data continuously. It would be too expensive to have an operator typing data into the computer and saving it on a storage device like we do today. Timeshare systems were not invented yet and this machine was too slow and tiny for time sharing. In order to perform batch jobs, operators or programmers would use the keypunch machine to type their program and data onto punch cards (usually in a different room). The keypunch machine was an electro-mechanical device that looked like a giant typewriter (IBM 026):
By Columbia University, The IBM 026 Keypunch
A punch card reader is connected as an input to the 701 in order to read in a batch of punch cards. The cards can be read in at a rate of 150 cards per minute. Each card holds one line of data from a program or 72 characters wide. If the punch cards are used as binary input, then they can contain 24 full words per card. A program can be punched onto a stack of cards and then loaded into the card reader for execution. Programmers used a lot of common routines with their programs, so they would punch a routine on a small stack of cards and then include that stack with their main program to be run in sequence (see: Buchholz IBM 701 System Design, Page 1274 Card programming). Then they could save the common routine cards to be used with other jobs. The stacks of cards were equivalent to today’s “files”.
By IBM Archives, IBM 711 Punch Card Reader
The 701 was normally configured with a line printer that can print 150 lines per minute. Information to be printed was transferred from the multiplier/quotient register to 72 thyratrons (a type of current amplifier tube) connected directly to the printer. The tyratrons were located inside the Analytical Control Unit and their function was shared by the printer and the card punch (thyratrons activated the print magnets or the punch magnets). Data that was printed came directly from the electrostatic storage and needed to be converted by the program into decimal data before going to the printer.
I have provided links from each embedded photo above to the sources (with the exception of diagrams I copied from the sources below). You may click on a photo to go to the source and obtain more information. For more detailed information about the IBM 701, I would recommend clicking through these sites/documents: