As polygonal models rapidly grow to sizes orders of magnitudes bigger than the memory of commodity workstations, a viable approach to simplifying such models is parallel mesh simplification algorithms. A naive approach that divides the model into a number of equally sized chunks and distributes them to a number of potentially heterogeneous workstations is bound to fail. In severe cases the computation becomes virtually impossible due to significant slow downs because of memory thrashing. We present a general parallel framework for simplification of very large meshes. This framework ensures a near optimal utilization of the computational resources in a cluster of workstations by providing an intelligent partitioning of the model. This partitioning ensures a high quality output, low runtime due to intelligent load balancing, and high parallel efficiency by providing total memory utilization of each machine, thus guaranteeing not to trash the virtual memory system. To test the usability of our framework we have implemented a parallel version of R-Simp [Brodsky and Watson 2000].
A new approach for large dataset isosurface extraction is presented. The approach's aim is efficient parallel isosurfacing when the dataset cannot be processed entirely in-core. The approach focuses on reducing the memory requirement and optimizing disk I/O while achieving a balanced load. In particular, an accurate model of isosurface extraction time is exploited to evenly distribute work across processors. The approach achieves processing efficiency by also avoiding unnecessary processing for portions of the dataset that are not intersected by the isosurface. To reduce the redundant computations and the storage requirements, a flexible, variably-granular data structure is utilized, thereby achieving excellent time and space performance.
A number of problems are well suited for volumetric representation for both simulation and storage, however, the large amount of data that needs to be processed and rendered with these volumes makes interactive manipulation extremely challenging. We present a scalable PC cluster system (VG cluster) designed specifically to enable simultaneous volumetric computation and visualization, using compositing hardware devices and the latest PC graphics accelerators. We demonstrate the flexibility and performance of this system with several different applications that include reaction-diffusion simulation, volumetric image processing, and vector field visualization. We also discuss how to improve the visual computing performance of this system with some load balancing techniques.
We present a new visibility-based prefetching algorithm for interactive out-of-core rendering of large models on an inexpensive PC. Using an approximate visibility technique, we can very accurately and efficiently determine which geometry will be visible in the near future and prefetch that geometry from disk before it must be rendered. Our prefetching algorithm is a key part of a visualization system capable of rendering a 13-million triangle model with 99% accuracy at interactive frame rates. Our prefetching algorithm is the first of its kind to be based on a from-point visibility technique, and enables interactive rendering on a commodity PC, as opposed to expensive high-end graphics workstations or parallel machines.
We describe a new set of parallel rendering components for VTK, the visualization toolkit. The parallel rendering units allow for the rendering of vast quantities of geometry with a focus on cluster computers. Furthermore, the geometry may be displayed on tiled displays at full or reduced resolution. We demonstrate an interactive VTK application processing an isosurface consisting of nearly half a billion triangles and displaying on a power wall with a total resolution of 63 million pixels. We also demonstrate an interactive VTK application displaying the same geometry on a desktop connected to the cluster via a TCP/IP socket over 100BASE-T Ethernet.
Recently developed interactive ray tracing systems combine the high performance of todays CPUs with new algorithms and implementations to achieve a flexible and high-performance rendering system offering high-quality, but nonetheless interactive 3D graphics. However, due to its history in offline rendering, interactive ray tracing is usually limited to static scenes and simple walkthroughs. In order to become truly interactive ray tracing must efficiently support dynamic scenes. We present a simple and practical method that allows to interactively ray trace dynamic scenes in a distributed PC cluster environment. Our method separates the scene into independent objects with common properties concerning dynamic updates - similar to OpenGL display lists and scene graph libraries. Three classes of objects are distinguished: static objects are treated as before, objects undergoing affine transformations are handled by transforming rays, and objects with unstructured motion are rebuilt whenever necessary. We present performance and scalability results of our system using a variety of test scenes stressing a wide range of dynamic behaviour.
We introduce a multilayered image cache system that is designed to work with a pool of rendering engines to facilitate a frame-less, asynchronous rendering environment for scientific visualization. Our system decouples the rendering from the display of imagery at many levels; it decouples render frequency and resolution from display frequency and resolution; allows asynchronous transmission of imagery instead of the compute-send cycle of standard parallel systems; and allows local, incremental refinement of imagery without requiring all imagery to be rerendered. Interactivity is accomplished by maintaining a set of image tiles for display while the production of imagery is performed by a pool of processors. The image tiles are placed in fixed places in camera (vs. world) space to eliminate occlusion artifacts. Display quality is improved by increasing the number of image tiles and imagery is refreshed more frequently by decreasing the number of image tiles.
Image space occlusion culling is an useful approach to reduce the rendering load of large polygonal models. Like most large model techniques, it trades overhead costs with the rendering costs of the possibly occluded geometry. Meanwhile, modern graphics hardware supports occlusion culling, whereas they associate a significant query overhead, which hurts in particular, if the occlusion culling query itself was unsuccessful. We propose the occupancy map - a compact, cache-optimized representation of coverage information - to reduce the number of costly but unsuccessful occlusion culling queries and to arrange multiple occlusion queries. The information of the occupancy map is used to skip an occlusion query, if the respective map area is not yet set $the respective area has not yet received rendered pixels -, hence an occlusion query would always return not occluded. The remaining occlusion information is efficiently determined by asynchronous multiple occlusion queries with hardware-supported query functionality. To avoid redundant results, we arrange these multiple occlusion queries according to the information of several occupancy maps. Our presented technique is conservative and benefits from a partial depth order of the geometry.
While commodity computing and graphics hardware has increased in capacity and dropped in cost, it is still quite difficult to make effective use of such systems for general-purpose parallel visualization and graphics. We describe the results of a recent project that provides a software infrastructure suitable for general-purpose use by parallel visualization and graphics applications. Our work combines and extends two technologies: chromium, a stream-oriented framework that implements the OpenGL programming interface; and OpenRM scene graph, a pipelined-parallel scene graph interface for graphics data management. Using this combination, we implement a sort-first, distributed memory, parallel volume rendering application. We describe the performance characteristics in terms of bandwidth requirements and highlight key algorithmic considerations needed to implement the sort-first system. We characterize system performance using a distributed memory parallel volume rendering application, and present performance gains realized by using scene specific knowledge to accelerate rendering by reducing network traffic. The contribution of this work is an exploration of general-purpose, sort-first architecture performance characteristics as applied to distributed memory, commodity hardware, along with a description of the algorithmic support needed to realize parallel, sort-first implementations.
We have constructed a distributed parallel ray tracing system that interactively produces isosurface renderings from large data sets on a cluster of commodity PCs. The program was derived from the SCI Institute's interactive ray tracer (*-Ray), which utilizes small to large shared memory platforms, such as the SGI Origin series, to interact with very large-scale data sets. Making this approach work efficiently on a cluster requires attention to numerous system-level issues, especially when rendering data sets larger than the address space of each cluster node. The rendering engine is an image parallel ray tracer with a supervisor/workers organization. Each node in the cluster runs a multithreaded application. A minimal abstraction layer on top of TCP links the nodes, and enables asynchronous message handling. For large volumes, render threads obtain data bricks on demand from an object-based software distributed shared memory. Caching improves performance by reducing the amount of data transfers for a reasonable working set size. For large data sets, the cluster-based interactive ray tracer performs comparably with an SGI Origin system. We examine the parameter space of the renderer and provide experimental results for interactive rendering of large (7.5 GB) data sets.
We describe a feature extraction and tracking algorithm for AMR (adaptive mesh refinement) datasets that operates within a distributed computing environment. Because features can span multiple refinement levels and multiple processors, tracking must be performed across time, across levels, and across processors. The resulting visualization is represented as a "feature tree". A feature contains multiple parts corresponding to different levels of refinements. The feature tree allows a viewer to determine that a feature splits or merges at the next refinement level, and allows a viewer to extract and isolate a multilevel isosurface and watch how that surface changes over both time and space. The algorithm is implemented within a computational steering environment, which enables the visualization routines to operate on the data in-situ (while the simulation is ongoing).
Adaptive Mesh Refinement (AMR) is a technique used in numerical simulations to automatically refine (or de-refine) certain regions of the physical domain in a finite difference calculation. AMR data consists of nested hierarchies of data grids. As AMR visualization is still a relatively unexplored topic, our work is motivated by the need to perform efficient visualization of large AMR data sets. We present a software algorithm for parallel direct volume rendering of AMR data using a cell-projection technique on several different parallel platforms. Our algorithm can use one of several different distribution methods, and we present performance results for each of these alternative approaches. By partitioning an AMR data set into blocks of constant resolution and estimating rendering costs of individual blocks using an application specific benchmark, it is possible to achieve even load balancing.
Parallel volume rendering offers a feasible solution to the large data visualization problem by distributing both the data and rendering calculations among multiple computers connected by a network. In sort-last parallel volume rendering, each processor generates an image of its assigned subvolume, which is blended together with other images to derive the final image. Improving the efficiency of this compositing step, which requires interprocesssor communication, is the key to scalable, interactive rendering. The recent trend of using hardware-accelerated volume rendering demands further acceleration of the image compositing step. We present a new optimized parallel image compositing algorithm and its performance on a PC cluster. Our test results show that this new algorithm offers significant savings over previous algorithms in both communication and compositing costs. On a 64-node PC cluster with a 100BaseT network interconnect, we can achieve interactive rendering rates for images at resolutions up to 1024x1024 pixels at several frames per second.
The recent advance of graphics hardware allowed real-time volume rendering of structured grids using a 3D texturing approach. The next challenging problem is to extend the algorithms to time-varying volumetric data (4D functions), which consume more storage and are not directly supported in current graphics hardware. Here we present a new visualization technique that includes (1) a compression scheme of sparse 4D functions into 3D textures, and (2) a visualization algorithm that decompress the stored data from the 3D textures using the programmability of fragment shaders, allowing real-time visualization of such data. We illustrate the system in action with datasets resulting from computational fluid dynamics simulations.
With the recent advances in commodity graphics hardware performance, PC clusters have become an attractive alternative to traditional high-end graphics workstations. The main challenge is to develop parallel rendering algorithms that work well within the memory constraints and communication limitations of a networked cluster. Previous systems have required the entire 3D scene to be replicated in memory on every PC. While this approach can take advantage of view-dependent load balancing algorithms and thus largely avoid the problems of inter-process communication, it limits the scalability of the system to the memory capacity of a single PC. We present a k-way replication approach in which each 3D primitive of a large scene is replicated on k out of n PCs (k/spl Lt/n). The key idea is to support 3D models larger than the memory capacity of any single PC, while retaining the reduced communication overheads of dynamic view-dependent partitioning. In this paper, we investigate algorithms for distributing copies of primitives among PCs and for dynamic load balancing under the constraints of partial replication. Our main result is that the parallel rendering efficiencies achieved with small replication factors are similar to the ones measured with full replication. By storing one-fourth of Michelangelo's David model (800 MB) on each of 24 PCs (each with 256 MB of memory), our system is able to render 40 million polygons/second (65 % efficiency).
This paper presents a visualization technique based on particle tracking. The technique consists in defining a set of points distributed on a closed surface and follow the surface deformations as the velocity field changes in time. Deformations of the surface contains information about dynamics of the flow; in particular, it is possible to identify zones where flow stretching and foldings occur. Because the points on the surface are independent each other, it is possible to calculate the trajectory of each point concurrently. Two parallel algorithms are studied; the first one for a shared memory Origin 2000 supercomputer and the second one for a distributed memory PC cluster. The technique is applied to a fluid moving by natural convection inside a cubic container.
Due to the impressive price-performance of today's PC-based graphics accelerator cards, Sandia National Laboratories is attempting to use PC clusters to render extremely large data sets in interactive applications. This paper describes a sort-last parallel rendering system running on a PC cluster that is capable of rendering enormous amounts of geometry onto high-resolution tile displays by taking advantage of the spatial coherency that is inherent in our data. Furthermore, it is capable of scaling to larger sized input data or higher resolution displays by increasing the size of the cluster. Our prototype is now capable of rendering 120 million triangles per second on a 12 mega-pixel display.
