Multicore 3D Rendering Memory Allocation for Primitive Order
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Implementing rendering tasks in parallel on a multicore GPU while maintaining the order of primitives as provided by the application driver and managing memory efficiently to facilitate the rendering of complex scenes.
Innovation Solution
A multicore graphics rendering system with a hierarchical memory management system that uses allocation lists (ALIST) and virtualised memory spaces to manage memory allocation and ordering of rendering tasks, ensuring efficient use of memory and maintaining the correct rendering order.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If rendering tasks are processed in parallel on multicore GPU, then rendering speed is improved, but memory management complexity increases and ordering of primitives must be maintained
Solution Approach 1:
The parameter buffer is divided into multiple primitive blocks, each associated with a specific group index range. This segmentation allows parallel processing of different geometry processing tasks while maintaining order through group indices, resolving the contradiction between parallel rendering speed and memory management complexity.
Solution Approach 2:
Group indices serve as an intermediary mechanism between parallel geometry processing tasks and the sequential fragment processing stage. The allocation list uses group indices to track and manage memory allocation across multiple cores, enabling parallel execution while preserving the original draw call order through the intermediary group index system.
2Reliability
If memory is allocated for all geometry processing tasks before fragment processing, then rendering order is preserved, but memory usage increases and may cause overflow
Solution Approach 1:
The allocation list dynamically tracks memory allocation based on group indices and draw call order. Memory is allocated and released in response to geometry processing completion and fragment processing progress, rather than being statically pre-allocated. This dynamic approach preserves rendering order through the allocation list's tracking mechanism while reducing overall memory usage by releasing unused memory.
Solution Approach 2:
Memory associated with geometry processing tasks is released back to the allocation pool once fragment processing for those tasks is complete. The allocation list identifies which memory regions can be recovered based on the current fragment processing position, enabling continuous memory reuse and preventing memory overflow while maintaining rendering order.
Data Source
AI summary
A multicore graphics rendering system is disclosed, comprising a plurality of cores configured to implement tile-based rendering of a stream of primitives. First cores are configured to process groups of primitives, to produce transformed geometry data. The transformed geometry data describes, for each of a plurality of tiles, the primitives processed by each first core that are present in that tile, each group being associated with a group index. The group indices define the ordering of the groups in the stream of primitives. An allocation list (ALIST) stores, for each portion of memory written to by the first cores, an indication of a part of the frame with which that portion is associated, and the latest group index of the transformed geometry data written to the portion. The ALIST is used to identify, and free, portions of memory that have been fully consumed in a partial render.