I was reading up on the history of the computer and I came along the IA-64 (Itanium) processors. They sounded really interesting and I was confused as to why Intel would decide to drop them.

The ability to choose explicitly what 2 instructions you wanted to run in that cycle is a great idea, especially when writing your program in assembly, for example, a faster bootloader.

The hundreds of registers should be convincing for any assembly programmer. You could essentially store all the functions variables in the registers if it doesn't call any other ones.

The ability to do instructions like this:

(qp) xor r1 = r2, r3    ; r1 =   r2  XOR r3

(qp) xor r1 = (imm8), r3 ; r1 = (imm8) XOR r3

versus having to do:

; eax = r1
; ebx = r2
; ecx = r3

mov eax, ebx ; first put r2 into r1
xor eax, ecx ; then set r1 equivalent to r2 XOR r3

mov eax, (imm32) ; first put (imm32) into r1
xor eax, ecx ; then set r1 equivalent to (imm32) XOR r3

I heard it was because of no backwards x86 comparability, but couldn't thy be fixed by just adding the Pentium circuitry to it and just add a processor flag that would switch it to Itanium mode (like switching to Protected or Long mode)

All the great things about it would have surly put them a giant leap ahead of AMD.

Any ideas?

Sadly this means you will need a very advanced compiler to do this. Or even one per specific model of the CPU. (E.g. a newer version of the Itanium with an extra feature would require different compiler).

When I was working on a WinForms (target only had .NET 2.0) project in Visual Studio 2010, I had a compile target of IA-64. That means that there is a .NET runtime that was able to be compiled for IA-64 and a .NET runtime means Windows. Plus, Hamilton's answer mentions Windows NT. Having a full blown OS like Windows NT means that there is a compiler capable of generating IA-64 machine code.

  • 1
    This answer provides some background info about the Itanium you might find useful. – amiregelz Nov 26 '12 at 18:08
  • 1
    I consider that the EDGE processors are the most promising new architecture. And they are even better than the VLIW processors (such as the Itanium). You might want to read the linked page down at "A new ISA?" and "Theory" as that part explains why they are much better. – Dan D. Nov 26 '12 at 18:25
  • @DanD the problem is that x86 is a de facto standard. The closest you could probably get is Apple switching from Intel to EDGE, but even then it could take years. – Cole Johnson Nov 26 '12 at 18:31
  • "I heard it was because of no backwards x86 comparability, but couldn't thy be fixed by just adding the Pentium circuitry to it and just add a processor flag that would switch it to Itanium mode (like switching to Protected or Long mode)" If they could make chips with twice as many transistors without sacrificing cost, performance, reliability, heat, and so on, they'd already be doing it. – David Schwartz Nov 26 '12 at 18:37
  • 1
    I thought the Itanium was not dead yet. – David Schwartz Nov 27 '12 at 3:18

Performance was very disappointing compared to expectations and it didn't sell well compared to Intel's x86 architectures.

Intel talked me into building my Hamilton C shell on Itanium running Windows NT sometime around 2000 for a trade show. Itaniums were hard to come by so I used a VPN to a machine in their lab. Having already built versions for NT on x86, MIPS, Alpha and PowerPC, the "port" was trivial, just minor tweaks mostly to my makefiles. I think it took me maybe a half hour.

But the performance was truly underwhelming, definitely so over the VPN, and still disappointing when I got to the trade show and could try it right there in person. Itanium went nowhere because it wasn't a great product and nobody bought it.


For a while, Intel touted my experience porting to the Itanium using their VPN remote development experience on their website. Gone now but snapshotted at archive.org, here's what it said in their remote FAQ:

Q: Do you have a customer I can talk to about the Remote Access service?

A: Yes, Hamilton Laboratories*. For an in-depth look at the benefits Hamilton Laboratories derived from the service, see the Hamilton Laboratories case study.

In the "case study" it says I built an Itanium version because customers were clamoring for it. But I don't recall ever selling a copy for Itanium. Sold them for everything else, including PowerPC (and how many of those running NT do suppose there were?) just never for Itanium.

Challenge: To accelerate development of its Hamilton C Shell product to ensure a favorable time-to-market port of its customers' architecture tools for Intel® Itanium® and Windows* 2000.

