One of the biggest problems for super servers is power--hence, cooling. What goes in comes out as heat. Fortunately, one of the aspects of multiple-processor systems provides a way to keep things cool. Running chips at a slower frequency significantly reduces power consumption, and the effects usually aren't linear.
For example, cutting the frequency by 20% may cut power requirements by 50%. Of course, the trick is to add enough processors to meet the performance requirements while trying to run them at the optimal power/performance point.
The other problem is software--or rather, the difficulty in writing applications to take advantage of a large number of processors. Cluster-management software helps, especially for Web-based services. A range of products, such as the Sun N1 Grid Engine and the open-source Linux Beowulf cluster support, addresses these areas.
These products tend to support a more loosely coupled environment with higher-latency links, such as Ethernet. Individual applications or copies of applications tend to run on the processors within a node within a cluster. This type of environment can take advantage of the large number of processors. Yet other programming techniques tend to be required when a small number of programs needs to use a large number of processors.
Parallel programming techniques have improved over the years. Still, most applications tend to make limited use of multithreading. A more natural parallel programming environment is necessary.
One approach provides a parallel programming framework like the Parallel Virtual Machine (PVM)--developed by the University of Tennessee, Oak Ridge National Laboratory, and Emory University in 1989--or the Message Passing Interface (MPI).
MPI is the de facto standard at this point, with variations for most of the switch fabrics in use today. With it, applications can be moved easily from one super server platform to another. However, system optimization tends to be application-specific because of MPI's explicit nature.
Another approach would be to make the programming environment more suitable. That's the goal of Sun's Fortress project. "It is trying to do with Fortran what Java did for C," says Sun Fellow Guy Steele.
Some of the key design themes include efficient abstraction, making parallelism normal and tractable, and making stupid mistakes impossible. Scientific computing is the target, so other considerations include emulation of standard mathematical notation.
Fortress and current parallel programming environments have one major difference--assumptions about the hardware. Fortress programmers don't know about the number of processors involved, and the number may change while the application is running. For instance, some processing nodes may be shut down to reduce power consumption or for maintenance, but the system as a whole will continue to run. Fortress takes NUMA into account as well.
Also, the loops are parallel by default in Fortress. Sequential operation must be specified explicitly. This is the opposite of conventional languages like C++ or Java. The concept of data distributions should make subdivision easier. For example, the underlying system would be able to automatically split an array among the memory of different processing nodes.
Fortress is still a project, not a final environment or product. But it's one of many projects that finally could enable programmers to take advantage of the hardware.
Super servers continue to grow in power and performance, even as their size gets smaller. In turn, this allows more processors to be packed into the same amount of space. A wide variety of applications can take advantage of the current architectures, though very sophisticated parallel processing applications may need to wait until the software catches up.