| Research |
Appears in the Proceedings of SIGGRAPH 2001
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.
Appears in the Proceedings of IEEE Visualization 1999
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.
Appears in the Proceedings of the 2000 Eurographics/SIGGRAPH Workshop on Graphics Hardware
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.
Appears in the Proceedings of SC2000
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.