5

Back in the 50s and 60s people had:

  • random access, read-write memories like Magnetic Cores.
  • sequential access, read-write memories like Delay Lines and Magnetic Tapes.

And:

  • sequential access, write once, read-only memories like Punch Card and Perforated Tape, which are not called ROM traditionally.

So what about random access, read-only memories which are called ROM now? Which kind of random access, read-only memories, say Core Rope Memory, Mask ROM, PROM, TROS, CROS..., was cheapest per kbit before Year 1970? And which kind has the simplest decoding/addressing mechanism?

PS:

  • Historical price of ROM talks about solid state ROM, which is totally different a question.

  • By saying random/sequential, there lies Direct-access storage device (DASD, like Magnetic Drums and Data Cells) in between, which has fixed address and variable access time, while this question talks about ROMs without delay of seeking.

2
  • Comments are not for extended discussion; this conversation has been moved to chat.
    – Chenmunka
    Feb 19 at 9:13
  • "... memories like Punch Card and Perforated Tape" -- You're (incorrectly) conflating (computer) memory with (nonvolatile) storage media and peripherals. A CPU instruction that accesses memory can complete in one cycle (probably with wait states). The various peripherals and media (that you incorrectly call "memory") require device drivers using I/O operations. There simply is no equivalence.
    – sawdust
    Feb 22 at 7:22
7

The question seams to imply that there was a need for a ROM in the same sense as it was used in the 1970s and 80s, but why wasting address space and money on storage that could only be used for one purpose?

Machines, way passed the mentioned cut of date of 1970, used magnetic media (drums) and magnetic core for RAM. Both are persistent storage, this means information stored there will be present even after a power cycle. All a CPU needed to do is starting to operate from that memory. Data processing and scientific computing relied on having RAM for changing tasks, while process automation as well was happy with loading core once a while and after that simply used it ROM like - some machines had even ways to switch of writing of (new) data, essentially turning core into ROM.

Long story short: Prior to the 1970s there was no need for ROMs in the sense we know today.

Applications of ROM like storage was, if at all, needed in micro program storage, but solutions here were rather specific to each CPU manufacturer and machine, like CCROS, TROS and similar (*1,*2). Also, noone really wanted ROMS. In fact, this is the very reason why IBM developed the floppy drive: to load the microcode from a persistent media to micro code storage. That way they could use RAM,but kept the content static - and change it when needed.

All ROM like solutions of the time were special to type and hand made.

ROMs as we know now grew out of decoders. Fixed function devices translating information - like turning a key press into ASCII. A job that for early terminals was done literally with piles of diodes (*3). But even this use did only come up after 1970. As only then the need for high volume production, i.e. more than a few dozend, became a thing.

was cheapest per kbit before Year 1970?

Since there were no common, interchangeable solution before 1970, but only partitial solutions specific to each device, comparable prices can not be given.


*1 - I remember a TROSS like system using modified punch cards instead of special mylar sheets. While not as dense, they had the advantage that ROM content could created by using a standard key punch. Thus patching a ROM was simply DUPing the card until the change, enter the new value and DUPing again until the card was done. ROM changes within minutes, needing only equipment available in any computing center - beside the special cards that is. Even more, a new ROM stack could be delivered as tape and outputted by using a standard card punch.

Depending on one's POV, this may qualify as 'cheapest', still, it's a low volume hand made thing.

*2 - Core Rope Memory was as well a very specific niche solution

*3 - I remember that in 1977 I got hold of two scrapped terminal keyboards, which served as my main source for diodes for several years, as every key was connected to a row of 0..7 diodes to encode its ASCII value.

7
  • Core memory, sure, but I'm curious -- which machine was still using drum memory after 1970? Feb 18 at 21:20
  • 1
    @MichaelGraf You mean beside the fact that the question is about before 1970? Quite some. Beside that drums were still a thing for the big guys, even new machines like the PDP-11, introduced in 1970, were delivered with drums. Most notably an 11/45 in 1974 to UC Berkeley with core memory and a drum. There's a reason that the 1977 introduced BSD Unix uses /dev/drum for swap. Disks were simply slower. A typical 70s drum had a average access time of 8 µs - about 8-10 times faster than any disk drive. Drums were a thing for process controll and fast data recording all the way intothe 1980s.
    – Raffzahn
    Feb 18 at 22:42
  • Thanks! I asked because you wrote in your answer that drums were used for RAM well past 1970. Feb 18 at 23:17
  • @MichaelGraf We're deep in the swamp of arbitrary definitions, aren't we? :)) I often come back to a point were I see that IBM's early concept of all storage being simply different levels of the same separated not by usage but access time.
    – Raffzahn
    Feb 18 at 23:43
  • Can you recall the name of the TROS-like system? That sounds very attractive.
    – Schezuk
    Feb 19 at 4:08
