[ghaff]

There was also Intel's whole pursuit of frequency--they demoed I think it was a 10GHz chip at IDF at one point (and Itanium was essentially an ILP-oriented design)--and resistance to multi-core. Some of it was doubtless Intel convincing themselves they could make it work. But they were also under a lot of pressure from Microsoft who didn't have confidence that they could do SMP effectively--at least that's what a certain Intel CTO told me. (Ironically, multi-core didn't end up being nearly the issue a lot of people were wringing hands over at the time thought it would be for various reasons.)

[dogma1138]

I’m not sure Itanium was a technical failure, to me it always was a business model failure as that CPU was co-developed with HP and essentially became a dedicated HP-Oracle box and by the time the ecosystem was opened up it was too late.

The heavy reliance on the compiler for ILP was an “odd-choice” but not something that was unsound in principle.

If the ecosystem was more open from the get go and more vendors were involved it had a much better chance of taking off.

And if nothing else at least it was something new.

The biggest disappointment I have with Itanium is that it and later Larabee/XeonPhi kinda pushed Intel even further into their own little x86 box when it came to processing units.

I think that failure is also why they haven’t really done anything interesting with Altera.

[ece]

They do have Xe-graphics now. It's the closed Intel has come to a competitive non-x86 part in recent memory. It feels kind of forced though, everyone else has their own CPU+GPU now including Apple/Nvidia in addition to AMD/QC, so why wouldn't Intel? They also have OneAPI.

It would be interesting to see an explicitly JIT-based approach to ILP.

[ethbr0]

From my personal memory at the time, early NUMA multicore on Windows wasn't the smoothest sailing.

[ghaff]

It wasn't. A few years earlier, I was the product manager for a line of large NUMA systems which admittedly had far larger near-far memory latency differences than it was on multicore systems. Commercial Unix systems still could have issues for write-intensive workloads but Windows was pretty much unusable for configurations that had far memory. Things were likely better by the mid-2000s but Windows was definitely still behind Unix in this regard. (Don't really know where Linux was at that point but IBM at least had done work in OSDL on various scale-up optimizations.)

[glandium]

It seems it's not great now either, seeing how the first iteration of AMD's Threadripper performed badly on Windows.

[thu2111]

In fairness it's not like Microsoft are alone in that. Single-thread performance is still incredibly important. The Mill focuses on single thread performance almost exclusively for that reason: nobody ever made the mythical auto-parallelising compilers we were all supposed to have by now, not even for Haskell. The big wins for exploiting parallelism in most ordinary software have been just scaling up lots of independent single-threaded transactional workloads via sharding, and massively concurrent runtimes like the JVM where you can move all the memory management workload onto other cores and out of the critical paths. In terms of ordinary programmers writing ordinary logic, single-threaded perf is still where it's at which is why the M1 has 4 big super-wide cores and 4 small cores rather than 32 medium cores.