2

Like most people, I grew up in the 1980s, and bore whitness to the great 8-bit home computer revolution. From where I'm sitting, "computers" started with slow 8-bit machines just powerful enough to run non-trivial software, and slowly evolved to gradually add things like hardware-accelerated multiplication, FPUs, memory protection, virtual addressing, virtual memory, premptive multitasking, etc.

However, I'm slowly discovering that there was also a secret, hidden world of mainframes and minicomputers, some of which already had such advanced features, in some cases decades earlier. I guess I had always assumed that since mainframes came before microcomputers, the mainframes must have been even more primitive than the early 8-bit home computers — but it seems I was wrong!

Indeed, it seems some of the earliest computers around already had really quite wide data paths (which is odd, considering some poor soul had to manually wire them all by hand, one at a time). I always thought it was only when VLSI made it possible to put thousands and thousands of components into a tiny space that people started making really wide busses.

Now obviously, I imagine one could easily fill entire books about the history of advanced computing hardware. (For all I know, those books might even have already been written!) But can anyone summarise approximately when the following became generally available:

  • Hardware interrupts. (Presumably the earliest machines didn't have these.)
  • A hardware call stack. (Ubiquitous today, but I gather that's comparatively recent.)
  • One-instruction integer multiplication.
  • Hardware-accelerating floating-point arithmetic.
  • Virtual addressing (i.e., a programmable mapping from program addresses to physical memory).
  • Virtual memory (i.e., using secondary storage to transparently simulate primary storage).
  • Memory protection.
  • Processor privilege levels (i.e., the OS can prevent user programs from doing things at the hardware level).
  • Premptive multitasking. (OK, this one is more of an OS feature... but it still requires hardware resources to implement.)
  • Garbage collection. (I'm guessing this came in with Lisp, but I still don't know when that was...)

Note that I'm not asking which one, specific machine did any of these "first". I'm asking when they became features that were at least moderately widely implemented (i.e., not obscure).

closed as too broad by Ross Ridge, Felix Palmen, Wilson, Dr Sheldon, wizzwizz4 Feb 1 at 10:13

Please edit the question to limit it to a specific problem with enough detail to identify an adequate answer. Avoid asking multiple distinct questions at once. See the How to Ask page for help clarifying this question. If this question can be reworded to fit the rules in the help center, please edit the question.

  • 2
    Lets be serious, this Question Is way to broad, as it basically asks about everything in Computing. Hard to get any broader. Last but not least, it mixes up hardware and software as well as real invention with assumptions based on today's canon. – Raffzahn Jan 31 at 22:35
  • 2
    "Like most people, I grew up in the 1980s" <- this is an interesting statement ;) -- "I'm asking when they became features that were at least moderately widely implemented (i.e., not obscure)." <- this makes the question IMHO too vague and broad -- although your single points are probably quite interesting! – Felix Palmen Jan 31 at 22:38
  • 2
    I suspect (but OP can tell us!) that "grew up in the 1980s" is a reference to perceived "typical Retrocomputing members", but I have seen quite a few people on this site that are much older and in my own world, my son (12 years old) is lately been doing plenty of reading about the 6502. – manassehkatz Jan 31 at 22:49
  • 2
    @manassehkatz +1 just for having a son really interested in how things work :) – Felix Palmen Jan 31 at 22:53
  • 3
    Garbage collection is not usually thought of as a hardware feature even today. – Erik Eidt Jan 31 at 23:19
7

None of these answers are guaranteed to be the first computer with the feature mentioned, but they're the first I'm aware of.

