How does core memory work?

Magnetic core memory technology relies on the physics of electromagnetism. Core memory is made up of tiny iron or ferrite rings. These rings are actually called cores although I'm going to refer to them as rings because I find that things get too confusing otherwise.

Consider one such ferrite ring. If we run a wire through this ring and send a strong enough DC electrical current through the wire then the ring will become magnetized in a circular fashion. Specifically, if you were to put the ring down flat on a table and look at it from above and then run the current through the ring from above to below then the ring would become magnetized in a clockwise direction.

Important: once an iron ring has been magnetized in either a clockwise or counterclockwise direction, it will remain magnetized in the same direction indefinitely if it isn't interfered with.

If we then run a strong enough current but in the opposite direction through the ring, we can cause the ring to become magnetized in the other direction. If we run a strong enough current through the ring sometime later and in the same direction that the last "strong enough" current was sent through the ring then nothing happens because the ring is already magnetized in the direction appropriate for the direction of the current.

If a ring is currently magnetized in the "wrong" direction for the current that is about to be sent through the ring then there is a certain minimum amount of current which must be sent through the ring to make the ring's magnetic field flip directions.

How are we doing? Make sure that that's clear before continuing.

Onwards!

Let's put our single ring aside and consider the following diagram:

```          x              y              z
|              |              |
/-|-\          /-|-\          /-|-\
A/  |  \       D/  |  \       G/  |  \
p---|--+-----------|--------------|--------p
\  |  /        \  |  /        \  |  /
\---/          \---/          \---/
|              |              |
|              |              |
|              |              |
/-|-\          /-|-\          /-|-\
B/  |  \       E/  |  \       H/  |  \
q---|--+-----------|--------------|--------q
\  |  /        \  |  /        \  |  /
\---/          \---/          \---/
|              |              |
|              |              |
|              |              |
/-|-\          /-|-\          /-|-\
C/  |  \       F/  |  \       I/  |  \
r---|--+-----------|--------------|--------r
\  |  /        \  |  /        \  |  /
\---/          \---/          \---/
|              |              |
|              |              |
x              y              z
```
This diagram contains nine rings which are organized into a grid (the vaguely octagonal things in the picture are the ferrite or iron rings). The horizontal and vertical lines are wires (three vertical wires and three horizontal wires). Each horizontal wire runs through each of the rings in a row. Each vertical wire runs through each of the rings in a column.

Important: The wires in a horizontal row always enter each ring in the row from the bottom as it enters the ring from the left and out the top as it exits the ring to the right (notice how each horizontal wire is always hidden by the left side of each ring and how the right side of each ring is always hidden by the wire). Similarily, as the vertical wire in a row travels upwards (i.e. towards the top of your screen), it enters each ring from the bottom and exits out the top.

