Pixel Shader Thread Assembly via Shared Parameter Storage
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Multithreaded processing systems face challenges in reducing storage resources needed for pixel shader program threads, as existing methods require separate storage of common parameters for each thread, increasing die area and costs.
Innovation Solution
Pixels are assembled into launch groups within a pixel shader program thread buffer, sharing common parameters among multiple threads to minimize storage needs, allowing efficient use of limited parameter storage resources.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If separate copies of common parameters are stored for each pixel shader program thread, then each thread has full parameter access, but storage resources and die area increase significantly
Solution Approach 1:
The patent merges common parameters into a shared parameter storage location that is accessible by multiple pixel shader program threads. Instead of duplicating parameter copies in each thread's local storage, the system consolidates redundant parameter data into a single shared repository, allowing threads to access the same parameter instance. This directly reduces the quantity of stored data while maintaining complete parameter access for all threads.
Solution Approach 2:
The shared parameter storage structure serves multiple functions: it stores common parameters for multiple threads simultaneously, acts as a central repository that can be accessed by any thread needing those parameters, and reduces overall storage requirements. This universal storage mechanism eliminates the need for thread-specific parameter copies while ensuring all threads have access to the complete parameter set.
2Productivity
If more pixel shader program threads are executed simultaneously, then processing throughput increases, but storage resources for parameters are insufficient
Solution Approach 1:
By merging common parameters into a shared storage location, the system enables more threads to execute simultaneously without proportionally increasing storage requirements. The shared parameter storage acts as a common resource pool that supports multiple concurrent threads, allowing the system to scale thread execution while maintaining efficient storage utilization.
Solution Approach 2:
The system discards redundant parameter copies that would otherwise be stored in each thread's local memory. By eliminating these duplicate storages and recovering the space, the system can allocate resources to support a higher number of simultaneous thread executions, thereby increasing processing throughput without expanding the overall storage footprint.
3Area of stationary object
If parameter storage size is reduced to save die area, then system cost decreases, but the ability to support concurrent threads is limited
Solution Approach 1:
The patent merges parameter storage into a compact shared structure that reduces die area by eliminating redundant parameter copies. This consolidated storage approach maintains the ability to support multiple concurrent threads by providing a shared access mechanism, thus preserving thread concurrency capability while significantly reducing the physical area required for parameter storage.
Solution Approach 2:
Instead of copying parameter data to each thread's local storage (which consumes excessive space), the system uses a single shared copy that is referenced by multiple threads. This single-copy approach dramatically reduces storage requirements and die area while maintaining full parameter availability for all concurrent threads through shared access.
Data Source
AI summary
Systems and methods for assembling pixel shader program threads for execution based on resource limitations of a multithreaded processor may improve processing throughput. Pixels to be processed by the pixel shader program are assembled into a launch group for processing by the multithreaded processor as multiple shader program threads. The pixels are assembled based on parameter storage resource limitations of the multithreaded processor so that common parameters shared by multiple pixels are not stored separately for each pixel. Therefore, the limited parameter storage resources are efficiently used, allowing more shader program threads to execute simultaneously.