Introduction

Ray tracing is the holy grail in computer graphics when it comes to its capacity of rendering realistic, high-quality images ⁽¹⁾, but this is paid with rendering time, ray tracing is considered to be slow when compared against other techniques such as rasterization ⁽¹⁾.

The way that ray tracing works is by defining a tridimensional scene that contains an origin (represented by a (x, y, z) coordinate), a projection plane, and several objects (primitives) that are part of the scene ⁽²⁾. Mathematical rays are cast from the origin to each one of the pixels from a projection plane that represents the screen image that a user sees. If an intersection is detected between the ray and one or several objects from the scene, the color of the object with the closest intersection to the origin is the one that is painted for that pixel. This process repeats for all the pixels that are part of the projection plane. ⁽²⁾

The algorithm for a basic ray tracer is quite simple. It is composed of a nested loop in which the external loop iterates through the vertical pixels of the projection plane, and the internal loop iterates through the horizontal pixels ⁽⁹⁾. A ray is generated for each coordinate (composed of the horizontal pixel x and the vertical pixel y) to calculate its intersection (if any) with the nearest object from the scene, in order to print the color of that object in the screen. If no intersection is detected, a default color is assigned ⁽²⁾. Figure 1 displays the pseudocode of a ray tracer.

Figure 1. Ray tracer pseudocode.

It’s well documented that when rendering an image using the ray tracing algorithm, most of the time is spent in computing ray/object intersection ⁽¹⁵⁾. The basic ray tracing technique (without acceleration structures) has an O(I n) time complexity. I represents the total number of pixels in the image, and n is the total number of objects that comprise the scene. Rendering time becomes unmanageable with scenes with a few thousand objects ⁽²⁾.

Several approaches have been developed to improve the ray/object intersection computation time. The two most popular techniques are Kd-Trees and Bounding Volume Hierarchy (BVH) ⁽¹⁵⁾.

The Bounding Volume Hierarchy acceleration structure uses a subdivision of the primitives (objects) that are part of the scene by creating a partitioned hierarchy of disjoint sets. Figure 2 shows the BVH mechanism; the objects of the scene are included in containers to create a binary tree data structure, where the primitives of the scene are in the leaves of the tree, and each intermediate node represents a container that stores the elements of the nodes beneath it ⁽¹⁾.

Figure 2. Bounding Volume Hierarchy diagram. Source: ⁽¹⁵⁾

BVH provides rendering acceleration because when a ray is generated, its intersection is calculated for each of the nodes of the tree. If there is not an intersection with a node, all the subtree for that node can be ignored ⁽¹⁵⁾. The performance gain goes from O(I n) of the basic ray tracing algorithm to an average of O(I log n), which is the height of the binary tree ⁽¹⁵⁾.

Kd-Trees are a variation of binary space partitioning trees (BSP) that subdivides tridimensional space with planes. The way that a BSP works is by creating a bounding box that contains the entire scene. If the number of objects included in that box is greater than a defined threshold, the box is split by a plane. This process continues recursively until a maximum defined depth of the tree is reached, or each leaf of the resulting tree contains a sufficiently small number of objects ⁽¹⁵⁾. The splitting planes can be placed in arbitrary positions inside a bounding box as long it is perpendicular to one of the coordinate axes. This property of the Kd-Trees makes their construction and traversal more efficient compared to other types of BSPs ⁽¹⁵⁾. The asymptotic complexity of Kd-Trees is the same as BVH, with an average of O(I log n) ⁽¹⁵⁾.

Figure 3 shows the Kd-Trees mechanism; the tree is built by recursively splitting the bounding box of the scene geometry perpendicular to one of the coordinate axes. As the figure shows, the first split goes along the x axis, so the triangle will be inside the container in the right. The left region is split several more times with axis-aligned planes. ⁽¹⁾.

Figure 3. Kd-Trees diagram. Source: ⁽¹⁵⁾

In this research, we evaluated the performance of state-of-the-art BVH and Kd-Trees acceleration structures for ray tracing in a modern CPU architecture. We implemented both methods in the C programming language and explored both algorithm’s performance in different scenes that simulate real rendering scenarios. Maintaining up-to-date performance evaluation of the acceleration structures in modern x86 CPUs could lead to new findings regarding its performance. These processors have several internal improvements that could favor a specific acceleration technique. We found that contrary to popular belief, Kd-Trees provided better performance than BVH in the defined experiments.

Different efforts for improving the performance of the ray tracing algorithm can be found in Background section. The description of our implementation of the acceleration structures are in Design. Methodology has the hardware used, the experiments and the method of analysis of the obtained data. Results section has the obtained results which are discussed in Discussion. Finally, in the Conclusion and Future Work section we provide our final remarks of the results obtained and propose other problems that could be explored.

Background

There are several different approaches to improve the performance of the ray tracing algorithm. Some works have developed hybrid algorithms that combine ray tracing with rasterization, so for effects that require a lot of computational power, the cheaper rasterization technique is used ⁽⁹⁾. There are commercial solutions that used this approach, like Nvidia RTX ⁽⁶⁾. The downside is that it is not a pure ray tracing solution, and there is a compromise between image quality (photorealistic effects) and performance.

When using the GPU architecture for rendering an image with ray tracing, RAM-VRAM memory transactions are commonplace, partly due to the relatively small cache of GPU architecture. This makes memory bandwidth a bottleneck for performance ⁽⁷,¹⁵⁾. Another initiative focused on the reduction of memory transactions to the GPU by compressing the transferred information ⁽²¹⁾. This approach reduces the bottleneck caused by the memory bandwidth but adds time due to the compression and decompression of the data in all memory transactions.

As mentioned before, ray/object intersection is where most rendering time is spent ⁽¹⁵⁾. One of the first practical acceleration structure implementation through bounding objects was developed for the CPU architecture by ⁽¹¹⁾. Since that implementation, several works have been done to improve the performance of the BVH accelerator, like the explicit caching of node-pairs to enhance the access time to the Bounding Volume Test Tree ⁽⁵⁾. Another approach has created private workstack in to reduce memory access and inter-thread synchronization. The modifications mentioned above to the BVH algorithm creates new problems such as work-flow divergence and load-imbalance in several cases, which leads to degraded performance ⁽³⁾.

There is research to improve the performance of the BVH acceleration structure through tightly coupled heterogeneous computing ⁽¹⁸⁾. The focus of this research was to utilize the full resources of processors that have an integrated GPU. The performance gain provided by the study was promising. Still, they don’t evaluate the performance of the Kd-Trees acceleration structures and require the use of CPUs with integrated GPUs for the acceleration gain.

Another approach for accelerating ray/object intersection are binary partitioning trees (BSP trees), in which the axis-aligned BSP Trees (Kd-Trees) are the most popular for ray tracing ⁽¹⁾. The first reported use of using a Kd-Trees for ray tracing was by ⁽¹⁰⁾. Work to improve the shortcomings of a naive implementation of the Kd-Trees have been done by ⁽⁴⁾, where it implements a space-efficient representation that avoids redundant objects from leaf nodes. This approach highly improves the performance of the traversal during ray/object intersections.

Performance comparison between BVH and Kd-Trees has been performed in several research efforts, like the one in ⁽¹⁹⁾. This effort is focused only on the GPU architecture, so they don’t provide insight into how both algorithms perform on the modern CPUs. Efforts like the one in ⁽¹²⁾ provides a performance evaluation of both algorithms, where Kd-Trees provided performance better in some scenarios. The main disadvantage of this research is that it was performed a long time ago when the typical CPU architecture only had one core and a very small cache memory ⁽⁸⁾.

As far as we know, there haven’t recent efforts to evaluate the performance of the BVH and Kd-Trees acceleration structures in recent (2018+) mainstream CPU architectures. In this research, we provided an up-to-date comparison of the performance of both algorithms, using our own implementation of state-of-art BVH and Kd-Trees algorithms in the C programming language.

Design

In this research, we created our own ray tracer with BVH and Kd-Trees acceleration heavily based in the state of the art algorithms found in ⁽¹⁵⁾ and ⁽¹⁾. We used the C programming language as allow us to implement low-level optimizations for memory access and mathematical operations ⁽²²⁾.

