LGP-30 — A Drum Computer of Significance

Affordable computing by rotating bits at 3700 rpm.

In July 1956, when IBM was still considering its answer (which was to become the IBM 1401) to the French challenge that was the Bull Gamma 3 (1952), then posing a serious threat to IBM’s monopolic line-up of punched card appliances, Librazette, Librascope’s employees’ and PR gazette, proudly announced that the company’s new LGP-30 computer had been promoted to production.

The computer had been developed by Stan Frankel as the MINAC at CalTech in 1954 and Librascope had bought Frankel’s design (apparently in the same year), releasing it as the LGP-30 in 1956. Librascope, originally a venture focused on aviation equipment, had been acquired by General Precision Equipment Corporation (GPE) in 1941, which in turn had formed a joint venture with the Royal McBee Corporation, then world’s largest manufacturer of typewriters, just at the beginning of 1956. Thus, the LGP-30 (Librascope General Purpose 30) was rather shipped under the new Royal Precision brand (with LGP now standing for Librascope General Precision). However, this wasn’t the last change in branding during the lifetime of the LGP-30, as Datamation announced in its August issue of 1965 that Control Data (CDC) had “acquired the business computer operation of General Precision’s Librascope through an exchange of stock”, including installations of the LGP-30, while GPE would now be concentrating on “military, space, and special-application markets.”

The computer generally known as the Royal McBee LGP-30 was a desk-sized appliance (w × h × d: 44″ × 33″ × 26″ or 1120 mm × 840 mm × 660 mm) and weighed in at about 800 pounds (360 kg). It came with a Flexowriter-style console typewriter and consisted internally of just 113 vacuum tubes, 1,450 solid state diodes, and a magnetic drum for memory (4K of 31-bits words) and 3 registers. It plugged into an ordinary wall socket, from which the combined circuitry drew up to 1500 Watts. All this could be yours for just US$ 47,000 ($433,000 in 2018), which was actually the first viable option for small-to-medium scale computing.

The LGP-30 uses just 15 flip-flops and a logical network made of diodes and resistors to achieve its functionallity by just that few electronic components. Each flip-flop (or “toggle”) presents a bit in duplicate, both the normal and the inverted output of its internal state, such facilitating the basic monotonic Boolean functions And and (inclusive) Or by simple diode networks. (Compare: Stanley P. Frankel, “The Logical Design of a Simple General Purpose Computer” in: IRE Transactions on Electronic Computers, March 1957, pp. 5.)

(The other viable option was the Bendix G-15, also introduced in 1956, which came at $49,500 without peripherals, a working model affording to around $60,000, over $500,000 in today’s money.)

Drum Computing

Let’s talk about the elphant in the cabinet, namely the magnetic drum: This was a precision worked metal cylinder 6.5 inches in diameter and 7 inches long, evenly coated with a magnetic surface. Read-write heads were positioned at 64 cylindrical tracks, each of them consisting of 64 sectors of 32 bit positions. These made up to 64 × 64 = 4069 or 4K of 32-bit words of memory. As the 32^nd bit of each word was used merely as a spacer on the drum to separate words, this was always set to zero in memory and the word-size was effectively 31 bits.

This drum rotated at 3700 rpm or 1 revolution per 17 milliseconds, which also defined the max access time for a word. However, there were also 3 special tracks, each with separate write and read heads at an offset of one word on the rotating drum, permanently rewriting the three registers, the accumlator (AC), the counter (PC), and the instruction register, which provided a quick access time of just 0.26 milliseconds.

While this was obviously not Random Access Memory (RAM), but sequential like a delay line, it was a viable and cost effective option when stable and reliable memory was still some of a technical challenge. Besides the price tag, this machine provided the blue print for what was to become the successful category of mini computers (semi-officially starting with the 12-bit PDP-8 in 1965.)

The computer itself was running at 120 kilocycles (120 kHz), which wasn’t too bad for a small 1950s’ machine. However, we had to add memory access times to this, which was still good for “over 400 additions per second” (Programming Manual, p.7). Moreover, 4K of 31-bit words were actually ample at the time, it was at least sufficient to implement a proprietary language (ACT, revisions I–III) and two versions of Algol 60: Dartmouth ALGOL 30, implementing the full set less features requiring run-time storage allocation, and SCALP (Self Contained Algol Processor), which only implemented a basic subset.

Instructing the LGP-30

Let’s have a look at the Programming Manual (Royal Precision Electronic Computer LGP - 30 Programming Manual; Royal McBee Corporation, Port Chester, NY, April 1957), which is available

• as a PDF at Bitsavers and
• as HTML-formatted text at Ed Thelen’s website.

— Small Rant —

Now, usually early computer manuals are a joy to read. Commonly, these are that clear and informative that you may built a binary compatible emulator based on them. However, the LGP-30 Programming Manual, which is merely a typoscript, is none of these. It’s a bit confusing, to say the least. We read astounding sentences, like, “As indicated, bit positions 12 through 15 in a word are used to represent the order. Since 4 bits are used to represent the order, there are 24 or 16 possible orders in the LGP-30.” — what “24” in 4 bits are you speaking of, what number system is this?!? (OK, this is a formatting error in the HTML-version.) —, or incomplete, hence incorrect, sample programs are provided, which are fixed-up as the manual goes along (which may be rather confusing to the novice, the manual is addressing). Or, the notation “n at q” is introduced without further explanations (however, we may infer the meaning as we eventually finish the manual.)

While 320~493 (Wikipedia) machines were produced in total (which is quite a number for an early computer), the LGP-30 remains some of a mystery to date, which may be partly due to this manual. ;-)

So here are some observations of note:

As mentioned above, the word size was 32 bits with the 32^nd bit used as a spacer (on the magnetic drum) and always zero in memory, making for effective 31 bits (0…30) from the programming side of things. There are 64 tracks at 64 sectors on the drum, providing 4096 (or 4K) 31-bit words in total. There are also 3 permanently updated tracks on the drum for the PC, the instruction register and AC (there’s a read-head and a write-head at an offset and these registers are read and rewritten constantly for quick access). Clock speed was 120 kilocycles, which isn’t too bad.

While some descriptions (like the Wikipedia article) are a bit mysterious about single operand instructions, the LGP-30 follows the usual pattern of instruction words with the operand directly encoded in the lower part. On the LGP-30, the operand is always a memory address and addresses are formed of the track and the sector number. This causes gaps in between addresses where we cross tracks, as in 2062, 2063, 2100…

In numeric context, the sign-bit is in it’s usual place in the most significant position and negative values are represented in the then common one’s complement (all bits simply flipped).

What’s a bit unusual is the layout of the instruction with some spacing around the significant bits:

± 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 S
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 P  bits

- - - - - - - - - - - - I I I I - - T T T T T T S S S S S S - -  encoding

I: 4 bits (12 – 15) instruction order (opcode)
   (2 bits spacing)
T: 6 bits (18 – 23) track number in binary (0…63)
S: 6 bits (24 – 29) sector number (0…63)

4 bits make for 16 versatile instructions, including a single conditional jump (branch on AC negative), an instruction to deposit PC+2 in an address (for subroutine returns), an instruction to just store the address part in a word in memory as an operand, as well as multiplication and division (which follow the usual pattern of a fixed point format with the fractional point at the left, after the sign bit). There’s no indirect addressing and self-modification is a must.

For a small instruction set, there’s a lush variety of deposit commands: h (store AC and Hold) c (store and Clear AC) and y (store address part only). There are even conditional break points (you had to press buttons to ignore them), which makes this quite a versatile and well balanced instruction set.

h – hold and store  (deposit AC in memory)
c – clear and store (deposit AC and set AC to zero)
y – store address   (deposit AC as operand)

The presence of dedicated instructions for multiplication and division may be surprising, but is propably for the intended use as a replacement for complex (electro-)mechanical calculators. Multiplications and divisions are performed in the then usual way of applying repetitive multiplication and division shifts for each bit position.

(For multiplication a partial product is formed for each bit by adding the multiplicand to the accumulator, if the least bit in the multiplicand is HI. Then, both registers, accumulator and the multiplicand are shifted left by one bit position and a zero is filled into the least significant bit of the accumulator before the next partial product is formed. For division, it’s a similar procedure, but now the divisor is subtracted from the dividend and both registers are roted to the right. On the LGP-30 the accumulator is temporarily extended to slightly over twice its normal size by the use of a second reading head for these instructions. [Compare, Stanley P. Frankel, 1957, p.11])

Notably, subtractions and divisions may effect overflow, which will cause the machine to stop, but a multiplication may never overflow, since both operands are assumed to be fractional values with the fractional point left of the most significant bit. On the other hand, this means that a multiplication will produce a result twice as long as a normal word and that the scaling of the result is the sum of the scaling of the two operands. To cope with this, there are actually two instructions for multiplication, “m”, which puts the most significant part of the result in the accumulator, and “n”, which puts the least significant part of the result in the accumulator.

Further, this means, we have to keep track of the scaling factor q as in “7 at 5”, meaning 7 scaled by 5 bit positions to the right. For additions and subtractions, the scaling factor must match, so we are meant to adjust the scaling by shifts. However, there are no shift instructions at all! Instead, multiplications and subtractions by powers of 2 are used to accomplish the same. (Quite inverse to later computers, which do have shift instructions, but may lack the more complex multiply/divide.)

Here’s the instruction set in it’s entirety (mind the use of mnemonic letter designations):

As we may discern, this isn’t way dissimilar from the instruction set of the UNIVAC I, which is, however, more complex. Even some of the letter designations are the same. (However, the the UNIVAC usues decimal arithmetics in binary excess-three encoding, where the LGP-30 uses binary.) While this may be merely coincidence and due to market forces, we may observe that Stan Frankel, LGP-30’s designer, came from Eckert’s and Mauchly’s ENIAC team.

Mind that subroutines required explicit handling of return addresses. E.g.,

addr    instr.    note
 ...
1010    r 2030    store return address (PC + 2 = 1012) at end of subroutine
1011    u 2000    jump to start of subroutine
1012    h 1030    store AC at address 1030 (we continue here)
 ...

2000    a 1031    start of subroutine (here, add contents of addr. 1031)
 ...
2030    u 0       return (address is fixed up by ‘r’ instruction)

And here’s the sample program from the Programming Manual, exhibiting self-modification in all its glory in order to compute the formular (((a₀x + a₁)x + a₂)x + a₃)x + a₄ — notes in parentheses by me (N.L.):

addr    instr     operand            result (notes)

1000    b 2002    a 2005             initial add instruction (“add a0”)
1001    c 1005    .                  (store it at 1005 and set AC to zero)
1002    h 2000    (zero)             initialize working storage
1003    b 2000    working storage    (load partial result into AC)
1004    m 2004    x                  (multiply by x)
1005    a(2005)   an                 (inserted at 1001)
1006    h 2000    working storage    intermediate and final results
1007    b 1005    a(2005 + n)        (load instruction code at 1005)
1008    a 2001    1 at 29            (increment it: add 1)
1009    h 1005    a(2005 + n+1)      (store it at 1005, next addd instr.)
1010    s 2003    a 2010             flag (subtract “last addition + 1”)
1011    t 1003    .                  (jump to 1003, if negative)
1012    h 2000    final result       (store it)
1013    r 3050    .                  (deposit return address)
1014    u 3000    print routine      (jump to subroutine, not implemented)
1015    z 000     .                  stop

2000    working storage              (partial result)
2001    1 at 29                      (constant: 1 @ q = 29)
2002    a 2005                       (first add instruction, “add a0”)
2003    a 2010                       (stop condition, “add 2010”)
2004    x
2005    a0                           (set and modified by program)
2006    a1
2007    a2
2008    a3
2009    a4

Mind how a0 is set at the beginning of the program and is then, after its initial use, reused as a secondary working storage to advance over a_n+1.

I/O and Encoding

Remember the instruction layout with the 4 bits for the opcode followed by a two-bit gap? This is probably for the 6-bit encoding of the characters of the console typewriter (a Flexowriter with non-standard encoding). There are always 4 significant bits followed by 2 zone bits.
A set of letters is used for the instructions, but only the higher 4 significant bits are used as the opcode (while the two zone-bits are masked by the gap):

 Numbers  Instructions     Others          Controls

0 000010    z 000001    :;     001111    Lower Case  000100
l 000110    b 000101    ?/     010011    Upper Case  001000
2 001010    y 001001    ].     010111    Color Shift 011000
3 001110    r 001101    [,     011011    Car. Return 010000
4 010010    i 010001    Vv     011111    Back Space  010100
5 010110    d 010101    Oo     100011    Tab         011000
6 011010    n 011001    Xx     100111    Stop (')    100000
7 011110    n 011001    =+     001011    Start Read  000000
8 100010    n 011001    _−     000111
9 100110    m 011101    Space  000011
f 101010    p 100001    Delete 111111
g 101110    e 100101
j 110010    u 101001
k 110110    t 101101
q 111010    h 110001
w 111110    c 110101
            a 111001
            s 111101

Mind the unusual hexadecimal sequence 0…9, f, g, j, k, q, w. (Apparently, any prominent pairs of keys left on the keyboard, which weren’t used for an instruction already, was chosen.)

Also, there’s no “1”, rather, lower-case “L” was used for this (which is in the numbers group) at a time, when computer keyboards didn’t lend themselves so much to the special purpose than to common typing habits.

The instruction letters were color-coded on the keyboard (white key caps instead of the usual brown) – which makes the LGP-30 probably the first computer to use color-coded single-key instructions — ZX Spectrum fans may be surprised to learn that their beloved machine wasn’t the first to do so. ;-)

Input and output, both from the keyboard and from paper tape are provided by the Flexowriter. Input is performed by the combination of a void print command (“p 0000”, Start Read — this will “wake up” the console typewriter and cause it to send a ready signal back to the computer) and followed by the actual input command, which fills AC from the right by groups of bits, shifting any previous contents to the left. Input is read either in 6 bits, or just the most significant 4 bits (ignoring the two lower bits) as recommended for numbers. AC is filled that way from right until a Stop character (1000, ') is encountered. (This may also explain, why the single quote / apastrophe was used as a separator in the ACT language.)

Operations

Startup procedures are surprisingly simple: Just put the computer into manual input mode (which puts the machine into single instruction mode and prevents any recordings of transient signals onto the drum), press the “Operate“ button on the console and “Power On”, and the computer will engage in an automatic 2-stage startup sequence, lasting 50 seconds each. The first one is an intentionally slow warm-up stage, in order to preserve the filaments and to prolong the life of the vacuum tubes (valves), while the machine is helpfully putting on the “Stand By” light. The second one raises the circuitry to full DC voltages, slowly so for the same reasons. As the lights change from “Standby to Operate” to “Operate”, you probably have the loader program already in memory (since the drum provides nonvolatile memory) and you are ready to go.

If not, it’s time to enter the bootstrap loader. We could enter this either the hard way by the keyboard or run a paper tape instead. Button “Fill Instruction” simply transfers the contents of the accumulator into the instruction register and “Execute Instruction” executes it.

(The entire bootstrap code is, “c000j'000p0000'c0004'000i0000'c0008'000cxxxx'c000j'000b0008'c0010'000a001j'c0014'000y0008'c0018'000u0000'c001j'000z0004'”. Mind that input is hexadecimal and characters are read into the accumulator at the right-hand side.)

There are also a few provisions for modifying the flow of control: Buttons “Break Point 32..4” disable conditional break points (stop commands with bits corresponding to the break point number set in the track portion of the operand), while “Transfer Control“ modifies any test commands with the sign-bit set into unconditional transfers (jumps).

The “Transfer Control” button may be used to implement a console option like in the Story of Mel: Have a zero or positive value in the accumulator and a test instruction (“t”) with the sign-bit set. If the “Transfer Control” button is deployed, we take the jump (unconditionally), if not, the program falls through to the next instruction as the condition “AC negative” is not met.

Of course, the machine provides visual feedback, but not by the usual console blinkenlights, instead, it ingeniously employs a CRT oscilloscope to display the contents of its three registers, one pulse per bit:

Finally, if you wanted to increase the speed and versatility of your operations, optional peripheral devices were also available, like the photo-electric paper tape reader Model 342:

Of course, you weren’t “hacking” your program directly into the console typewriter, rather, you’d use a coding sheet like the following, filling in your program by hand (which is also, how programs were distributed for the most):

Significance

The significance of the LGP-30 is really in its availability and relative affordability. It introduced digital computing to a variety of institutions and private companies, which couldn’t have afforded a more complex machine, and did so with surprising simplicity and ease of operations. Despite its slim instruction set, this was was a fully fledged general purpose computer, perfectly capable of coping with most practical problems. The 1956 sales brochure by Royal McBee lists a large variety of application domains for the machine:

(LGP-30 – The Royal Precision Electronic Computer; Royal McBee Corporation, S-526, 1956; pp.3,4. Illustrations: ibidem.)

This is an impressive list of applications which had been rather tedious, if not impossible, to tackle using a mechanical calculator or a punchcard appliance, but could now be handled with a reasonable turn-around time. The LGP-30 is really the machine which introduced the digital age at a practical level.

One of those, who were jump-started by the LGP-30 into a new age and to an entirely level, was Edward Lorenz, who is commonly attributed the “father of chaos theory” and popular for the butterfly effect. Notably, Lorenz had been heading the MIT group, which conducted numerical weather simulations at the Princeton IAS machine, but it was for the direct access to the LGP-30, the practicality of which dwarved the power of the computational colossus. One of those involved in the work, which resulted in Lorenz’s masterwork “Deterministic Nonperiodic Flow”, was Margaret Hamilton, who had arrived at MIT in summer of 1959, just after Lorenz had bought and familarized himself with the machine. Eventually, Margaret Hamilton migrated to the MIT Instrumentation Laboratory and programmed the onboard flight software for Apollo Guidance Computer (AGC).

Much to its consequence, the LGP-30 is also the machine, which brought BBN (Bolt, Beranek and Newman, Inc., until then a psychoacoustics lab with close relations to MIT and Harvard) and J.C.R. Licklider into computing. — Here in the words of Leo Beranek, the second “B” in “BBN”:

Licklider had been on staff only few months when he told me, in fall 1957, that he wanted BBN to buy a digital computer for his group. When I pointed out that we already had a punched-card computer in the financial department and several analog computers in the experimental psychology group, he replied that they did not interest him. He wanted a then state-of-the-art digital machine produced by the Royal-McBee Co., a subsidiary of Royal Typewriter.
“What will it cost?” I asked.
“Around $30,000,” he replied, rather blandly, and noted that this price tag was a discount he had already negotiated.
I exclaimed, “BBN has never spent anything approaching that amount on a single research apparatus. What are you going to do with it?”
“I don’t know,” Lick responded, “but if BBN is going to be an important company in the future, it must be in computers.”
Although I hesitated at first — $30,000 for a computer with no apparent use seemed just too reckless — I had a great deal of faith in Lick’s convictions and finally agreed that BBN should risk the funds. I presented his request to Labate and Baruch, and with their approval, Lick brought BBN into the digital era. Lick sat at that computer many hours each day, literally hoarding the machine, learning how to do digital programming.

(Leo Beranek in, A Culture of Innovation – Insider Accounts of Computing and Life at BBN, Waterside Publishing, 2011; PDF-version pp.33.)

Later, BBN picked up one of the two DEC PDP-1B production prototypes (which came in 4 cabinets instead of the 3 of the final production model) and then the PDP-1D timesharing prototype, which had been designed to BBN’s specifications. Without the humble LGP-30, neither BBN nor Licklider would have been in computing, let alone networking – and there wouldn’t have been the ARPAnet or the Internet, either. Given the importance of BBN for DEC as an early key customer and a bridgehead to the industry, and the decisive early acquisition of the PDP-1B prototype, which was vital for DEC’s venture into manufacturing computers, without the LGP-30, there might have been no PDPs and no VAXes, as well.

And there many more stories like these to be told about the LGP-30. It may be fair to say that this was the machine, the digital world as we know it was founded on. It jump-started the digital age on a broader basis, not so much for its speed or capabilities, but for its affordability, its practical packaging and manageable operations.

Norbert Landsteiner,
Vienna, 2019-07-20

Discuss/comment on Hacker News (oops, front page).