-
WireGL: A Scalable Graphics System for Clusters
Appears in
the Proceedings of SIGGRAPH 2001
Abstract:
We
describe WireGL, a system for scalable interactive rendering on a
cluster of workstations. WireGL provides the familiar OpenGL API to
each node in a cluster, virtualizing multiple graphics accelerators
into a sort-first parallel renderer with a parallel interface. We also
describe techniques for reassembling an output image from a set of
tiles distributed over a cluster. Using flexible display management,
WireGL can drive a variety of output devices, from standalone displays
to tiled display walls. By combining the power of virtual graphics,
the familiarity and ordered semantics of OpenGL, and the scalability
of clusters, we are able to create time-varying visualizations that
sustain rendering performance over 70,000,000 triangles per second at
interactive refresh rates using 16 compute nodes and 16 rendering
nodes.
Adobe
PDF Format (284K)
-
A Distributed Graphics System for Large Tiled Displays
Appears in the Proceedings of IEEE Visualization 1999
Abstract:
Recent interest in large displays has led to renewed development of tiled
displays, which are comprised of several individual displays arranged in an
array and used as one large logical display. Stanford's ``Interactive Mural'' is
an example of such a display, using an overlapping four by two array of
projectors that back-project onto a diffuse screen to form a 6' by 2' display
area with a resolution of over 60 dpi. Writing software to make effective use of
the large display space is a challenge because normal window system interaction
metaphors break down. One promising approach is to switch to immersive
applications; another approach, the one we are investigating, is to emulate
office, conference room or studio environments which use the space to display a
collection of visual material to support group activities.
In this paper we describe a virtual graphics system that is designed to support
multiple simultaneous rendering streams from both local and remote sites. The
system abstracts the physical number of computers, graphics subsystems and
projectors used to create the display. We provide performance measurements to
show that the system scales well and thus supports a variety of different
hardware configurations. The system is also interesting because it uses
transparent ``layers,'' instead of windows, to manage the screen.
Adobe
PDF Format(150K)
Color Plate in
PDF Format(2MB)
-
Tracking Graphics State For Networked Rendering
Appears in the Proceedings of the 2000 Eurographics/SIGGRAPH Workshop
on Graphics Hardware
Abstract:
As networks get faster, it becomes more feasible to render large data
sets remotely. For example, it is useful to run large scientific simulations
on remote compute servers, but visualize the results of those simulations on
one or more local displays. The WireGL project at Stanford is researching
new techniques for rendering over a network. For many applications, we can
render remotely over a gigabit network to a tiled display with little to no
performance loss compared to running locally. One of the elements of WireGL
that makes this performance possible is our ability to track the graphics
state of a running application.
In this paper, we will describe our techniques for tracking state, as
well as efficient algorithms for computing the difference between two
graphics contexts. This fast differencing operation allows WireGL to
transmit less state data over the network by updating server state lazily.
It also allows our system to context switch between multiple graphics
applications several million times per second without flushing the hardware
accelerator, resulting in substantial performance gains when sharing a
remote display between multiple clients.
Adobe
PDF Format(69K)
-
Distributed Rendering for Scalable
Displays
Appears in the Proceedings of SC2000
Abstract:
We will describe a new distributed graphics system that is designed to allow
an application to render to a large, tiled display. Our sys-tem uses a cluster
of off-the-shelf PCs connected with a high speed network to allow an unmodified
existing application to achieve scalable output resolution for such a display.
This paper presents an efficient sorting algorithm which minimizes the cluster
network traffic for a scalable display. We will demonstrate that for most
applications, our system provides a scalable output resolution with little or no
performance loss.
PDF Format
Slides from Supercomputing talk