7 ms·
Intel has had some bad luck trying to move past x86. ia432, i860, i960 (which found niche markets), and ia64. The revisions to the sales forecasts from market
by rrmm 10y ago
Intel has had some bad luck trying to move past x86. ia432, i860, i960 (which found niche markets), and ia64.
The revisions to the sales forecasts from market research companies were ugly https://en.wikipedia.org/wiki/File:Itanium_Sales_Forecasts_edit.png https://en.wikipedia.org/wiki/File:Itanium_Sales_Forecasts_e...
And it killed MIPS and ALPHA architectures on the server, but I guess ended up pushing everyone towards x86 while ia64 was delayed until AMD jumped in an released x86-64.
- krylon 10y agoGiven the ambitious plans of making ia64 THE architecture for high-end servers, that was an EPIC failure (painful pun fully intentional...). About the only (major) vendor that uses Itanics is HP, and when Intel decides they no longer want to build them, HP is in trouble, unless they manage to get The Machine ready first, which I am not overly optimistic about (but happy to be proven wrong).
- ghaff 10y agoHPE has already largely switched its Itanium-based product lines to x86.
- krylon 10y agoThanks for the info, I did not know that.
- microtherion 10y agoWhile the Itanium as such was a big failure, it may have been a strategic triumph overall, as several RISC vendors scaled back or stopped their own efforts in anticipation of switching to Itanium. Once Intel decided to switch to x86-64, it does not look like they paid a big price to catch up (thanks to cross licensing, they could easily get the IP, and they still had their manufacturing strengths), so it's not clear to me that Intel faced ANY disadvantages in the long run (as opposed to their partners).
- gaius 10y agoYep Itanic killed SGI for example. MIPS are still going tho'!
- nickpsecurity 10y agoIt's even worse than that. Intel acquired Alpha, tried to jointly license it with Samsung, and that failed too. I have no idea what the status of that IP is. They should probably try to open it up like OpenPOWER to see if anything comes of it. Meanwhile, its legacy remains in Shinwei processors that likely came from stolen I.P. and power supercomputers. ;) Far as their failures, I think the reason is that they always do something simpler and better but then add some weird stuff that screws it up. Gotta maintain backward compatibility where possible plus make compilers easy. A great example of doing it right would be i960 w/out the BiiN crap, with C compatibility, and x86 emulation a la Transmeta or Loongson. Instead, they did no x86 or C compatibility plus Ada support. Countering market demand killed it even if market was being short-sighted. Better approach is Cambridge's CHERI which provides both benefits and tooling compatible enough for FreeBSD: https://www.cl.cam.ac.uk/research/security/ctsrd/cheri/ https://www.cl.cam.ac.uk/research/security/ctsrd/cheri/ Another good example of doing it right is Hardbound which experimented on x86 ISA: https://www.cis.upenn.edu/acg/papers/asplos08_hardbound.pdf https://www.cis.upenn.edu/acg/papers/asplos08_hardbound.pdf These two both drastically improve an important area of CPU's, mainly security or reliability, while maintaining as much compatibility as possible with existing investments. The CPU's and compilers do most of the work actually. Many of the good designs also modify only a small part of CPU investment and/or compiler to reuse those too. So, my recommendation for Intel is to stop trying to get clever (Itanium, SGX) in favor of copying stuff that works, makes sense, is backward compatible, and has major reuse of x86.
- rrmm 10y agoIntel has always used the x86 to add incremental improvements which are aimed at improving bottlenecks (Pentium 4 not withstanding). The bad side is that x86 is a multilayered blob of random features cobbled together; (I'm glad AMD got to x86-64 first). But it's produced a processor that offers useful things to people along with backwards compatibility. And that seems to be what people want. I wonder if deprecating and eventually removing the ugly parts of the architecture over time would work for Intel (even if they had to bifurcate the architecture). What doesn't work for Intel (and its customers) is huge revolutionary new archs with straight-out-of-research advanced features and no compatibility.
- pjmlp 10y agoI believe if AMD hadn't released x86-64, our desktops would be running on Itaniums. It would take some time to sort of the issues, but given the Wintel stronghold on the desktop, everyone would be moving screaming into Itanium and feel happy about it later on. But AMD gave people an alternative, so Itanium died.
- newscracker 10y agoThe Wintel platform (stack) has relied on backward compatibility for long to hold on to the userbase. So moving to Itanium just wasn't in its blood or character and wouldn't have happened easily even if AMD hadn't jumped in with x64. The Itanium architecture and processor development was happening for a very, very long time (code name "Merced", IIRC) and didn't have much to show for due to incompatibility with x86.
- pjmlp 10y agoSure it would have been a slow process, but Windows was already available and Microsoft could have done just like Apple did. Intel would announce x86 EOL and legacy apps would be emulated or JiTted on Itanium. Their problem was that Intel wasn't the only company producing x86 chips.
- nickpsecurity 10y agoAlso happened for VMS and AS/400. Further, recall that Transmeta invented HW JIT for x86 to run it on power-efficient, non-x86 corr. Finally, Loongson is doing x86 emulation on top of MIPS multicore. So, there's plenty precedent that your scenario could've played out. Don't forget alternative, though, where Centaur/VIA could just receive a gigantic shift in business their way. Or AMD just keeps accelerating x86. Actually, AMD64 seems inevitable in this scenario.
- deleted 10y ago[deleted]
- CamperBob2 10y agoNo way. At the time x86-64 came out, nobody needed it enough to pay extra for it, and that's still true for a large number of users today. Switching architectures just to get to 64 bits was never going to happen. Itanium would have had to bring a lot more to the table than that, and it indisputably didn't.