The Burroughs 220 Computer

From Folklore
Jump to: navigation, search

Unisys History Newsletter.
Volume 5, Number 2
April, 2001
by George Gray

After core memory was perfected in the mid-1950s, the major computer vendors used it in new models of their machines. Remington Rand replaced the UNIVAC 1103 with the 1103A in 1955, and IBM replaced the 701 and 702 with the 704 and 705. Burroughs had to do the same for its drum-memory Datatron, and the new machine was the 220. It was originally named the Datatron 220, but somewhere along the way, the company decided to drop the Datatron name and referred to the computer simply as the Burroughs 220 or B220. It was announced in 1957 which was rather late for a vacuum-tube computer. By this time, other companies, such as Philco, NCR, and RCA were starting to announce computers that used transistors in their processors (CPUs). The B220 still used vacuum tubes: 1800 of them in its central processing unit. In other respects, the 220 was a worthy successor to the Datatron. The 4080-word drum was replaced by core memory: from 4,000 words up to 10,000 words. The word size remained 44 bits and the data formats (fixed-point, floating-point, and alphanumeric) were carried forward from the Datatron. Fixed-point numbers were stored as a 4-bit sign digit followed by 10 4-bit data digits. In floating point, there was a sign digit, two digits for the exponent (characteristic), and eight digits for the mantissa. The exponent was biased by 50 to provide for negative values; thus, exponents of -50 through 0 were stored as 00 through 50, and exponents of 1 through 49 were stored as 51 through 99. Alphanumeric data was indicated by the presence of a 2 in the word's sign digit, and each word held five characters, each character being represented by two decimal digits. A was represented by 41, B by 42, and so on! up through 69 for a Z.

The use of decimal representation and decimal arithmetic rather than binary on the Datatron and the B220 was an attempt to compromise between "scientific" and "business" computing. During the first and second generations of computer hardware, this split into the two types of machines was very common. On the scientific side, the UNIVAC 1103A and the IBM 704 used binary arithmetic and had the capability to do floating-point computation, while business-oriented machines such as the UNIVAC II and the IBM 705 used decimal arithmetic and lacked floating-point. Burroughs was trying to provide both scientific (floating-point) and business (decimal) capabilities, an approach that prevailed in third generation computers, starting with the IBM 360.

The B220's instruction format was also the same as on the Datatron: one sign digit, four control digits, a two-digit operation code, and four-digit operand/address field. However, the instruction set itself was quite different. For example the B220 opcode for add was 12, while on the Datatron it was 74. The B220's basic instruction set consisted of 41 instructions, but variations (indicated in one of the control digits) brought the actual number of operations to 94. This was an increase over the number on the Datatron. The Datatron instructions which related specifically to drum memory were gone, while the B220 added capabilities for partial-word operations, allowing the testing or manipulation of particular digits or characters in a word.

The B220 had a doubleword arithmetic register, a four digit index register, a register to contain the current instruction, and a register to point to the next instruction. The use of the index register was indicated by placing an odd value in the sign bit of the instruction word.

Burroughs developed a simulator program that allowed the B220 to run 205 machine programs. It translated each 205 instruction into one or more B220 instructions and then executed it/them. This simulation was slow and intended only as a stopgap measure for sites in transition. A programming manual warned: " The fact that in these circumstances the 220 operates no faster than the 205 illustrates the main weakness of interpretive routines, since the computation speed of the 220 is approximately ten times that of the 205." While the general point is well taken, the ten-to-one ratio is not in accordance with the published add time for the two machines, which were 200 microseconds on the B220 and 1019 on the 205.

The B220 supported a variety of peripheral devices: magnetic tape, the Datafile, paper tape readers/punches, printers, the Cardatron, and card readers/punches. There was no drum storage device, such as those UNIVAC provided on its File Computer and the later models of the Solid State Computer.

The B220 could have up to ten tape drives. Its magnetic tape, like that of the Datatron, was 3/4 inch wide, rather than the 1/2 inch width which eventually became standard for open reel tape, and the tape was 3500 feet long. This made the reels noticeably bigger than those used on other computers. With the extra width, the tape was divided into two "lanes", each with six channels (tracks). Four of the tracks were for data bits, one for parity (even parity), and one for control information. The recording density was 208 digits per linear inch. Blocks could be from 20 to 100 words long. The tape moved at 120 inches per second, giving a nominal transfer rate of 25,000 digits or 12,500 characters per second. While the physical characteristics of the tape were the same as on the Datatron, the coding format was different, so that translator routines had to be written. Alternatively, tapes could be copied offline on a Magnetic Tape Converter.

