Data Distribution Strategies for High-Resolution Displays [pdf] [ps]
Han Chen, Yuqun Chen, Adam Finkelstein, Thomas Funkhouser, Kai Li, Zhiyan Liu, Rudrajit Samanta, and Grant Wallace.
Computers & Graphics, Special Issue on Mixed Realities - Beyond Conventions, 2001.

Hybrid Sort-First and Sort-Last Parallel Rendering with a Cluster of PCs [pdf] [ps]
Rudrajit Samanta,Thomas Funkhouser, Kai Li, and Jaswinder Pal Singh.
SIGGRAPH/Eurographics Workshop on Graphics Hardware, Interlaken, Switzerland - August, 2000.

Sort-First Parallel Rendering with a Cluster of PCs [pdf] [ps]
Rudrajit Samanta, Thomas Funkhouser, Kai Li, and Jaswinder Pal Singh.
Sketch at SIGGRAPH 2000, New Orleans, Louisiana - July 2000.

Early Experiences and Challenges in Building and Using A Scalable Display Wall System [pdf] [ps]
Kai Li, Han Chen, Yuqun Chen, Douglas W. Clark, Perry Cook, Stefanos Damianakis, Georg Essl, Adam Finkelstein, Thomas Funkhouser, Allison Klein,  Zhiyan Liu, Emil Praun, Rudrajit Samanta, Ben Shedd, Jaswinder Pal Singh, George Tzanetakis and Jiannan Zheng.
IEEE Computer Graphics and Applications, vol 20(4), pp 671-680, 2000.

Load Balancing for Multi-Projector Rendering Systems [pdf] [ps]
Rudrajit Samanta, Jiannan Zheng, Thomas Funkhouser, Kai Li, and Jaswinder Pal Singh.
SIGGRAPH/Eurographics Workshop on Graphics Hardware, Los Angelos, California - August, 1999. 

We investigate a new hybrid of sort-first and sort-last approach for parallel polygon rendering, using as a target platform a cluster of PCs. Unlike previous methods that statically partition the 3D model and/or the 2D image, our approach performs dynamic, view-dependent and coordinated partitioning of both the 3D model and the 2D image. 

Using a specific algorithm that follows this approach, we show that it performs better than previous approaches and scales better with both processor count and screen resolution. Overall, our algorithm is able to achieve interactive frame rates with efficiencies of 55.0% to 70.5% during simulations of a system with 64 PCs.

While it does have potential disadvantages in client-side processing and in dynamic data management---which also stem from its dynamic, view-dependent nature---these problems are likely to diminish with technology trends in the future. 
 
 
 

Interactive visualization of complex 3D data sets has traditionally required tightly-integrated parallel rendering hardware.  However, recently, the performance of PC graphics hardware has been improving at a more rapid rate, and some inexpensive PC graphics accelerators can already deliver performance competitive with high-end graphics processors, while costing orders-of-magnitude less.  The objective of our research is to investigate whether it is possible to construct a high-performance and inexpensive parallel rendering system utilizing a cluster of PCs.  The main challenges are to develop a system architecture and parallel algorithms that provide good speedups by avoiding the performance limitations of network communication.  In this paper, we report our experiences with a prototype system based on a sort-first architecture.  In short, we find that requirements of PC communication can be kept within practical limits of cluster communication if the scene database can be replicated on every PC, to the point where classical problems in parallel rendering, such as imbalanced loads and high ``overlap factors,'' are the dominant issues.  During experiments with our prototype system using 16 PCs, we observe performance around 8 times faster than an SGI InfiniteReality, leading us to conclude that PC clusters provide an attractive, lower-price alternative for high-performance rendering. 

The graphic below describes the general scheme for our parallel rendering system.  The client PC first analyzes the scene and creates and appropriate load-balanced partition.  It then communicates this partition to the server machines which subsequently render the relevant parts of the screen.  Finally, these servers send the rendered pixels to the display PC which puts these pixels together to form the completed frame. 

Multi-projector systems are increasingly being used to provide large-scale and high-resolution displays for next-generation interactive 3D graphics applications, including large-scale data visualization, immersive virtual environments, and collaborative design.  These systems must include a very high-performance and scalable 3D rendering subsystem in order to generate high-resolution images at real time frame rates.  This paper describes a sort-first based parallel rendering system for a scalable display wall system built with a network of PCs, graphics accelerators, and portable projectors.  The main challenge is to develop scalable algorithms to partition and assign rendering tasks effectively under the performance suited for constructing a parallel rendering system running on a PC cluster.

In the 2 images below we show the imbalance generated when each projector simple renders it's own region.  On the left we notice that the 4 machines of the extreme left and right are simple idle.  On the right we notice that almost equal amounts of work has been distributed to all 8 machines in the system. The bars on the bottom right of each image show the load on each of the machines.
 

Simple static partition                                                             KD-Tree partition