Glenn’s Computer Museum
|Home||Old Military||Later Military||Analog Stuff||IBM Stuff||S/3 Mod 6||S/32||Components||Encryption||Misc||B61|
The museum is incomplete: the last change was on 9/11/2014. A change log is here.
I have a special interest in IBM equipment since I was an application programmer on early IBM computers (1963-1965) and I worked at IBM for 21 years (1967-1988) having a very rewarding career. In the early 1960's I programmed applications in Fortran and assembly language for an IBM 7090 (along with some programming for an IBM 1401). Then, in college I did extensive assembly programming on an IBM 1620. After getting a Master's degree, I started with IBM in 1967 (in San Jose) as a programmer on the IBM 1130 and the IBM 1800 operating systems (these were a low-end scientific computer and a specialized process-control computer). I also worked on the initial definition of the 1800 follow-on: the IBM System/7.
Moving to Boca Raton, I became a manager of the BASIC operating system for the IBM System/3 Model 6. This little-known product was actually IBM's first "personal computer", albeit a little large: it was a desk with a keyboard, CRT monitor, removable disk and an attached printer. Its operating system was essentially a BASIC language interpreter.
Excitingly, the museum now has a (almost working) and complete System/3 Model 6. Check it out
I then became the architecture for a proposed low-end System/360 computer, which morphed (along with my moving to Rochester, MN) into a business-oriented single-user computer: the IBM System/32. I managed the development of the system software for the System/32.
After the System/32, I started the initial architecture design for the IBM System/38 family. The "second-system effect" was clearly at work here; we decided to advance the state-of-the-art in many areas (and we did, although it took longer than we planned). In particular, innovations in the System/38 were:
Next, moving to Austin, I started several advanced technology projects, one of which morphed into the IBM RT product (sometimes called the RT/PC). I ended up managing both the hardware and operating systems development for the RT. The RT was the first IBM product to use a RISC processor (the ROMP processor), and a UNIX based operating system (IBM AIX). I also managed a project to define an IBM-wide AIX strategy.
At this point I was made an IBM Fellow and henceforth worked on my Fellow projects, the last of which was a processor that would merge the Intel x86 instruction set architecture with the IBM Power architecture. While this "L86" project ("last x86") never became a product, there are tendrils of its philosophy still embedded in my current company's x86 processors. There is even a few external references to the L86 in books, here's one.
Early 9020 versions used System/360 Model 50 processors for all six processors, but our console comes from the latest 9020E version which used three Model 65's for "compute elements" and three Model 50's for "I/O control elements". Our control console is from one of the Model 65 computers, and is slightly different than the standard Model 65 console.
A quick deviation to discuss the IBM System/360. While technically obsolete now, the introduction of the System/360 family was a seminal event in computer evolution. The instruction set architecture was the most modern for its day and had many influences on current architecture (such as 8-bit bytes and 32-bit words). It also introduced a new I/O approach: a high-performance and programmable "channel" that could attach a vast and diverse set of I/O devices. The most significant feature was the concept of a family of computers, all having the same instruction architecture but with different performance and capacities, and all using the same I/O devices. Initially six models were announced: the Model 30, the Model 40, the Model 50, the Models 60 and 62, and the Model 70. These covered a performance range of about 100:1 and ranged from microprogrammed eight-bit datapath to hardwired 64-bit datapath. Yet they all ran the same software and used the same physical I/O devices.
Another eight model types were delivered during the System/360's lifetime, including the highly influential Model 67, Model 85, and Model 91. As a result of the technical features and especially the scalability and software compatibility across the family, the System/360, and its follow-ons such as the System/370 family, dominated the mainframe business.
The 9020 system had an abnormally long lifetime; the corresponding System/360 commercial products were withdrawn from sales in 1977, but the 9020 lingured in use until the early 1990's. One reason for this long life is the fact that much of the air traffic control application was written in System/360 assembly language. Another factor is the 9020's specialized radar console interfaces. As an example of the 9020 staying power, here's a scary NTSB report from 1996 about ARTCC outages pointing out that some of the ARTCCs are still using the 9020's at late as 1995! This reports discusses problems such as aging components where "replacements can be obtained only by scavenging parts from the [FAA] training computer". Thirty years is a long time for any complex equipment to remain functional, but in the world of computing technology, thirty years is many many generations of architecture and technology. Consider, as one example, that the 9020's used magnetic core memory and that a Model 65's performance was less than 1 MIPS!
The museum has a control console from a IBM 705 computer.
I believe this to be very rare item since the 705 was first shiped in late 1954 and was withdrawn in early 1960.
That's a long time ago and there can't have been many shipped during that short period
(but I haven't found credible numbers for the toal shipped).
Also, the 705 was quite expensive: about $590,000 in 1954 dollars.
(Note that on our console the original IBM 705 banner has been replaced with a customer's banner ("Confederation Life"). Since computers were so rare in the 1950's they were usually proudly displayed in a "glass house" by their users, often with the user's name on them.)
The IBM 705 architecture was heavily optimized for business applications such as billing, payroll, accounts receivable, and inventory control, as opposed to computationally intensive applications. In early computers, hardware was so expensive and limited in capability that the each computer was specifically designed for certain types of applications, with a common differentiator being character handling vs. arithemetic computation. In the 1950's IBM introduced several 700-series computer starting with the pioneering IBM 701. The IBM 702, IBM 705 were optimized for business applications, while the IBM 704 and IBM 709 were optimized for engineering and scientific applications. Shown on the left is a pre-System/360 "family tree" drawing from IBM of its early computers which illustrates the various model and their introduction dates. This application optimization continued through later transistorized descendants of these 1950-era computers (such as the IBM 7080 which was the follow-on to the 705) until the introduction in 1964 of the IBM System/360 family, which had a "general purpose" architecture. Even after that, low-end IBM computers such as the IBM 1130, System/3, System/32, and System/38 were optimized for specific applications. And, process-control applications were addressed by the specialized IBM 1800, IBM System/7, and IBM Series/1 families.
The IBM 705 used vacuum tubes (about 1,700 of them) for its logic and used magnetic core memory for storage. Its instruction-set architecture was heavily optimized for business applications. Of special note is the fact that memory was organized into 7-bit "characters" and the two accumulators (corresponding to current processor registers) each contained 256 characters. The memory size was either 20,000 or 40,000 characters. A load from memory into the accumulator took about 17 microseconds. The main input and output was magnetic tape (5M characters per reel), but a card reader and punch as well as a printer could be directly attached.
In addition to the control console, we also have some electronic components and original documentaion (some probably rare) for the IBM 705. We have several of the pluggable processor logic elements as shown on both sides along with an ad for the IBM 701 showing the same type of pluggable unit. Also shown is our stack of more than 25 original IBM documents about the 705 including the introductory volume of the Customer Engineer (CE) internal documentation. This document describes the details of the logic elements and memory components.
One of the most important peripheral I/O devices in a IBM 705 system was the IBM 767 Data Synchronizer. Figure 14 show a picture of the 767 from the IBM 705 Reference manual. The Data Synchronizer was the forerunner of what later became IBM's System/360 "Data Channels". It attached up to 10 IBM 729 tape Drives and allowed overlapping reads and writes across these devices to and from the main memory of the IBM 705. In today's terms it was a "multiplexed buffered DMA (Direct Memory Access) controller".
The museum contains a IBM 767 control panel, as shown in Figures 15, 16, and 17. Note that the front panel has a large bus connector on it.
Figures 18 through 22 show two other control panels that I am sure come from pre-System/360 IBM equipment, but I have not been able to identify them yet.
As discussed above, the
IBM System/360 family was a very significant milestone in computer history.
The Model 30 was the smallest member of the family that was fully instruction-set compatible with the other models.
The hardware had an eight-bit datapath and the System/360 instruction set was completely microprogrammed along with an emulator for
the popular IBM 1401.
The museum has a control panel from a Model 30. Ours is interesting because it has controls not normally found on a Model 30 console. For example, in this web picture, note the blank area to the immediate left of the emergency pull" power disconnect (the upper right red button). On our console, this area has controls for what sounds like "expanded storage".
On a personal note, in 1967 and 1968 at IBM, I often used a Model 30 directly and was very familiar with the console.
The microcode was contained in a control store implemented as read-only storage, or ROS (this is IBM's term, today we call it read-only memory, or ROM). Then, as today, ROS is implemented as a two-dimensional array of word-lines, which select the output for a particular address, and the orthogonal bit lines which are the outputs. Since only one word line is active at a time, the output for each bit of selected the ROS word can be defined by either no connection at the intersection of the word-line and bit-line, or by connecting the word line to the bit line through a diode. That is, when a bit-line is asserted, the output of the ROS is defined by the connects or no connects to the bit lines for that particular address. The difference among the many implementations of ROM are primarily in the choice of this connection mechanism. Different types of "diodes" affect the speed, size, and ability to change the ROS.
All except the high-end model of the original introduction used microcode to implement the System/360 architecture. Three different types of ROS were used: Card Capacitor ROS, Transformer ROS, Balanced Capacitor ROS. We have samples of all three of the types. Figure 1 shows a storage card of the Model 30's Card Capacitor ROS. The storage card looks like an IBM punched card except it is made of Mylar and has metal lines etched on it. (Much more about this ROS design can be found in J.W.Haskell,Design of a Printed Card Capacitor Read-Only Store, IBM Journal, March 1966.) Figure 2 is a closeup of the card. Each card has 12 word lines corresponding to the 12 rows on a standard punched card. The contacts for the word lines are on the right in the picture. Each word line attaches to 60 bit "pads" (again corresponding directly to the punch positions in a standard IBM card). The metal pad can be eliminated by punching that position with a standard card punch. Thus, bits in the microcode word for each word line are defined by the metal pad being present or absent.
The ROS cards are placed in a frame where bit lines run vertically aligned with each of the 60 column. A thin sheet of Mylar goes between the card and the bit lines to form the capacitive coupling between the metal pad and the word line. The cards are mounted on a 20x12" board with four cards on each side. The mechanics of the boards (ground planes, pressure on the card, insulator thickness, etc.) are such that the coupling ratio between a punched and unpunched pad is at least 10:1. The boards are assembled into a module to form the complete ROS. The Model 30 ROS used 43 boards for a capacity of 4032 60-bit words (with one spare board). The access time for this ROS is 0.75 microsecond.
It was relatively easy to change ROS cards in installed systems. This flexibility was important because the Model 30 had an option to emulate the machine instruction set of the very popular IBM 1401. Figure 9 (taken from another source) show IBM Field Engineer changing the ROS for a Model 30.
Figure 3 show the code portion of a module from the Model 40 Transformer ROS. Instead of a capacitor forming the connection between the word line and the bit line, the TROS used a transformer at the intersection. Figure 4 is a closeup of one of the Mylar strips containing two 54-bit ROS words. The word line is etched on the strip and completes a loop from one end back to the same end. The current is routed in one of two ways around a central metal core for each bit. The current direction around the core determines whether it is sensed as a 0 or 1. The current direction is controlled by punches that disconnect one side of the current loop around each bit post. (Much more about this ROS design can be found in D.M.Taub,The Design of Transformer (Diamond Ring)Read-Only Stores, IBM Journal, September 1964.)
Figures 5 & 6 show the "bit line" sensing mechanism that sits on top of the metal cores for each bit. Each module has 128 tapes, each storing 2 words. A total of 16 modules formed the ROS for the Model 40, for a total of 4K words. The access time was 240ns with a cycle time of 625ns. Figure 8 shows 8 modules of the Model 40 ROS; another 8 modules are behind the visible ones.
Figure 10 is part of the Balanced Capacitor ROS of the IBM System/360 Model 50. It is called balanced because the capacitance load on the word line is the same regardless of the pattern of bits. This is as opposed to the Card Capacitor ROS shown in Figure 1 where the number of 1 bits changes the word line capacitance. The balanced approach allows a faster access time: the timing of the Model 50 was 90 ns access and 200 ns cycle. The disadvantage of the balanced approach is that the bit patterns have to be manufactured into the card, as opposed to the card capacitor approach where new ROS bits can be created on site.
Figure 11 shows a closeup of the card. A ROS bit is represented by two locations along the word lines. There are two "word" line for each bit: one is the drive line to trigger reading. Attached to this line is one "pad" shaped per bit. There are two sense lines for each bit on the sensing plane that the ROS cards are pressed against: one for 1 and one for 0. The position of this bit pad over the two sense lines determines whether it is represents a 1 or 0. The other word line a "balance" line for attaching the complement of the bit flags. For example, compare the first two bits of the top two bit rows in Figure 11. The first two bit pads are the same: the right pad is attached to the drive line. The next bits are different: top row has left pad attached, and bext row has right pad attached.
(Much more about this particular ROS design can be found in S.A.Abbas,A Balanced capacitor Read-Only Storage, IBM Journal, July 1968.)
Mercury tubes were first used for delay lines; for example the UNIVAC I used mercury delay lines. A major improvement over mercury tubes was Magnetostrictive memory. The museum has a great example: it is the memory from an IBM 2848 control unit which fed video data to several IBM 2260 Display stations, the first video display terminals that IBM made (shipped in the mid-1960's)
Magnetostriction means that a material (a metal wire in our case) changes shape in the presence of a magnetic field. In our case, the wire expands or contracts , thus creating a mechanical pulse that propagates along the wire. Our wire was made of a special nickel-titanium-iron allow that had the right properties for propogating the mechanical impulse along the wire.
Figure 1 shows a memory module from the 2848 control unit. Each module held 11,520 bits, and there were up to four modules in a 2848 control unit, which could service eight 2260 terminals. A 2260 screen was 12 rows of 80 characters. Each character was represented by a six-bit code, so a 2260 needed 5,760 bits to refresh its display.
The memory worked by generating "bit" waves using a magnetic transducer at one end of the storage wire. Figure 3 shows the transducer and start of the wire, and Figure 4 shows the end of the wire, the sensor, and a fine-tuning adjustment. Figure 2 shows a close-up of the wire coils of wire, as well as the circuit board which used discrete germanium transistors. The access time for this memory was about several hundred microseconds, the time for a wave to travel along the complete wire. Both ends of the wire are dampened to prevent feedback of reflected waves.
I love IBM card equipment!
Until the early '60s, most business applications were done on standalone card processing units (called by IBM unit record equipment by IBM) like the ones in our collection (shown following this topic). Even when computers started to be used, most programming was done on punched cards and all computers had punched card input and output. It wasn't until the middle seventies at IBM that we internally switched from card input to CRT terminals. Figure 1 is a box of 2000 fresh punched cards just waiting for our machines to use. (When I programmed on punch cards at IBM, our programs consisted of several trays of cards, each try containing several of these boxes.)
Standalone card equipment ranged from simple devices like keypunches to primitive computer devices like the IBM 602 Calculating Punch which could do multiplication and division. All but the simplest card equipment could be "programmed" by wiring a control board like the ones shown here (often called a plugboard). Other than the fairly rare calculating punches, the most advanced card devices were accounting (also called tabulating) machines like the IBM 407 which read cards and printed a report based on the card data using some counters and simple branching logic (as defined by the plugboard program). hese tabulating machines were the computers of their day and were pervasively used in business.
Accounting machines could also be used in non-obvious ways; in my first computer job in 1963 (application programming an IBM 7090 in Fortran and assembler), one of the scientists had programmed an IBM 407 to do matrix multiplication. (Here's a technical paper on this magic. Figure 2 shows a page describing the programming.) Later in college (1965-67) the computer we used (an IBM 1620) had only card input and card output. The output punched cards were hand carried from the computer to the 407 for listing. (The 407 was also used for many business tasks such as producing the student grade reports.) So, since every run I made ended up on the 407, I naturally learned how to program the 407 to do "cute", but useless things. We had lots of 407 boards, each preprogrammed with a particular application, similar to having multiple computer programs today.
Here is my collection of plugboards for IBM card equipment. Figure 3 is the board for an IBM 402 accounting machine, an earlier version of the 407, and Figure 4 show how the plugs come out of the other side. When the plugboard is inserted into the machine, the plugs contact sockets that are hardwired to card read brushes, card punch controls, and internal counters and other logic. Figure 4 also shows the label of what this program supposedly did (payroll). Figure 5 shows our four IBM 557 Alphabetic Interpreter plugboards. Since we actually have a 557 in the museum, having multiple boards allows us to have different programs ready to us. On the left side are some programming "statements" (plug wires) ready for more programming.
Figure 6 shows the plugboard for an IBM 088 Collator. Figure 7 shows the plugboard for an IBM 533 Card Read Punch. The 533 is particularly important as it was the input/output device for the IBM 650 computer, commonly considered to be the first mass produced computer. The 650 was the first computer I ever saw in person (on a high-school field trip to the engineering lab at UC, Berkeley), and it had a great influence on my later choice to specialize in computers.
Figure 9 shows the plugboard for an IBM 602 Calculating Punch. Figure 8 is a closeup of this board showing some of the controls for multiplying and dividing. Figure 10 shows our three plugboards for our IBM 514 Reproducing Punch. (Also shown are some programming plugs; these can be used on all the IBM boards.) Figure 12 show the control board for a rare device: the IBM 063 Card-Controlled Tape Punch. This device read cards and punched the corresponding values in paper tape.
Finally, Figure 11 shows a particularly rare piece: the control plugboard for an IBM 6400 Accounting Machine. This device is little know and I've never seen one (as opposed to all the other devices discussed in this section).
Finally, I now possess a IBM 407 control board. As described above, this is my favorite card devices and the epitomy of card processing complexity. Figure 15 show the large (and heavy, about 25 pounds) 407 control board with an apparently working program. Figure 17 shows the label of the program which is "PAYROLL/CALC FICA/RETIREMENT/TAXABLE WAGES". This payroll application is a typical 407 function (our college 407 was used monthly for this very purpose). Figure 16 shows a close-up of some of the program's logic. The big orange and gray blob things are splitters and combiners of signals.
I'm getting too many of these to photograph them, so here is my inventory of IBM card equipment control panels: Type 46-47 IBM 650 system Type 77 IBM 77 Collator Type 85 (x2) IBM 85 Numeric Collator Type 88 IBM 88 Numeric Collator Type 88-2 IBM 88 Numeric Collator Type 101 IBM Statistical Sorting Machine Type 323 IBM 323 Card Punch, part of RAMAC 305 system Type 380 IBM 380 Console, part of RAMAC 305 system Type 402-403 (x4) Type 407 Type 513 Type 514 (x2) Type 513-514-523 Type 521-541 Type 548 Type 553 Type 557 (x2) Type 604 (x2) 604 Electronic Card Calculating Punch Type 834-836 IBM 870 Document Writing System Type 6400
In its heyday of computer design, IBM not only had great electonic technology but their packaging was unbelievably good.
Here are some examples in the museum.
IBM Thermal Conduction Module (TCM)Figures 1-5 shows the IBM TCM used in the 3081 computers, circa 1981. It is six inches square and weighs about 5 lbs. The outside of the cover is shown in Figure 4. The reverse side of the cover is Figure 1 which contains an 11x11 array of spring-loaded copper slugs. Figure 5 shows a side view of the cover and slugs (I have lost some of the springs so some of our slugs don't pop-up). When the cover is mounted on the bottom assembly, the copper slugs each press one one of 11x11 flip-chip mounted gate-array TTL chips, each containing about 704 circuits. The chips are mounted on a thick ceramic substrate containing 33 wiring levels. The back side of the ceramic, shown in Figure 2, contains 1800 I/O pins.
The area above the copper slugs in the cap was filled with helium to help conduct heat to the cover. The cover was attached to a water cooled plate.
IBM 3745 Thermal Conduction Module (TCM)
IBM Z9 MCMOkay, so this is not exactly an old item: it was shipped in 2006. It does, however, show another instance of IBM's great technology capabiility, so since I'm covering older technology I thought it belonged--it's just so cool!
This is a processor module from the IBM Z9 mainframe/super server. There are 8 processor chips, each containing 2 cores, each with 256KB of L1 cache, along with 4 L2 cache chips comprising 40MB, plus controlers for cache, memory, and I/O. About 4.5 billion transistors altogether with a very impressive package.
The ceramic package has 102 internal wiring planes, 5,184 total pins including 2,970 signal pins. It dissapates 1200 Watts of heat and is normally water cooled, but there is a air-controlled backup where the clock speed is reduced.
The Z9 chips are implemented in IBM 90nm technology. Interestingly, we used that same technology for a processor design we did in the mid 2000's. Our tiny chip (about 30M transistors) could run at 2.0 GHz. The Z9 processor chips run at 1.7GHz. This is a tremendous achievement considering how much larger the Z9 is than our processor (150x spread across 16 chips!).
A keypunch was the source of data and programming when I started in computing.
As one typed on he keyboard, the characters were punched into the card (using a unique 12-hole code).
After all your data or program lines were punched, the collected cards were read by
standalone card devices (like a sorter) or by card readers attached to a computer.
As late as the early 1970's at IBM, our programs consisted of thousands of cards held in metal trays
(that fit into special file cabinets.)
A program library was thus very similar to a real library, only with many trays of cards instead of books.
Much more information about IBM keypunches, histoy, how they work, codes, and so forth, is found here.
Figure 1 shows our IBM 026 Keypunch. The 026 was first introduced in 1949 replacing even older keypunch models. Figure 2 shows our more modern IBM 029 Keypunch. The 029 was first introduced in 1964 and was the last version IBM made.And Figure 3 show a semi-portable (it weighs about 40 lbs.) IBM 010 Keypunch. This device allows the operator to punch one card column at a time (the keys trigger a solenoid punch). Interestingly, I can't find any references to a IBM model "10" keypunch. There is a manual 010 that is similar, but obviously of earlier origin.
Figure 1 shows our IBM 557 Alphabetic Interpreter.
It is essentially a card printer.
The information to be printed, however, comes from the same card that is being printed,
and the plugboard control can perform reformatting of the data to be printed.
This process requires a lot of complicated machinery.
Figure 2 shows part of the card path mechanics.
Card are read at the top and part of the 60 individual print bars is seen at the very bottom.
The 557 was first introduced in 1954 and is the next-to-last of a line of IBM card interpreters.
An example application of the 557 is printing payroll checks on card stock. Another of IBM's card machines (or even a computer) would punch the information on cards, which would then be run through a 557 to print the readable information such as recipient and amount.
|Figure 1 shows our IBM 514 Reproducing Punch. It basically reads punched cards and punches new cards based on the read cards, but not necessarily with the same data. In addition to simple punch-for-punch reproduction, based on the plugboard control the 514 can perform other functions such as inserting "master" information on each punched card, reproducing only some of the data and possibly in different locations, and creating and printing sequence numbers on the output cards.|
Here is the quintessential piece of card equipment: a sorter.
Our IBM 083 is one of the last of a line of IBM card sorters.
Card sorters read one particular column as each card is passed through them
and sends the card to the appropriate bin for what's punched in that column.
Since there are 12 punch positions in each column, the read cards are
routed one of 13 separate bins (12 plus one for errors).
The 083 sorts at 1,000 cards a minute: over 16 per second.
When it runs, it's very impressive; the cards move faster than the eye can follow.
It also has a card counter for verifying the number of cards processed.
JOSS (JOHNNIAC Open Shop System)
was a new computer language, which together with new remote terminals,
attached to RAND's
JOHNNIAC mainframe computer,
comprised one of the first time sharing computer systems.
This RAND document
from RAND contains more information about the language and using the JOSS system.
Of particular interest to us is the special console designed for JOSS,
which is described in detail in
this RAND report.
The JOSS console comprises a modified IBM 731 "input-output" electric typewriter attached to a specially designed control logic
which interfaces between the typewrite and a full-duplex communication channel.
Figures 1 and 2 come from this RAND report showing the console: the typewriter on top of the control box.
The museum contains an instance of the JOSS console control box. Figures 3 and 4 show the front and back sides. Figure 5 shows one of the 50 cards containing in the control unit's logic. This appears to use diode logic. Also in Figure 5 we see the RAND label and serial number of our controller. Figure 6 show some information pasted to the side of the controller, and Figure 7 show some of the status lights on the top of the controller.
As I mentioned above, the IBM System/360 family had a new and powerful type of I/O attachment:
the IBM channel.
The channle comprised a programmable I/O controller and standard physical attachments to a wide variety of I/O devices.
There were two basic type of channel controllers: A selector channel, and a multiplexor channel.
The IBM 2870 was the multiplexor control unit for the System/360 family. Figure 1 is the control panel from an 2870 controller. (The wooden frame is an add-on for displaying the panel.) Figure 2 is a page from the 2870 manual showing this control panel. Careful study of the control and status indicators shows that the 2870 was effectively a programmable computer.