Virtual Function Sharing in Shared Virtual Memory
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current communication mechanisms between heterogeneous processors like CPU and GPU allow only one-way communication, preventing natural functionality partitioning and requiring duplicate scene classes for CPU and GPU, leading to inefficient data copying.
Innovation Solution
Implementing a computing platform that supports two-way communication through virtual functions in a shared virtual memory by using table-based and non-coherent region techniques, allowing fine-grain partitioning and shared object management between CPU and GPU.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Device complexity
If one-way communication mechanism is used between heterogeneous processors, then implementation simplicity is maintained, but functionality partitioning capability deteriorates
Solution Approach 1:
The patent segments the monolithic communication mechanism into separate virtual function tables for CPU and GPU, allowing each processor type to have its own optimized function table while maintaining shared memory access. This enables fine-grained functionality partitioning where different scene class functions can be selectively executed on CPU or GPU based on their computational characteristics.
Solution Approach 2:
The patent creates a universal shared virtual memory space that can be accessed by both CPU and GPU processors, allowing the same memory region to serve multiple purposes: storing scene class data, storing virtual function tables, and enabling bidirectional function calls. This multi-functional memory space eliminates the need for separate communication channels.
2Adaptability or versatility
If duplicate scene classes are created for CPU and GPU, then functionality partitioning is enabled, but data copying overhead increases
Solution Approach 1:
The patent merges the scene class data storage and virtual function table storage into a single shared virtual memory space. Both CPU and GPU processors access the same scene class instances and their associated virtual function tables, eliminating the need to maintain duplicate scene class copies. This unified approach allows functionality partitioning through virtual function selection without duplicating data.
Solution Approach 2:
Instead of copying entire scene class instances between CPU and GPU memory spaces, the patent copies only the necessary virtual function table entries dynamically. The scene class data remains in shared memory, and processors call appropriate functions through their respective virtual function tables, minimizing data copying to only what is absolutely necessary.
3Productivity
If shared virtual memory with virtual function sharing is implemented, then communication efficiency improves, but system complexity increases
Solution Approach 1:
The patent introduces virtual function tables as intermediary structures that mediate between the shared virtual memory and the heterogeneous processors. These tables act as lookup mechanisms that translate processor-specific function calls into appropriate execution contexts, simplifying the interaction model while enabling efficient shared memory access and bidirectional communication.
Data Source
Figure 1~2
Figure 3~4
Figure 5
AI summary
A computing platform may include heterogeneous processors (e.g., CPU and a GPU) to support sharing of virtual functions between such processors. In one embodiment, a CPU side vtable pointer used to access a shared object from the CPU 110 may be used to determine a GPU vtable if a GPU-side table exists. In other embodiment, a shared non-coherent region, which may not maintain data consistency, may be created within the shared virtual memory. The CPU and the GPU side data stored within the shared non-coherent region may have a same address as seen from the CPU and the GPU side. However, the contents of the CPU-side data may be different from that of GPU-side data as shared virtual memory may not maintain coherency during the run-time. In one embodiment, the vptr may be modified to point to the CPU vtable and GPU vtable stored in the shared virtual memory.