Scaling Linux to New Heights: the SGI Altix 3000 System

With 64 processors and 512GB of memory, SGI claims the title of world's most powerful Linux system.

SGI recently debuted its new 64-bit, 64-processor, Linux system based on the Intel Itanium 2 processor—a significant announcement for the company and for Linux. This system marks the opening of a new frontier as scientists working on complex and demanding high-performance computing (HPC) problems can now use and deploy Linux in ways never before possible. HPC environments continually push the limits of the operating system by requiring larger numbers of CPUs, higher I/O bandwidth and faster and more efficient parallel programming support.

Early on in the system's development, SGI made the decision to use Linux exclusively as the operating system for this new platform. It proved to be a solid and very capable operating system for the technical compute environments that SGI targets. With the combination of SGI NUMAflex global shared-memory architecture, Intel Itanium 2 processors and Linux, we were breaking records long before the system was introduced.

The new system, called the SGI Altix 3000, has up to 64 processors and 512GB of memory. A future version will offer up to 512 processors and 4TB. In this article, we explore the hardware design behind the new SGI system, describe the software development involved to bring this new system to market and show how Linux can readily scale and be deployed in the most demanding HPC environments.

Hardware and System Architecture Background

The SGI Altix 3000 system uses Intel Itanium 2 processors and is based on the SGI NUMAflex global shared-memory architecture, which is the company's implementation of a non-uniform memory access (NUMA) architecture. NUMAflex was introduced in 1996 and has since been used in the company's renowned SGI Origin family of servers and supercomputers based on the MIPS processor and the IRIX 64-bit operating system. The NUMAflex design enables the CPU, memory, I/O, interconnect, graphics and storage to be packaged into modular components, or bricks. These bricks can then be combined and configured with tremendous flexibility to match a customer's resource and workload requirements better. Leveraging this third-generation design, SGI was able to build the SGI Altix 3000 system using the same bricks for I/O (IX- and PX-bricks), storage (D-bricks) and interconnect (router bricks/R-bricks). The primary difference in this new system is the CPU brick (C-brick), which contains the Itanium 2 processors. Figure 1 shows the types of bricks used on the SGI Altix 3000 system. Figure 2 depicts how these bricks can be combined into two racks to make a single-system-image 64-processor system.

Figure 1. NUMAflex Brick Types

Figure 2. Two Possible NUMAflex Configurations

SGI Altix 3000 C-Brick Block Diagram and Specifications

Preparing Linux for a New Hardware Platform

On a well-designed and balanced hardware architecture such as NUMAflex, it is the operating system's job to ensure that users and applications can fully exploit the hardware without being hindered due to inefficient resource management or bottlenecks. Achieving balanced hardware resource management on a large NUMA system requires starting kernel development long before the first Itanium 2 processors and hardware prototype systems arrive. In this case, we also used the first-generation Itanium processors for making the CPU scaling, I/O performance and other changes to Linux necessary for demanding HPC environments.

The first step in preparing the software before the prototype hardware arrives is identifying, as best you can, the necessary low-level hardware register and machine programming changes the kernel will need for system initialization and runtime. System manufacturers developing custom ASICs for highly advanced systems typically use simulation software and tools to test their hardware design. Before hardware was available, we developed and used simulators extensively for both the system firmware and kernel development to get the system-level software ready.

When the original prototype hardware based on first-generation Itanium processors arrived, it was time for power-on. One of the key milestones was powering the system on for the first time and taking a processor out of reset, then fetching and executing the first instructions from PROM.

Figure 3. SGI engineers celebrate power-on success.

After power-on, the fun really began with long hours and weekends in the hardware “bring-up” lab. This is where hardware, diagnostic and platform-software engineers worked together closely to debug the system and get the processor through a series of important milestones: PROM to boot prompt, Linux kernel through initialization, reading and mounting root, reaching single-user mode and then going into multi-user mode and then connecting to the network. After that, we did the same thing all over again with multiple processors and multiple nodes—typically pursued in parallel—with several other bring-up teams at other stations that trail closely behind the lead team's progress.

Figure 4. During bring-up, a hardware engineer, a PROM engineer and an OS engineer discuss a bug.

Once we had Linux running on the prototype systems with first-generation Itanium processors, software engineers could proceed with ensuring that Linux ran and, in particular, scaled well on large NUMA systems. We built and used numerous in-house, first-generation Itanium-based systems to help ensure that Linux performed well on large systems. By early 2001, we had succeeded in running a 32-processor Itanium-based system—the first of its kind.

Figure 5. The author's son in front of an early 32-processor Itanium-based system, Summer 2001.

These first-generation Itanium-based systems were key in having Linux ready for demanding HPC requirements. Well before the first Itanium 2 processors were available from Intel, the bulk of the scaling, I/O performance and other changes for Linux could be developed and tested.

As one group of SGI software engineers was busy working on performance, scaling and other issues, using prototypes with first-generation Itanium processors, another team of hardware and platform-software engineers was getting the next-generation SGI C-brick with Itanium 2 processors ready for power-on to repeat the bring-up process all over again.

Figure 6. First power-on of the Itanium 2-based C-brick.

By mid-2002, the bring-up team had made excellent progress, from power-on of a single processor to running a 64-processor system. The 64-processor system with Itanium 2 processors again marked the first of its kind. All this, of course, was with Linux running in a single-system image.

Throughout this whole process, we passed any changes in Linux or bugs found back to the kernel developers for inclusion in a future release of Linux.



Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

Couple more questions for Steve on CPUs and the technology.

Anonymous's picture

Why the process of choosing the Itanium 2 CPU? What are the benefits of this platform in your view? Would other CPUs have worked as well (PowerPC, MIPS, AMD/Hammer) or could there be processor module versions based on these models in the future? Can the traditional workstation market benefit from some of this technology (i.e. an small case with support for 4 modules only)?



Re: Scaling Linux to New Heights: the SGI Altix 3000 System

Anonymous's picture

how many bogomips does this monster achieve 8-) ?

Re: BogoMIPS and Pricing

SteveNeuner's picture

> how many bogomips does this monster achieve 8-) ?


First, please keep in mind that bogomips only times the cpu delay loop.

Thus, a bogomips value says nothing about memory bandwidth, parallel

instructions, cache sizes, etc. Thus, while it may be interesting to know

how fast a cpu spins while doing nothing, it doesn't say much about what

it can do with real work. :^)

Second, the method for calculating bogomips will be vary depending

on the processor, so this number should not be used to compare between

different processors types. For example, on the Intel Itanium processor,

it times the following loop (a single bundle using an instruction and loop

register that have been optimized for looping):

2e0: nop.m 0x0

2e6: nop.i 0x0

2ec: br.cloop.sptk.few 2e0 ;;

While on i386 with the rdtsc instruction (Pentium or better), bogomips

times the following loop (5 instructions, 3 registers and a read of the

hardware clock):

10: f3 90 repz nop

12: 0f 31 rdtsc

14: 29 c8 sub %ecx,%eax

16: 39 d8 cmp %ebx,%eax

18: 72 f6 jb 10

Given that comparing this number between different processors types is an apples to

oranges comparison, and FWIW, here's the info taken from a 64 processor (Intel Itanium 2),

SGI Altix(tm) system:

[root@parrot root]# grep processors /var/log/dmesg

Total of 64 processors activated (76359.40 BogoMIPS).

All processors have done init_idle

[root@parrot root]#

> And the price tag?

Please refer to the pricing and availability information in the

press release at:

Hope that helps.

Steve Neuner


Re: Scaling Linux to New Heights: the SGI Altix 3000 System

Anonymous's picture

And the price tag?