SOC Rendering Architecture for Multi-GPU Coordination
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for rendering tasks on multi-core heterogeneous systems do not effectively utilize internal resources for collaborative rendering between multiple GPUs and lack flexible resource allocation, especially in complex scenarios.
Innovation Solution
A rendering system and method on an SOC platform that divides processors into groups, utilizes inter-core communication for collaborative rendering among graphics processors, and employs a shared memory for efficient task distribution and synchronization.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If a single system and single GPU are used for rendering, then the system configuration is simple, but the rendering efficiency and resource utilization are insufficient
Solution Approach 1:
The system divides processors into multiple processor groups (first processor group, second processor group, etc.) and assigns different operating systems to each group. Each processor group has a corresponding graphics processor that can perform rendering independently, enabling parallel processing and improving rendering efficiency while maintaining manageable system complexity through modular organization.
Solution Approach 2:
The patent combines multiple processor groups running different operating systems with multiple graphics processors into a unified rendering system. The inter-core communication circuit enables these separate components to work together cooperatively, merging their rendering capabilities to achieve high-performance rendering while utilizing internal chip resources effectively.
2Adaptability or versatility
If multiple processor groups with different operating systems are used, then resource utilization and rendering efficiency are improved, but system complexity and coordination difficulty increase
Solution Approach 1:
The inter-core communication circuit serves as an intermediary mechanism that enables coordination between processor groups running different operating systems. It facilitates task distribution, synchronization, and data sharing between the graphics processors, reducing the coordination complexity that would otherwise arise from managing multiple independent systems.
Solution Approach 2:
The system design allows any processor group to be assigned to any graphics processor for rendering tasks, creating a flexible multi-functional resource allocation model. The shared memory provides universal access for all processor groups, enabling them to collaborate on rendering tasks regardless of their specific operating system, thus improving adaptability.
3Productivity
If collaborative rendering between multiple GPUs is implemented, then rendering efficiency is maximized, but the complexity of task distribution and synchronization increases
Solution Approach 1:
The system pre-establishes the mapping relationship between processor groups and graphics processors, and pre-configures the shared memory structure for collaborative rendering. This preliminary setup enables efficient task distribution and synchronization during actual rendering operations, reducing the complexity of real-time coordination while maximizing rendering throughput.
Data Source
AI summary
A rendering system based on a system-on-chip (SOC) platform includes a plurality of processors, a plurality of graphic processors, an inter-core communication circuit, and the shared memory. The plurality of processors are divided into more than two processor groups. The plurality of operating systems are run by a plurality of different processor groups. A plurality of graphics processors receive a rendering tasks sent by the plurality of operating systems, respectively. An inter-core communication circuit is configured to cause the plurality of processors of the plurality of processor groups to communicate with each other. The plurality of graphics processors read image data in the shared memory, and rendered image data is transmitted to the shared memory.