Shell: Accelerating Ray Tracing on GPU

Transcription

1 Shell: Accelerating Ray Tracing on GPU Kai Xiao 1, Bo Zhou 2, X.Sharon Hu 1, and Danny Z. Chen 1 1 Department of Computer Science and Engineering, University of Notre Dame 2 Department of Radiation Oncology, University of Maryland School of Medicine Abstract. Ray tracing is a fundamental process in many areas including computer graphics and medical applications. Different hierarchical acceleration structures for ray tracing have been developed. Such ray tracing approaches executed on advanced many-core processors such as GPU, however, turns out to be memory bounded due to their frequent search operations in the hierarchical structures. This paper proposes a novel acceleration approach (called Shell) aiming to tackle the mismatch between the ray tracing behaviors and the GPU memory features. The approach can work with any common spatial hierarchical (e.g., Kd-trees) representation of a ray tracing scene. It organizes the information of adjacent regions into memory chunks which can be read by only one memory transaction in GPU, and guarantees the minimum number of memory transactions for each ray traversal. Performance evaluations of the Shell approach based on real medical images show that it is 4X to 7.8X faster than the existing most advanced Kd-tree based ray tracing approach on GPU. The performance gain may offer significant improvements for other GPU based algorithms that heavily depend on ray tracing, such as interactive rendering and radiation dose calculation. 1 Introduction Ray tracing is a crucial component in a wide range of applications such as computer graphics (e.g., [9, 10, 12]) and radiotherapy (e.g., [1, 4, 8]). In graphics processing, a massive number of rays from light sources or scene objects often need to be traced along their trajectories. If a ray hits an object, it is terminated and secondary rays are generated [3]. In radiotherapy, ray tracing is required in virtually all dose calculation methods for estimating the total amount of radiation energy delivered. Here, ray tracing is used to either determine particle interaction sites or to spatially adjust energy diffusion around interaction sites. Despite its importance, ray tracing is well known to be computationally intensive [2, 5]. Extensive studies have been conducted from both the algorithm and platform perspectives. From the algorithm view point, many traversal acceleration structures, such as Kd-trees [10] and Bounding Volume Hierarchies (BVH) [7], have been proposed. The fundamental idea behind these approaches is to intelligently organize the scene objects so that efficient search and hit-test can be achieved. For ray tracing in uniform grids, the regular spatial (voxel) structure allows fast access of objects with implicit addressing mechanisms. Hence, improvements are mainly gained from low-level operation optimization. Siddon s algorithm [11] and the 3DDDA algorithm [3] are good examples.