Solution: Used the Remote Access Program, including high speed Internet access and Shiva® VPN client to access an Itanium development environment, modifying source code and make files, testing debugging and recompiling 64-bit application remotely in just 7 hours time.

  • 5
    Nothing to tweak. My whole C shell is highly multithreaded but especially in those days, had to be very portable C and very efficient as written because the compilers I was using in the early 90s were often very basic and the optimizers sometimes unreliable. I had already built for 64-bit RISC machines and had already found and fixed any alignment problems. For perf, I've always gone straight to the Win32 APIs for everything, so it wasn't possibly a bad C runtime library, either. The really hot machine was the Alpha and compared to it, the Itanium was just disappointing. – Nicole Hamilton Nov 26 '12 at 18:38
  • 8
    Just looked at your C Shell. It is pretty awesome. I always looked at Cygwin as a copout. I'm going to have to try it out some time. – Michael Brown Nov 26 '12 at 21:42
  • 6
    That was Intel, not Microsoft, with that crazy remote developing system. Microsoft was very helpful to developers. Microsoft helped arrange for me to get my MIPS, Alpha and PowerPC machines. I used to get hand-made CDs of the new builds of NT from the dev group in early 1992, when there weren't many copies anywhere outside the Microsoft campus. – Nicole Hamilton Nov 27 '12 at 3:43
  • 8
    No, the NT kernel was quite agnostic about processor architecture. Dave Cutler was a fanatic about that. They started NT development on an i960, just so as to avoid any x86-isms creeping into the code. And while they dropped the i960, the NT 3.1 Beta was released on x86 and MIPS in July 1992 and on Alpha a couple months later, iirc. Microsoft had helped me get the MIPS and the Alpha machines so I supported all 3 processors as they got announced. The only thing special about the Itanium was that it was a disappointment and didn't sell well. – Nicole Hamilton Nov 27 '12 at 18:30
  • 1
    @ColeJohnson - As Nicole Hamilton points out the problem wasn't the NT kernel. I mean heck Windows Server 2008 R2 supported the Itanium. So the problem wasn't the operating system. The problem was the platform itself. Of course it didn't help that AMD threw a wrench in Intel's plans by just extending the x86 platform itself. – Ramhound Dec 5 '12 at 14:56

Quick answer: Poor performance. Intel tried to release a revolutionary product when they should have evolved to the product they wanted.

More specifically: The processor was not fast enough under general circumstances. Intel released the processor just as the processor speed to memory speed gap was widening. Itanium, being a Reduced Instruction Set (RISC) processor required more bytes-per-instruction than its cousin, x86 variants. The increased memory load, caused the processor to run slowly.

All this was exasperated by the entire architecture being, essentially, a first release. While RISC itself was not a new idea, many of the hardware components were and needed new layout designs. There were also many new ideas in the Itanium instruction layout which needed to be thoroughly digested by the development community before high-quality software would become available.

