6 ms·
> Intel clung to the x86 instruction set Itanium launched in 2001 (per Wikipedia); if anything, I'd say they overestimated how readily they could ditch x86. Of
by yjftsjthsd-h 6y ago
> Intel clung to the x86 instruction set
Itanium launched in 2001 (per Wikipedia); if anything, I'd say they overestimated how readily they could ditch x86. Of course, it might be that replacing x86 was a good idea and it was just that Itanium sucked (I'd accept that possibility, given the whole "needs a smarter compiler than exists" thing). But I do agree with the general feeling that Intel and MS both overestimated how solid/entrenched they were.
- himinlomax 6y agoItanium didn't fail because people wanted x86, it failed first and foremost because it sucked badly.
- corty 6y agoMaybe correct, there was even a 32bit x86 mode, it was just ridiculously slow.
- TheCondor 6y agoI believe that was software that did the emulation. I actually had a dual Merced system that I ran linux on for a while. It didn’t suck so much as it was “different.“ Intel should have known this, but you buy processors because they are faster or cheaper. These days the third rail is energy but it’s basically the same, if you pay more you want a lot more and “Different” costs. Itaniums where a whisker faster than their ia32 offerings at the time, they cost a lot more though, and they were different. Beyond that, it was like a geek designed the specs with out a market story, risc chips were coveted by x86 dorks because they had 32 registers to the x86’s 5 or 6, well ia64 had 128... If you’re just doing simple stack frame compiler work without full program optimization, how many functions need 32 registers? Let alone 128? everyone could see that you wanted to simplify things in order to put silicon where it mattered for longer term performance, mid to late 90s reordering conditionals for branch prediction was sort of hot in compiler dork and low level circles, well Merced fixed that by adding a lot of complex logic to take both branches and retire the wrong one. IBM, HP and Sun needed different reliability and serviceability features on their high end systems too, from the big enterprise metal perspective they were toy parts for PCs, but they cost more, didn’t run your existing software and weren’t 2x faster or anything like that. They didn’t take a holistic market view as they made it. Rather than work with ibm, sun and hp on those high end issues, they just went back to the lab and told them when the first parts would be out. Not really sure what goes on inside intel, they have a lot of brilliant people. I suspect that they cannibalize themselves because nothing will ever be as successful as the x86 was when they owned every aspect of the part and package and things are decided to be a failure before they ship. With ia64 nobody asked why. Xeon phi, they gpu and machine learning stuff reflects that too.
- crest 6y agoYou can make use of a lot more than 32 registers, but not with existing RISC or x86 instructions. If I remember correctly EPIC had global registers like your normal RISC, local registers like SPARC and support for batch renaming registers to implement software pipelines. Software pipelining can make use of a lot of registers and exploit the high IPC EPIC was supposed to provide. Still an ISA that avoids the pipeline prologue and epilogue could make software pipelining useful for a lot more algorithms ... in theory.
- twoodfin 6y agoDid Intel ever present a roadmap for getting IA-64 chips into commodity PC hardware? I recall at the time it was assumed to be their plan, but I wonder in retrospect if they were actually interested in disrupting their own low end products.
- chasil 6y agoThe original Merced was a performance disaster, if I remember it, and nobody wanted it. HP saw the disaster coming and designed their own McKinley Itanium, but a bit later, and HP obviously didn't want Dell to have it. The compiler support was not good outside HP-UX, if I remember correctly. And then AMD64 happened, and Microsoft told Intel that there would be no further 64-bit PC instruction sets, and the market would choose between AMD and Itanium. Cue the guillotine.
- pjmlp 6y agoHad AMD not been allowed to produce x86 clones and the history would have been quite different, eventually everyone would be dragged into Itanium no matter what.
- _ph_ 6y agox86-64 did not only kill the Itanium but also all the RISC competitors like Alpha and especially Sparc. While x86 had pretty much pushes the alternatives from the desktop, if you wanted to run a 64 bit server, you had to go with the RISC architectures. When I joined my company in 2005, all the servers were still Sun Sparc and only slowly Opterons got deployed.
- pjmlp 6y agoWhich is a pity, Solaris SPARC is currently the only server UNIX that makes proper use of hardware memory tagging, while neither AMD nor Intel managed to make a proper implementation of MPX.
- 6y ago
- chasil 6y agoARM essentially toyed with VLIW with Thumb and Thumb2. As I understand it, these were influenced by SuperH, a 32-bit RISC design that uses 16-bit instructions, so two are always executing at once. The busybox-armv7m Thumb2 binary is the smallest of all the compiled architectures. Thumb2 appears to have been much more practical.
- theresistor 6y agoThere’s nothing VLIW-like in Thumb or Thumb2. It’s just a more compact encoding.
- repiret 6y agoVLIW stands for Very Long Instruction Word, not variable length.
- RcouF1uZ4gsC 6y agoI think AMD killed Itanium. I think Intel’s plan was to leave x86 forever stuck at 32- bit and have Itanium be the natural upgrade path as computers started running into the 4 GB limitations. I think it would have been a nice transition story. However, when AMD released AMD64 it killed this strategy. You could now buy a chip that natively ran x86 32 bit at full speed, plus be able to run code that could address more than 4 GB of RAM. Once AMD64 came out, Itanium was a dead architecture.
- stuartd 6y agoIf anyone's interested, Raymond Chen did a series of posts on the idiosyncranies of the Itanium processor, starting here: [0] [0] https://devblogs.microsoft.com/oldnewthing/20150727-00/?p=90821 https://devblogs.microsoft.com/oldnewthing/20150727-00/?p=90...
- thesz 6y agoI read it and found that write to R0 (zero read register) triggered CPU fault. This means that there is some hardware that checks condition that will not happen during normal course of events - compiler won't generate such code and write to register that reads zero is harmless. That hardware stays there, occupies space (does not matter how little) and drains energy (no matter how little). This part of hardware is utterly meaningless and shows how priorities were skewed during design phase. It also shows why Itanium was such a bad chip - features were piled up instead of being cut down. RISC-V did cut down on features first (compare division overflow in RISC-V and OpenRISC) and has a process to add them. This is why RISC-V is easy to implement even in OoO variant and why it is being picked up by everyone and their dog.
- pjmlp 6y agoThat is also what I believe, had AMD not been allowed to produce x86 clones after their legal dispute, and we would eventually all be using Itanium nowadays.
- vardump 6y ago"...as computers started running into the 4 GB limitations..." You mean 64 GB limitations? 32-bit x86 could handle that much, and I'm sure it would have without AMD64.
- _ph_ 6y agoI fear, the Itanium strengthened the believe at Intel, that x86 is the one and only architecture. The downfall of the Itanium had several reasons. They went beyond RISC with EPIC, a technology which had great theoretical promises, but had not been shown to yield those results in practise. Also, the project suffered from bad management and delays. Finally AMD pushed x86 just far enough forward to be a viable alternative. In the beginning, the Itanium was an expensive, power-hungry monster, but it did perform quite well for heavy computations. It could have had a much better future, if Intel had not abandoned it - the software situation could have been much better, if for example Linux boards had been made available to all interested. The latest version only made it to a 32nm process, the transistor count being smaller than in a modern iPhone. So just redoing the same design in a cutting-edge process would make for a very interesting processor.
- corty 6y agoIntel misjudged that selling to businesses, as a processor for servers running usually Windows software, usually long-lived, special purpose, expensive, enterprise, etc. would be different from selling processors for consumer hardware like phones. There most software is mass-produced, cheap, has a short lifetime. So for the consumer, changing the architecture to something different like Arm is easier, because if fart-app #1 doesn't work, just use #2... Whereas with business purchases, the software is picked first, and the software vendor dictates the hardware, usually being very conservative and not prone to "experiments" like Itanium. Intel misjudged both sides, for phones x86 compatibility was never necessary, for business machines, it absolutely is (for the largest number of customers, there have been exceptions).