2 2 Another direction to improve ray tracing performance is to fully exploit the potential of the given hardware. As we enter the many-core era, Graphics Processing Units (GPU) are increasingly used in ray tracing. For ray tracing in uniform grids, Greef et al. [4] implemented Siddon s algorithm [11] on GPU and obtained a 2.1X to 10.1X speedup over a single-threaded CPU implementation. Due to its fast voxel traversal feature, the 3DDDA algorithm [3] has also been employed in multiple GPU-based dose calculation approaches [8, 13]. For ray tracing in non-uniform grids, there exist many studies, especially on Kd-tree based approaches. Major obstacles of porting existing Kd-tree based algorithms onto GPU are that GPU lacks of efficient stack support and can suffer from long off-chip memory access latency (400 to 600 times slower than a computational operation [2]). Hence, lots of efforts have been devoted to developing efficient stackless Kd-tree ray tracing algorithms, including Kd-restart [5, 6], Kd-backtrack [5], and Kd-rope [9]. The Kd-rope method is considered the best since it is 30%-50% faster than other approaches [10]. Unfortunately, all these algorithms eventually have to search the Kd-tree repeatedly to detect the next traversing region. For a Kd-tree of height H, each search visits O(H) tree nodes on average. Since search operations need to read every node visited into the on-chip memory, and each reading requires multiple memory transactions due to the information size of a node, the performance of existing stackless GPU ray tracing algorithms cannot efficiently utilize GPU s memory bandwidth. In this paper, we propose a new acceleration structure, called Shell, to improve the ray tracing performance on GPU. Unlike Kd-trees which are originally a general-purpose structure, our proposed structure is specifically designed for ray tracing and for tackling the mismatch between ray tracing behaviors and the GPU memory architecture. On one hand, our Shell structure focuses on the neighboring relationship among scene regions instead of the inclusive relationship which is explored in hierarchical structures like Kd-trees and BVH. On the other hand, decomposition results for all hierarchical structures can be used by our approach while the compactness of the scene representation is preserved. The innovative idea of Shell is to provide a self-containing representation for each region so that it allows immediate access of any neighboring region without traversing a hierarchical structure. With the proposed Shell structure, the inter-region traversal completely avoids any hierarchical search steps, which are originally necessary and expensive in hierarchical acceleration structures. Consequently, for a ray traversing k regions in a decomposed scene, our Shell approach performs exactly k memory transactions. In comparison, any Kd-tree based method would use O(kH) memory transactions for a tree height of H. We evaluate the effectiveness of our Shell approach by comparing it with the Kd-rope method in [9], which is considered to be the most advanced for GPU ray tracing. We have used real medical images in our evaluation. Our experimental results show that, for different ray configurations, ray tracing based on the Shell approach is 4X to 7.8X faster than the Kd-rope based ray tracing. Such speedup is significant for applications, such as those from computer graphics and radiotherapy, where ray tracing is a major performance bottleneck.

3 3 Fig. 1. An example for ray tracing in 2D SR structure 2 Shell Structure The Shell structure aims to capture information needed for ray tracing in a given scene. Its key idea is to use a small amount of memory to store some essential information such that the neighboring regions of any region can be quickly accessed during the ray traversal process. The Shell structure makes use of two basic assumptions for the scene description. First, a scene is given on a uniform grid system. Second, the scene is divided into non-overlapping regions each containing a contiguous set of voxels. The voxels within a region share some common features such as density. Both assumptions hold for ray tracing environments in many medical, imaging and other applications. Without loss of generality, we let the regions be represented as axis-aligned boxes. Note that such region-based partitions can be easily obtained for a given scene by using hierarchical decomposition methods such as Kd-trees or Octrees. Figure 1(a) illustrates an example of a scene with 7 regions where the voxels along the region boundaries are shown while the internal voxels are omitted. In traditional hierarchical structures, a data structure associated with a region contains pointers to hierarchically related regions. For the example in Figure 1(a), a 5-level Kd-tree representation of the scene is given in Figure 1(b). Based on this representation, for the traversal example of ray (P 1, P 2 ) in Figure 1(a), 2 tree nodes are visited for finding region A, 2 for traversing from region A to B, and another 4 from region B to G. Therefore, the traversal for ray (P 1, P 2 ) in this Kd-tree needs to visit 8 nodes. Since a node s size of a Kd-tree is typically larger than the size of a single memory transaction in GPU, each visit of a tree node generates multiple memory transactions. In our Shell structure, instead of using pointers for referencing the relationship between adjacent regions, we associate a Shell-Region (SR) with each region. Each SR consists of a set of Shell-Units (SUs) corresponding to the voxels along the boundary of the region for storing information about the region s neighbor-

