Distributed GPU Visualization Framework for Parallel Data Rendering
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current computing systems face challenges in achieving sustained parallelization of calculations using multiple GPU devices due to path-dependency issues and the need for device-specific algorithm customization, which limits concurrency and scalability.
Innovation Solution
A distributed computer system with a head node, worker nodes equipped with GPUs, and a sink node that processes and renders database data in parallel, allocating memory and dividing data chunks efficiently across GPUs to ensure continuous data streams and asynchronous operations, thereby overcoming path-dependency and allowing for concurrent execution without requiring algorithm revisions.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If multiple GPU devices are used to perform calculations, then processing speed and parallelization capability are improved, but path-dependency issues and device-specific customization requirements worsen, limiting sustained concurrency
Solution Approach 1:
The patent segments the calculation process into distinct phases: data preparation phase (path-dependent operations executed on CPU) and computation phase (parallel operations executed on GPUs). This segmentation allows each GPU to work independently on its assigned data partition without path-dependency conflicts, while the CPU handles the path-dependent data preparation. The segmentation resolves the contradiction by enabling sustained parallelization across multiple GPUs without requiring device-specific algorithm customization.
Solution Approach 2:
The patent introduces an intermediary data structure (prepared data in system memory) that acts as a buffer between the CPU's path-dependent operations and the GPUs' parallel computation. The CPU prepares and validates the data, then passes it to the GPUs for computation. This intermediary approach allows the system to maintain high concurrency across multiple GPUs while isolating them from path-dependency issues, eliminating the need for device-specific customization.
2Productivity
If CPU cores are increased to handle more data processing, then processing capacity is improved, but power consumption and heat generation worsen, limiting the number of cores to about ten to twenty
Solution Approach 1:
The patent replaces the mechanical system of increasing CPU core count (which generates heat and consumes power) with a different approach: using multiple GPU devices that are more energy-efficient per core. Instead of adding more CPU cores, the system uses GPUs which have higher density of processing cores with lower power consumption and heat generation. This substitution resolves the contradiction by enabling higher processing capacity without the adverse thermal and power effects of increasing CPU cores.
3Productivity
If GPU core count is increased to improve parallelization, then processing power is improved, but programming complexity and device-specific optimization requirements worsen
Solution Approach 1:
The patent creates a universal data preparation interface that works across different GPU devices without requiring device-specific optimization. The CPU-based data preparation phase produces standardized data structures that can be consumed by any GPU in the system. This universal approach allows the system to leverage high core-count GPUs for parallelization while maintaining simple, device-agnostic programming. The universality principle resolves the contradiction by decoupling the parallelization capability from programming complexity.
Data Source
AI summary
A technique for rendering database data in visualized form using a distributed computer system including a plurality of networked worker nodes each including a graphics processing unit (GPU) is disclosed. The technique includes receiving, at a head node, a user request to render data, forwarding the request to the worker nodes, processing, in parallel, by the worker nodes, chunks of respective shards of data to be rendered. The technique also includes merging, in parallel, by each of the worker nodes, initial images formed by the processing within respective shards, to form a plurality of integrated images, merging, in parallel, respective integrated images to form worker node images, and transmitting respective worker node images to the sink node. The technique also includes merging the worker node images to form a final image, converting the final image to an output image, and providing the output image to the user.