Garuda: A Scalable Tiled Display Wall Using Commodity PCs

Abstract

Cluster-based tiled display walls can provide cost-effective and scalable displays with high resolution and a large display area. The software to drive them needs to scale too if arbitrarily large displays are to be built. Chromium is a popular software API used to construct such displays. Chromium transparently renders any OpenGL application to a tiled display by partitioning and sending individual OpenGL primitives to each client per frame. Visualization applications often deal with massive geometric data with millions of primitives. Transmitting them every frame results in huge network requirements that adversely affect the scalability of the system. In this paper, we present Garuda, a client-server-based display wall framework that uses off-the-shelf hardware and a standard network. Garuda is scalable to large tile configurations and massive environments. It can transparently render any application built using the Open Scene Graph (OSG) API to a tiled display without any modification by the user. The Garuda server uses an object-based scene structure represented using a scene graph. The server determines the objects visible to each display tile using a novel adaptive algorithm that culls the scene graph to a hierarchy of frustums. Required parts of the scene graph are transmitted to the clients, which cache them to exploit the interframe redundancy. A multicast-based protocol is used to transmit the geometry to exploit the spatial redundancy present in tiled display systems. A geometry push philosophy from the server helps keep the clients in sync with one another. Neither the server nor a client needs to render the entire scene, making the system suitable for interactive rendering of massive models. Transparent rendering is achieved by intercepting the cull, draw, and swap functions of OSG and replacing them with our own. We demonstrate the performance and scalability of the Garuda system for different configurations of display wall. We also show that the server and network loads grow sublinearly with the increase in the number of tiles, which makes our scheme suitable to construct very large displays.

Co-processor acceleration of an unmodified parallel solid mechanics code with FEASTGPU

“…GPU-enhanced systems have traditionally been deployed for parallel rendering (Humphreys et al, 2002;van der Schaaf et al, 2006) and scientific visualisation (Kirchner et al, 2003;Nirnimesh et al, 2007). One of the largest examples is 'gauss', a 256 node cluster installed by GraphStream at Lawrence Livermore National Laboratory (GraphStream, Inc., 2006).…”

Distributed massive model rendering

“…Specific examples include rendering every Nth frame or distributing primitives to different pipelines based on screen space. Some of these systems and APIs like Chromium [8], Garuda [9], NetJuggler [2], CGLX [3] and Equalizer [5] provide scalable rendering on shared memory systems.…”

“…The Garuda system [9] provides a scalable, geometry managed display wall. This is a cluster-based tiled display wall which uses an Adaptive Culling algorithm to determine the objects visible to each display-tile.…”

Scalable rendering of massive triangle meshes on light field displays

“…The approach is more general, and data distribution can follow sort-first, sort-last or hybrid strategies [15,16]. Data can be distributed in a transparent manner by intercepting calls at the graphics API level [11] or at the display manager level [17], as well as by implementing data distribution features at the scene graph level, as in OpenSG [18], Szyzygy [19], Blue-C [20], and Garuda [21]. Managing data distribution at the scene description level requires more application programmer effort, but offers more optimization opportunities, since data transfers can be performed at coarser scales, and high-level object structures can be exploited by culling algorithms to reduce network requirements.…”

“…Managing data distribution at the scene description level requires more application programmer effort, but offers more optimization opportunities, since data transfers can be performed at coarser scales, and high-level object structures can be exploited by culling algorithms to reduce network requirements. Our approach follows an object-based server-push philosophy, similar to the one employed in Garuda [21], that exploits client and server object caches and multicasting to reduce network load. However, our system is tailored to render massive models on a light field display, in which all rendering clients almost fully share the same view, and must use specialized techniques to adapt and project geometry onto the display.…”