4 4 ing regions. Figure 1(a) illustrates the Shell structure for the 7 regions, where the shaded squares along the boundary of each region are the SUs. By judiciously storing the neighboring region information, this Shell structure can effectively eliminate the need for traversing tree nodes in hierarchical structures such as a Kd-tree for ray tracing and hence dramatically reduce the number of memory transactions. As a quick example, in Figure 1(a), ray (P 1, P 2 ) exits region A at (8,10). If we can read SU(8,10) with one memory transaction to acquire region B s information, the ray tracing process will immediately proceeds to region B. Furthermore, if we can determine the next exit location (10,15) of ray (P 1, P 2 ) from region B as well as the memory location of SU(10,15), we can traverse from region B to G again with only one memory access. Compared with the Kd-tree based traversal discussed above, the Shell structure reduces the number of memory accesses from 8 to 2 for tracing ray (P 1, P 2 ). From the above discussion, it is clear that the efficiency of the Shell structure relies on three crucial features. First, information stored at each SU must be sufficient for describing its neighboring region s information. Second, the data at an SU must be obtainable with a single memory transaction. Third, the address of an SU must be easily computable. Below, we provide additional details on how our Shell structure design fulfills these three requirements. An SU is designed to contain all necessary information about its neighboring region such that the data can be used to determine the attribute of the region as well as to locate the memory address of the next SU that a given ray will intersect. Specifically, this information includes the neighbor s geometric data, associated attribute and the memory addresses of the associated SUs in this region. Since a region is an axis-aligned box, its geometric data can be captured by only two 3D points: R 0 (the smallest values of x, y, and z) and R 1 (the largest values of x, y, and z). The associated attribute is different for different applications. For example, in the radiation dose calculation application, the attribute is the region s average density; in computer graphics, it is a list of objects located inside the region. To avoid the need of maintaining in each SU multiple memory addresses of SUs in the neighbor region, we resort to an ordered arrangement for storing SUs in the memory. With this order, each SU only stores the memory address of the SU located at R 0 in the neighboring region. To retrieve other SUs, we use the memory address of the SU at R 0 as the base address to compute the other SUs memory offsets according to their coordinates. To guarantee that an SU can be loaded by one memory transaction, the size of each SU should be no bigger than the size of a single memory transaction in the GPU architecture. In NVIDIA s GPU, the maximum size of an off-chip memory transaction is 128 bits (16 bytes). With this constraint, we design each SU as a 16-byte aligned structure, which contains two integers for the region s geometric data (R 0 and R 1 ), one pointer for the memory address of the SU at R 0, and one 32-bit element (integer, or float, or pointer) for the attribute. In order to facilitate the SU address calculation, we need a deterministic way of arranging all the SUs in an SR. In a 3D scenario, there are three types of SUs: (1) Face SU (FSU), which is located on a region s face and has 1 adjacent region;

5 5 Fig. 2. Illustration of (a) an Edge Shell Unit and (b) a Corner Shell Unit (2) Edge SU (ESU) (see Figure 2(a)), which is located on a region s edge and has 3 adjacent regions; (3) Corner SU (CSU) (see Figure 2(b)), which is located at a region s corner and has 7 adjacent regions. In each region, there are 6 faces, 12 edges and 8 corners. We arrange the SUs following the order of FSUs first, then ESUs, and finally CSUs. For each type of SUs, we arrange them according to the increasing order of their x, y, and z coordinates, respectively. Given the above SU arrangement, we can readily calculate the memory address of any SU at a point P i. Let (x i, y i, z i ) represent the coordinates of point P i and (x 0, y 0, z 0 ) for point R 0 representing the smallest x, y and z coordinates of the same region. The memory address of SU at (x i, y i, z i ) is M 0 + O i, where M 0 is the memory address of the SU at (x 0, y 0, z 0 ). The SU s type can be determined by checking the ray intersection coordinates. Let D x, D y and D z be the lengths of the region along the x, y and z directions, respectively. O i can be computed as follows. (We only show some representative formula due to the page limit.) If point P i is on a face (i.e., an FCU) parallel to the x plane, then O i = 2(D x D y + D x D z ) + x i x 0 D x D y D z + (z i z 0 ) D y + (y i y 0 ). (1) If point P i is on an edge (i.e., an ESU) parallel to the x-axis, we have O i = 2(D x D y + D x D z + D y D z ) + 4(D z + D y ) +(2 z i z 0 D z + y i y 0 D y ) D x + (x i x 0 ). (2) If point P i is at a corner (i.e., a CSU), we have O i = 2(D x D y +D x D z +D y D z )+4(D z +D y +D x )+4 z i z 0 +2 y i y 0 + x i x 0. D z D y D x (3) When performing ray tracing for a ray, the first entering and the last exiting points of the scene need special attention as they impact how we start and end a ray tracing process. To efficiently handle these cases, we further introduce two additional types of SUs: Inward SUs (ISUs) and Outward SUs (OSUs) on the boundary of the scene. Details of these are omitted due to the page limit. 3 Ray Tracing with the Shell Structure Based on the Shell structure introduced above, we can accomplish ray tracing by using only one memory access per region penetrated by a ray. This is shown in Algorithm 1. Specifically, the traversal of a ray starts from determining the

