SGI's Itanium super smokes Java test
Don't bogart that Altix box
Even before Rackable Systems bought the carcass of supercomputer maker Silicon Graphics in April and took its name a month later, the future of the Itanium-based Altix shared memory supercomputers was in question.
Since the takeover, the new SGI has been trying to stir up some interest in the existing machines while not exactly committing to the future Itanium processors from Intel.
What is a supercomputer maker that wants to sell big boxes today (but which is working on a shared memory system code-named "UltraViolet" and taking the NUMAlink technology from the Altix machines and mixing it with the future Intel eight-core "Nehalem EX" processors due early next year) to do? Look for business in the data center by positioning the current shared memory Altix super as a great box to run Java applications, apparently.
SGI teamed up with the Leibniz Rechenzentrum in Germany, one of its largest customers, to run a series of commercial benchmark tests from the Standard Performance Evaluation Corporation on its high-end Altix 4700 sporting dual-core, 1.6 GHz Itanium 9040 processors. The LRZ has a 1,024-core Altix 4700 set up with 4 TB of shared memory across the NUMA nodes and is one of the most powerful boxes that SGI ever sold. Just for fun, SGI and LRZ carved out half of the machine's cores (which are comprised of 128 two-socket blade servers) and 1.5 TB of shared main memory and let the SPECjbb2005 commercial Java benchmark run like a bat out of hell on the machine.
The Altix 4700 setup was configured with Novell's SUSE Enterprise Linux 10 operating system and Oracle's JRockit JVM, and cranked through more than 9.6 million business operations per second (BOPS) on the SPECjbb2005 test. (One wonders why SGI and LRZ didn't give the SPEC Java test the whole machine, and perhaps bust through 19 million BOPS.)
The benchmark tests come a month after server maker Sun Microsystems was bragging about how well its Sparc T5440 quad-socket servers using its revved 1.6 GHz T2+ did on the SPECjbb2005 test. (The SPECjbb2005 test is essentially the TPC-C online transaction processing benchmark implemented in Java and without the ridiculous disk storage requirements that the TPC-C test carries.) As El Reg reported, a T5440 (which has 32 cores and 256 threads) with 256 GB of main memory was able to deliver 841,380 BOPS using Solaris 10 and the HotSpot JVM from Sun.
While that is pretty good BOPS, upstart server maker 3Leaf Systems stole the SPECjbb2005 show with a NUMA cluster based on an InfiniBand backbone and special three-socket system boards that put two quad-core Opteron 8384 processors and a special NUMA ASIC called Voyager on the SPECjbb2005 test. With 128 cores and 488 GB of main memory, running 3Leaf's own DVVM hypervisor and the combination of Red Hat Enterprise Linux 5.2 and Oracle's JRockit JVM, the 3Leaf Voyager box cranked through 5.5 million BOPS.
Here's the important part if you are SGI. An Altix 4700 tested back in the fall of 2007 held the SPECjbb2005 record, surpassing 5.18 million BOPS.
With 3Leaf Systems getting ready to do a server launch any day now and very likely using more powerful six-core Opteron processors and faster interconnects, SGI has to do a pre-emptive strike on 3Leaf's impending launch to hold the title. 3Leaf was mum on its plans, and sources at the company say that it only did the SPEC Java test at all because it was a "business requirement" and that it would have rather waited for its fall product launch.
While all of this leapfrogging is technically interesting, I don't know of one Altix 4700 that has ever been installed to run Java applications or commercial ERP systems, but over the years, SGI (the old SGI, that is), has occasionally run some tests to try to stir up interest.
What many of us observed so long ago is that for SGI to survive, it might need to go broad and support commercialized workloads like Java middleware or databases for transaction processing. (That was not the original design intent of the "Starfire" 64-socket server that SGI stupidly sold to Sun Microsystems in 1996, but Sun took that box and rode the dot-com boom with it brilliantly, becoming a player in commercial data center computing in the process.) But for SGI to go corporate would have taken precious resources away from the central HPC applications that the Altix 4700 was truly designed to handle. So SGI dabbled here and there, but never made a big push. Perhaps with the Nehalem EX-based UltraViolet NUMA machines due early next year (maybe), this will change. But it seems unlikely that SGI will do anything with the Itanium-based Altix boxes other than to continue to sell and support what it has. (Yes, I know there is some vague talk about possibly supporting the future "Tukwila" quad-core Itaniums in the UltraViolet systems.)
The real pity (perhaps) is that Java, because of its interpreted nature and therefore its high overhead compared to compiled languages, has not found a place in mainstream supercomputing. But HPC shops like compiled programs written in Fortran and C++ because they run close to the iron. And commercial data centers, which are more conservative than bleeding-edge HPC labs, are unlikely to venture far from the familiar x64 or RISC/Unix SMP platforms on which they currently run Java and database workloads.
SGI has also put the Altix 4700 through a bunch of other SPEC paces. The recent tests include the SPECint_rate_006 integer benchmark, the result of which you can see here and which shows the Altix 4700 at LRZ with all 1,024 cores humming hitting 9,030 on the test. (By comparison, a two-socket Xeon 5570 box does about 250 on this test, and this result from SGI is over four times as high as the largest SMP boxes from IBM, Sun, and Fujitsu tested to date.)
SGI also put the SPECfp_rate2000 floating point test on the LRZ box, and got the same 10,600 rating that it got on a similarly sized box using the faster 1.66 GHz Itanium 9150s it tested in January 2009. You can see the floating point test results here. SGI's result is more than six times that which IBM can deliver with its 64-core Power 595 machine in raw floating point performance as gauged by SPECfp_rate2000; it is also more than 7.6 times what Hewlett-Packard can deliver in a single system image with 128 of the same Itanium cores in its Integrity Superdome and six times what Fujitsu and Sun can deliver with the 256-core Sparc Enterprise M9000. ®