We believe that the evolving service/object three-tier commodity
architecture can and should form the basis for high-performance
computational grids. These grids can incorporate (essentially) all of
the services of the three-tier architecture outlined above, using
its protocols and standards wherever possible, but using specialized
techniques to achieve the grid goal of dependable performance. One
might achieve this goal by simply porting commodity services to
high-performance computing systems. Alternatively, one could continue
to use the commodity architecture on current platforms while enhancing
specific services to ensure higher performance and to incorporate new
capabilities such as high-end visualization (e.g., immersive
visualization systems: Chapter 
) or massively
parallel endsystems (Chapter ). The advantage of this
approach is that it facilitates tracking the rapid evolution of
commodity systems, avoiding the need for continued upkeep with each
new upgrade of the commodity service. This results in a
high-performance commodity computing environment that offers the
evolving functionality of commodity systems without requiring
significant re-engineering as advances in hardware and software lead
to new and better commodity products.
The above discussion indicates that the essential research challenge for high-performance commodity computing is to
enhance the performance of selected components within a commodity framework in such a way that the performance improvement is preserved through the evolution of the basic commodity technologies.
We believe that the key to achieving this goal is to exploit the three-tier structure by keeping high-performance computing enhancements in the third layer--which is, inevitability, the home of specialized services. This strategy isolates high-performance computing issues from the control or interface issues in the middle layer.
Let us briefly consider how this strategy works. Figure 1.2 shows a hybrid three-tier architecture in which the middle tier is implemented as a distributed network of servers. In general, these servers can be CORBA, COM, or Java-based object-Web servers: any server capable of understanding one of the basic protocols is possible. The middle layer not only includes networked servers with many different capabilities but can = also contain multiple instantiations of the same server to increase performance. The use of high-functionality but modest-performance communication protocols and interfaces at the middle layer limits the performance levels that can be reached. Nevertheless, this first step gives a modest-performance, scalable, parallel (implemented, if necessary, in terms of multiple servers) system that includes all commodity services (such as databases, object services, transaction processing, and collaboratories).
Figure 1.2: Today's heterogeneous interoperating hybrid server
architecture. High-performance commodity computing involves adding
high performance in the third tier.
The next step is applied only to those services whose lack of performance constitutes a bottleneck. In this case, an existing backend (third layer) implementation of a commodity service is replaced by its natural high-performance version. For example, sequential databases are replaced by parallel database machines, and sequential or socket-based messaging distributed simulations are replaced by message-passing implementations on low-latency, high-bandwidth dedicated parallel machines (specialized architectures or clusters of workstations).
Note that with the right high-performance software and network
connectivity, clusters of workstations (Chapter )
could be used at the third layer. Alternatively, collections of
middle-tier services could be run on a single parallel computer.
These various possibilities underscore the fact that the relatively
clean architecture of Figure 1.3 can become
confused. In particular, the physical realization may not reflect the
logical architecture shown in Figure 1.2.
Figure 1.3: Integration of Object Technologies (CORBA) and the Web=3D