Jae-Ho Nah

SGRT: a scalable mobile GPU architecture based on ray tracing

Recently, with the increasing demand for photorealistic graphics and the rapid advances in desktop CPUs/GPUs, real-time raytracing has attracted considerable attention. Unfortunately, raytracing in the current mobile environment is difficult because of inadequate computing power, memory bandwidth, and flexibility in mobile GPUs. In this work, we present a novel mobile GPU architecture called the SGRT (Samsung reconfigurable GPU based on RayTracing) by enhancing our previous works with the following features: 1) a fast compact hardware engine that accelerates a traversal and intersection operation, 2) a flexible reconfigurable processor that supports software ray generation and shading, and 3) a parallelization framework that achieves scalable performance. Unlike our previous work, the current architecture is designed for both static and dynamic scenes with a smaller area. Experimental results show that the SGRT can be a versatile graphics solution, as it supports compatible performance compared to desktop GPU raytracers. To the best of our knowledge, the SGRT is the first mobile GPU based on full Whitted raytracing.

MobiRT: an implementation of OpenGL ES-based CPU-GPU hybrid ray tracer for mobile devices

Three-dimensional user interfaces on mobile devices are increasingly important. For more realistic three-dimensional visualization on mobile devices, we present the implementation of an OpenGL ES-based CPU-GPU hybrid ray tracer. This ray tracer exploits the availability of CPU and GPU architectures to fully support reflection, refraction, hard shadows, and dynamic scenes. To the best of our knowledge, our ray tracer is the first to demonstrate full Whitted ray tracing of dynamic scenes using OpenGL ES.

gkDtree: A group-based parallel update kd-tree for interactive ray tracing

This paper proposes a new group-based acceleration data structure called gkDtree for interactive ray tracing of dynamic scenes. The main idea of the gkDtree is to construct the acceleration structure with a multi-level hierarchy, and to integrate a parallelization approach to result in a faster update and a more efficient tree traversal. A gkDtree can be viewed as a set of kd-trees, each of which is a local acceleration structure corresponding to a group. For a gkDtree, a scene is divided into several groups based on a scene graph. The local acceleration structure of each group involving only dynamic primitives is rebuilt. To achieve higher parallelization, dependencies among groups in different levels are removed before rebuilding occurs in parallel. To enhance the scalability of parallelization, a simple and fast load-balancing scheme is introduced. Furthermore, we apply a variety of accurate SAH (surface area heuristic) algorithms into tree generation for both static and dynamic groups. The experimental results show that a gkDtree has a real-time update performance. It has an update performance that is up to 166 times faster than a kd-tree for our test scenes in a six-core hardware system environment. Furthermore, the results also show that tree traversal performance of a gkDtree is competitive with that of a kd-tree.

An FPGA implementation of whitted-style ray tracing accelerator

This paper presents an FPGA implementation of a full whitted-style ray tracing accelerator. It achieves about 1.3 M rays per second over realistic 3 D scenes. The future implementation with ASIC is expected to achieve real-time performance.

Adaptive undersampling for efficient mobile ray tracing

Aiming to develop an efficient ray tracer for a mobile platform, we present an adaptive undersampling method that enhances the rendering speed by effectively replacing expensive ray-tracing operations with cheap interpolation whenever possible. Our method explores both object- and image-space information gathered during ray tracing to detect possibly problematic pixels. Rays are fired only for these pixels. We also present a postcorrection algorithm that minimizes annoying artifacts inevitably caused by undersampling. Our implementation on a mobile GPU demonstrates that this method can speed up the rendering computation significantly, while retaining almost the same visual quality of the rendering.

A novel mobile GPU architecture based on ray tracing

Recently, with the increasing demand for photorealistic graphics and the rapid advances in desktop CPUs/GPUs, real-time ray tracing has attracted considerable attention. Unfortunately, ray tracing in the current mobile environment is difficult because of inadequate computing power, memory bandwidth, and flexibility in mobile GPUs. In this paper, we present a novel mobile GPU architecture called the SGRT (Samsung reconfigurable GPU based on Ray Tracing) with the following features: 1) a fast compact hardware engine that accelerates a traversal and intersection operation, 2) a flexible reconfigurable processor that supports software ray generation and shading, and 3) a parallelization framework that achieves scalable performance. Experimental results show that the SGRT can be a versatile graphics solution, as it supports compatible performance compared to desktop GPU ray tracers.

L-Bench: An Android benchmark set for low-power mobile GPUs ☆

Abstract In recent years GPUs have become one of the most important components in mobile application processors (APs). Thus, performance measurement and analysis of mobile GPUs are crucial to mobile AP manufacturers, device manufacturers, graphics application programmers, and end users. However, it is hard to analyze mobile GPUs in depth via existing high-level (with frames per second) or low-level benchmarks (with a fill rate, ALU performance, etc.). To bridge the gap between the benchmarks, we present a novel Android benchmark set for low-power GPUs, called L-Bench. This benchmark set consists of mid-level micro-benchmarks implemented on OpenGL ES 3.1, which are carefully chosen for different workloads. By analyzing the results, this benchmark suite provides not only frames per second of each benchmark but also performance of each GPU subsystem (geometry units, ALUs, texture mapping units, raster operations pipelines, caches/memory units, and tessellators) and overall GPU performance. For experiments, we perform our benchmark suite on five representative mobile devices that have different mobile GPUs, after that, we describe comprehensive analysis of each GPU architecture.

Efficient ray sorting for the tracing of incoherent rays

High-quality rendering via ray tracing requires the tracing of many incoherent secondary rays. In order to accelerate the tracing of incoherent rays, we propose a simple sorting method to increase ray coherence. In this method, we use ray origin buckets and ray direction grids to reorder rays quickly. We implemented our approach on the Manta interactive ray tracer and achieved up to a 1.48× speedup.

Geometry transition method to improve ray-tracing precision

We propose a method for moving the view position to the origin and moving the coordinates of primitives so that they are at the same distance in order to improve ray-tracing precision. This approach exploits the principle that a floating-point number provides higher precision near zero. In this way, we can significantly reduce the number of self-intersections occurring in ray tracing that are caused by limited floating-point precision. The experimental results show that the number of self-intersections is reduced by up to 84.6 %. We also propose a hardware approach to resolve the computational overhead in the proposed algorithm. Its contribution to the hardware size is very small in comparison with the size of the entire ray-tracing hardware.

A split node cache scheme for fast ray tracing

We propose a node cache scheme for efficient ray tracing hardware. The scheme uses an aspect that traversing high-level nodes have more locality. In this method, a node cache is split into a high-level node cache and a low-level node cache. The data of the high-level nodes is retained during one frame. In addition, this scheme has a hybrid tree layout. That is, the high-level nodes are represented to the breath-first layout for a division of nodes, and the low-level nodes are represented to the depth-first layout for an effective use of locality. Simulation results show the reduction in cache miss ratio up to around three percent.