The Datafile was an attempt to provide relatively fast-access storage in the absence of drums. It was comprised of 50 parallel loops of magnetic tape, each 250 feet long, with a read-write head that could move to any of the loops. Thus no tape would ever have to move more than 250 feet, and the average access time was 15.3 seconds. The tape loops used the same format as the B220's regular magnetic tape, and each loop could hold 40,000 words of data, giving the whole Datafile a capacity of 2 million words. Although the access time was slow, it was certainly faster than reading conventional tape.

Paper tape was frequently used on the B220; a computer could have up to 10 paper tape readers and up to 10 punches. The readers operated at 500 or 1000 characters per second. Since punched card peripherals operated at speeds considerably slower than that of computers, Burroughs provided the Cardatron for the B220 to serve as a buffered control unit, driving up to seven readers or punches. The Cardatron had a small (two inch diameter) drum as a buffer for each card device, which would serve as a staging area between the device and the computer's memory. Plugboards in the Cardatron could be wired to do data editing (such as zero suppression) in the Cardatron, thus relieving the B220's processor of those tasks.

In the 1950s and 1960s it was customary to announce computers as soon as their design was complete, so that one or two years might pass between announcement and the first shipment to a customer. The B220 was announced in early 1957, and the first one was delivered to Stanford Research Institute in October 1958. By the beginning of 1960, 31 B220s were installed. Burroughs was not alone in producing last-minute vacuum tube computers, for this was just one month after the initial shipment of the UNIVAC 1105 and two months after the first IBM 709. IBM was able to follow up with the transistor 7090 in November 1959, but Burroughs had nothing. All Burroughs could do was run ads in Datamation where James Bradburn, Vice President of the Burroughs ElectroData Division said that the B220 was a good system and compared well with early transistor computers. Sales literature pointed to its low cost ("For the price of a medium-scale computer, the Burroughs 220 provides the speed and c! apacity of a large scale system.") and reliability ("Burroughs 220 reliability is a matter of record--not prediction. During an 11-week period, installed 220 systems had an average work-week of 60 hours--with 98.7% availability.") The company also had a sales brochure telling about the great things a B220 was doing at California Institute of Technology.

Approximately fifty-five B220s were built. The price ranged from $640,000 to $1,209,000, depending on the amount of memory and the number and type of peripherals. The Cardatron cost around $100,000 and the Datafile $25,000. For those who leased, the average monthly rental was $17,000.

Following is a partial list of B220 sites:

  • Stanford Research Institute
  • California Institute of Technology
  • Cornell University
  • Georgia Institute of Technology
  • Case Institute of Technology
  • Dow Chemical
  • John Deere
  • Babcock & Wilcox
  • Allstate Insurance
  • Abbott Laboratories
  • U.S. Geological Survey
  • U.S. Army Signal Center (Fort Monmouth)
  • Long Beach Naval Shipyard
  • Randolph Air Force Base

Programming on the B220 was done primarily in assembly language. Burroughs provided an assembler in 1960, known as STAR 1. It allowed for the use of alphabetic mnemonics (ADD) in place of the numeric op-codes (12) and provided a rudimentary form of relative addressing. Data items could be grouped into regions and relative addressing done within the region, so that 0050010 would be address 10 within region 5. Another assembler called BLEAP was written at Stanford University. ALGOL was the principal higher-level language. In 1960, a group at Burroughs led by Robert Barton and Joel Erdwin wrote a compiler called BALGOL. It was used extensively on the 220 at Stanford University, where over 80 percent of the programs were in ALGOL. The remainder were written in the BLEAP assembly language. The ALGOL compiler was so fast, a Stanford official said, that programs were usually recompiled each time they were run.

An unknown Air Force programmer on the B220 at Randolph had written a system in which the data on a tape could be of arbitrary format and length because it was preceded by program code which could extract the data. This distant precursor of object oriented encapsulation came to the attention of Alan Kay (then an Air Force programmer) who later developed the Smalltalk programming language.

The customers were generally happy with the B220, and some machines were used for a long time. The B220 at Georgia Tech was still being used in the mid-1960s to teach introductory programming, when most other work had been moved to transistor computers.

Copyright 2000 by George Gray