8 ms·
Linux Looks to Retire Itanium/IA64 Support
- rbanffy 4y agoSuch a shame. It could have made much more of an impact if released with better Linux support back then...
- chasil 4y agoAMD64 was a shark that ended the Itanic, as efficiently as the Itanic ended Alpha and PA RISC (if not moreso). When the Pentium 4 adopted AMD's instruction set after Microsoft's refusal to support a new Intel 64-bit ISA, the customer base evaporated.
- TEP_Kim_Il_Sung 4y agoProfessor Itanium shouldn't have messed with compound X.
- rbanffy 4y ago> after Microsoft's refusal to support a new Intel 64-bit ISA Back then, having Microsoft’s blessing could make or break an ISA. I can’t shake the feeling Itanium was being sold to the wrong crowd.
- crest 4y agoIntel managed to kill off two competing architectures with Itanium only to get taken out by AMD in turn. Karma is a bitch.
- yokoprime 4y agoMaybe, but performance was never great and it solved yesterdays problems
- blacklion 4y agoNope. It needed good compiler, not OS kernel. Itanium performance relied on very smart compilers, and they not happened in time.
- eej71 4y agoI'm not sure it was ever going to happen.
- kjs3 4y agoItanic is just the latest in a long line of architectures that include the caveat "well, yeah, that's a problem but the compiler will make up for that". While compilers have measurably improved over the last 30+ years, the magic compiler tech that makes things like Multiflow Trace, Cydrome or Itanium performant enough to make a difference in the market hasn't materialized. It isn't that the compiler didn't 'happen in time', it still hasn't happened.
- FullyFunctional 4y agoWhat really happened was that cache misses kept increasing in latency (CPUs getting faster, memory isn't) and static scheduling simply cannot scale that far. Multiflow and friends would have exactly the same problem in a modern implementation - static scheduling is fundamentally hopeless. Transmeta did slightly better as CMS (the "JIT") could take advantage of biases discovered at runtime, but still couldn't do as well as a fully dynamic scheduler.
- fweimer 4y agoThe shift to Linux happened around the same time, and few people would bother with anything else but GCC. It might have might made a difference if the Gelato Federation had arrived earlier, with more funding, and a mandate to conduct generic toolchain maintenance, in addition to Itanium-specific work. Kind of what Linaro does today. I think Gelato was way too late, and I don't recall it being particularly impactful (but it's been a long time ago, sorry).
- rbanffy 4y agoThe shift to Linux was a bit too late. By the time it happened, Itanium was lagging behind, with Intel resources relocated to match AMD’s 64-but x86 offensive. Maybe, with enough resources Intel and the FOSS community would be able to get the smart compilers an JIT optimisations that could have made EPIC a competitive architecture.
- msla 4y agohttps://en.wikipedia.org/wiki/Itanium https://en.wikipedia.org/wiki/Itanium Itanium had Linux support from day one: > The Trillian Project was an effort by an industry consortium to port the Linux kernel to the Itanium processor. The project started in May 1999 with the goal of releasing the distribution in time for the initial release of Itanium, then scheduled for early 2000.[183] By the end of 1999, the project included Caldera Systems, CERN, Cygnus Solutions, Hewlett-Packard, IBM, Intel, Red Hat, SGI, SuSE, TurboLinux and VA Linux Systems.[184] The project released the resulting code in February 2000.[183] The code then became part of the mainline Linux kernel more than a year before the release of the first Itanium processor. ... for values of "day one" which are prior to the release of the actual hardware. > The Trillian project was able to do this for two reasons: > the free and open source GCC compiler had already been enhanced to support the Itanium architecture. > a free and open source simulator had been developed to simulate an Itanium processor on an existing computer.[185] Itanium was The Future for a good while. It got plenty of resources, hardware, software, and marketing. By the late 1990s, people knew that full support in FOSS was required, so they made it happen. Itanium died because it was founded on a fundamental idea (making parallelism explicit and relying on software to extract it using static analysis) that simply didn't pan out, and when AMD brought the x86 ISA into the 64-bit world it was done.
- five82 4y agoThe tech was solid but the implementation left a lot to be desired. I still shudder when I think about the RHEL 6 Itanium DB cluster I "inherited" and had to maintain. A very temperamental serial console that would constantly freeze up. No local storage so we were forced to boot from SAN. I prayed every time we rebooted that it would actually come back up. Plenty of times it didn't.
- rbanffy 4y agoBut that’s all on the tooling side. It’s not really Itanic’s fault. Had it run a decently reliable OS, it’d be fine. It never lived up to the hype, but caches were humongous for the time and more than once they were able to hold most of my working dataset.
- kjs3 4y agoI would argue that the shame isn't what Itanium might-have-been, but the architectural roads-not-taken because Itanium absorbed all the resources and mindshare. Would have been interesting to see where Alpha, HPPA...even MIPS R10K family...would be today had the investment thrown away on Itanium been spent more wisely elsewhere.
- ajross 4y agoThey'd have been at the same place we are today. CPU architecture is a mature technology and other than horizontal integration and super-wide parallelism, all the basic ideas were already fixed by the early 90's. Those architectures were all just regurgitating each others ideas anyway, there was very little genuine innovation in late RISC. Well, with the arguable exception of Alpha. The 21264 presaged the modern core most closely, even if it was too big and expensive to be very competitive on desktops. The, er, "21364" reached market a few years later and took over the world as the Pentium Pro.
- ghaff 4y agoI generally agree although I do think there's too much mythology around Alpha. What if Intel had said to HP "That's a really dumb plan" when it brought up the idea of EPIC? I agree probably not much. Intel would presumably have accelerated what Gelsinger called a 64-bit RAS Xeon in a magazine article. Probably good for Intel and not clearly negative for HP. (Both companies went that route in the end anyway.) Less money would have been wasted in general but it's not like a company spending $100s of millions on Itanium would have told its engineers and other employees to go fiddle with some other exotic architecture. It probably just wouldn't have hired them in the first place.
- ajross 4y agoSeems almost certain that we would have ended up with something that looks exactly like x86_64 a few years earlier in that case, no? I mean, it's not like AMD invented fundamentally new concepts or anything. The doubled GPR set was likely to happen regardless. The REX mechanism might work differently (like moving to a 3-address encoding). Maybe Intel wouldn't have dropped segmentation and we had a new selector record in long mode to worry about. Maybe we wouldn't have the sign bit rule in addresses. None of those are design-breakers. Again, if no one (including giants like Apple and NVIDIA) has invented new ways to run code in the last 30 years either, it seems like wishful thinking to argue that Intel would have somehow done it had they been less wrong about VLIW.
- dekhn 4y agoI can't see how. It was priced too high to be attractive to the people running Linux at that time, while not being any faster. It was aimed at people running large-scale enterprise DBs, which was not a good use case for linux at the time.
- sliken 4y agoWhat was missing? HP donated some 2U itaniums to my university, I installed Redhat, downloaded from Redhat. All the expected packages where there, and it just worked.
- PreInternet01 4y agoYeah, IA64 was really exciting, until the hardware came out... Even the 'workstation' class machines were ridiculously loud and took a dedicated circuit to power them. And the boot times, oh, the boot times. Then, the instruction set turned out to be all kinds of meh, and the optimizing compilers supposed to compensate for that never turned up. So, yeah, this was pretty much unavoidable. Even hardcore VAX holdouts (which HP eventually tried to capture, unsuccessfully) are on x64 by now...
- mrweasel 4y agoI've never been able to figure out if IA64 was poorly designed, or if the migration path was just to hard. The AMD64 seemed like a bit of a hack when it came out, but at the same time it was just a better solution for most. We had two Itanium servers for a project I worked on, both donated by HP. They weren't anything special, certainly didn't feel like an upgrade over our Sun machines.
- PreInternet01 4y agoNah, it was just poorly designed. Intel promised two things for IA64: more instructions per clock and much higher clock rates. The first promise failed to materialize due to suitable compilers being much too difficult to implement, which in turn stopped investments in silicon improvements (which, in hindsight, would have been extremely challenging as well).
- FullyFunctional 4y agoI'd offer a slightly modified take: - the promised compilers are _impossible_ as we can't predict all branches and all cache misses in _general_ (works better for floating point heavy code), - the failure to clock higher was IMO largely due to a ridiculously bloated and over-complicated ISA. In other words, EPIC was doomed from birth. I've written about IA-64 many times; it actually had many neat ideas, but in the end Intel yet again failed spectacularly in moving away from their archaic legacy.
- deleted 4y ago[deleted]
- deleted 4y ago[deleted]
- lonelygirl15a 4y agoRelevant conversation here 11 days ago: https://news.ycombinator.com/item?id=34651799 https://news.ycombinator.com/item?id=34651799
- johnklos 4y agoThis reminds me of a quote from fortune(6): The United States is like the guy at the party who gives cocaine to everybody and still nobody likes him. -- Jim Samuels Intel spent billions of dollars trying to make Itanic a thing. They schemed with HP to buy and kill Alpha, in spite of the fact that at the time Alpha was in some of the fastest supercomputers in the world. They shot themselves in the foot by avoiding adopting amd64 extensions for so long in their x86 processors and doing other seemingly brain-dead things that only make sense when examined in the light of their desire to push Itanic. They made deals all across the industry to get people to sign up to support Itanic, and in the end people got a very mediocre CPU that always promised more than it delivered and always cost significantly more for the same amount of performance elsewhere. In the meanwhile, Alpha is still supported by gcc, has repositories of tens of thousands of current binary packages, and still has options for modern open source OSes. m68k has gcc and clang support. Heck - even VAX has ongoing gcc support. You can barely give away an Itanic system these days. It truly is a very sad architecture. OTOH, some people are still having fun with Itanic systems: https://twitter.com/search?q=%40jhamby%20itanium https://twitter.com/search?q=%40jhamby%20itanium
- yrro 4y ago'No results for "@jhamby itanium"' Are the tweets private or is this a further example of Twitter's degradation?
- saurik 4y agoClick Latest. There it shows the right thing... ...but also says "including results for @jhamby ritanium" and has a link "search instead for @jhamby itanium". If you click that, then Top works. (Note my iOS Twitter app version is somewhat old, so I guess I can't guarantee that this specific sequence doesn't work for you.)
- yrro 4y agoThanks, and good GRIEF that is TERRIBLE UI design!
- 4y ago
- danjoredd 4y agoThey still supported Itanium? I was sure that this was abandoned YEARS ago
- chungy 4y agoOnce something makes it to Linux, it's very hard to root out. As long as there's even just ONE dedicated developer keeping it alive, it'll remain there.
- dragontamer 4y agoThose who want "excitement" in instruction sets should study GPUs, POWER10, ARMv8, AVX512, and ARM's SVE these days. GPU instructions, such as bpermute, permute, warp-vote, and other such concepts are the biggest "conceptual" changes to compute I've ever seen. DirectX12, Vulkan, CUDA, HIP, it doesn't really matter what you study per se, the GPU community knows brute force performance and is advancing it. From this perspective, your study guides are the NVidia PTX guide (CUDA's assembly language), and AMD's RDNA2 ISA. Also keep in mind the NVidia PTX wgmma instruction, which is key to 16-bit 4x4 matrix multiplications (aka: Deep Learning / Tensors). NVidia's underlying assembly is undocumented (instead, hidden away by the PTX layer / compiler). But people have been figuring out how it works under the hood. I don't think NVidia is trying to keep it a secret, as much as they just prefer users to work at the PTX layer, which would be more portable in the long term. Studying this SASS assembly is harder but still possible: https://arxiv.org/abs/2208.11174 https://arxiv.org/abs/2208.11174 --------- x86-wise, the pext and pdep instructions are single-cycle gather/scatter bitwise operations over 64-bits. I consider these to be the greatest advancements to compute theory on the x86 side and highly suggest people to play with these instructions. They're incredible. POWER and ARMv8 have extremely clean implementations of load-acquire / store-release, and I expect this to be fundamental to large-scale scaling of CPUs, cache-coherence, and even I/O in the long run. ------- AVX512 and SVE are other ideas into SIMD compute. AVX512 has compress instructions that I think work extremely well for common SIMD code (ex: the stream compression problem). SVE tries to be agnostic with SIMD-width. A noble effort, but its the odd one out (AVX512, NVidia CUDA, and AMD HIP all rely upon static SIMD-widths). I'm still interested in what it can do with its "SIMD-width agnostic" framework, but I also recognize that it stands alone in today's ISAs. -------- The closest thing to Intel Itanium is probably Xilinx FPGAs, which I'm told are VLIW-based instructions still. The old Itanium went all in on VLIW, but its just not a popular ISA-style today, and is largely considered "defeated". But VLIW apparently lives on in DSPs and Xilinx FPGAs. While no one seems to be investing in this concept, its still being studied (by at least DSP programmers) and could be a darkhorse comeback in 10 years or so.
- andix 4y agoI guess only legacy systems run on Itanium, and they probably won’t use the newest Linux kernel. Or as it seems, most of them don’t run Linux at all. If Linux support would be important, I guess Intel or one of the mainframe manufacturers would chip in.
- johnklos 4y agoPart of the problem with the whole Itanic ecosystem is that Intel never spend much energy trying to improve gcc, instead improving and pushing their own compilers.
- jabl 4y agoI guess the thinking when they got started was that this FOSS stuff was for smelly hippies and not serious use. And once the world had converted to Itanium, having to buy Intel compilers to wring decent performance out of it, would have given Intel another big revenue stream. In other news, the Intel compiler suite has been recently refactored on top of clang&llvm. How the world turns..
- fweimer 4y agoThe timing is a bit unexpected, given that there was a similar discussion not too long ago, and I think someone stepped up as a quasi-maintainer (maybe even Adrian, who now acked the removal patch). Itanium will be remember for quite a while because it gave us the Itanium C++ ABI: https://itanium-cxx-abi.github.io/cxx-abi/ https://itanium-cxx-abi.github.io/cxx-abi/ It's actively maintained and continuously adjusted to new implementation requirements for newer C++ standards versions. Despite the name, it's the C++ ABI that GNU/Linux (and most non-Windows targets) uses for other CPUs as well. I know that people don't like this kind of ABI stability (or C++), but it's what enables widespread C++ usage in distributions, without the need for flag days/mass rebuilds or tons of manually created compat packages. We might not have Qt or KDE without the Itanium C++ ABI.
- cesarb 4y ago> Itanium will be remember for quite a while because it gave us the Itanium C++ ABI There are two other things Itanium gave us, which will also be remembered for a long time: EFI (rebranded as UEFI for its portable non-Itanium implementation), and GPT (the partition table format for disks bigger than 2TB).
- rayiner 4y ago> Itanium will be remember for quite a while because it gave us the Itanium C++ ABI What a thing to be remembered for. But fitting for the inelegant, baroque architecture IA64 ended up becoming.