Fine-Grained Rendering Predication via IGPU-DGPU Bitstream Culling
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current predicated rendering techniques are coarse, leading to inefficiencies and increased overhead, particularly when dealing with complex graphics objects, as they provide limited information on object visibility, resulting in unnecessary rendering and increased command stream complexity.
Innovation Solution
A graphics system with an integrated graphics processing unit (IGPU) and a discrete graphics processing unit (DGPU) processes batches of triangles, determining culling through a modified rendering pipeline and writing bits into a bitstream to indicate whether batches are culled, allowing the DGPU to render only visible batches, thereby optimizing processing efficiency.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If predicated rendering is used to determine object visibility, then rendering efficiency is improved by avoiding unnecessary rendering, but the granularity of culling is too coarse leading to unnecessary rendering of partially visible objects
Solution Approach 1:
The patent segments the graphics object into multiple batches of triangles, with each batch independently processed through the rendering pipeline. The IGPU processes batches sequentially and writes culling results to a bitstream, allowing fine-grained control over which portions of the object are rendered. This segmentation enables precise culling at the batch level rather than treating the entire object as a single unit.
2Measurement precision
If sub-bounding volumes are used to achieve finer-grained culling, then culling precision is improved, but additional overhead is required to generate and render sub-bounding volumes decreasing overall performance
Solution Approach 1:
The patent extracts the culling decision-making function from the main rendering pipeline by using a separate IGPU that processes batches and writes results to a bitstream. The DGPU then reads this bitstream to determine whether to render each batch. This extraction eliminates the overhead of generating and rendering sub-bounding volumes while achieving fine-grained culling through the batch-level bitstream approach.
Solution Approach 2:
The IGPU performs preliminary processing of each batch through the rendering pipeline to determine visibility before the DGPU commits to full rendering. The culling decision is made in advance by the IGPU and stored in the bitstream, allowing the DGPU to skip rendering entirely for culled batches. This preliminary action prevents wasted rendering effort on invisible geometry.
3Measurement precision
If the IGPU processes batches through the rendering pipeline to determine culling, then fine-grained predication is achieved, but processing time is increased
Solution Approach 1:
The patent merges the culling function into the existing rendering pipeline by having the IGPU process batches through the same pipeline that would be used for final rendering. This allows reuse of existing pipeline stages and resources for both culling and rendering, minimizing additional processing time while achieving fine-grained predication.
Data Source
AI summary
One embodiment of the present invention sets forth a technique to perform fine-grained rendering predication using an IGPU and a DGPU. A graphics driver divides a 3D object into batches of triangles. The IGPU processes each batch of triangles through a modified rendering pipeline to determine if the batch is culled. The IGPU writes bits into a bitstream corresponding to the visibility of the batches. The DGPU reads bits from the bitstream and performs full-blown rendering, including shading, but only on the batches of triangles whose bit indicates that the batch is visible. Advantageously, this approach to rendering predication provides fine-grained culling without adding unnecessary overhead, thereby optimizing both hardware resources and performance.