Hardware interrupts. (Presumably the earliest machines didn't have these.)

None of the machines of the 1940s had them. They were available on later models of the IBM 709 for IO channel events in the late 50s.

The PDP-1 minicomputer from 1960 had interrupts. (I had described this as an option, but it seems all of them came with it.)

There is a fascinating article here about the history of interrupts. It cites the NBS DYSEAC of 1954 as the first machine with IO interrupts.

Essentially all computers had them by the late 1960s. They even managed to cram interrupts into the tiny PDP-8. The original Intel 8008 processor had interrupts in a limited form, and almost all general purpose microprocessors since have had them.

A hardware call stack.

The Burroughs B5000 series introduced in 1961 was designed exclusively for high level languages. It was a stack machine with separate call and data stacks. So was the English Electric KDF-9 from 1964.

As noted in the comments, the PDP-6 of 1964 included a number of stack-oriented operations. The PDP-11 of 1970 was one of the first minicomputers with hardware stack support.

Hardware stacks were common on all new designs, including microprocessors, from about the mid-70s until the RISC era.

One-instruction integer multiplication

The IAS machine and its clones of the late 1940s had a hardware multiplier and a multiply instruction. The IBM 701 was an IAS clone and IBMs 7xx family all had hardware multiply.

These instructions generally took a good number of cycles, and multiplication was slower than addition. Even the original Pentium took its time at multiplication when compared to addition.

Hardware multiply was common on all mainframes from the beginning, most minicomputers of the late 1970s (and as an option before that), and it worked its way into microprocessors around 1978 with processors like the 68000 and 8086.

Hardware-accelerating floating-point arithmetic.

Zuse's relay machines of the 1940s used floating point arithmetic internally. The IBM 704 of 1952 was the first serially-produced machine with hardware floating point.

Most mainframes had hardware floating point, sometimes as an option early on. Some low-end models implemented it entirely in slow microcode.

It was often available on minicomputers as an option. It wasn't until the 1990s that commodity microprocessors like the 486DX or 68040 came standard with floating point.

Virtual memory & Virtual Addressing & Memory Protection & Processor Privilege Levels

All honours go to the Manchester Atlas of 1960. It used a system very similar to modern designs. There were supervisor and user modes, with virtual memory backed by paging.

CTSS on the IBM 7090 in close second place in 1961.

They became commonplace on the System/360, and a number of minicomputers implemented it from around 1970 as well. It was not common on commodity microprocessors until the Intel 386.

Preemptive multitasking

As we would understand it today, the Manchester Atlas also has a good claim for this one. But a number of systems of the 1950s were developed which had something akin to threading, and hopped between multiple tasks driven by a hardware interrupt. The massive AN/FSQ-7 is an example.

It was common on mainframe operating systems from the late 1960s, and minicomputers aimed at time-sharing would support it from about 1970 on as well. It did not become common in microcomputer operating systems until the 1990s, although technically possible to implement on even the earliest processors like the 8080 or 6800.

Garbage collection.

You're right. LISP gained this around 1960. It has shown up in various languages ever since. Given the overhead particularly with memory, it didn't become very common until the late 1980s. Even in the 1990s, the fact that Java is garbage-collected was a source of some controversy.

In terms of hardware support for garbage collection, that was probably Lisp machines.

  • To my knowledge, sequence break (interruptsl were built into every PDP-1 ever made. I don't know why you called it an option. – Walter Mitty Feb 1 at 3:35
  • The PDP-6 introduced in 1964, had 4 stack oriented instructions, PUSH, POP, PUSHJ, and POPJ. There were many earlier stack oriented computers, as the earlier answers show. – Walter Mitty Feb 1 at 3:38
3

Preface: Since this question is way to broad, I will not go into depth of the points but try to address a rather general background.

However, I'm slowly discovering that there was also a secret, hidden world of mainframes and minicomputers, some of which already had such advanced features, in some cases decades earlier.

Very true

I guess I had always assumed that since mainframes came before microcomputers, the mainframes must have been even more primitive than the early 8-bit home computers — but it seems I was wrong!

This is more due to different development timing, but equally due to different requirements.

  • Mainframes developed out of an early one (or a few) of a kind computers which, in hindsight could be rather considered prototypes - and with these prototypes many of the developments you mention were tried, so when mainframes went into wider usage (and soon matured), everything was there from the start of real widespread use.

  • Micros in contrast are more like minis before them, taking a step back from building a nice full figured computer and instead building one as minimal as possible to cut cost down and make them available to a wider range of applications - and customers. Customers that could live with many restrictions, as even the most awkward computer is way better than having no computer.

Indeed, it seems some of the earliest computers around already had really quite wide data paths (which is odd, considering some poor soul had to manually wire them all by hand, one at a time).

(It wasn't that hard, as everything was quite well documented - paired with good testing equipment backplane wiring (which I guess is the real issue here) high quality could be delivered in time and price - and even repairing and field patches were rather convenient)

I always thought it was only when VLSI made it possible to put thousands and thousands of components into a tiny space that people started making really wide busses.

No. It's quite the other way around.

Making wide busses was the best way to speed up mainframes. Doubling bus width doubles memory access speed without the need for any faster component. Similar wide ALUs increased speed the same way. But while extending ALU width beyond to base word size (like 16 or 32 bit) will not speed up anything, doing so with memory does continue way longer.

This became even more important when integration did speed up the CPU core, while memory (at least at the amount needed for ever growing tasks) was still comparably slow core. That way memory interfaces for mainframes already reached 128 and 256 bit (16 or 32 byte) in the mid to late 1970s - this remained important even after introduction of semiconductor main memory, as the core grew even faster.

Sounds familiar, doesn't it? Microprocessors did go the same way over the last two decades. Some 30+ years after mainframes did.

Now, as said before, minis and even more so micros where all about cutting resources down to a level to allow (basic) implementation in just a few TTLs or a single IC. Get busses and ALU (and register) size down to the minimum requirement was a great way to do so.

Note that I'm not asking which one, specific machine did any of these "first". I'm asking when they became features that were at least moderately widely implemented (i.e., not obscure).

This is often the same - or, in most cases it means just pointing to the IBM /360ff :))

And yes, it is true that many features had first implementation before the /360, and these computers where sold and produced in more than one unit, the real break thru for many of the points came with IBM's /360. An instant success and guideline for any further mainframe development. One may go so far and make this the point in time where the name and structure for 'mainframe' was settled for good.

It was Gene Amdahls skills (*1) that took all these different developments - and even more all the way different expectations that grew out of various incompatible designs IBM did before - and forged it into a single architecture, one that is now built, sold and operated for more than 50 years - and still going strong when it's about data shovelling :))


The asked for timeline in total may look like this:

  • 1930s - Single Instruction Integer Multiplication
  • 1940s - Hardware Floating Point (even binary)
  • 1950s (late) - Virtual Memory
  • 1950s (late) - Privilege Levels
  • 1958 - Hardware Interrupts
  • 1960s (early) - Memory Protection
  • 1960s (early) - Preemptive Multitasking
  • 1962 - Hardware Call Stack
  • 1962 - Virtual Addressing

And all of this in one machine would be 1964 and the IBM /360.


(Ok, as usual I have a hard time to hold myself jumping onto such easy targets - so lets give it some quick words)

Hardware interrupts. (Presumably the earliest machines didn't have these.)

Only the very very first - and definitely way before anything that wasn't a one of a type. Interrupts in the modern sense became an imperative, as soon as overlapping I/O was introduced. One of the first produced machine series to do so was the IBM 709 (still a tube computer) in 1958 - which also maybe qualifies as the first CPU with a co-processor, as the I/O-Sequencer did handle the I/O requests in parallel to the CPU.

A hardware call stack. (Ubiquitous today, but I gather that's comparatively recent.)

The Burroughs B5000 in 1962 (?) might qualify as an early production example. It never really caught on with mainframes. For minis (and more so later micros) it was again a way to cut down on instruction set. A 'software' stack as linked list is in many ways superior to a hardware stack (and yes, there where mainframes like the Siemens X series offering linked list instructions for fast management of such a stack)

One-instruction integer multiplication.

Already way before series produced machines. And depending on the view point even before modern computers as well. Mechanical punch card calculators like the Dehomag D11 of 1936 could do so (The D11 could do more than one multiplication at the same time. Its predecessor BK of 1934 had multiply as well, but only one at a time and only as part of a specialized extension for utility companies called BKZ). Except with their block (card) based program structure laid out as plugboard is hard to split up in terms of 'instructions'.

Hardware-accelerating floating-point arithmetic.

This even predates integer - at least when it comes to computers, as Zuse's machines where all FP based, read the very basic data type handled in hardware was FP, no character and no integer at all.

Virtual addressing (i.e., a programmable mapping from program addresses to physical memory).

The idea has been described in the mid 1950s and first implemented at the end of the 50s in England (Atlas) and as production machine with the Burroughs B5000 of 1962 - except it might have been more of a swapping concept IIRC. Another great contender (as another-dave reminds me) would be the Ferranti-Packard 6000 as well of 1962. While that machine did not sell remarkably well, the ICT/ICL 1900, a follow-up design did have a widespread usage in GB and its former colonies. Its exceptional success even made IBM offer a micro code set for the mid range IBM /370-145 to be able to run ICL programs.

The real break thru with all workings like today might be attributed to IBM's /360 model 67 in 1965 and RCA's Spectra 70 Model 46 in 1966

Virtual memory (i.e., using secondary storage to transparently simulate primary storage).

This even predates virtual addressing in form of overlay management.

In fact, development had to advance first to make this issue arise at all. Early mainframes had drum memory as main memory, so for most parameters there was no differentiated storage concept. Later, when faster memory became available it was even the other way around, as some drum content could be held in core - until core finally took over. At that point overlay management, made possible by the introduction of relative addressing against a base register, allowed early virtual memory concepts.

Here (as well as with virtual addressing) often the CTSS, running on an IBM 709x (transistorized version of the 709), is cited as first, and in an academic sense it might be. Then again, swapping out a user (program) to tape isn't anything I do consider adequate. It took a few more years to make that work.

So then it is about a complete system, usable for every day tasks the /360 will make points.

Memory protection.

Again the IBM system /360 made the mark as first wide usage here by adding the ability to assign a memory key to each page (4 KiB) and have an active memory key that is compared to the page key with every access.

Processor privilege levels (i.e., the OS can prevent user programs from doing things at the hardware level).

Prevalent since the 1950s, and again the /360 would mark its terrain here in 1964 :))

Premptive multitasking. (OK, this one is more of an OS feature... but it still requires hardware resources to implement.)

Not much. As soon as there is some way to interrupt, how infrequent ever, preemptive multitasking can be made. In fact, today we subsume several features under preemptive that are not necessarily a must.

For example, early schedulers where based on fixed priorities. For example with a rather simple scheduler model the /360 could offer a feature to handle up to 15 'program counters'. Well, not real ones, the mechanics where tied to the same way memory protection was done, but virtual ones. They had a strict priority from 15 to 1. Whenever one did go into a waiting state - usually by issuing an I/O operation, the next lower, non waiting PC was given control. Either until this program did run into an I/O situation, or completion of an I/O operation of a higher PC was messaged (by a completion interrupt) and that PC was resumed.

The whole idea wasn't so much about offering equal computing power to a multitude of users (or programs) but to use the time a machine otherwise would wait for slow I/O like reading the next card, tape or disk block. So the goal wasn't to supply many virtual machines, but keeping utilisation of the expensive tool as close to 100% as possible.

This is BTW a great example, that history isn't always as simply comparable as one may assume. Motivation and target set may have been totally different from today - even when it led to development of very similar mechanics.

In general, while preemptive multitasking was possible on mainframes already since the early 1960s, it only gained traction very late in the 1970s. That's about the time when the requirements slowly moved to allow more and more programs handled in parallel at the same time with real time response - and the CPUs also gained enough power to do so.

Garbage collection. (I'm guessing this came in with Lisp, but I still don't know when that was...)

And not really a computer feature at all (if we exclude way exotic CPUs like the i432 that included hooks to support garbage collection of high level languages)


*1 - See how hard I try to avoid the term genius? If I got a paragon of computing it's for sure Mr. Amdahl - on par with Woz, Bauer and Wirth.

  • Would the downvoter be so kind and explain the reasoning? – Raffzahn Jan 31 at 23:45
  • I think you're requiring too much for 'virtual addressing'. My interpretation is that any scheme that makes the addresses issued by program distinct from the addresses used by hardware qualifies as virtual addressing. Simple relocation registers suffice. So, the 360/67 mention belongs under the heading 'virtual memory' – another-dave Feb 1 at 0:53
  • A field for many debates. Yes, you are right, a relocation register would do the trick - except, the /360 didn't have such. So it was the 67 that introduced the capability of address translation. On the other hand, virtual memory does need neither. It just needs a background storage and teh ability to address register relative. – Raffzahn Feb 1 at 0:57
  • The /360 was a late entrant in the field of protecting programs (and programmers) from each other :-) – another-dave Feb 1 at 1:01
  • 1
    The Manchester Atlas virtual paging system had pretty much all of the features a modern processor has. i.e. paged memory, automatic address translation through a paging table and hardware memory protection, so I think it takes the prize on the whole of that area. Of course they were never sold as commercial machines. – JeremyP Feb 1 at 9:46
