Parallel 3D Acceleration Structure Construction in GPUs
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for constructing bounding volume hierarchies (BVHs), octrees, and k-d trees on GPUs are limited by sequential processing, which underutilizes parallel cores and results in suboptimal performance, especially as the number of cores increases, and often produce trees in breadth-first order instead of the more efficient depth-first order.
Innovation Solution
A method for constructing hierarchical trees in a fully parallel fashion using binary radix trees, where internal nodes are built in parallel with ancestor nodes, requiring only a linear amount of temporary storage, and utilizing Morton codes for sorting and indexing to ensure data locality and efficient cache usage.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Manufacturing precision
If sequential processing is used to construct tree hierarchies, then tree quality can be maximized using surface area heuristic, but construction speed decreases and parallel cores are underutilized
Solution Approach 1:
The patent divides the tree construction process into independent segments that can be processed in parallel. Each thread handles a specific range of primitives and constructs tree nodes independently, then results are merged. This segmentation enables parallel processing while maintaining quality through the surface area heuristic, resolving the contradiction between tree quality and construction speed.
Solution Approach 2:
The patent transitions from sequential one-dimensional processing to parallel multi-dimensional processing. By assigning threads to process different levels and ranges of the tree hierarchy simultaneously, the solution exploits the temporal and spatial dimensions for parallelism, achieving both high quality and fast construction.
2Productivity
If sequential processing is used, then construction speed can be maintained at acceptable levels, but the amount of parallelism that can be achieved is limited and parallel cores are underutilized
Solution Approach 1:
The patent segments the construction workload across multiple threads, with each thread responsible for processing specific primitive ranges and tree levels. This segmentation enables full utilization of parallel cores while maintaining construction speed through the surface area heuristic, resolving the contradiction between productivity and parallelism utilization.
Solution Approach 2:
The patent implements continuous parallel processing where multiple tree levels and node constructions occur simultaneously without idle time. Threads continuously process nodes as they become available, maximizing the utilization of parallel cores throughout the entire construction process, thereby achieving high productivity with full parallelism.
3Ease of operation
If sequential processing is used, then existing methods output hierarchy in breadth-first order, but depth-first order would be preferable considering data locality and cache hit rates
Solution Approach 1:
The patent inverts the traditional breadth-first traversal approach by implementing depth-first order construction through parallel processing. By processing tree levels in reverse order and using thread coordination, the system achieves depth-first output order which improves data locality and cache hit rates, resolving the contradiction between ease of operation and processing time.
Data Source
AI summary
A system and method for constructing binary radix trees in parallel, which are used for as a building block for constructing secondary trees. A non-transitory computer-readable storage medium having computer-executable instructions for causing a computer system to perform a method is disclosed. The method includes determining a plurality of primitives comprising a total number of primitive nodes that are indexed, wherein the plurality of primitives correspond to leaf nodes of a hierarchical tree. The method includes sorting the plurality of primitives. The method includes building the hierarchical tree in a manner requiring at most a linear amount of temporary storage with respect to the total number of primitive nodes. The method includes building an internal node of the hierarchical tree in parallel with one or more of its ancestor nodes.