6

Here are two "random access, read-only memory" solutions as an example on how those were used on early computers. Both map into the address space of the CPU, and are intended to use for bootstrap programs, that load the core memory with the actual program (that one would today have in ROM).

That worked because core memory retains its contents even after power loss, so you can basically use it as a sort of ROM. It only needs to be loaded once, or re-loaded in case it gets overwritten, or has a bit-flip or similar.

The CDC series (and the Cray, too, I think) had a deadstart panel. Here is a picture of the deadstart panel of a CDC 6600, and this link has a pictore of a more fancy one, with a description. It was essentially a set of 12 x 12 switches (so, 144 bits), and would contain the bootstrap program for a peripheral processor (PP), which then would first initialize itself from some other kind of storage, and then the main CPU.

The PDP-8/E had a MI8-E Bootstrap Loader card. I haven't been able to find a full picture, but this link has some close-ups. It's essentially 32 words of 12 bits (344 bits in total) hard-coded with diodes, with different variants for different bootstrap programs for different devices. You could set the start and load address with wires on the cards.

I have not found any prices for those, but from the low number of bits, you can see that it was not economical to attempt any kind of "ROM". The PDP-8 price list from 1967 lists 4 kWords (with 12 bits) of core memory at around $8000 dollars. While it was technically possible to make core rope memory at the same density, I'd would have expected it to be much more expensive, as it was no longer regular, and each bit would have to be painstakingly programmed and checked manually.

18
  • That CDC deadstart panel is really cool. Feb 19 at 4:34
  • Out of interest, a planned project of mine is to design & build a useful 8-bit system without using an existing, working computer -- this means I can't use EPROMs/Flash/any other programmable ROM solution as I will have nothing to program it with. My current plan is to use something similar to the MI8-E, but designed with standard logic ICs: 2x 74LS138s to decode 16 addresses, diodes to pull down an internal data bus from the outputs, and a 74LS244 to drive that onto the CPU data bus if the full address decode is correct. I believe this design would have been viable & fairly cheap in 1970.
    – occipita
    Feb 19 at 7:53
  • 1
    @occipita: this sounds like you should ask a separate question for that, but the standard approach is to include a front panel with switches and a bit of logic so you can directly enter values into the RAM. That's e.g. how it worked on the PDP-8, and many other minis, early micros (Altair), and even early mainframes. No diodes to simulate ROM needed, just operator time to enter the initial program.
    – dirkt
    Feb 19 at 8:26
  • 1
    @occipita: You may want to look into the load mode of the RCA 1802 processor. It is an elegant way to implement front-panel loading of memory. Also described here.
    – DrSheldon
    Feb 19 at 14:21
  • 1
    @occipita I really think now this deserves its own question, but the beauty of a front panel really is that it's very cheap, easy to use, it's not difficult to make corrections, and it does double as a debugging help - all of which is much more difficult with a hex keyboard, and processor support. If you've never used a front panel, do give it a try.
    – dirkt
    Feb 19 at 16:59
2

EDSAC (operational in 1949) had read-only memory to hold its Initial Orders. The Initial Orders were wired on to uniselectors, and when running, allowed the easy (!) loading of other programs from paper tape. That is, they provided the services of a boot ROM, with some aspects of an assembler built it.

Since this was post-war Britain, the uniselectors were almost certainly surplus equipment, and therefore cheap.

The capacity was around 50 words; see this link for a listing of "Initial Orders 2". There's a picture of the uniselectors on a modern reconstruction of EDSAC here.

2
  • This sounds like it what I was looking for when I asked retrocomputing.stackexchange.com/questions/1625/… and it might be good to add the information there as well.
    – supercat
    Feb 20 at 18:32
  • @supercat - before I joined! but you're right it would have answered your question. I'll add something. Somewhere I ran across a description of how the program was actually encoded on the uniselectors; it would be nice if I could find it again! Feb 20 at 20:17
1

The Apollo Guidance Computer used Core Rope memory. The read-only instructions were woven into the rope (in one story, by canonical little-old-ladies)

Before that, computers used diode matrix memory, and switched relay selection of plugboard settings, both of which were fixed access time read-only data stores.

1

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.