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.
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.
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.