0

A lot of that showed up in the 1950s and 1960s.

I/O interrupt -supposedly DYSEAC, 1954. (Some prior computers had traps for various purposes).

Hardware call stack - don't know the first, but KDF9 had one in 1960. But note 'call stack' and 'activation record stack' are not the same thing, and nor is 'expression evaluation stack' (KDF9 had the latter, too).

Virtual addressing, memory protection - seems like datum-and-limit has been around forever. Ferranti-Packard FP6000 had it in 1959 The two go hand-in-hand: the datum relocates "program address X" to "physical address Y" and the limit keeps the program's accesses in its allocated memory.

Virtual memory - Atlas (1962). It had privilege levels too, not sure whether it's a first.

Preemption - well, all you need for that is a timer interrupt. CTSS in 1960 on a modified 7090, maybe?

  • Isn't the DYSEAC a one off computer, and the KDF9 more like mid 1960s? Still, the Ferranti is a good reminder, haven't thought about them. While the machine itself didn't have much success, I think the same architecture was used for a later quite successful ICL series - popular in GB and India – Raffzahn Feb 1 at 0:54
  • Yup. The FP6000 more or less turned into the ICT 1904, the middle of the range for the first wave of 1900s (which range was a response to the /360 announcement; though I think the 1900 got to the market first because the FP6000 design already existed). KDF9 was announced in 1960, first shipped in 1964. Side note: you can guess my nationality by the examples I choose. – another-dave Feb 1 at 2:26
  • Re: DYSEAC: yes. I had at first thought the question was seeking 'the first' use. My error. – another-dave Feb 1 at 2:31
  • Well, It was already obvious before :)) The sharp decline of GB in the 60s dragged even promising industries down there where quite great developments (I like the ICL 1500 - even though it's not a Brit development). A usual result when governments (and people) try to cling to a bygone time. (DYSEAC) noting to be sorry. I mentioned already that I like the question as it does not go for the usual obscure 'first' coal, did I? Anyway, even on the island it's time to get some sleep - and so will I :)) – Raffzahn Feb 1 at 2:35

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