IBM 1620

Memory The IBM 1620 Model I was a variable word length, binary-coded decimal (BCD) computer using magnetic-core memory. The Model I core could hold 20,000 decimal digits with each digit stored in six bits. Memory access Memory was accessed two decimal digits at the same time (even-odd digit pair for numeric data or one alphameric character for text data). Each decimal digit was six bits, composed of an odd parity Check bit, a Flag bit, and four BCD bits for the value of the digit in the following format: C F 8 4 2 1 The Flag bit had several uses: • In the least significant digit it was set to indicate a negative number (signed magnitude). • It was set to mark the most significant digit of a number (word mark). • In the least significant digit of five-digit addresses it was set for indirect addressing (an option on the Model I, standard on the 1620 Model II). Multi-level indirection Among these are that the machine's Branch and Transmit instruction together with Branch Back allow only one level of nested subroutine call, forcing the programmer of any code with more than one level to decide where the use of this "feature" would be most effective. He also showed how the machine's paper tape reading support could not properly read tapes containing record marks, since record marks are used to terminate the characters read in storage. One effect of this is that the 1620 cannot duplicate a tape with record marks in a straightforward way: when the record mark is encountered, the punch instruction punches an EOL character instead and terminates. However this was not a crippling problem: • the data can be copied to the end of memory and punched verbatim with a DN instruction instead of WN • tapes were usually duplicated offline. Most 1620 installations used the more convenient punched card input/output, rather than paper tape. The successor to the 1620, the IBM 1130,"Similar demands for small to medium scientific computers resulted in the IBM 1620 and its successor the IBM 1130." {{cite book ==Software==

IBM supplied the following software for the 1620: • 1620 Symbolic Programming System (SPS) (assembly language) • FORTRAN • FORTRAN II required 40,000 digits or more of memory • GOTRAN simplified, interpreted version of FORTRAN for "load and go" operation ==1620 non-decimal arithmetic==

Since the Model I used in-memory lookup tables for addition/subtraction, limited bases (5 to 9) unsigned number arithmetic could be performed by changing the contents of these tables, but noting that the hardware included a ten's complementer for subtraction (and addition of oppositely signed numbers). To do fully signed addition and subtraction in bases 2 to 4 required detailed understanding of the hardware to create a "folded" addition table that would fake out the complementer and carry logic. Also the addition table would have to be reloaded for normal base 10 operation every time address calculations were required in the program, then reloaded again for the alternate base. This made the "trick" somewhat less than useful for any practical application. Since the Model II had addition and subtraction fully implemented in hardware, changing the table in memory could not be used as a "trick" to change arithmetic bases. However an optional special feature in hardware for octal input/output, logical operations, and base conversion to/from decimal was available. Although bases other than 8 and 10 were not supported, this made the Model II very practical for applications that needed to manipulate data formatted in octal by other computers (e.g., the IBM 7090). ==Model I==

The IBM 1620 Model I (commonly called "1620" from 1959 until the 1962 introduction of the Model II) was the original. It was produced as inexpensively as possible, to keep the price low. • It lacked conventional ALU hardware: arithmetic was done by memory table lookup. Addition and subtraction used a 100-digit table (at address 00300..00399). Multiplication used a 200-digit table (at address 00100..00299). ==Model II==

The IBM 1620 Model II (commonly called simply the Model II) was a vastly improved implementation, compared to the original Model I. The Model II was introduced in 1962. • It had basic ALU hardware for addition and subtraction, but multiplication was still done by in-core memory table lookup, using a 200-digit table (at address 00100..00299). Memory addresses at address 00300..00399 were freed by the replacement of the addition table with hardware, resulting in storage of two selectable "bands" of seven five-digit index registers. • Rather than being an available option, as in the Model I, the divide hardware using a repeated subtraction algorithm, was built in. Floating-point arithmetic was an available option, as were octal input/output, logical operations, and base conversion to/from decimal instructions. • The entire core memory was in the IBM 1625 memory unit. Memory cycle time was halved compared to the Model I's (internal or 1623 memory unit), to 10 μs (i.e., the cycle speed was raised to 100 kHz) by using faster cores. A Memory Address Register Storage (MARS) core memory read, clear, or write operation took 1.5 μs and each write operation was automatically (but not necessarily immediately) preceded by a read or clear operation of the same "register(s)" during the 10 μs memory cycle. • The processor clock speed was also doubled, to 2 MHz, which was still divided by 20 by a 10 position ring counter to provide the system timing/control signals. The fetch/execute mechanism was completely redesigned, optimizing the timing and allowing partial fetches when the P or Q fields were not needed. Instructions took either 1, 4, or 6 memory cycles (10 μs, 40 μs, or 60 μs) to fetch and a variable number of memory cycles to execute. Indirect addressing added three memory cycles (30 μs) for each level of indirection. Indexed addressing added five memory cycles (50 μs) for each level of indexing. Indirect and indexed addressing could be combined at any level of indirection or indexing."Multi-level indirection could be used (you could even put the machine in an infinite indirect addressing loop), and in the middle three digits of five-digit addresses (on the 1620 II) they were set to select one of seven index registers. {{cite book |url=https://books.google.com/books?isbn=1456751158 |isbn=978-1456751159 ==Models I and II consoles==

While the Lower console for both the Model 1 and the Model 2 IBM 1620 systems had the same lamps and switches, the Upper console of the pair were partly different. Upper console The balance of the Upper console was the same on both models: • Operation Register 25 lamps • Memory Buffer Register 30 lamps • Memory Address Register 25 lamps • Memory Address Register Display Selector – Rotary switch, 12 positions Lower console • Emergency Off Pull Pull switch • Check Condition status lamps/switches 15 lamps & 5 toggle switches • Program Switches 4 toggle switches • Console operator lights/switches 13 lights, 1 power switch, and 12 buttons Console typewriter The Model I console typewriter was a modified Model B1, interfaced by a set of relays, and it typed at only 10 characters per second. There were a set of instructions that wrote to the typewriter, or read from it. The general RN (read numeric) and WN (write numeric) instructions had assembly language mnemonics that supplied the "device" code in the second address field, and the control code in the low-order digit of the second address field. • WNTY: Write Numeric TYpewriter: each memory location contained a 6-bit character in the range of 000000 to 001001; with this instruction, each memory location was rendered as one of the characters "0" through "9". • WATY: Write Alphanumeric TYpewriter: each pair of memory locations contained two 6-bit digits that appeared on the typewriter as one of the 64 characters that could appear. • RNTY: Read Numeric TYpewriter: read a numeric value from the typewriter keyboard • RATY: Read Alphanumeric TYpewriter: read a character from the keyboard and store as a two-digit alphanumeric character • TBTY: TaB TYpewriter. Tabs had to be set manually, so this instruction was rarely used. • RCTY: Return Carriage TYpewriter: Caused the typewriter to do what we now call a CR/LF sequence. To simplify input and output, there were two instructions: • TNS: Transmit Numeric Strip: Converts a two-digit alphanumeric representation of "0" to "9" to a single-digit representation • TNF: Transmit Numeric Fill: Converts a single-digit representation of digits to a sequence to two-digit alphanumeric sequence that represented "0" through "9" The Model II used a modified Selectric typewriter, which could type at 15.5 cps a 55% improvement. ==Peripherals==

drum plotter Available peripherals were: • IBM 1621 Paper tape reader • IBM 1622 Punch card reader/punch • IBM 1624 Paper tape punch (sat inside the 1621 on a shelf) • IBM 1626 Plotter controller • IBM 1627 Plotter • IBM 1311 Disk drive: Model 3 master drive controlling up to 3–Model 2 slave drives. • IBM 1443 Printer, flying type bar • IBM 1405 Disk Drive available as RPQ (request price quotation) The standard "output" mechanism for a program was to punch cards, which was faster than using the typewriter. These punched cards were then fed through an IBM 407 mechanical calculator which could be programmed to print two cards, thus being able to use the additional print columns available on the 407. All output was synchronous, and the processor paused while the Input/Output (I/O) device produced the output, so the typewriter output could completely dominate program running time. A faster output option, the IBM 1443 printer was introduced May 6, 1963,"1963 : On May 6, the IBM 1443 printer, for use with the IBM 1620 data processing system, makes its debut." {{cite web It could print either 120 or 144 columns. The character width was fixed, so it was the paper size that changed; the printer printed 10 characters to the inch, so a printer could print a maximum of 12 inches or 14.4 inches of text. In addition, the printer had a buffer, so the I/O delay for the processor was reduced. However, the print instruction would block if the line had not completed. ==Operating procedures==

The "operating system" for the computer constituted the human operator, who would use controls on the computer console, which consisted of a front panel and typewriter, to load programs from the available bulk storage media such as decks of punched cards or rolls of paper tape that were kept in cabinets nearby. Later, the model 1311 disc storage device attached to the computer enabled a reduction in the fetch and carry of card decks or paper tape rolls, and a simple "Monitor" operating system could be loaded to help in selecting what to load from disc. A standard preliminary was to clear the computer memory of any previous user's detritus being magnetic cores, the memory retained its last state even if the power had been switched off. This was effected by using the console facilities to load a simple computer program via typing its machine code at the console typewriter, running it, and stopping it. This was not challenging as only one instruction was needed such as 160001000000, loaded at address zero and following. This meant transmit field immediate (the 16: two-digit op-codes) to address 00010 the immediate constant field having the value 00000 (five-digit operand fields, the second being from address 11 back to 7), decrementing source and destination addresses until such time as a digit with a "flag" was copied. This was the normal machine code means of copying a constant of up to five digits. The digit string was addressed at its low-order end and extended through lower addresses until a digit with a flag marked its end. But for this instruction, no flag would ever be found because the source digits had shortly before been overwritten by digits lacking a flag. Thus the operation would roll around memory (even overwriting itself) filling it with all zeroes until the operator grew tired of watching the roiling of the indicator lights and pressed the Instant Stop - Single Cycle Execute button. Each 20,000 digit module of memory took just under one second to clear. On the 1620 II this instruction would NOT work (due to certain optimizations in the implementation). Instead there was a button on the console called Modify which when pressed together with the Check Reset button, when the computer was in Manual mode, would set the computer in a mode that would clear all of memory in a tenth of one second regardless of how much memory you had; when you pressed Start. It also stopped automatically when memory was cleared, instead of requiring the operator to stop it. Other than typing machine code at the console, a program could be loaded via either the paper tape reader, the card reader, or any disk drive. Loading from either tape or disk required first typing a "bootstrap" routine on the console typewriter. The card reader made things easier because it had a special Load button to signify that the first card was to be read into the computer's memory (starting at address 00000) and executed (as opposed to just starting the card reader, which then awaits commands from the computer to read cards) this is the "bootstrap" process that gets into the computer just enough code to read in the rest of the code (from the card reader, or disc, or...) that constitutes the loader that will read in and execute the desired program. Programs were prepared ahead of time, offline, on paper tape or punched cards. But usually the programmers were allowed to run the programs personally, hands-on, instead of submitting them to operators as was the case with mainframe computers at that time. And the console typewriter allowed entering data and getting output in an interactive fashion, instead of just getting the normal printed output from a blind batch run on a pre-packaged data set. As well, there were four program switches on the console whose state a running program could test and so have its behavior directed by its user. The computer operator could also stop a running program (or it may come to a deliberately programmed stop) then investigate or modify the contents of memory: being decimal-based, this was quite easy; even floating-point numbers could be read at a glance. Execution could then be resumed, from any desired point. Aside from debugging, scientific programming is typically exploratory, by contrast to commercial data processing where the same work is repeated on a regular schedule. Console The most important items on the 1620's console were a pair of buttons labeled Insert & Release, and the console typewriter. • Insert – Pressing this key with the computer in Manual mode reset the program counter (in the MARS core memory) to zero, switched the computer into Automatic and Insert modes, and simulated the execution of a Read Numeric from Typewriter to address zero (unlocked the typewriter keyboard, shifted the typewriter into numeric mode). Note: unlike a real Read Numeric from Typewriter, Insert mode would force a Release after 100 digits had been typed to prevent overwriting the arithmetic tables. • Release – Pressing this key while doing a Read from the Typewriter terminated the Read, switched the computer into Manual mode, and locked the typewriter keyboard. The typewriter is used for operator input/output, both as the main console control of the computer and for program controlled input/output. Later models of the typewriter had a special key marked R-S that combined the functions of the console Release & Start buttons (this would be considered equivalent to an Enter key on a modern keyboard). Note: several keys on the typewriter did not generate input characters, these included Tab and Return (the 1620s alphameric and numeric BCD character sets lacked character codes for these keys). The next most important items on the console were the buttons labeled Start, Stop-SIE, and Instant Stop-SCE. • Start – Pressing this key with the computer in Manual mode switched the computer to Automatic mode (causing the computer to begin executing at the address in the program counter). • Stop-SIE – Pressing this key with the computer in Automatic mode switched the computer to Manual mode when the currently executing instruction completes. Pressing this key with the computer in Manual mode switched the computer into Automatic mode for one instruction. • Instant Stop-SCE – Pressing this key with the computer in Automatic mode switched the computer into Automatic/Manual mode at the end of the current memory cycle. Pressing this key with the computer in Manual or Automatic/Manual mode switched the computer into Automatic/Manual mode and executed one memory cycle. For program debugging there were the buttons labeled Save & Display MAR. • Save – Pressing this key with the computer in Manual mode saved the program counter into another register in the MARS core memory and activated Save mode. When a Branch Back instruction was executed in Save mode, it copied the saved value back to the program counter (instead of copying the return address register as it normally did) and deactivated Save mode. This was used during debugging to remember where the program had been stopped to allow it to be resumed after the debugging instructions that the operator had typed on the typewriter had finished. Note: the MARS register used to save the program counter in was also used by the Multiply instruction, so this instruction and the Save mode were incompatible! However, there was no need to use multiply in debugging code, so this was not considered to be a problem. • Display MAR – Pressing this key with the computer in Manual mode displayed the selected MARS register and the contents of the memory at that address on the console lamps. All of main memory could be cleared from the console by entering and executing a transfer instruction from address to address +1, this would overwrite any word mark, that would normally stop a transfer instruction, and wrap around at the end of memory. After a moment, pressing Stop would stop the transfer instruction and memory would be cleared. IBM 1621/1624 Paper Tape reader/punch The IBM 1621 Paper Tape Reader could read a maximum of 150 characters per second;The IBM 1624 Paper Tape Punch could output a maximum of 15 characters/second. by modern standards, however, with repetition, the procedure soon became automatic and you no longer thought about the details involved. GOTRAN was much simpler to use, as it directly produced an executable in memory. However it was not a complete FORTRAN implementation. To improve this various third-party FORTRAN compilers were developed. One of these was developed by Bob Richardson, a programmer at Rice University, the FLAG (FORTRAN Load-and-Go) compiler. Once the FLAG deck had been loaded, all that was needed was to load the source deck to get directly to the output deck; FLAG stayed in memory, so it was immediately ready to accept the next source deck. This was particularly convenient for dealing with many small jobs. For instance, at Auckland University a batch job processor for student assignments (typically, many small programs not requiring much memory) chugged through a class lot rather faster than the later IBM 1130 did with its disk-based system. The compiler remained in memory, and the student's program had its chance in the remaining memory to succeed or fail, though a bad failure might disrupt the resident compiler. Later, disk storage devices were introduced, removing the need for working storage on card decks. The various decks of cards constituting the compiler and loader no longer need be fetched from their cabinets but could be stored on disk and loaded under the control of a simple disk-based operating system: a lot of activity becomes less visible, but still goes on. Since the punch side of the card reader-punch did not edge-print the characters across the top of the cards, one had to take any output decks over to a separate machine, typically an IBM 557 Alphabetic Interpreter, that read each card and printed its contents along the top. Listings were usually generated by punching a listing deck and using an IBM 407 accounting machine to print the deck. ==Hardware implementation==

(SMS) card Most of the logic circuitry of the 1620 was a type of resistor–transistor logic (RTL) using "drift" transistors (a type of transistor invented by Herbert Kroemer in 1953) for their speed, that IBM referred to as Saturated Drift Transistor Resistor Logic (SDTRL). Other IBM circuit types used were referred to as: Alloy (some logic, but mostly various non-logic functions, named for the kind of transistors used), CTRL (another type of RTL, but slower than SDTRL), CTDL (a type of diode–transistor logic (DTL)), and DL (another type of RTL, named for the kind of transistor used, "drift" transistors). Typical logic levels of all these circuits (S Level) were high: 0 V to -0.5 V, low: -6 V to -12 V. Transmission line logic levels of SDTRL circuits (C Level) were high: 1 V, low: -1 V. Relay circuits used either of two logic levels (T Level) high: 51 V to 46 V, low: 16 V to 0 V or (W Level) high: 24 V, low: 0 V. These circuits were constructed of individual discrete components mounted on single sided paper-epoxy printed circuit boards with a 16-pin gold-plated edge connector, that IBM referred to as SMS cards (Standard Modular System). The amount of logic on one card was similar to that in one 7400 series SSI or simpler MSI package (e.g., 3 to 5 logic gates or a couple of flip-flops). These boards were inserted into sockets mounted in door-like racks which IBM referred to as gates. The machine had the following "gates" in its basic configuration: • "Gate A" Forward hinged gate that swings out the back for access, after "Gate B". • "Gate B" Rear hinged gate that swings out the back for access. • "Gate C" Slides out back for access. Console Typewriter interface. Mostly relay logic. • "Gate D" Slides out back for access. Standard I/O interface. There were two different types of core memory used in the 1620: • Main memory • Coincident Current X-Y Line addressing • 20,000, 40,000, or 60,000 Digits • 12-bit, even-odd Digit Pair • 12 one-bit planes in each module, 1 to 3 modules • 10,000 cores per plane • Memory Address Register Storage (MARS) memory • Word Line addressing • 16 Words, minimum of eight used in basic configuration • Single Word read, multiple Word clear/write • 24-bit, five-digit decimal Memory Address (no 8 - Ten Thousand bit stored) • 1 plane • 384 cores The address decoding logic of the Main memory also used two planes of 100 pulse transformer cores per module to generate the X-Y Line half-current pulses. There were two models of the 1620, each having totally different hardware implementations: • IBM 1620 I • IBM 1620 II ==Development history==

A computer for the "small scientific market" In 1958 IBM assembled a team at the Poughkeepsie, New York development laboratory to study the "small scientific market". Initially the team consisted of Wayne Winger (Manager), Robert C. Jackson, and William H. Rhodes. Requirements and design The competing computers in this market were the Librascope LGP-30 and the Bendix G-15; both were drum memory machines. IBM's smallest computer at the time was the popular IBM 650, a fixed word length decimal machine that also used drum memory. All three used vacuum tubes. It was concluded that IBM could offer nothing really new in that area. To compete effectively would require use of technologies that IBM had developed for larger computers, yet the machine would have to be produced at the least possible cost. To meet this objective, the team set the following requirements: • Core memory • Restricted instruction set • No divide or floating-point instructions, use subroutines in the "general program package" • Wherever possible replace hardware with existing logical machine functions • No arithmetic circuits, use tables in core memory • Least expensive Input/Output possible • No punch cards, use paper tape • No printer, use operator's console typewriter The prototype The team expanded with the addition of Anne Deckman, Kelly B. Day, William Florac, and James Brenza. They completed the (codename) CADET prototype in the spring of 1959. Meanwhile, the San Jose, California facility was working on a proposal of its own. IBM could only build one of the two and the Poughkeepsie proposal won because "the San Jose version is top of the line and not expandable, while your proposal has all kinds of expansion capability - never offer a machine that cannot be expanded". Management was not entirely convinced that core memory could be made to work in small machines, so Gerry Ottaway was loaned to the team to design a drum memory as a backup. During acceptance testing by the Product Test Lab, repeated core memory failures were encountered and it looked likely that management's predictions would come true. However, at the last minute it was found that the muffin fan used to blow hot air through the core stack was malfunctioning, causing the core to pick up noise pulses and fail to read correctly. After the fan problem was fixed, there were no further problems with the core memory and the drum memory design effort was discontinued as unnecessary. Transferred to San Jose for production Following announcement of the IBM 1620 on October 21, 1959, due to an internal reorganization of IBM, it was decided to transfer the computer from the Data Processing Division at Poughkeepsie (large scale mainframe computers only) to the General Products Division at San Jose (small computers and support products only) for manufacturing. Following transfer to San Jose, someone there jokingly suggested that the code name CADET actually stood for "can't add, doesn't even try", referring to its use of addition tables in memory rather than dedicated addition circuitry (and SDTRL actually standing for "sold down the river logic" became a common joke among the CEs). This stuck and became very well known among the user community.{{cite book Implementation "levels" • Model I • Level A; prototype. • All flip-flops in the design were transistorized versions of the original Eccles-Jordan trigger circuit. While this machine was fully functional, it was found that the capacitor coupling used in these proved troublesome in the noisy signal environment of relays and timing cam driven switches used to drive the console typewriter. This necessitated a complete redesign of the machine to use S-R flip-flops instead (except for two triggers used to generate clocks for the S-R flip-flops). However usage of the term Trigger was retained in all the documentation when referring to a flip-flop, as it was IBM's conventional term (as alphamerics was their term for alphanumerics). • This is the only level using a one piece vertical control panel, when the design was transferred from Poughkeepsie to San Jose it was redesigned to the two piece angled control panel used on all production models. • Level B; first production. • This is the only level using a burnished aluminum lower control panel, later levels finished this panel with white. • Level C; introduction of 1622 card reader/punch. • Level D; introduction of 1311 disk drives and addition of optional "Gate J" containing disk control logic. • Level E; introduction of Floating-Point option. • Level F • Level G; introduction of Interrupt option (needed for IBM 1710). • Did not support BT & BB subroutines in interrupt code! • Disk control logic on "Gate J" logic merged into "Gate A" & "Gate B". • Made possible because much of logic was compacted using cards designed for the Model II. • Level H; improved Interrupt option that supported BT & BB subroutines in interrupt code. • Final version of the Model I. • Model II (no information on "Levels" available at this time) :: The 1620 Model II introduced basic ALU hardware for addition and subtraction (making "Can't Add, Doesn't Even Try" no longer applicable) and index registers. • Model III • Work was begun on a 1620 Model III but the project was quickly canceled as IBM wanted to promote sales of their new System/360 and discontinue the old lines. Patents ==Notable uses==

An IBM 1620 model II was used by Vearl N. Huff, NASA Headquarters (FOB 10B, Washington DC) to program a three-dimensional simulation in Fortran of the tethered Gemini capsule Agena rocket module two-body problem at a time when it was not completely understood if it was safe to tether two objects together in space due to possible elastic tether induced collisions. The same computer was also used to simulate the orbits of the Gemini flights, producing printer-art charts of each orbit. These simulation were run over-night and the data examined the next day. In 1963 an IBM 1620 was installed at IIT Kanpur providing the kicker for India's software prowess. In 1964 at the Australian National University, Martin Ward used an IBM 1620 model I to calculate the order of the Janko group J1. In 1966 the ITU produced an explanatory film on a 1963 system for typesetting by computer at the Washington Evening Star, using an IBM 1620 and a Linofilm phototypesetter. In 1964 an IBM 1620 was installed at The University of Iceland, becoming the first computer in Iceland. ==Use in film and television==

• A radio program was developed by DJ Rege Cordic for KDKA Pittsburgh, based on a baseball game simulator developed by John Burgeson of IBM and his brother, Paul, then an ensign in the U.S. Navy. This program was used in numerous demonstration events in the years 1960 to 1963 as an example of the power of computers to perform simulation exercises. • The fictional computer Colossus of Colossus: The Forbin Project used about a dozen scrapped 1620 front panels purchased on the surplus market, in various orientations. • A similar arrangement was used in a late TV episode"THRUSH is developing an 'ultimate computer'..." {{cite web ==Anecdotes==

CADET Many in the user community recall the 1620 being referred to as CADET, jokingly meaning "Can't Add, Doesn't Even Try", referring to the use of addition tables in memory rather than dedicated addition circuitry. See development history for an explanation of all three known interpretations of the machine's code name. The internal code name CADET was selected for the machine. One of the developers says that this stood for "Computer with ADvanced Economic Technology", however others recall it as simply being one half of "SPACE - CADET", where SPACE was the internal code name of the IBM 1401 machine, also then under development. ==Bibliography==