Double-Precision Floating-Point Data Visualizations Using Vulkan API

TL;DR

The paper addresses the challenge of achieving high-precision data visualization in GPU-based rendering by comparing native double-precision rendering in Vulkan against emulated double-precision approaches. It analyzes the GPU pipeline, Vulkan/GLSL capabilities, and the trade-offs between single and double precision, then empirically evaluates 2D and 3D point datasets and fractal models. Results show that native double-precision on modern GPUs provides faster rendering and more stable accuracy than emulation, especially for large datasets, informing API and implementation choices for high-precision graphics. The work highlights the practical impact of leveraging native precision in Vulkan for scientific visualization and sets a direction for future real-world data validation and library integration.

Abstract

Proper representation of data in graphical visualizations becomes challenging when high accuracy in data types is required, especially in those situations where the difference between double-precision floating-point and single-precision floating-point values makes a significant difference. Some of the limitations of using single-precision over double-precision include lesser accuracy, which accumulates errors over time, and poor modeling of large or small numbers. In such scenarios, emulated double precision is often used as a solution. The proposed methodology uses a modern GPU pipeline and graphics library API specifications to use native double precision. In this research, the approach is implemented using the Vulkan API, C++, and GLSL. Experimental evaluation with a series of experiments on 2D and 3D point datasets is proposed to indicate the effectiveness of the approach. This evaluates performance comparisons between native double-precision implementations against their emulated double-precision approaches with respect to rendering performance and accuracy. This study provides insight into the benefits of using native double-precision in graphical applications, denoting limitations and problems with emulated double-precision usages. These results improve the general understanding of the precision involved in graphical visualizations and assist developers in making decisions about which precision methods to use during their applications.

Figures (8)

• Figure 1: Beginning with the input assembler, which takes the vertex data to assemble vertices into primitives, the pipeline is followed by a vertex shader for geometric transformations. Then, there is a tessellation control shader that performs the division of the surface, followed by the tessellation evaluation shader, refining the vertices. Subsequently, there is a geometry shader for generating or modifying geometry. Thereafter, it proceeds to the rasterizer, which projects 3D primitives onto the 2D screen. Next up is a fragment shader to compute pixel attributes, an early depth test optimization by discarding occluded fragments, the blending stage, which combines fragment colors, among other things, for transparent effects, and an output merger that finally writes the image in the frame buffer for display.
• Figure 2: This image is a bit-layout of single and double-precision floating-point numbers, as represented in accordance with the IEEE 754 standard. Single precision number would be 32 bits long. Bits needed for this: 1 bit for the sign, 8 bits for exponent, and 23 bits for mantissa. Double precision number: it is 64 bits; 1 bit for the sign, 11 bits for exponent, and 52 bits for mantissa. It has a wider range and is more accurate in representing floating-point numbers.
• Figure 3: 2D and 3D Point Data Visualization Process: a) 2D Point Data Visualization: The Vulkan-based visualization application reads a .csv file consisting of randomly generated 2D points: in this data set, every point is represented by the x and y coordinates. The CSV file is then read by the Vulkan-based visualization application, which visualizes it on the screen. (b) 3D Point Data Visualization: Downloaded model data in glTF/GLB format and further converted it into a .csv file, including the x, y, and z coordinates for each point. Feeding this .csv file into the Vulkan-based visualization application would draw the 3D points onto the screen. As soon as three-dimensional points can be visualized, more complex structures and models represented with data will easily be analyzed and understood.
• Figure 4: This diagram shows initializing and managing GPU resources using the Vulkan API to visualize 2D and 3D point datasets. Vulkan exposes a low-level, general-purpose graphics API that is conceived to offer direct control of the GPU resources to ensure both high performance and flexibility. It details all the processes, from the initialization of the GPU resources to the creation of the graphics pipeline. The graphics pipeline and the initialization of GPU resources are showcased. This diagram provides a comprehensive overview of the stages and interactions involved in setting up and utilizing Vulkan for rendering within the application.
• Figure 5: A few of the visualized objects from 3D datasets with double-precision floating-points are included, and the column chart on the right-hand side shows a comparison of rendering times in milliseconds for emulated double-precision and native double-precision.