Back to News
Advertisement
Advertisement

⚡ Community Insights

Discussion Sentiment

70% Positive

Analyzed from 1764 words in the discussion.

Trending Topics

#https#itanium#qemu#windows#software#com#intel#more#compiler#modern

Discussion (74 Comments)Read Original on HackerNews

qubex•about 22 hours ago
“It runs quite slowly, (486-levels of performance on a Ryzen 5000 series according to this discord channel)”

I’m sure there’s a joke about that being a huge leap in performance for Windows on IA-64 over the past 23 years waiting to be made from this.

Joel_Mckay•about 21 hours ago
To be fair, most of ia64 performance issues were in the more complicated compilers. The chip itself had potential, but essentially abandoned the DOS/Windows market inertia. =3
bri3d•about 20 hours ago
No (sorry, I post this every time the Mythical Compiler Myth reappears), the problem with VLIW is that it fundamentally doesn’t work for anything with unpredictable memory access patterns, and modern general purpose computing has moved almost exclusively in this direction. For VLIW to work, you need to either guess correctly what is in cache or not have a cache at all; as soon as you mispredict what has been loaded, you stall while an OoO processor keeps going and a speculative OoO processor even keeps guessing. With multiple workloads on the same hardware (virtualization, multitasking, multitenancy) this becomes an intractable problem even in the presence of the magic compiler which can solve for software based unpredictability (branch likelihood and pointer chasing), because every context switch clobbers an unknown set of cache lines and blows the entire thing up.

VLIW works for single workloads. It works exceptionally well for single workloads with no or explicit cache like DSP. You can trade the footprint and complexity from OoO for a wider execution unit and more SRAM. It works well for HPC, too, for the same reason. But for anything where more than one process exists, it just really doesn’t work, and that’s most modern workload.

Itanium also has a unique set of self inflicted issues due in large part to Intel trying to make a wide variety of cross compatible parts, but IMO even if they’d got it right, it still would have died.

monocasa•about 16 hours ago
Itanium had all sorts of specialized machinery so that you could issue a load that's required in the future, and then keep chugging away at the instruction stream, similar to what an OoO processor does with it's reordering logic.

One example was "advanced loads" which allowed you to issue a load as soon as you knew the address, even in the face of potential pointer aliasing in the future, and then later complete the load when you actually hit a data dependency that requires it. https://devblogs.microsoft.com/oldnewthing/20150805-00/?p=91...

Another example is "speculative loads" which lets you issue a load before you even know if it's valid, such as unrolling a loop for an array that you don't know if is a multiple of the unrolled loop chunk length (and therefore might trap with a page fault if fully resolved). https://devblogs.microsoft.com/oldnewthing/20150804-00/?p=91...

seanmcdirmid•about 12 hours ago
VLIW is being heavily used in some AI inference tasks (by Apple, AMD, Google, mainly in optimizing latency). It also is a nice way to do inference on edge devices that aren’t using constantly advancing models. It’s pretty much dead in general purpose computing though, and lacks the versatility of GPUs to go beyond inference.
Joel_Mckay•about 19 hours ago
We agree it probably would have still failed, but mostly it was the legacy code-motion compatibility/performance issues that were practically inescapable without refactoring millions of lines of code.

gcc maintained the ia64 target a long time for unclear reasons, but it was also still inefficient on other platforms. The FOSS compiler worked, but that was its only performance metric that counted for many users. =3

Not sure why you think the Intel compilers were a myth, as they are still around working far better than gcc in many use-cases:

"An Overview of the Intel® IA-64 Compiler"

https://webdocs.cs.ualberta.ca/~amaral/courses/605/papers/In...

qubex•about 20 hours ago
Yeah EPIC pushed too much effort onto compilers and removed the context awareness of out of order reordering etc and the result was just a lame duck.
ColdStream•about 19 hours ago
Itanium is yet another example of how difficult it is to fight software ecosystem momentum.

It had potential but until you have an easy transition path, few will consider it. Apple figured that out during the 68K > PPC > X86 > ARM transitions.

wmf•about 18 hours ago
Itanium 1 had hardware x86 compatibility and Itanium 2 had software x86 emulation just like Apple. It wasn't enough.
Joel_Mckay•about 19 hours ago
Agreed, everyone has a pet architecture that fascinates them, but if its so good only 5 people can code for the target... it is e-waste within a year.

