performance of PA-RISC binaries on Itanium using Aries

[Gregory Fruth]

I'm looking into getting a
ZX6000 (Itanium 2) to replace
my trusty J2240 (PA-RISC 2.0).
Does anybody out there have
any real-world performance
comparisons for
PA-RISC binaries on Itanium 2?

I have a legacy PA-RISC
application (a large
engineering analysis code)
that I'd like to run on the
ZX6000; I know that the Aries
translator is supposed to let
you run such binaries on IPF,
but there's no indication of
how much of a performance hit
you take. Anybody have any
experience with this?

[Pete Randall]

Gregory,

I don't have any hard numbers but I do have a firm conviction that your engineering app should run like greased lightening on Itanium. Even the earlier Itaniums excelled at encryption type functions because of their excellent floating point performance. I would think that would equate well with your engineering apps.


Pete

[Robert-Jan Goossens]

Hi Gregory,

http://www.hoise.com/primeur/02/articles/monthly/UH-PR-10-02-1.html

http://www.xilinx.com/publications/xcellonline/partners/xc_hp-linux44.htm

http://www.intel.com/ebusiness/pdf/prod/itanium/wp023901.pdf

Hope these help a bit in your choise,

Regards,

Robert-Jan.

[Leif Halvarsson_2]

Hi,
I have done some performance test with a rx2600 Itanium box. My main goal was to test native Itanium code, the problem with this was the compilers. I had very much problem with the compilers, this may be different now, I have heard that the compilers is much improved.

I tried some PA-RISC programs, the good news was that it was no problem to get the program running. I had not enough time to do real benchmarks but with "ordinary" programs (for example OmniBack there was no performance problem.
It may be different with your type of programs (perhaps very memory intensive) the memory handling differs from PA-RISC and you should not expect to get very high performance.

[A. Clay Stephenson]

I'm doing this from memory from several HPWorld session but about the best case native to Aries comparison was about a 3x performance hit and the typical was worse. This was strictly comparing processes CPU times to CPU times. Most UNIX processes (unfortunately yours AIN'T in this category) are IO bound rather than CPU bound so that the overall performance hits are much smaller than you would expect and may even approach zero - especially if moving from an older PA-RISC box.

Your kind of application really needs a native port.

[doug hosking · Accepted solution]

Performance will obviously vary depending on the type of application. Here's a quick
test to give you a very rough idea:

List the primes from 1 to 50,000,000 using the standard HP-UX primes command (which is not
highly optimized):

PA R390 (240 MHz):
real 15.2
user 14.7
sys 0.3

rx2600 (900 MHz) running the native IA binary:
real 3.6
user 3.5
sys 0.1

rx2600 (900 MHz)running a PA binary under Aries
real 15.1
user 14.9
sys 0.1

Obviously it's significantly to your advantage to recompile native where you can, but in many cases an old PA binary will still give you quite reasonable performance under Aries, especially when compared to a machine like a J2240.

[Gregory Fruth]

Followup for future readers:

You can test your apps on Itanium (aka IPF) by getting an account
from the HP Test Drive program (www.testdrive.hp.com). I tested
my app on an RX2600 and found that the performance hit for
using Aries vs. native IPF was about 5x. Thus the app runs on
IPF+Aries about as fast as it does PA-RISC native on my J2240.