For instance, we avoided using pointers for the binary tree data structure of both acceleration methods. Instead, we flattened the tree and stored it in an array. Each element of the array is a struct that represents a node. The first child of the node will be stored in the index next to that node in the array; the second child’s index is stored in the struct ⁽¹⁵⁾.

Figure 4 shows a pointer representation of a binary tree, while figure 5 shows a flattened representation of the same tree stored in an array, like what we used. The traversal of an array is several times faster than the traversal of the same data structure using pointers ⁽¹⁰, ¹⁵⁾.

Figure 4. Pointer representation of a binary tree.

Figure 5. Flattened representation of a binary tree in an array.

To make an evaluation that contemplates real rendering scenarios, we implemented several types of primitives in the ray tracer: The included primitives are:

•Spheres.

•Cones.

•Cylinders.

•Discs.

•Triangles.

Also, we implemented transparencies, reflection, and anti-aliasing effects as they are usually present in real-world use of ray tracing for rendering ⁽¹⁾. We also wanted to evaluate the performance of both algorithms with the presence of both effects.

Methodology

For the evaluation, we choose to employ a Factorial Analysis of Variance (ANOVA) experiment, as it provides a mechanism for evaluating the impact that several factors under research have on a response variable ⁽¹³⁾. Using this methodology allowed us the assess the performance of the BVH and Kd-Trees acceleration structures and the effect that other factors had in rendering time.

A factor has different levels that could impact in some way the response variable ⁽¹⁴⁾. ANOVA lets us determine if the influence of a specific factor is statistically significant.

The factors and the levels used for our evaluation are the following:

Objects: The number of objects in the scene directly impacts rendering time. The following amounts were used:

•1000.

•4000.

•7000.

•10000.

•13000.

Image resolution: The more pixels that an image contains, the more level of detail it holds. Increasing the number of pixels (resolution) in an image increase rendering time ⁽⁹⁾. We selected three common image resolutions:

•1280 x 720.

•1440 x 900.

•1920 x 1080.

Effects: We used the 2k ⁽¹³⁾ form for evaluating the impact of the effects: anti-aliasing, reflections, and transparencies. This significantly reduced the number of experiments while allowing us to assess if influences in both algorithms’ performance. Visual effects directly increase rendering time ⁽¹⁷⁾. All possible combinations of the following three effects were considered:

•AA: Anti-aliasing.

•RE: Reflection (5 levels).

•TR: Transparency (5 levels).

Acceleration algorithm: This is the most crucial factor of our experiment; the levels are:

•Kd-Trees.

•BVH.

There are 5 x 3 x 8 x 2= 240 combinations, as we decided to do 15 replications to increase the validity of the results, we ended up with 240 x 15=3600 runs of the experiment. We automated the execution and recollection of data trough scripts.

The equipment used to run the experiments is described in table 1.

The scenes used for the experiments contained different objects randomly distributed through the x, y, z axis. We limited the random range to guarantee that all the objects were held inside the projection frame. We also randomized the sizes, shapes, and colors of the objects contained in the scene. In this way, we created a good representation of a ray-traced scene ⁽¹⁵⁾. The factors of resolution, effects, and acceleration algorithm were adjusted to fit a specific combination of the experiment.

The response variable of the experiments is rendering time, as it represents performance ⁽¹⁴⁾.

Our research differs from ⁽¹⁷⁾, as they used an Accelerated Processing Unit (APU) to increase the performance of computationally expensive workloads. It also differs from ⁽¹⁶⁾ as they make a performance evaluation of the classic and BVH accelerated ray tracing algorithm using all the computing resources available in commodity hardware solutions.

Results

To comply with ANOVA adequacy requirements, we applied a square root transformation of the response variable ⁽¹³⁾. Nonetheless, we present results de-transformed.

The results of the ANOVA analysis produced by R ⁽²⁰⁾ for this experiment are shown in table 2.

Average rendering time in function of the acceleration algorithm is presented in figures 6, 7, 8 and 9 presents the average rendering time per effects, objects and resolution factors in function of the acceleration algorithm.

Figure 6. Average rendering time in function of the acceleration algorithm.

Figure 7. Average rendering time per effects in function of the acceleration algorithm.

Figure 8. Average rendering time per object quantity in function of the acceleration algorithm.