In the end a lot of technology did end up getting used in Intel's existing release of chips - just not easily visible to the end-user.

  • 2
    Did you mean the poor performance when doing Itanium stuff, or the absolutely horrible performance when emulating legacy X86 code? – Hennes Nov 26 '12 at 20:07
  • 1
    both. My impression was the X86 emulator was not very important to the Itanium team. Instead the emulator was a critical product feature to get right because it was the stop-gap that most customers would build a first impression on. – A. Phillips Nov 26 '12 at 20:46
  • 1
    Itanium performance in well written Itanium code was fantastic - there just wasn't much good code out there. – A. Phillips Nov 26 '12 at 20:47
  • 5
    What does "well written Itanium code" mean, Aaron? If it's good clean C where everything's properly aligned with no untoward casts and so on, what more makes something particularly well-written for an Itanium? With my C shell, I could easily time compute-bound stuff (e.g., factoring numbers), i/o (copying or cat'ing files) and OS perf (creating threads or processes). On the Alpha, it was like, wow, this is fast. Give me a dual processor, I could measure it easily. I'm telling you, the Itanium was a dog any way you looked at it, especially compared to the hype. – Nicole Hamilton Nov 26 '12 at 21:05
  • 4
    The MIPS, Alpha and PowerPC platforms were new as well, along with all of NT in the early 90s and those other chips, especially Alpha, were fast compared to most x86 machines. I still have one of each of those other machines in my basement. Itanium just wasn't that great. This wasn't Intel's first misstep. Other greyhairs out there will remember their 432 disaster in 1981. That also was a badly-designed architecture that fell over in performance. – Nicole Hamilton Nov 26 '12 at 23:14

The itanium is a great design if you can leverage it advantages.

Sadly this means you will need a very advanced compiler to do this. Or even one per specific model of the CPU. (E.g. a newer version of the Itanium with an extra feature would require different compiler).

Creating such a compiler once is a hard task. To do that for every variation of a CPU is not economical.

  • You wouldn't need to update the compiler for the newer ones. You just would to leverage the new features. I heard they would maintain backwards compatibility. – Cole Johnson Nov 26 '12 at 17:58
  • He's fond of assembler only. – ott-- Nov 26 '12 at 17:59
  • I'm mentioning it would make the assembly coding easier. The compiler could at the least use the simplest instructions it can think of. – Cole Johnson Nov 26 '12 at 18:02
  • Creating a working compiler is quite different from one which efficiently uses the wide / parallel instructions abilities of a CPU. If you hand craft assembler you should be able to do wonderful stuff, but at the cost of a lot work. – Hennes Nov 26 '12 at 20:17
  • 2
    From an old slashdot thread: compilers for Itanium is hard – Rich Homolka Nov 26 '12 at 22:26

The other important part of the Itanium history that hasn't really been touched on is the fact that in 2001 with the Itaniums debut, it was impossible to get large amounts of RAM into commodity hardware. x86_64 was just a blip on the horizon and AMD Opterons wouldn't really even be released for another 2 years.

My first (and only) experience with an Itanium server was in 2002 at a chemical company where they needed an SQL Server to perform oil analysis to detect defects. This oil was coming from and going into multi-million dollar machines in a billion dollar company, so they had a cluster of Itaniums, each with 128Gb of RAM. 128Gb of RAM today is still a fair amount, but is easy and cheap to install in a server.

In 2002, 128Gb of RAM was a mammoth amount, and as they already had an existing SQL Server infrastructure, it was cheaper to fork out for a few Itanium machines and load them up with RAM, than it was to switch to a different platform and different database.

Now that it's trivial to to get 128Gb (or more) into a commodity server, one of the large parts of the Itanium market that didn't have any real viable competitors (the Opteron came along in 2003, and now of course servers that can take hundreds of gigs of memory are ubiquitous) is flooded with options that were cheaper to buy, cheaper to own, and faster.

  • I'm pretty sure a 128gb ddr3 ram module nowadays will run you at least one grand (USD) – Cole Johnson Nov 26 '12 at 21:46
  • 2
    I've never seen a 128Gb DDR module... but putting 128Gb of Registered ECC RAM into a server is more than $1000, but not much more; depends on the deal you can get from your supplier. – Mark Henderson Nov 26 '12 at 22:13
  • I've never seen a plain 128 gb module either. But this 8x16GB set is the equivalent and it costs $1,500 which is pretty cheap compared to the $10k sets I've seen other places – Cole Johnson Nov 26 '12 at 23:12
  • I see a lot of Gbs; should those be GBs? – Charlie Mar 8 '18 at 23:53

I heard that it was because AMD pushed Intel to allocate more resources to their mainstream processors in order to compete. AMD came out with their Athlon 64s in 2003, which had better price/performance than the Pentiums. There is a belief that if Intel continued to develop Itanium in full force then it would be faster than the current x86 processors.

  • 1
    The saying "Could have...Would have" applies to what Itanium could have been if AMD had not simply extended x86. Intel could have if they really wanted to, killed x86-64 but they were under pressure from Microsoft I am sure, if Intel didn't license x86-64 from AMD the current situation likely would be reversed with AMD leading and Intel barely able to keep up with AMD's advances. – Ramhound Dec 5 '12 at 15:01

Not the answer you're looking for? Browse other questions tagged or ask your own question.