IBM 650

From Wikipedia, the free encyclopedia
Jump to: navigation, search
This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. (February 2010)
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 650 front panel, rear view
The first IBM 650 in Norway (1959), known as "EMMA". CPU (right), Input-output-unit (middle) and punched card sorter (left). 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 over 2000 systems were produced between the first shipment in 1954 and its final manufacture in 1962. Support for the 650 and its component units was withdrawn in 1969.

The 650 is a two-address, bi-quinary coded decimal machine (both data and addresses were decimal), with memory on a rotating drum. The 650 was marketed to scientific and engineering users as well as users of existing IBM unit record equipment (electro-mechanical punched card-processing machines) upgrading from so-called Calculating Punches, like the IBM 604 model, to computers proper.[1] Because of its relatively low cost and simple programming, the 650 pioneered a wide variety of applications, from modeling submarine crew performance[2] to teaching high school students computer programming.

Contents

[edit] Hardware

The basic 650 system consisted of three components:

Optional components:

  • Disk Unit (IBM 355) Systems with a disk unit were known as a IBM RAMAC 650 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 (5 characters per word) at addresses 0000 to 1999. A Model 4, introduced in 1959, doubled the drum capacity to 4,000 words.[3] 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 microsecs on the IBM 7040 to 5000 microsecs 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:

  • 60 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
  • 3 4-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 reg A, adding 4000 to the second address for index reg B, and by adding 4000 to each of the two addresses for index reg 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 8 digit mantissa and 2 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 (5 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) and will process an income tax program of the time, with input and output on punched cards.

The IBM 7070, announced 1960, was designed to provide a "transistorized IBM 650" upgrade path. The IBM 1620, introduced in 1959, addressed the lower end of the market. Both were decimal machines, but neither were instruction set compatible.

[edit] 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.[4]

70 RD Read
71 PCH Punch
69 LD Load distributor
24 STD Store distributor
10 AU Add to upper
15 AL Add to lower
11 SU Subtract from upper
16 SL Subtract from lower
60 RAU Reset (entire accumulator) and add into upper
65 RAL Reset and add into lower
61 RSU Reset and subtract into upper
66 RSL Reset and subtract into lower
20 STL Store lower into memory
21 STU Store upper into memory *
22 STDA Store lower data address
23 STIA Store lower instruction address
17 AABL Add absolute to lower
67 RAABL Reset and add absolute to lower
18 SABL Subtract absolute from lower
68 RSABL Reset and subtract absolute into lower
19 MULT Multiply
14 DIV Divide
64 DIVRU Divide and reset upper
44 BRNZU Branch on non-zero in upper
45 BRNZ Branch on (accumulator) non-zero
46 BRMIN Branch on minus
47 BROV Branch on overflow
90-99 BRD Branch on 8 in distributor positions 1-10 **
30 SRT Shift (accumulator) right
31 SRD Shift and round
35 SLT Shift left
36 SCT Shift left and count ***
84 TLU Table lookup
00 No-Op No operation
01 Stop Stop 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

[edit] Software

Software included:

[edit] See also

[edit] References

[edit] Notes

  1. ^ 650 Customers
  2. ^ Integrated models of cognition systems By Wayne D. Gray, p.36
  3. ^ IBM 640 Model 4 announcement
  4. ^ http://www.bitsavers.org/pdf/ibm/650/24-5003-0_CPU_Extensions.pdf
  5. ^ HOPL shows the name as BLISS, which is incorrect; the correct form is given in "Flow-Based Programming" - ISBN 0442017715

[edit] External links

Retrieved from "http://en.wikipedia.org/w/index.php?title=IBM_650&oldid=478855200"
Personal tools
Namespaces
Variants
Actions
Navigation
Interaction
Toolbox
Print/export
Languages