IBM 650


The IBM 650 Magnetic Drum Data-Processing Machine is an early digital computer produced by IBM Corporation in the mid-1950s. The first one was installed in late 1954 and it was the most-popular computer for the next 5 years. It was announced in 1953 and in 1956 enhanced as the IBM 650 RAMAC with the addition of up to four disk storage units. Almost 2,000 systems were produced, the last in 1962. Support for the 650 and its component units was withdrawn in 1969.
The 650 was a two-address, bi-quinary coded decimal computer, with memory on a rotating magnetic drum. Character support was provided by the input/output units converting punched card alphabetical and special character encodings to/from a two-digit decimal code. The 650 was marketed to business, scientific and engineering users as well as to users of punched card machines who were upgrading from calculating punches, such as the IBM 604, to computers. 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 to teaching high school and college students computer programming.

History

The first 650 was installed on December 8, 1954 in the controller's department of the John Hancock Mutual Life Insurance Company in Boston.
The IBM 7070, announced 1958, was expected to be a "common successor to at least the 650 and the IBM 705| 705". The IBM 1620, introduced in 1959, addressed the lower end of the market. The UNIVAC Solid State was announced by Sperry Rand in December 1958 as a response to the 650. None of these had a 650 compatible instruction set.

Hardware

The basic 650 system consisted of three units:
Weight:.
Optional units:
Rotating drum memory provided 1,000, 2,000, or 4,000 words of memory at addresses 0000 to 0999, 1999, or 3999 respectively. Words on the drums were organized in bands around the drum, fifty words per band, and 20, 40, or 80 bands for the respective models. A word could be accessed when its location on the drum surface passed under the read/write heads during rotation. Because of this timing, the second address in each instruction was the address of the next instruction. Programs could then be optimized by placing instructions at addresses that would be immediately accessible when execution of the previous instruction was completed. IBM provided a form with ten columns and 200 rows to allow programmers to keep track of where they put instructions and data. Later an assembler, SOAP, was provided that performed rough optimization.
The LGP-30, Bendix G-15 and IBM 305 RAMAC computers used vacuum tubes and drum memory, too. But they were quite different to the IBM 650.
Instructions read from the drum went to a program register. Data read from the drum went through a 10-digit distributor. The 650 had a 20-digit accumulator, divided into 10-digit lower and upper accumulators with a common sign. Arithmetic was performed by a one-digit adder. The console, distributor, lower and upper accumulators were all addressable; 8000, 8001, 8002, 8003 respectively.

IBM 653 Storage Unit

The optional IBM 653 Storage Unit, was introduced on May 3, 1955, ultimately providing up to five features:
The 650 instructions consisted of a two-digit operation code, a four-digit data address and the four-digit address of the next instruction. The sign was ignored on the basic machine, but was used on machines with optional features. The base machine had 44 operation codes. Additional operation codes were provided for options, such as floating point, core storage, index registers and additional I/O devices. With all options installed, there were 97 operation codes.
The Table lookup instruction could high-equal compare a referenced 10-digit word with 48 consecutive words on the same drum band in one 5ms revolution and then switch to the next band in time for the next 48 words. This feat was about one-third the speed of a one-thousand times faster binary machine in 1963 for looking up 46 entries as long as both were programmed in assembler. There was an optional Table lookup Equal instruction, with the same performance.
The Read instruction read an 80 column card of numeric data into ten memory words; the distribution of digits to words determined by the card reader's control panel wiring. When used with the 533 Reader Punch unit's Alphabetic device, a combination of numeric and alphanumeric columns could be read. An expansion feature allowed more alphanumeric columns but certainly not over 50, as only ten words were stored on the drum by a card read operation.
with IBM 650 instruction chart above blackboard, upper right
The base machine operation codes were:
17AABLAdd absolute to lower accumulator
15ALAdd to lower accumulator
10AUAdd to upper accumulator
45BRNZBranch on accumulator non-zero
46BRMINBranch on minus accumulator
44BRNZUBranch on non-zero in upper accumulator
47BROVBranch on overflow
90-99BRDBranch on 8 in distributor positions 1-10 **
14DIVDivide
64DIVRUDivide and reset upper accumulator
69LDLoad distributor
19MULTMultiply
00NO-OPNo operation
71PCHPunch a card
70RDRead a card
67RAABLReset accumulator and add absolute to lower accumulator
65RALReset accumulator and add to lower accumulator
60RAUReset accumulator and add to upper accumulator
68RSABLReset accumulator and subtract absolute from lower accumulator
66RSLReset accumulator and subtract from lower accumulator
61RSUReset accumulator and subtract from upper accumulator
35SLTShift accumulator left
36SCTShift accumulator left and count ***
30SRTShift accumulator right
31SRDShift accumulator right and round accumulator
01STOPStop if console switch is set to stop, otherwise continue as a NO-OP
24STDStore distributor into memory
22STDAStore lower accumulator data address into distributor
Then store distributor into memory
23STIAStore lower accumulator instruction address into distributor
Then store distributor into memory
20STLStore lower accumulator into memory
21STUStore upper accumulator into memory *
18SABLSubtract absolute from lower accumulator
16SLSubtract from lower accumulator
11SUSubtract from upper accumulator
84TLUTable lookup

Notes:
The IBM 653 options could implement additional instruction codes.

Sample program

This one-card program, taken from the 650 Programming Bulletin 5, IBM, 1956, 22-6314-0, will set most of the drum storage to minus zeros. The program includes examples of instructions being executed from the console switches and from an accumulator.
To begin, a load card is keypunched with 80 consecutive digits so that, when read, drum locations 0001 through 0008 contents will be as shown.
0001 0000010000
0002 0000000000-
0003 1000018003
0004 6100080007
0005 2400008003
0006 0100008000
0007 6900060005
0008 2019990003
The console digit switches are manually set to a Read instruction with data address 0004.
loc- op|data|next
ation |addr|instruction
| |addr
8000 RD 70 0004 xxxx Read load card into 1st band read area
Each drum band has a read area; these read areas are in locations 0001-0010, 0051-0060, 0101-0110 and so on. Any address in a band can be used to identify that band for a read instruction; the address 0004 identifies the 1st band. Execution begins then, from the console with the reading of the 8 words on the load card into locations 0001-0008 of the 1st memory band. In the case of reading a load card, the "next instruction address" is taken from the data address field, not the next instruction address field. Thus execution continues at 0004
0004 RSU 61 0008 0007 Reset entire accumulator, subtract into upper the value 2019990003
0007 LD 69 0006 0005 Load distributor with 0100008000
0005 STD 24 0000 8003 Store distributor in location 0000, next instruction is in 8003
Note: the moving of data or instructions from one drum location to another
requires two instructions: LD, STD.
Now a two instruction loop executes:
8003 STL 20 1999 0003 Store lower accumulator
The "1999" data address is decremented, below, on each iteration.
This instruction was placed in the upper accumulator by the RSU instruction above.
Note: this instruction, now in the upper accumulator, will be decremented and then
executed again while still in the accumulator.
0003 AU 10 0001 8003 Decrement data address of the instruction in the accumulator by 1

The STL's data address will, eventually, be decremented to 0003, and the AU... instruction at 0003 will be overwritten with zeros. When that occurs execution continues as follows:
0003 NOOP 00 0000 0000 No-operation instruction, next instruction address is 0000
0000 HALT 01 0000 8000 Halt, next instruction address is the console

Donald Knuth's series of books The Art of Computer Programming is famously dedicated to a 650.

Software

included: