The Launch Vehicle Digital Computer (LVDC) had a key role in the Apollo Moon mission,
guiding and controlling the Saturn V rocket.
Like most computers of the era, it used core memory, storing data in tiny magnetic cores.
In this article, I take a close look at an LVDC core memory module from
Steve Jurvetson's collection.
This memory module was technologically advanced for the mid-1960s, using surface-mount components, hybrid modules, and flexible connectors that
made it an order of magnitude smaller and lighter than mainframe core memories.2
Even so, this memory stored just 4096 words of 26 bits.1
A core memory module from the LVDC. This module stored 4K words of 26 data bits and 2 parity bits. It weighs 2.3 kg (5.1 pounds) and measures about 14 cm×14 cm×16 cm (5½"×5½"×6"). Click on any photo for a larger version.
The race to the Moon started on May 25, 1961 when President Kennedy stated that America would land a man on the Moon before the
end of the decade.
This mission required the three-stage Saturn V rocket, the most powerful rocket ever built.
The Saturn V was guided and controlled by the Launch Vehicle Digital Computer3 (below), from liftoff into Earth orbit, and then
on a trajectory towards the Moon. (The Apollo spacecraft separated from the Saturn V rocket at that point, ending the LVDC's role.)
The LVDC mounted in a support frame. The round connectors are visible on the front side of the computer. There are 8 electrical connectors and two connectors for liquid cooling. Photo courtesy of
IBM.
The LVDC was just one of several computers onboard the Apollo mission.
The LVDC was connected to
the Flight Control Computer, a 100-pound analog computer.
The Apollo Guidance Computer (AGC) guided the spacecraft to the Moon's surface.
The Command Module contained one AGC while the Lunar Module contained a second AGC7
along with the Abort Guidance System, an emergency backup computer.
Multiple computers were onboard an Apollo mission. The Launch Vehicle Digital Computer (LVDC) is the one discussed in this blog post.
Unit Logic Devices (ULD)
The LVDC was built with an interesting hybrid technology called ULD (Unit Logic Devices).
Although they superficially resembled integrated circuits, ULD modules contained multiple components.
They used simple silicon dies, each implementing just one transistor or two diodes.
These dies, along with thick-film printed resistors, were mounted on a half-inch-square ceramic wafer to
implement a circuit such as a logic gate.
These modules were a variant of the SLT (Solid Logic Technology) modules developed for IBM's popular S/360 series of computers.
IBM started developing SLT modules in 1961, before integrated circuits were commercially viable,
and by 1966 IBM produced over 100 million SLT modules a year.
ULD modules were considerably smaller than SLT modules, as shown in the photo below, making them more suitable for a compact space computer.4
ULD modules used ceramic packages instead of SLT's metal cans,
and had metal contacts on the upper surface instead of pins. Clips on the
circuit board held the ULD module in place and connected with these contacts.5
The LVDC and associated hardware used more than 50 different types of ULDs.
SLT modules (left) are considerably larger than ULD modules (right). A ULD module is 7.6 mm × 8 mm.
The photo below shows the internal components of a ULD module.
On the left, the circuit traces are visible on the ceramic wafer, connected to four tiny square silicon dies.
While this looks like a printed circuit board, keep in mind that it is much smaller than a fingernail.
On the right, the black rectangles are thick-film resistors printed onto the underside of
the wafer.
Top and underside of a ULD showing the silicon dies and resistors. While SLT modules had resistors on the upper surface, ULD modules had resistors underneath, increasing the density but also the cost. From IBM Study Report Figure III-11.
The microscope photo below shows a silicon die from a ULD module that implements two diodes.6
The die is very small; for comparison, grains of sugar are displayed next to the die.
The die had three external connections through copper balls soldered to the three circles.
The two lower circles were doped (darker regions) to form the anodes of the two diodes, while the upper-right circle was the cathode, connected to the substrate.
Note that this die is much less complex than even a basic integrated circuit.
Photo of a two-diode silicon die next to sugar crystals. This photo is a composite of top-lighting to show the die details, with back-lighting to show the sugar.
How core memory works
Core memory was the dominant form of computer storage from the 1950s until it was replaced by semiconductor memory chips in the 1970s. Core memory was built from tiny ferrite rings called cores, storing one bit in each core by
magnetizing the core either clockwise or counterclockwise.
A core was magnetized by sending a pulse of current through wires threaded through the core.
The magnetization could be reversed by sending a pulse in the opposite direction.
To read the value of a core, a current pulse flipped the core to the 0 state. If the core was in the 1 state previously, the changing magnetic field created a voltage in a sense wire threaded through the cores. But if the core was already in the 0 state, the magnetic field wouldn't change and the sense wire wouldn't pick up a voltage. Thus, the value of the bit in the core was read by resetting the core to 0 and testing the sense wire. An important characteristic of core memory was that the process of reading a core destroyed its value, so it needed to be re-written.
Using a separate wire to flip each core would be impractical, but in the 1950s a technique called
"coincident-current" was developed that used a grid of wires to select a core.
This depended on a special property of cores called hysteresis:
a small current has no effect on a core, but a current above a threshold would magnetize the core.
This allowed a grid of X and Y lines to select one core from the grid.
By energizing one X line and one Y line each with half the necessary current, only the core where both lines crossed would get enough current to flip leaving the other cores unaffected.
Closeup of an IBM 360 Model 50 core plane. The LVDC and Model 50 used the same type of cores, known as 19-32 because their
inner diameter was 19 mils and their outer diameter was 32 mils (0.8 mm).
While this photo shows three wires through each core, the LVDC used four wires.
The photo below shows one core plane from the LVDC's memory.8
This plane has 128 X wires running vertically and 64 Y wires running horizontally, with a core at each intersection.
For reading, a single sense wire runs through all the cores parallel to the Y wires.
For writing, a single inhibit wire (explained below) runs through all the cores parallel to the X wires.
The sense wires cross over in the middle of the plane; this reduces induced noise because noise from one half of the plane cancels out noise from the other half.
The plane above had 8192 locations, each storing a single bit.
To store a word of memory, multiple core planes were stacked together, one plane for each bit in the word.
The X and Y select lines were wired to zig-zag through all the core planes, in order to select a bit of the word from each plane.
Each plane had a separate sense line for reading, and a separate inhibit line for writing.
The LVDC memory used a stack of 14 core planes (below), storing a 13-bit "syllable" along with a parity bit.10
The LVDC core stack consists of 14 core planes. This stack is at the US Space & Rocket Center. Photo from
NCAR EOL. I retouched the photo to reduce distortion from the plastic case.
Writing to core memory required additional wires called the inhibit lines.
Each plane had one inhibit line threaded through all the cores in the plane.
In the write process, a current passed through the X and Y lines, flipping the selected cores (one per plane) to the 1 state, storing all 1's in the word.
To write a 0 in a bit position, the plane's inhibit line was energized with half current, opposite to the X line.
The currents canceled out, so the core in that plane would not flip to 1 but would remain 0.
Thus, the inhibit line inhibited the core from flipping to 1. By activating the appropriate inhibit lines, any desired word could be written
to the memory.
To summarize, a core memory plane had four wires through each core: X and Y drive lines, a sense line, and an inhibit line.
These planes were stacked to form an array, one plane for each bit in the word. By energizing an X line and a Y line, one core in each plane was selected. The sense line was used to read the contents of the bit, while the inhibit line was used to write a 0 (by inhibiting the writing of a 1).9
The LVDC core memory module
In this section, I'll explain how the LVDC core memory module was physically constructed.
At its center, the core memory module contains the stack of 14 core planes shown earlier.
This is surrounded by multiple boards with
the circuitry to drive the X and Y select lines and the inhibit lines, read the bits from the
sense lines, detect errors, and generate necessary clock signals.11
Memory Y driver panel
A word in core memory is selected by driving the appropriate X and Y lines through the core stack.
I'll start by describing the Y driver circuitry and how it generates a signal through one of the 64 Y lines.
Instead of having 64 separate driver circuits, the module reduces the amount of circuitry by using 8 "high" drivers and 8 "low" drivers.
These are wired up in a "matrix" configuration so each combination of a high driver and a low driver selects a different line.
Thus, the 8 high drivers and 8 low drivers select one of the 64 (8×8) Y lines.
The footnote12 has more information on the matrix technique.
The Y driver board (front) drives the Y select lines in the core stack.
The closeup view below shows some of the ULD modules (white) and transistor pairs (golden) that drive the Y select lines.
The "EI" module is the heart of the driver;
it supplies a constant voltage pulse (E) or sinks a constant current pulse (I) through a select line.14
A select line is driven by activating an EI module in voltage mode at one end of the line and an EI module in current mode at the other end.
The result is a pulse with the correct voltage and current to flip the core.
It takes a hefty pulse to flip a core;
the voltage pulse is fixed at 17 volts, while the current is adjusted from 180 mA to 260 mA depending on the temperature.13
Closeup of the Y driver board showing six ULD modules and six transistor pairs. Each ULD module is labeled with an IBM part number, the module type (e.g. "EI"), and an unknown code.
The board also has error-detector (ED) modules that detect if more than one Y select line is driven at the same time.
Implementing this with digital logic would require a complicated set of gates to detect if two or more of the 8 inputs are high.
Instead, the ED module uses a simple semi-analog design:
it sums the input voltages using a resistor network. If the resulting voltage is above a threshold, the output is triggered.
A diode matrix
is underneath the driver board, containing 256 diodes and 64 resistors. This matrix converts the 8 high and 8 low pairs of signals from the driver board into connections to the 64
Y lines that pass through the core stack.
Flex cables on the top and bottom of the board connect the board to the diode matrix.
Two flex cables on the left (not visible in the photo) and two flex cables on the right (one visible) connect the diode matrix to the
core stack.15
The flex cable visible on the left connects the Y board to the rest of the computer via the I/O board (described later)
while a small flex cable on the lower right connects to the clock board.
Memory X driver panel
The circuitry to drive the X lines is similar to the Y circuitry, except there are 128 X lines compared to 64 Y lines.
Because there are twice as many X lines, the module has a second X driver board underneath the one visible below.
Although the X and Y boards have the same components, the wiring is different.
This board and the similar one underneath drive the X select lines in the core stack.
The closeup below shows that the board has suffered some component damage.
One of the transistors has been dislodged, a ULD module has been broken in half, and the other ULD module is cracked.
The wiring is visible inside the broken module as well as one of the tiny silicon dies (on the right).
This photo also shows vertical and horizontal circuit board traces on several of the board's 12 layers.
A closeup of the X driver board showing some damaged circuitry.
Underneath the X driver boards is the X diode matrix, containing 288 diodes and 128 resistors.
The X diode matrix uses a different topology than the Y diode board to avoid doubling the number of components.16
Like the Y diode board, this board contains components mounted vertically between two printed circuit boards.
This technique is called
"cordwood" and allows the components to be packed together closely.
Closeup of X diode matrix showing diodes mounted vertically using cordwood construction between two printed circuit boards. The two X driver boards are above the diode board, separated from it by foam. Note how the circuit boards are packed very closely together.
Memory sense amplifiers
The photo below shows the sense amplifier board on top of the module.17
It has 7 channels to read 7 bits from the memory stack; an identical board below processes another 7 bits, for 14 bits in total.
The job of the sense amplifier is to detect the small signal (20 millivolts) generated by a flipping core, and turn it into a 1-bit output.
Each channel consists of a differential amplifier and buffer, followed by a differential transformer and an
output latch.
At the left, the 28-conductor flex cable connects to the memory stack, feeding the two ends of each sense wire into the amplifier circuitry, starting with an MSA-1 (Memory Sense Amplifier) module.
The discrete components are resistors (brown cylinders), capacitors (red), transformers (black), and transistors (golden).
The data bits exit the sense amplifier boards through the flex cable on the right.
The sense amplifier board on top of the memory module. This board amplifies the signals from the sense wires to produce the output bits.
Memory inhibit drivers
The inhibit board is on the underside of the core module and holds
the inhibit drivers that are used for writing to memory.
There are 14 inhibit lines, one for each plane in the core stack.
To write a 0 bit, the corresponding inhibit driver is activated and the current through
the inhibit line prevents the core from flipping to a 1.
Each line is driven by an ID-1 and ID-2 (Inhibit Driver) module and a pair of transistors. The high-precision 20.8Ω resistors at the top and
bottom of the board regulate the inhibit current.
The 14-wire flex cable on the right connects the drivers to the 14 inhibit wires in the core stack.
The inhibit board on the bottom of the memory module. This board generates the 14 inhibit signals used during writing.
Memory clock driver
The clock driver is a pair of boards that generate the timing signals for the memory module. Once the computer starts a memory operation, the various timing signals used by the memory module are generated asynchronously by the module's clock driver.
The clock driver boards are on the bottom of the module, between the core stack and the inhibit board so it is hard to see the boards.
The clock driver boards are below the core memory stack but above the inhibit board.
The photo above looks between the clock driver boards; the inhibit board is on the bottom.
The blue components are multi-turn potentiometers, presumably to adjust timings or voltages. Resistors and capacitors are also visible on
the boards.
The schematic shows several MCD (Memory Clock Driver) modules, but I can't see any modules on the boards.
I don't know if that is due to the limited
visibility, a change in the circuitry, or another board with these modules.
Memory input-output panel
The final board of the memory module is the input-output panel (below), which distributes signals between the boards of the memory
module and the remainder of the LVDC computer.
At the bottom, the green 98-pin connector plugs into the LVDC's memory chassis, providing signals and power from the computer.
(Much of the connector's plastic is broken, exposing the pins.)
The distribution board is linked to this connector by two 49-pin flex cables at the bottom (only the front cable is visible).
Other flex cables distribute signals to the X-driver board (left), the Y-driver board (right), the sense amplifier board (top), and inhibit board (underneath).
The 20 capacitors on the board filter the power supplied to the memory module.
The input-output board is the interface between the memory module and the rest of the computer. The green connector at the bottom plugs into the computer, and these signals are routed through flat cables to other parts of the memory module. This board also has filter capacitors.
Conclusion
The LVDC's core memory module provided compact, reliable storage for the computer.
The lower half of the computer (below) was filled by up to 8 core memory modules.
This allowed the computer to hold a total of 32 kilowords of 26-bit words, or 16 kilowords in redundant high-reliability "duplex" mode.18
The LVDC held up to eight core memory modules. Photo at US Space & Rocket Center, courtesy of
Mark Wells.
The core memory module provides an interesting view of a time when 8K of storage required a 5-pound module.
While this core memory was technologically advanced for its time,
the hybrid ULD modules were rapidly obsoleted by integrated circuits.
Core memory as a whole died out in the 1970s with the
advent of semiconductor DRAMs.
The contents of core memory are retained when the power is disconnected, so it's likely that the module still holds the software from
when the computer was last used, even decades later.
It would be interesting to try to recover this data, but the
damaged circuitry poses a problem so the contents will probably remain locked inside the memory module for decades more.
I announce my latest blog posts on Twitter, so follow me @kenshirriff for future articles. I also have an RSS feed.
For an explanation of core memory, see CuriousMarc's video where we wire up a core plane and demonstrate how it works.
I've written before about core memory in the IBM 1401, core memory in the Apollo Guidance Computer,
and core memory in the IBM S/360.
Thanks to Steve Jurvetson for supplying the core array.
Notes and references
Front view of the igniter. The black text is hard to read under the brown front.
Oscilloscope trace pickingup electrical noise from the igniter over the air. Image from CuriousMarc's video.
Schematic of the spark generator.
