Informatics Engineering    
   
Table of contents ☛
(Prev) IBM 37xxIBM 700 7000 series (Next)

IBM 650

An IBM 650 at Texas A&M University. The IBM 533 card reader and punch is on the right.
IBM 650 front panel, showing bi-quinary indicators. (IBM Museum, Sindelfingen)
Close-up of bi-quinary indicators
IBM 650 at Texas A&M, opened up to show rear of front panel, vacuum modules and storage drum
The first IBM 650 in Norway (1959), known as "EMMA". Punched card sorter (left), Input-output-unit (middle), CPU (right). Now at Norwegian Museum of Science and Technology in Oslo.
Vacuum tube circuit module of type used in the 650.
A classroom in 1960 at the Bronx High School of Science with IBM 650 instruction chart above blackboard, upper right

The IBM 650 (photo) was one of IBM’s early computers, and the world’s first mass-produced (photo) computer. It was announced in 1953 and almost 2000 systems were produced, the last in 1962.[1] Support for the 650 and its component units was withdrawn in 1969.

The 650 was a two-address, bi-quinary coded decimal machine (both data and addresses were decimal), with memory on a rotating magnetic drum. Although a decimal machine, limited character support was provided by the input/output units converting alphabetical and special characters to a two-digit decimal code. The 650 was marketed to scientific and engineering users as well as to users of existing IBM punched card machines who were upgrading from Calculating Punches, like the IBM 604, to computers.[2] Because of its relatively low cost and ease of programming, the 650 was used to pioneer a wide variety of applications, from modeling submarine crew performance[3] to teaching high school and college students computer programming.

Contents

Hardware

The basic 650 system consisted of three components:

Optional components:

  • Disk Unit (IBM 355[1]) Systems with a disk unit were known as a IBM 650 RAMAC Data Processing System
  • Card Reader Unit (IBM 543)
  • Card Punch Unit (IBM 544)
  • Control Unit (IBM 652) Magnetic Tape Controller
  • Auxiliary Unit (IBM 653) Core storage, index registers, floating point arithmetic
  • Auxiliary Alphabetic Unit (IBM 654)
  • Magnetic Tape Unit (IBM 727)
  • Inquiry Station (IBM 838)
  • Tape To Card Punch IBM 46 Model 3
  • Tape To Card Punch IBM 47 Model 3
  • Alphabetical Accounting Machine IBM 407

The rotating drum memory (photo) provided 2,000 signed 10-digit words of memory (five characters per word) at addresses 0000 to 1999, which is approximately 8.5 KB in today's units.[4] A Model 4, introduced in 1959, doubled the drum capacity to 4,000 words.[5] A word could not be accessed until its location on the drum surface passed under the read/write heads during rotation (rotating at 12,500 rpm, the non-optimized average access time was 2.5 ms). Because of this timing restriction, the second address in each instruction word was the address of the next instruction. Programs could be optimized by placing instructions around the drum based on the expected execution time of the previous instruction. One specialized instruction, "Table lookup", could high-equal compare a reference 10-digit word with 46 consecutive following words on the drum in one 5ms revolution and then switch to the next track in time for the next 46 words (there were fifty words per track/revolution). This feat was about one-third the speed of a one-thousand times faster binary machine in 1963 (1500 microseconds on the IBM 7040 to 5000 microseconds on the IBM 650) for looking up 46 entries as long as both were programmed in assembler. One higher-level language made the IBM 7040 dramatically slower at table-look-up.

The optional Auxiliary Unit (IBM 653), was introduced on May 3, 1955, providing up to three features:

  • Sixty 10-digit words of magnetic core memory at addresses 9000 to 9059; a small fast memory (this device gave a memory access time of 96µs, a 26-fold raw improvement relative to the rotating drum), needed for a tape and disk I/O buffer
  • Three four-digit index registers at addresses 8005 to 8007; drum addresses were indexed by adding 2000, 4000 or 6000 to them, core addresses were indexed by adding 0200, 0400 or 0600 to them. If the system had the 4000 word memory drum then indexing was by adding 4000 to the first address for index register A, adding 4000 to the second address for index register B, and by adding 4000 to each of the two addresses for index register C. (the indexing for 4000-word systems only applied to the first address). The 4000-word systems required transistorized read/write circuitry for the drum memory and were available before 1963.
  • Floating point – arithmetic instructions with am eight-digit mantissa and two-digit characteristic (offset exponent) – MMMMMMMMCC, providing a range of ±0.00000001E-50 to ±0.99999999E+49