Apple is an exception as it has always had a walled-garden ecosystem with the OS, so can force shifts in architectures unlike most companies. The M3/M4 Pro series with unified GPUs is probably the best design on the consumer market right now, but people are not leveraging it as much as they would have in other ecosystems.

Have a wonderful day =3

djhope99•about 20 hours ago
I have a funny story about a windows IA-64 box.

I was working for a large bank and it was all windows, including production. We used to run WebSphere Application Server on Windows. I was looking for a dev server to run unit tests on, including integration tests which required an actual WebSphere instance. The infrastructure team said they had “a box” going spare and it turned out to be IA64 on Windows.

If my memory serves me correctly WebSphere only ran on windows for IA-64 up to 6 and we were running on 7.

I had to do a bit of hacking but I did manage to get it working using the dlls from the 6 version. It was fine for running integration tests and a pretty fast box considering.

shoo•about 15 hours ago
Am I right to guess that neither your dev nor prod machines ran IA-64? If so that's not ideal, but beggars can't be choosers & a spare box from the infra team available right now is better than getting a box built to meet your exact specs available after the usual multi-quarter internal lead time.

Superficially it sounds a little crazy, but it's probably a lot less crazy than far more mainstream antipatterns (e.g. 'lets have our CI download all the dependencies from npm over the internet each time the build runs')!

Did running the unit tests on IA-64 ever flush out genuine issues that were 'working by accident' on x86?

cbmuser•about 22 hours ago
What's even crazier is that someone vibe-coded ia64 emulation support for QEMU: https://github.com/syunnPC/qemu-system-ia64
userbinator•about 22 hours ago
It's interesting to see how LLMs have definitely become a force-multiplier to motivate people into doing things they wouldn't otherwise have the time and effort to.
pizza234•about 21 hours ago
It really depends on the end goal. For personal tools that one uses, LLMs are extremely useful. But publicly used software doesn't only need to be written - it also needs to be maintained. And considering that it's extremely easy to implement features that are not used, vibe coded software tends to be, in best case, a mixed bag, and in worst (I believe typical) case, quickly abandoned.

Vibe coded software is the modern equivalent of the shovelware of the 90s.

userbinator•about 16 hours ago
Vibe coded software is the modern equivalent of the shovelware of the 90s.

I don't think so, especially as the latter was attempting to make a profit but this clearly wasn't done with a for-profit motive in mind.

monster_truck•about 19 hours ago
In this domain and others like it especially!

It's bone crushingly dry to try and figure this kind of shit out yourself, can do everything right according to every available reference and code comment only to get compiler and linker errors nobody has ever seen or posted about. Weeks and weeks of smashing your face against a wall until it gives. Now anyone can get twice as far in an evening. And that fuckin rules

Hard to not get a little hyperbolic about it... but I can't wait for everyone to exhaust their meme projects/ports and models to get just a bit better. Feels like we're about to have something of a golden age when everyone starts really making the stuff they've always wanted.

MBCook•about 17 hours ago
Plus you can point it at actual software or tests with known results and tell it to keep going until it gets it.
rbanffy•about 22 hours ago
I have been pairing with Claude Opus and it’s quite impressive. I have explored a number of possible changes to things like VTE and the Hercules mainframe emulator.
anyfoo•about 19 hours ago
Sweet. What changes to Hercules have you been considering? I have had a long running (and maintained!) MVS instance in Hercules for quite a few years now, just for fun.
natas•about 21 hours ago
Would be amazing to implement a JIT in hercules (would make it 10x faster potentially as fast as z/PDT which implements a JIT); good timing as IBM is retiring z/PDT!
qubex•about 22 hours ago
Open Source and LLMs seem to be complementary technologies that have resulted in an absolute surge of productivity multipliers.
ColdStream•about 19 hours ago
Recently thanks to Modern Vintage Gamer on youtube, there has been a push to see if you could get Doom to run on the NeoGeo. Because of its very unique hardware (no framebuffer) it is a very unqiue and tough task.

And yet, some folks have come to the battle and have ended up extensively using LLM's to code it. It is wild to see that these things can target such an obscure platform and get some decent results in a very short amount of time.

