Problem Overview

Ray-tracing refers to the rendering technique where one or more rays are cast for every pixel on the screen. Each time the ray encounters geometry, new rays can be spawned to create additional lighting effects, such as soft shadows, ambient occlusion, or specular reflections. Ray-tracing produces pictures that are far more photo-realistic than those produced via rasterization -- the technique used with OpenGL -- since it can model more of the paths from light emitters. Further, studies have shown that these more realistic lighting approximations can better aid in the interpretation of scientific data compared to the more primitive rasterization lighting models.

Rasterization has been much more widely used than ray-tracing because it is must faster. However, recent trends are causing ray-tracing performance to be increasing viable:

• First, the amount of work to do for rasterization is typically dominated by the geometry (i.e., number of triangles), while the amount of work to do for ray-tracing is typically dominated by the number of rays (i.e., the number of pixels). Trends in scientific computing have more and more complex scenes, while the number of pixels is staying approximately constant.
• Second, the number of cores available on a node is increasing quickly. Many-core nodes (100s to 1000s of cores per node) are increasingly available, whether through GPUs or the Intel Xeon Phi. These additional cores are ideal for ray-tracing workloads. Further, there is concern that rasterization libraries (i.e., OpenGL or its software counterpart Mesa3D) will not be ubiquitously available on the increasingly-varied many-core platforms in the future, although they have been in the past.

Results To Date

GraviT will combine user interface, parallel scheduling algorithms, and optimized ray-tracing engines. When possible, hardware-specific engines such as Embree or Optix will be used. But part of GraviT's mission is to provide portable performance over all architectures; developers who use the GraviT framework should feel future-proofed against architectural change. To support this, we have been developing a ray-tracing engine with portable performance over many architectures.

EAVL is a visualization library that aims to provide portable performance. This performance is achieved by providing abstractions that can be easily ported over many-core architectures. The abstractions are that of data-parallel primitives: operations that can be carried out in time proportional to the logarithm of the input size on a vector machine. Examples of such operations are gather, scatter, map, and reduce. Developers then implement algorithms by composing these data-parallel primitives. This approach is a departure from traditional approaches (i.e., writing CUDA code directly), but it is effective in enforcing development that is proven to be parallelizable. To date, we have produced a functioning ray-tracer using these data-parallel operations. This ray-tracer will become part of GraviT and provide GraviT with a way for porting to architectures that are not covered by known ray-tracers, such as Embree or Optix.

CDUX People

Garrett Morrison
M.S. Student (alum)

Matt Larsen
Ph.D. Student (alum)

Hank Childs
CDUX Director

External Collaborators

• Paul Navratil, TACC
• Jeremy Meredith, ORNL

Publications

Ray-Tracing Within a Data Parallel Framework Matthew Larsen, Jeremy Meredith, Paul Navratil, and Hank Childs IEEE Pacific Visualization, Hangzhou, China, April 2015 [PDF]     [BIB]

Dynamic Scheduling for Large-Scale Distributed-Memory Ray Tracing Paul Navratil, Donald Fussell, Calvin Lin, and Hank Childs EGPGV, Cagliari, Italy, May 2012 Best Paper [PDF]     [BIB]