Graphics Engine Multiple Context Execution
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current graphics engines can only execute one context at a time, leading to underutilization of computational resources due to varying resource requirements among different graphics applications.
Innovation Solution
Implementing a system that allows simultaneous execution of multiple contexts on a graphics engine using independent command streamers and prioritization logic to manage workloads, enabling efficient resource allocation and improved responsiveness.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If only one context is executed at a time on the graphics engine, then the system is simple to manage, but the hardware resources are underutilized
Solution Approach 1:
The patent divides the graphics engine into multiple independent command streamers, each capable of handling a separate context. This segmentation allows parallel execution of multiple contexts while maintaining manageable complexity through modular architecture. Each command streamer is a self-contained unit that can independently process commands for its assigned context.
Solution Approach 2:
The graphics engine is designed with universal command streamers that can handle different types of workloads (3D rendering, compute operations, video processing) across multiple contexts. Each command streamer is multi-functional, capable of processing various command types and serving different applications simultaneously, thereby improving resource utilization without proportionally increasing complexity.
2Productivity
If multiple contexts are executed simultaneously on the graphics engine, then resource utilization improves, but the complexity of managing multiple contexts increases
Solution Approach 1:
The patent segments the context management into dedicated command streamers, where each streamer is responsible for a specific context. This segmentation enables simultaneous execution of multiple contexts (improving productivity) while distributing management complexity across multiple independent units rather than centralizing it, making the overall system more manageable.
Solution Approach 2:
The system performs preliminary actions by pre-configuring and initializing multiple command streamers before execution begins. Each command streamer is prepared in advance to handle its assigned context, reducing the complexity of runtime context switching and enabling smoother parallel execution. This preliminary setup allows the system to achieve high throughput without proportionally increasing operational complexity.
3Adaptability or versatility
If small graphics applications run on the graphics engine, then the system remains simple, but the computational resources are underutilized
Solution Approach 1:
The command streamers are designed with universal capabilities to handle both small and large graphics applications effectively. Each command streamer can adapt its resource usage based on the application size and complexity, allowing small applications to run efficiently while still utilizing a portion of the available computational resources. This multi-functionality ensures broad application compatibility while minimizing resource waste through dynamic resource allocation.
Data Source
Figure 1
Figure 2
Figure 3
AI summary
Apparatus and method for simultaneous command streamers. For example, one embodiment of an apparatus comprises: a plurality of work element queues to store work elements for a plurality of thread contexts, each work element associated with a context descriptor identifying a context storage region in memory; a plurality of command streamers, each command streamer associated with one of the plurality of work element queues, the command streamers to independently submit instructions for execution as specified by the work elements; a thread dispatcher to evaluate the thread contexts including priority values, to tag each instruction with an execution identifier (ID), and to responsively dispatch each instruction including the execution ID in accordance with the thread context; and a plurality of graphics functional units to independently execute each instruction dispatched by the thread dispatcher and to associate each instruction with a thread context based on its execution ID.