6 6 Algorithm 1 Ray Tracing with Shell Structure 1: Input: ray R, scene S, memory location M 0 of the first voxel in S. 2: Output: list of regions that R penetrates, L. 3: more region to trace := true; 4: while more region to trace == true do 5: compute (x i, y i, z i ) where R intersects the next region in S; 6: M i = M 0 + O i ; // compute M i of SU at (x i, y i, z i ) 7: access memory location at M i ; 8: if M i does not contain an OSU then 9: update M 0 with the information read from M i; 10: append the attribute read from M i to L; 11: else 12: more region to trace := false; 13: end if 14: end while coordinates of the first intersection voxel between the ray and the scene (Line 5). Based on this coordinate information and the initial memory location of the scene, the memory address of the SU corresponding to the voxel is computed using one of the expressions given in (1) (3) (Line 6). The information for the adjacent region is then obtained by one memory transaction (Line 7) and the necessary variables are updated. The process continues until the ray intersects a voxel that corresponds to an OSU, and the traversal is complete. We briefly analyze the complexity of Algorithm 1 below. Since computation operations in GPU only take 1-8 cycles while an off-chip (i.e., device) memory transaction takes cycles [2], the amount of computation (for determining memory addresses) in Algorithm 1 is negligible compared to the memory access time. For a ray traversing through M regions, Algorithm 1 only needs to issue M off-chip memory transactions for accessing M SUs. Its time complexity hence is O(M). As a comparison, existing hierarchical-structure based ray tracing algorithms all have a time complexity of O(M logn), where N is the number of leaf nodes (regions) in the hierarchical structure. 4 Evaluation To evaluate the Shell approach, we implemented two GPU ray tracing programs based on the Shell structure and Kd-rope structure, respectively. Their performances are then compared using different images and ray sets on the NVIDIA C1060 GPU platform (240 cores, 1.3GHz, 4GB device memory). The evaluation metrics include the speedup of the total GPU execution time and the speedup of the off-chip memory access time. An Octree decomposition program is developed to construct the hierarchical structures of the images, where the user can specify a standard deviation threshold to indicate the maximum variation allowed in each region. In our experiment, 3 different images (Images 1-3) are used. The decomposition settings and results are shown in Table 1, where N r is the average number of voxels per region.

7 7 Table 1. Octree decomposition settings and results Description Size Threshold N r Image 1 artificial lung phantom % 8.6 Image 2 breast image % 15.1 Image 3 breast image % 4.3 Table 2. Configuration of ray sets Description Direction deviation Origins P 0 RC-1 parallel rays = 0 (0, 5, 5) P 0 (0, 10, 10) RC-2 parallel rays = 0 (0, 0, 0) P 0 (0, 30, 30) RC-3 distributed rays = 1 (0, 10, 0) P 0 (0, 40, 20) RC-4 random rays = random P 0 = random To investigate the impact of ray distributions on performance, 4 sets of rays (25600 rays in each set) are used in the experiment. The settings of these sets are given in Table 2. All rays originate from the surface of the image volume and traverse through the image along their directions. The rays in the first two sets (RC-1 and RC-2) follow the same direction (which allows a large number of regions to be penetrated), but have their origins distributed evenly within different ranges (with RC-1 having a smaller range than RC-2). Rays in RC-1 and RC-2 hence help reveal how the spatial distribution of ray origins effects the performance. The third set (RC-3) emulates the scenarios where rays are evenly distributed in the 3D spherical space, a case often found in radiotherapy applications. The last set (RC-4) consists of randomly generated rays. Table 3 shows the performance results for the Shell based and Kd-rope based ray tracing programs. Comparing with the Kd-rope, our Shell acceleration approach reduces the off-chip memory reading time by about 5.3X to 8.2X, and improves the total GPU execution time by about 4.0X to 7.8X. Furthermore, tracing more divergent rays (e.g., those in RC-2, RC-3 and RC-4 are more divergent than those in RC-1) takes more execution time but benefits more from Table 3. Ray tracing performance results and comparison Image 1 Image 2 Image 3 RC-1 RC-2 RC-3 RC-4 RC-1 RC-2 RC-3 RC-4 RC-1 RC-2 RC-3 RC-4 Shell Kd-rope MEM SP EX SP GPU execution time (ms) of the program with corresponding structures. 2 Speedups of Shell s off-chip memory reading over Kd-rope s. 3 Speedups of Shell s total GPU execution time over Kd-rope s.