The IBM 533 reader punch unit could only read a maximum of 26 columns of alphanumerics from cards in mostly fixed columns. An expansion allowed more but certainly not over 50, as only ten words could be read from a card (five characters per word).

The IBM 650 (pictured here) at the Haus zur Geschichte der IBM Datenverarbeitung (House for the History of IBM Data Processing), Sindelfingen, is still running (as of May 2004[update]) and will process an income tax program of the time, with input and output on punched cards.

The IBM 7070, announced 1958, was expected to be a common successor to at least the 650 and the 705.[6] The IBM 1620, introduced in 1959, addressed the lower end of the market. Both were decimal machines, but neither had a compatible instruction set.

Instruction set

IBM 650 instructions consisted of a two-digit op code, a four-digit data address and the four-digit address of the next instruction. The sign was ignored. The 650 had a 20-digit accumulator, divided into 10-digit upper and lower sections with a common sign. Data read from the drum went through a 10-digit distributer. Instructions went to a program register. Arithmetic was performed by a one-digit adder. Additional instructions were provided for options, such as floating point, core storage, index registers and additional I/O devices. The base machine had 42 op codes. With all options installed, there were 97 op codes.[7]

70RDRead
71PCHPunch
69LDLoad distributor
24STDStore distributor
10AUAdd to upper
15ALAdd to lower
11SUSubtract from upper
16SLSubtract from lower
60RAUReset (entire accumulator) and add into upper
65RALReset and add into lower
61RSUReset and subtract into upper
66RSLReset and subtract into lower
20STLStore lower into memory
21STUStore upper into memory *
22STDAStore lower data address
23STIAStore lower instruction address
17AABLAdd absolute to lower
67RAABLReset and add absolute to lower
18SABLSubtract absolute from lower
68RSABLReset and subtract absolute into lower
19MULTMultiply
14DIVDivide
64DIVRUDivide and reset upper
44BRNZUBranch on non-zero in upper
45BRNZBranch on (accumulator) non-zero
46BRMINBranch on minus
47BROVBranch on overflow
90-99BRDBranch on 8 in distributor positions 1-10 **
30SRTShift (accumulator) right
31SRDShift and round
35SLTShift left
36SCTShift left and count ***
84TLUTable lookup
00No-OpNo operation
01StopStop if console switch is set to stop, otherwise no-op

Notes:

  • * Value stored takes sign of accumulator, except after a divide operation; then sign of remainder is stored.
  • ** Used to allow 533 control panel to signal CPU.
  • *** Counts high-order zeros in upper accumulator

Software

Software included:

See also

References

Notes

  1. ^ Pugh, Emerson W. (1995). Building IBM: Shaping an Industry and Its Technology. MIT Press. p. 182. ISBN 978-0-262-16147-3.
  2. ^ IBM Archives 650 Customers
  3. ^ Integrated models of cognition systems By Wayne D. Gray, p.36
  4. ^ Each word represents a signed 10-digit decimal number. 2^33 is approximately 8.5 billion (10 digits). To account for the signing, double that -- 2^34 ~= 17 billion. So, on a lower bound, each IBM 650 word can hold information equivalent to 34 bits. Now, 2000x34 = 68000 bits of data. That's 8500 bytes (divide by 8.) which translates to 8.5 KB (divide by 1000) or 8.3 KiB (divide by 1024.)
  5. ^ IBM 650 Model 4 announcement
  6. ^ Bashe, Charles J.; Johnson, Lyle R; Palmer, John H.; Pugh, Emerson W. (1986). IBM's Early Computers. MIT. p. 473. ISBN 0-262-02225-7.
  7. ^ IBM 650 CPU Extensions
  8. ^ HOPL shows the name as BLISS, which is incorrect; the correct form is given in "Flow-Based Programming" - ISBN 0-442-01771-5

External links

this next link seems to be broken, try it sometime in April 2006:Haus zur Geschichte der IBM Datenverarbeitung (German)[dead link]

(Prev) IBM 37xxIBM 700 7000 series (Next)