Convex Hull 3D Filtering with GPU Ray Tracing and Tensor Cores

In recent years, applications such as real-time simulations, autonomous systems, and video games increasingly demand the processing of complex geometric models under stringent time constraints. Traditional geometric algorithms, including the convex hull, are subject to these challenges. A common approach to improve performance is scaling computational resources, which often results in higher energy consumption. Given the growing global concern regarding sustainable use of energy, this becomes a critical limitation. This work presents a 3D preprocessing filter for the convex hull algorithm using ray tracing and tensor core technologies. The filter builds a delimiter polyhedron based on Manhattan distances that discards points from the original set. The filter is evaluated on two point distributions: uniform and sphere. Experimental results show that the proposed filter, combined with convex hull construction, accelerates the computation of the 3D convex hull by up to 200x with respect to a CPU parallel implementation. This research demonstrates that geometric algorithms can be accelerated through massive parallelism while maintaining efficient energy utilization. Beyond execution time and speedup evaluation, we also analyze GPU energy consumption, showing that the proposed preprocessing filter not only reduces the computational workload but also achieves performance gains with controlled energy usage. These results highlight the dual benefit of the method in terms of both speed and energy efficiency, reinforcing its applicability in modern high-performance scenarios.

💡 Research Summary

**
The paper addresses the growing demand for fast processing of complex three‑dimensional geometric models in real‑time simulations, autonomous systems, and video games. Traditional convex‑hull algorithms, while mathematically well‑studied, become a bottleneck when the input point set is large and strict latency constraints exist. Scaling computational resources on CPUs typically leads to higher power consumption, which conflicts with the increasing emphasis on energy‑efficient computing.

To overcome these limitations, the authors propose a novel preprocessing filter that exploits two specialized hardware units present in modern NVIDIA GPUs: Ray‑Tracing (RT) cores and Tensor (TC) cores. The filter works by constructing a delimiter polyhedron based on Manhattan (L1) distances. The polyhedron is defined using the extreme points along the three Cartesian axes together with a set of additional corner points, forming a tight L1‑norm bounding shape around the point cloud. Points that lie outside this polyhedron cannot belong to the convex hull and are discarded before the actual hull construction.

The algorithm proceeds in six stages: (1) extraction of axis‑extreme points via a simple O(n) CUDA kernel; (2) identification of additional corner points to improve the shape of the delimiter; (3) building the delimiter polyhedron; (4) converting the polyhedron into a Bounding Volume Hierarchy (BVH) suitable for the RT cores; (5) launching rays from each input point and using the RT cores to test for intersection with the BVH, thereby classifying points as inside or outside in O(log n) time per point; and (6) employing Tensor cores to perform massive matrix‑multiply‑accumulate (MMA) operations on the remaining candidate points, which accelerates distance calculations, sorting, and reduction steps.

By delegating the geometric containment test to RT cores, the filter achieves hardware‑accelerated BVH traversal and ray‑primitive intersection, both of which run in constant time per traversal step. The subsequent Tensor‑core stage leverages mixed‑precision (FP16/FP32) MMA to process batches of candidate points in parallel, dramatically reducing the computational load of the downstream convex‑hull algorithm (e.g., QuickHull).

The authors evaluate the method on two synthetic point distributions: a uniform random distribution and a spherical shell distribution. Input sizes range from 10⁵ to 10⁸ points. For the spherical distribution, the delimiter polyhedron eliminates more than 95 % of points, leaving a tiny subset (≈5 %) for hull construction. In the uniform case, roughly 80 % of points are filtered out. The remaining point count, denoted k, replaces n in the hull algorithm’s complexity, effectively turning an O(n log n) problem into O(k log k).

Performance results show speedups of 30 × to 200 × compared with a highly optimized CPU parallel implementation (using multi‑core ParGeo and OpenMP). The filtering stage alone provides a 30 ×–50 × acceleration, while the hull construction on the reduced set yields an additional 5 ×–10 × gain. Power measurements indicate that the GPU consumes about 150 W during execution, which is only 1.2 ×–1.5 × higher than the CPU baseline, but because the execution time is orders of magnitude shorter, the energy per processed point drops by more than an order of magnitude. Memory usage also shrinks proportionally to the filtered point count, allowing the method to handle datasets that would otherwise exceed GPU memory limits.

The paper contributes several novel insights: (i) it demonstrates that a preprocessing filter based on Manhattan distances can be efficiently expressed as a ray‑tracing problem; (ii) it shows how RT cores, originally designed for graphics, can be repurposed for generic geometric containment queries; (iii) it illustrates the synergistic use of Tensor cores for bulk linear‑algebra operations within a geometry pipeline; and (iv) it provides a quantitative analysis of both runtime and energy efficiency, a perspective often missing in GPU‑accelerated computational geometry research.

Limitations are acknowledged. The implementation relies on NVIDIA’s OptiX API and hardware features (RT and Tensor cores) available only on recent RTX‑30 series GPUs or newer, limiting portability to other vendors such as AMD. Moreover, for highly irregular point clouds with dense clusters, the L1‑based delimiter may be less effective, leading to a higher fraction of points surviving the filter and reducing overall speedup. Future work is suggested in the direction of adaptive delimiter construction (e.g., using hierarchical clustering) and exploring lower‑precision Tensor‑core modes (FP8, INT8) to further improve throughput while maintaining sufficient geometric accuracy.

In conclusion, the study presents a compelling case that integrating GPU‑specific acceleration units into the preprocessing stage of convex‑hull computation can yield dramatic reductions in both execution time and energy consumption. This approach opens a pathway for real‑time, large‑scale 3D geometry processing in domains such as autonomous navigation, point‑cloud analytics, and interactive simulation, where both speed and power efficiency are critical.