8 8 our Shell scheme. These results demonstrate that the Shell approach is more efficient than the existing most advanced hierarchical approach for ray tracing. 5 Conclusion In this paper, we introduce Shell, a new acceleration approach for ray tracing on GPU. The Shell structure can be built from any spatial and hierarchical structures such as Kd-trees. Our new ray tracing algorithm based on the Shell structure is able to conduct the ray traversal procedure without any search operations. Compared with the existing best hierarchical acceleration approaches for GPU ray tracing, our Shell based ray tracing approach achieved 4X to 7.8X speedup for different ray configurations. References 1. Ahnesjo A., (1989), Collapsed Cone Convolution of Radiant Energy for Photon Dose Calculation in Heterogeneous, Med. Phys., 16(4), Aila T., and Laine S., (2009) Understanding the Efficiency of Ray Traversal on GPUs, Proceedings of the Conference on High Performance Graphics, Amanatides J., and Woo A., (1987), A Fast Voxel Traversal Algorithm for Ray Tracing, In Eurographics, de Greef M., Crezee J., van Eijk J., Pool R., and Bel A., (2009), Accelerated Ray Tracing for Radiotherapy Dose Calculations on a GPU, Med. Phys., 36(9), Foley T., and Sugerman J., (2005), Kd-tree Acceleration Structures for a GPU Raytracer, Proceedings of the ACM SIGGRAPH/EUROGRAPHICS conference on Graphics hardware, Horn D., Sugerman J., Houston, M., and Hanrahan P., (2007), Interactive K-D Tree GPU Raytracing, ACM SIGGRAPH Symposium on Interactive 3d Graphics and Games, Proceedings, Ize T., Wald I., and Parker S., (2008), Ray Tracing with the BSP Tree, IEEE Symposium on Interactive Ray Tracing 2008, Proceedings, Jacques R., Taylor R., Wong J., and McNutt T., (2010), Towards Real-time Radiation Therapy: GPU Accelerated Superposition/Convolution, Computer Methods and Programs in Biomedicine, 98(3), Popov S., Gunther J., Seidel H., and Slusallek P., (2007), Stackless KD-Tree Traversal for High Performance GPU Ray Tracing, Computer Graphics Forum, 26(3), Santos A., Teixeira X., Farias T., Teichrieb V., and Kelner J., (2009), Kd-Tree Traversal Implementations for Ray Tracing on Massive Multiprocessors: A Comparative Study, ISCAHPC09, Siddon R.L., (1985), Prism Representation: A 3D Ray-tracing Algorithm for Radiotherapy Applications, Phys. Med. Biol., 30, Wald I., Ize T., Kensler A., Knoll A., and Parker S.G., (2006), Ray Tracing Animated Scenes Using Coherent Grid Traversal, Acm Transactions on Graphics, 25(3), Zhou B., Yu C.X., Chen D.Z., and Hu X.S., (2010), GPU-accelerated Monte Carlo Convolution/Superposition Implementation for Dose Calculation, Med. Phys., 37(11),