Each of these rings represents a single bit of memory or storage and every ring is currently magnetized in either a clockwise or a counterclockwise direction (we don't know which direction but we know it is one or the other). Let's assume that a ring which is magnetized in a clockwise direction is considered to be set to 0 and a ring which is magnetized in a counterclockwise direction is considered to be set to 1.

Now, if we wanted to set ring E to 0 (i.e. magnetize it in a clockwise direction) then we could send half of the required current down along wire y and the other half of the required current from right to left along wire q. Rings B, D, F and H would each get half the current required to flip them. Since this isn't enough current, none of these rings will flip. But, ring E gets a full dose of current because it gets half a dose from each wire. Consequently, ring E will flip if the magnetism of ring E isn't currently clockwise.

Ok. Now we've got ring E set to 0 (i.e. magnetized in a clockwise direction).

Let's now let's find out which direction ring C is magnetized in. If it is magnetized in a clockwise direction then it is currently 0, otherwise it is magnetized in a counterclockwise direction and is currently 1. In order to determine how a ring is currently magnetized, we need to run a third wire through every ring in the grid (i.e. one wire which travels through all nine rings). This new wire, which we'll call the sense wire, is always run through each ring in the same direction (i.e. top to bottom or bottom to top).

Now, we magnetize ring C in a clockwise direction (i.e. set ring C to 0) by running a current down on wire x and right to left on wire r. If ring C was previously set to 1 (i.e. magnetized in a counterclockwise direction) then the flip in magnetic field will induce a small but detectable pulse of electricity on our sense wire. If ring C was already set to 0 (i.e. magnetized in the same clockwise direction that we are setting it to) then there is no flip in the magnetic field on ring C and there is no pulse of electricity on our sense wire.

Well, we've managed to figure out what was in ring C but we had to force ring C to be 0 in order to do it (this method of having to destroy what was in ring C in order to find out what ring C was set to was called "destructive reading"). That's not an insurmountable problem because we can restore ring C's old value by using the information we just got off the sense wire to send a pulse through wires x and r again. The direction we send the pulse on each wire is determined by whether we want to set ring C back to 1 or leave it at 0 (it is simplest to always set ring C to the correct value even if it happens to already be the correct value).

So . . . where are we? We've got a way to set any one of the nine rings to either 0 or 1 and we've got a way to determine whether any one of the nine rings is currently 0 or 1. The method for setting a ring is reasonably clean but the method for reading a ring is a bit ugly. That's ok - that which works is better than that which doesn't! The bottom line is that we've got a way to implement a memory device (i.e. a device that remembers values) and that's what we set out to do.

Of course, we're not quite done yet because we're going to need more than nine bits of memory. We can increase the number of bits by simply making the grid larger. For example, if we make the grid 32 by 32 cores then there will be 1024 bits in a single grid. Now, if we construct eight grids then we can have 1024 bytes of memory. In order to be able to read or write all of the bits for a specific byte at the same time, we spread the bits in each byte across all eight grids.

Oops! Sorry!! One of the dinosaurs at the back of the room is starting to make rude noises. We'd better clean up our terms:

• what we've been calling a grid of cores was actually called a core plane, a plane of cores or a bit plane.
• the amount of time that it takes to write a value into a ring (you have to leave the current on long enough for the magnetic field to flip) is called the cycle time of the memory.
The dinosaur looks happier now so let's continue (it is never wise to upset a dinosaur and it is downright foolish to allow one to remain upset).

We've now explained how core memory works. Now let's look at some other issues:

• the amount of current that it takes to flip the magnetic field in one of these core rings depends on how much iron or ferrite is in the ring. If the ring is large and thick then it takes much more current than if the ring is small and dainty.
• the power that we're using gets turned into heat as it passes through the core subsystem.
Unless we want to spend a fortune on cooling and electricity, we better make the rings as small as possible.

In the early days of core memory, the core planes were assembled by hand (the lower labour costs in Mexico and other less developed countries were exploited to keep costs down). The process of stringing the wires through the cores was call knitting. As technology improved, the size of the core rings became smaller and smaller. It eventually became impossible for a human to knit core rings together. Consequently, workers in Mexico and other less developed countries lost their jobs and automatic core memory knitting machines were developed (does any of this sound familiar?).

I have some core memory from the early days in which each ring is about one millimeter in diameter. This core memory was made by hand and there are 1024 bits per plane. I've also got some core memory that dates from the later days of core memory in which the individual rings are so small that I need a magnifying glass to make out the individual rings (this core memory has 65,536 bits per plane and was almost certainly machine knitted).

Ready for a strange thought . . . the sets of core memory that I have probably (possibly?) (certainly?) still have the data that was last written to them just before the machines that they came out of were powered down!

As the 1960s were coming to an end, the technology for automatically making core memory was really becoming quite impressive. Unfortunately for the manufacturers of core memory, there was a new technology starting to appear - solid state memory. Although it took a while, eventually all computer memory was made out of solid state devices and the days of core memory were over.

Well . . . not quite! I've heard that there are still devices made today which use core memory because core memory has one major advantage over most if not all of the other memory technologies - once you set a core to a particular value, the value remains unchanged without you having to expend any energy (i.e. power) to preserve the value. Again, I'm not certain but I've heard that such devices are still manufactured and sold today for certain very specialized applications.

Trivia point: IBM announced the System/370 product line in 1970. One of the machines that they announced was the Model 145 which was their first computer to use solid state memory. The also announced a faster Model 155 on the same day. This faster model used core memory!

Note: I don't know whether or not the 145's solid state memory was slower than the 155's core memory as the 155 also had a cache and other enhancements which improved its performance.

The inventor of core memory

The next two paragraphs are derived (with heavy quoting as indicated by the use of quotation marks) from an article on the Forbes.com web site titled 85 Innovations (see reference below). I don't currently have any more information on the invention of core memory than this although I intend to try to dig more out (i.e. drop back in a month or three for more info).

Core memory was invented in 1949 by An Wang (1920-1990). According to the Forbes article that this paragraph is derived from, he also invented the "pulse transfer controlling device" which was "the first method of storing information on a computer without large magnetic drums". An Wang sold his patent to IBM for \$400,000 in order to be able to concentrate on another of his endeavours - Wang Laboratories. Some may remember Wang as the company that made a bundle selling early word processors. The company crashed and burned after An Wang's death.

The Forbes article goes on to say that Jay W. Forrester modified Wang's invention and the result "became the basis for all high-speed computer memory, lasting until microchips displaced it".

Some photos of my older set of core memory are available at

http://www.bouletfermat.com/danny/core.html

Sources:

• Computer Architecture by Caxton C. Foster; Copyright © 1970 Litton Educational Publishing, Inc.; ISBN 0-442-15639-1.
• Article titled 85 Innovations and dated 2002/12/23 on Forbes.com web site at http://forbes.com/2002/11/01/85.html (last accessed 2002/12/20)
• personal recollections (not personal experience - the recollections are of things that I've heard while fraternizing with friendly dinosaurs).

Magnetic core memory, also known as core memory, is a non-volatile RAM implementation that catalyzed the development of the information age.

Principle:
Magnetic core memory is formed by an array of ferrite toroids with wires passing through it. Generally, there are three wires that pass through each core, X, Y, and Sense/Inhibit. In earlier systems, Sense and Inhibit often resided on different wires; however, as cores became smaller, three wire core memory became a necessity.

Each toroid holds a certain magnetic state. In order to change that state, a magnetic field over a certain threshold is required. The current threshold is determined by the hysteresis of the magnetic material used to construct the cores.

Memory locations are selected by sending half of required current through both the X and Y wires. Only the grid location desired has the full current required to change the memory location.

There are two distinct cycles: a read and a write cycle. Both cycles are required for every memory operation.

A read cycle changes all bits read to 0. However, for every bit flipped from 1 to 0, a pulse will be registered on the Sense wire.

A write cycle can either replaces the data destroyed in the write cycle or put new data in its place. To write a 0, the Inhibit line is supplied with sufficient current to counter the effect of the X and Y wires. Consequently, the location stays in the 0 state. To write a 1, the Inhibit line is not used and the current from the location selection will flip the bit to 1.

History:
The concept was first conceived by An Wang, a Shanghai-born physicist, in 1948 at Harvard Computation Laboratory. Wang soon sold his patent (U.S. Patent #2,708,722 - "Pulse Transfer Controlling Device", 1955) to IBM for \$400,000. Further development of the idea came from MIT's Jay Forrester, head of the Whirlwind project. After, Forrester added his own finishing touches, it became the industry standard for fast RAM. MIT licensed Forrester's modifications to IBM who implemented it in its mainframe systems.

Applications:
Core memory was the RAM system of its time, implemented in all IBM's computers until the arrival of semiconductor in the 1970s. Semiconductor memory in its infancy was not as reliable as magnetic core technology; consequently, core memory dominated mission-critical applications for many years after the introduction of semiconductor RAM.

Cost:
In the 1950's a plane of 8192 bits (1 kB) cost approximately \$6,000, or about \$6 million per megabyte.

Speed:
Early core memory systems had a cycle time of around 6 µs (700 KHz). Eventually, the cycle time dropped to around 600 ns (1.7 MHz). On expensive projects, interleaving was often used to speed up the cycle time. Interleaving works much like RAID 0 in that consecutive bits are stored on different planes. Some IBM mainframes yielded an effective cycle time of approximately 20 ns (50 MHz) by using 32 interleaved planes.

Problems:
Like all magnetic devices, core memory is very susceptible to electromagnetic noise. Not surprisingly, the main mode of failure is interference, both external and internal. External interference is the easier of the two to treat; proper shielding of the storage device usually alleviated outside interference. By nature of the design, patterns of memory access can cause misreads. Reliability relied on a magical combination of memory timing, sense levels, and drive currents. Some later systems had a program that tried to flush out the problem with a brute force Worst Case Noise test.

At high access speeds, heat was also a problem. As wires heat up, their resistances change and consequently, the drive currents would fluctuate. Fluctuations in the drive current often then led to internal interference. Core Heating tests and thermistors were used to deal with the problem.

Construction:
All core memory were strung by hand using stereo microscopes. Thin needles were used to string the enamel-coated wires through the magnetic cores.