Scalable Devices - Scientific Visualization: Uncertainty, Multifield, Biomedical, and Scalable Visualization - page 349

WireGL employs sort-first parallel rendering [ 42 ], i.e., splitting up the rendering in
image space, which directly supports rendering on tiled displays. A major drawback
of this approach, however, is that the data have to be replicated on each render node,
i.e., this approach scales to large display sizes, but not as easily to large data sizes.
This problemwas reduced inWireGL [ 24 ] by filtering the OpenGL command stream
to correspond better to the sub-streams required by individual render nodes, which
builds on an early parallel graphics API implementation [ 27 ]. However, WireGL
requires all data to be transmitted over the network every frame, which incurs a
significant scalability problem for large data.
Compositing is a very important issue in distributed rendering, which is usually
handled completely in software, but special purpose hardware solutions such as
the Lightning-2 system [ 60 ] have been developed and combined with WireGL, for
example.
The Chromium system [ 26 ] builds on the earlier work of WireGL to create a
powerful framework for command stream processing and distribution, introducing
programmable command streamfilters that enable building general sort-first and sort-
last parallel rendering algorithms on top of the provided functionality. Like WireGL,
Chromium is based on intercepting OpenGL command streams.
The Equalizer framework [ 17 , 18 ] provides very general capabilities for distrib-
uted rendering, both for distributing data, as well as for rendering on tiled displays.
In contrast to the other middleware discussed here, Equalizer aims to provide a
full-featured distributed parallel rendering framework. However, this requires the
application code to use the Equalizer API and adapt its structure accordingly. Equal-
izer supports both sort-first and sort-last rendering approaches, and also provides
parallel compositing capabilities with different strategies, as well as load balancing.
The SAGE (Scalable Adaptive Graphics Environment) framework [ 29 - 32 , 53 ]
concentrates solely on streams of pixel data, which can be distributed efficiently to
the corresponding displays. In this way, SAGE can be used as a powerful low-level
primitive for streaming pixel data, which have been generated before by any dis-
tributed visualization algorithm. SAGE allows multiple clients to display different
views on a single display array, arranging for pixel streams to be sent to and dis-
played on the correct nodes. Application windows can be freely moved and resized
anywhere, seamlessly handling windows straddling multiple displays, and multiple
views partially overlapping the same display. In order to be able to stream pixel data,
all rendered images must be read back from the GPU to the CPU and then transmitted
over the network.
The CGLX framework [ 16 ] provides a GLUT-like application interface, which
allows for easy conversion of OpenGL code that uses GLUT to large display arrays.
Although distributed rendering is handled automatically, existing code must be con-
verted from GLUT to CGLX. Although the required code changes to convert a
GLUT application to CGLX are relatively minor, for applications that are not based
on GLUT, using CGLX is not straightforward. An example for using CGLX as the
low-level middleware to build a Gigapixel viewer is the Giga-stack system [ 50 ].