Introduction

Parallel processing has recently been used for speeding up volume rendering. Several factors seem to have sparked this trend:

• Volume data sets are usually quite large. High-quality volume rendering normally takes an unacceptably long time when done on uniprocessors.

• Acceleration techniques, such as template-based [YK92] or shear-warp rendering [LL94], tend to increase memory requirements and decrease the options the user has during rendering (the cost of perspective projection and full color rendering is non-existent in some techniques, and too expensive in others).

• Greater availability of parallel machines and large networks of workstations.

In a nutshell, the need for faster rendering of large data sets coupled with the wider availability of parallel machines and distributed environments have made parallel volume rendering a very important research area.

Recent work in parallel rendering can be divided broadly into two main categories: algorithms and systems. Algorithm researchers have concentrated on the design of highly efficient parallel volume rendering algorithms [SS91,MPS92,MPHK94,Hsu93,CC93,Neu93,NL92,WS93]. Their work has been concerned primarily with optimizing performance with respect to constant problem-size (CPS) scaling [SHG93] and has largely ignored systems issues. Lately, some work has been done in developing distributed rendering systems that can make use of available parallel resources [ABSS94,AMD94,RLGB94]. Unfortunately, this later work has focused on developing machine-dependent, self-contained applications that make only limited use of parallel processing, usually using naive parallel strategies. No work yet has addressed the problem of creating a toolkit for building more complex applications.

In this paper we concentrate on:

1. Introducing the PVR system, a component approach to building a distributed volume rendering system. Its unique load balancing scheme provides a continuum of cost/performance parameters that can be used to optimize rendering speed. The major goals of PVR are to achieve a level of portability and performance beyond that of other available systems and to provide a platform that can be used for further development. Using PVR, it is much simpler to build portable, high performance, complex distributed visualization systems (Figure 1).

2. Studying limits to interactivity and real-time performance achievable with current massively parallel machines.

  
Figure 1: The relationship of Distributed Visualization Environment (DVE) systems and PVR.

PVR was designed to provide DVEs (Distributed Visualization Environments) with the following characteristics:

• Transparency - PVR hides most of the hardware dependencies from the DVEs and the user.

• Flexibility - PVR provides several mechanisms by which the DVE can control rendering, in particular, a very simple and efficient load balancing scheme.

• Reliability - PVR provides the very basic functionalities which a DVE can be built upon, making it easier to avoid and find bugs and inconsistencies when developing DVEs. It also abstracts most of the distributed environment simplifying DVE implementation.

• Performance - PVR provides a high speed ray caster and mechanisms to fine tune performance for any given machine configuration.

• Scalability - The PVR rendering algorithms scale very well.

• Predictability - PVE provides mechanisms for estimating rendering performance. With this information, real-time DVEs can be more easily implemented.

• Extensibility - The PVE architecture can be easily extended, making it easy for the DVE to add new functionality.

It is well known that system complexity always limits the reliability of large software projects. Distributed systems exacerbate this problem with the introduction of asynchronous and non-local communication. With all of this in mind, we use a component approach to developing PVR. All components are independent of each other but can be easily linked together by communication channels using well-defined interface calls. We chose to use Tcl/Tk [Ous93] as the system glue. Tcl (Tool command language) is a script language designed to be used as a generic language in application programs. It is easily extendable with new user commands (in C or Tcl) and coupled with the graphical environment Tk, it is a powerful graphical user interface system. Using different Tk toolkits, one can create a full DVE from our components with minimal addition of C and interface code. The use of the Tcl/Tk, which are well-designed, debugged application language and graphical environment reduce system complexity.

Machine limitations, such as network latency and throughput, are the greatest obstacles to achieving high performance. As different renderers have different responses over a variety of networks, our system currently supports one ray casting renderer with two different space decomposition schemes [MPHK94,SK94]. The renderer is very portable, it can run over TCP/IP sockets, Intel iPSC/860 and Paragon; and a PVM (Parallel Virtual Machine) [GBD94] port is currently underway. Other renderers can be easily added, and we are currently adding support for irregular grid rendering. The system is a multiprocess application, organized in a client/server paradigm, where one client can be connected to several servers. Each server currently creates a renderer abstraction, where it receives high level rendering requests and produces and outputs a video stream in response.

DVEs can be easily developed by making use of the client/server metaphor. The DVE application is the client while the parallel resources act as the servers. DVE developed using Tcl/Tk is very portable, as Tcl/Tk has ports for almost all the operating systems available, and TCP/IP (our current communication protocol) is virtually universal. We give more details on the primitives from which DVEs can be built in Section 2, which describes the PVR system and its components, specifically the renderer and the PVR Tcl/Tk core. Section 3 provide details on the interactive performance of PVR, with specific results for the Intel Paragon using PVR.