jump to navigation

Thanks to HP, the Itanium Still Lives March 27, 2012

Posted by Peter Varhol in Architectures, Software development, Software platforms.
trackback

When PC software development meant working in MS DOS, programmers had to make a choice between using the small, medium, or large (and later huge) memory models.  These models required the use of different structures and pointers, and added an additional layer into architecting an application.  They had to do with the fact that Intel 80XXX processors segmented memory addressing into 64KB chunks.  Crossing a segment extracted a performance penalty, so you wanted to minimize the number of times you had to do that.  In time, it made software design more convoluted than it needed to be.

Fast-forward about ten years or so.  Intel 32-bit processors were able to abstract over this legacy structure, but the fundamental segmented architecture still exists under the covers.  Intel recognizes that it’s messy, and could possibly limit processor designs in the future.

So it starts over again, with a 64-bit processor called the Itanium (and later, Itanium 2).  I had a dog in this hunt; around 2000 Intel contracted with Compuware’s NuMega Lab, where I was a product manager, to make Itanium versions of its acclaimed SoftICE and BoundsChecker developer tools.  The Itanium used a completely different instruction set, but Intel implemented the x86 instruction set in microcode on top of it for the sake of backward compatibility.

It should also be noted at HP, shedding itself of its PA-RISC and DEC Alpha processor families, needed a high-performance replacement architecture, and invested heavily in Itanium systems and software.

As it turned out, there was no real business reason for reengineering the industry standard processor architecture.  It was an engineering decision, to make a better design, rather than to rally users around.  Intel spent billions of dollars over several years because its chip designers wanted something better than they had.

The Itanium was actually slower running x86 code than the best x86 processors at the time.  Other than HP, few system manufacturers adopted it.  And when AMD showed the way to 64-bit extensions to the x86, Intel made the same leap with the legacy processor architecture.

I’m reminded of this story by an ongoing lawsuit between HP and Oracle surrounding the availability of the latter’s flagship database on HP’s Itanium systems.  Oracle would like to cease supporting the Itanium, and cites HP’s substantial financial support to Intel to keep the Itanium alive.

I have no opinion on the lawsuit, except that it seems like a waste of good time and money.  But the story of the Itanium is of a project in which engineering triumphed over market requirements.  And it turned out badly for Intel, as well as HP and others.  If you build it, they won’t necessarily come.

Advertisements

Comments»

No comments yet — be the first.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: