Coherency is one of the most important factors that influences the performance of distributed ray tracing systems, especially when object dataflow approach is employed. Designing algorithms that exploit ray-to-ray, spatial, and temporal coherency result in highly scalable systems, as demonstrated by the two algorithms described in this paper. The coherent nature of our algorithms are also delineated by the excellent speedups achieved. Future efforts in parallel rendering should focus on incorporating other types of coherency as well, in our quest to attain the final goal of perfectly linear scalability. 8 compressed cells, 35000 cells will undergo compression and decompression in the case of 1 frame/phase as opposed to 4000 cells in the case of 30 frames/phase. The efficiency and speedup graphs of the ray-front algorithm for different volumes are shown in Figure 8. The algorithm demonstrates about 80% efficiency for 32 processors for all the test volumes. The timings for the 256 3 volumes could not be taken on a single processor due to lack of memory to fit the complete database. The speedups and efficiency are thus measured relative to that of 2 processors. The good speedup also suggests that considerable load-balancing has been achieved using the static block-cyclic scheme. Although the algorithm demonstrate considerable speedup, there is scope to further improve its performance. Currently, the FTBL is determined in a rather conservative manner, and a number of cells are fetched irrespective of whether they are needed in the future or not. If a more accurate determination of these cells is possible, then some cell requests and the associated overheads can be avoided. We are currently trying to accomplish a more efficient scheme for improved latency hiding. Dynamic load balancing for the rayfront algorithm is another area of future research. At the time of running these experiments, all 128 processors on the T3D were not available to a single user. We will report these results in the final paper. Object dataflow approaches are known to take advantage of object-space coherency to reduce the number of misses. For sufficient local memory sizes, this helps to reduce the amount of communication between processors compared with ray-dataflow approaches. The hit ratio can further be increased if frame-to-frame coherence is also exploited. The hit ratio directly effects the overheads incurred by the system. Each object fetched from non-local memory incurs a start-up cost, and if it is not a pre-fetch data acquisition scheme, …

Messages: a mechanism for intergrated communication and computation. 25 cost of implementing demand-driven eduction in the generator is negligible. Clearly, it is important to not only exercise the GLU programming model in expressing diverse applications, but also to develop abstract architectures that are inherently more scalable, thus eeectively exploiting less coarse-grain parallelism. References 1] E.A. Ashcroft. Dataaow and Eduction: Data-driven and demand-driven distributed computation. A descriptive and prescriptive model for dataaow semantics. 24 cessors with relatively medium-grain parallelism, sustaining this eeciency on a large workstation cluster is only possible if remote computing time is at least two orders of magnitude larger than the associated communication time. This study also connrms the fairly obvious intuition that the generator is the bottleneck of the generator/executor abstract architecture. There are two aspects to the generator bottleneck: one is the cost of communicating with all the executors and the other is the time spent in local function execution (i.e., the serial part of the application). And importantly, the generator spends only nominal amount of its time on eductive evaluation of the application kernels that were studied. The main contribution of this chapter is the validation of a dataaow-based approach to programming conventional parallel computers by showing that standard parallel application kernels can be succinctly expressed while reusing existing sequential code and that these kernels exhibit parallel performance which are comparable to those of equivalent kernels developed in lower-level explicit parallel programming systems. In particular, we have described a coarse-grain dataaow system for programming conventional parallel computers. The system is based on a hybrid model of programming (GLU) that consists of a multidimensional dataaow language Lucid for composing implicitly parallel programs using imperatively-speciied functions that specify computations. We have shown how GLU can be used to succinctly compose applications with substantial inherent parallelism from existing sequential code with only nominal modiications. We have shown how GLU programs can be mapped to abstract archi-tectures which then can be compiled to speciic target computers. Using the generator/executor abstract architecture, we have considered the ee-ciency of GLU programs executing in parallel on workstation networks. The speedup eeciency observed (speedup being relative to sequential execution on one processor) suggests that the generator eventually becomes the bottleneck mainly because communication cost and local function execution cost begin to dominate. We also observe that coarser granularity of parallelism means that better scaling of performance. Importantly, the performance study shows that GLU …