https://www.youtube.com/watch?v=WPxhuKTltsk

This is something that doesn't have any real economic value but many are more than happy to see happen.

ChickeNES•about 20 hours ago
Well, that's one vibe coded backburner'd project I can mark off my list...though maybe it would still be helpful so I'll link it here: https://github.com/ChickenParts/qemu-ia64

It booted Linux fine, was working on booting IPF EFI firmware when I got distracted by life and other projects.

natas•about 22 hours ago
I wish this could make it to qemu's main branch; always fun to preserve new systems. I wonder if it runs openvms/ia64 too!
rbanffy•about 22 hours ago
I think most of the machines that could run Windows could also run OpenVMS. It’s a bit unfortunate the company behind the OS needs to make money off its licenses though.
natas•about 21 hours ago
don't they still give some hobbyist licenses?
butterisgood•about 20 hours ago
When it comes to Itanium all I can think of is how I wish I could have an Alpha. And how no one should care about Itanium.

It’s the product of companies bent on doing all the wrong things.

MarekKnapek•about 15 hours ago
Wasn't there a problem with Alpha, that it had too weak memory model or something? Think of atomic instructions with multi CPU system. Or do I remember something wrong?
twoodfin•about 18 hours ago
It took longer than necessary, but in what ways do you think an Intel Core-derived chip is different from what an “Intel Alpha” would have been?

Taking for granted that hardware backcompat (Itanium had this, too!) was a starting requirement…

speed_spread•about 17 hours ago
Alpha was great but that wasn't enough against the convenience of just running an x86 box. It didn't find a niche quickly enough. ARM survived because they were low power. POWER survived because IBM is one big niche. MIPS died and reincarnated into RISC-V. I have no idea where Alpha would have gone had it not been dropped.
mixmastamyk•about 21 hours ago
Neat I did this on real hardware twenty plus years ago. Also tried Debian, iirc. My memory is that the workstation perf was decent but the thing was loud and used a lot of power. x86 emulation was slow. The nick, Itanic was mostly deserved.
Joel_Mckay•about 21 hours ago
The ia64 more complex compiler ecosystem made it difficult or impossible to port performant programs to the platform. Amd64 allowed people to keep building and running most programs with little understanding of what was happening in the architectural layers.

Even the 800lb guerilla Intel had to acknowledge amd64 was the next step, or it could end up a niche use chip like PowerPC.

The moral of the story is usability matters with consumer chip architecture. =3

xvilka•about 15 hours ago
It would make sense to implement it in QEMU instead. There was some previous work in the past, don't have a link right now to the original patchseries, but here is the repository[1]. In theory, it could be adapted to the modern QEMU code infrastructure and APIs and be a good starting point. Back in the past I started[2] doing that but quickly dropped because had no time to finish.

EDIT: It looks like it might be this one: https://github.com/syunnPC/qemu-system-ia64

[1] https://github.com/pvaibhav/qemu-ia64

[2] https://github.com/XVilka/qemu-ia64/branches/all

lorreyfum•about 20 hours ago
The Itanic was built specifically by HP to sink Fujitsu, hitachi, nec, unisys and sgi. So in that sense it was a success.
butterisgood•about 20 hours ago
True. But it’s a technological representation of all that’s wrong with the industry.
lorreyfum•about 20 hours ago
Absolutely. This monstrosity managed to have all what was wrong with CISC and all of the disadvantages of RISC at a higher price point than anything on the market at the time.
kstrauser•about 18 hours ago
This was my take on it: https://honeypot.net/2021/07/29/the-itanic-has.html

Key relevant quote:

> In 1994, Intel and HP looked around and saw a wide variety of successful server CPU architectures like Alpha, MIPS, SPARC, and POWER. This annoyed them and they decided to make a new CPU that no one would want to use.

itomato•about 18 hours ago
HP-UX support might make a compelling retirement project for someone.
pjmlp•about 14 hours ago
C and C++ compilers weren't great, but that HP-UX Vault was a great experience, before anyone knew what the word containers in computing world means.
natas•about 17 hours ago
For sure, I'm glad we have those emulators, real hardware is hard to find or expensive or faulty. Having emulators helps a lot.
shrubble•about 15 hours ago
OpenVMS ran on the Itanium also; wonder how far it could get in booting?