Figure 9. Average rendering time per resolution in function of the acceleration algorithm.

The average rendering time of each acceleration algorithm is displayed in table 3. This time includes and summarizes all combinations of effects, resolution, and object quantities.

Two sample images generating through the experiments are found in figures 10 and 11. Both images were rendered at the maximum resolution with all the effects.

Figure 10. Scene with 7000 randomly distributed objects.

Figure 11. Scene with 10000 randomly distributed objects.

Discussion

Table 2 shows that the factors defined for this research and its interactions are statistically different (as the low obtained p values demonstrates). With this information, we can conclude from the average rendering times that we obtained during the experiment.

The average rendering time per algorithm is summarized in Figure 6. The figure shows that for the defined experiment, Kd-Trees performs significantly better than BVH.

We proceeded to decompose the rendering time per each one of the factors defined for the experiment as it is shown in figures 7, 8 and 9. In all cases we found the same result, Kd-Trees has better performance than BVH.

For the case of effects in function of the acceleration algorithm, in figure 7, we see a tendency that as more effects are included in the image, the rendering time difference between BVH and Kd-Trees becomes larger. When an effect like anti-aliasing is included in a scene, it generates more rays and thus more mathematical operations and memory accesses during rendering ⁽¹⁾. More rays and memory accesses mean more traversals of the BVH and Kd-Trees binary trees. As we see from the results, Kd-Trees perform better when these two factors are increased.

For the case of object quantity in function of the acceleration algorithm, we found out that in all instances, Kd-Trees perform better. Still, we don’t see any tendency as object quantity increases. Object quantity is directly related to the size of the BVH and Kd-Trees trees, and thus is directly related to memory accesses ⁽¹⁵⁾. As our results showed, it seems that KD-Trees performs better than BVH when memory accesses are increased.

Increasing the resolution of an image, adds more mathematical operations and memory accesses, as is displayed in figure 9. Again, Kd-Trees performed better than BVH for all resolutions. We observed that as the number of pixels increased, the advantage of the Kd-Trees accelerator over BVH became larger.

Modern x86 CPUs are more efficient as they have a better internal design. For instance, modern CPUs have fewer pipeline stalls, more cache memory, better memory access mechanisms, and improved branch prediction than older processors ⁽⁸⁾. All these improvements could favor Kd-Trees in modern architecture. As we saw, for all defined scenarios, Kd-Trees performed better than BVH. Nonetheless, this is not the preferred acceleration technique in modern renderers ⁽¹,¹⁵⁾.

Trade-offs between BVH and Kd-Trees are well documented ⁽¹⁵⁾; for instance, BVH is more efficient building the tree than Kd-Trees, and Kd-Trees deliver slightly faster ray intersection tests. From our experiment, we can observe in table 3 the average rendering time of both algorithms, in which kD-Trees is 34% faster than BVH. In this case, Kd-Trees is considerably faster, not slightly.

Conclusions and Future Work

We explored the performance of the BVH and Kd-Trees algorithm in a modern x86 CPU. Our tests showed favorable results for the Kd-Trees acceleration structure in all tests. Our ray tracer included anti-aliasing, reflections, transparencies, different primitives and resolutions.

This research provided an up-to-date comparison of both algorithms in a modern processor. We implemented the ray tracer using the C programming language and did our implementations of both algorithms as fair as possible. Legacy x86 architectures are quite different from modern x86 processors as they have more cache memory, better memory access systems, reduced pipeline stalls, and improve prediction mechanisms ⁽⁸⁾. These factors could favor the KD-Trees ray/object intersection mechanism.

For future work we would like to explore more deeply the reason of the advantage of Kd-Trees over BVH, in this case we would like to explore memory access patterns, processor affinity and cache misses in both modern and legacy (at least 15 years older) x86 processors. Also, we would like to perform the tests in different programming languages, as different previous evaluations were performed in GPUs with CUDA ⁽¹⁹⁾, others were performed in C++ with legacy processors ⁽⁷⁾, so we would like to discard programming language as a driving factor for the performance differences. Finally, we would like to verify if the advantage of KD-Trees vs BVH remains in different CPU architectures like ARM, RISC-V and MIPS.

References

Fechas de Publicación

Histórico