Comment Re:Also, Itanium (Score 1) 137
No it couldn't have. The design was discovered (to be fair, thanks to Itanium's failure) to be fundamentally broken. The compiler can't know what will be hitting the CPU when the program is actually run.
Yes it does know, because the CPU only executes one massively wide instruction at a time.
The problem with VLIW is that the compiler technology back then wasn't very sophisticated. These days the modern optimizing compiler is shockingly good at optimization - even figuring out what you're trying to do and re-attempt to do it in a better way. (E.g., if you need to count the "1" bits, which is a common operation, you implement it in C with a while loop. Modern x86 CPUs have POPCNT, which is a single instruction that does exactly that, and the compiler can see you attempting to count the bits manually and replace all that code with the single instruction).
VLIW might actually be practical today because compilers have gotten many times better than even 20 years ago. The only difference moder CPUs are over VLIW ones is that the instruction scheduler is a hardware block in a modern CPU, whereas VLIW has it explicitly scheduled. But many times the compiler can provide hints to the hardware scheduler so it can better distribute the work.
Compilers are scary good at optimizing these days - I suggest checking out Matt Godbolt's Advent of Compiler Optimization series he did in December where he shows you what the modern compiler is capable of. Even telling you what caveats you might introduce in your code that disable optimization. (Matt Godbolt is one of the creators of Compiler Explorer).