Multi-Tenant GPU Time Slice Allocation and State Preservation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In cloud gaming, efficiently sharing graphics processing units (GPUs) between multiple applications is challenging due to difficulties in scheduling and ensuring predictable and frequent access, leading to idle resources and suboptimal utilization.
Innovation Solution
A method where a GPU resource is allocated in time slices to multiple applications, with processing halted at the end of each slice to ensure completion of ongoing commands, and the GPU configuration is preserved to resume processing in the next slice, ensuring each application gets guaranteed and predictable access.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If GPU resources are shared between multiple applications, then resource utilization is improved, but scheduling complexity increases
Solution Approach 1:
The GPU resource is divided into multiple time slices, with each time slice allocated to a specific application. This segmentation of time allows multiple applications to share the GPU resource in a structured manner, improving utilization while maintaining manageable scheduling complexity through predefined time-based partitions.
Solution Approach 2:
The system implements periodic time slicing where GPU access is granted to different applications in repeating cycles. Each application receives guaranteed time slices at regular intervals, providing predictable periodic access that simplifies scheduling while maximizing overall resource utilization across all applications.
2Productivity
If time slicing is used to share GPU, then resource utilization is improved, but processing continuity deteriorates
Solution Approach 1:
Commands are pre-loaded into rendering command buffers before the GPU time slice is allocated. This preliminary preparation ensures that when the GPU becomes available, processing can begin immediately without interruption or reconfiguration, maintaining processing continuity despite the time-sliced sharing arrangement.
Solution Approach 2:
The system preserves GPU configuration state between time slices and ensures commands are processed without interruption once started. This maintains continuous useful action within each allocated time slice, preventing processing disruptions while still allowing resource sharing across multiple applications.
3Reliability
If commands are halted at end of time slice, then predictable access is ensured, but processing time increases
Solution Approach 1:
Multiple commands are pre-loaded into rendering command buffers before the time slice begins. This allows the GPU to process a batch of commands efficiently within the allocated time slice without needing to halt frequently, reducing overall processing time while maintaining predictable access patterns through structured time slicing.
Solution Approach 2:
The system processes more commands than strictly necessary within each time slice by pre-loading additional commands into buffers. This excessive preparation ensures that predictable access requirements are met while minimizing the need for halting, as the GPU has a sufficient queue of pre-prepared commands to work through continuously.
Data Source
AI summary
A method for graphics processing, wherein a graphics processing unit (GPU) resource is allocated among applications, such that each application is allocated a set of time slices. Commands of draw calls are loaded to rendering command buffers in order to render an image frame for a first application. The commands are processed by the GPU resource within a first time slice allocated to the first application. The method including determining at least one command has not been executed at an end of the first time slice. The method including halting execution of commands, wherein remaining one or more commands are not processed in the first time slice. A GPU configuration is preserved for the commands after processing a last executed command, the GPU configuration used when processing in a second time slice the remaining commands.