GPU Resource Sharing for Duplicate Static Memory Mapping
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing graphics APIs struggle with sharing resources between application instances due to lack of system driver access to resource content and inconsistent memory management, leading to inefficient memory utilization and reduced application density.
Innovation Solution
Systems and methods that utilize graphics processing units (GPUs) to compute resource identifiers and manage memory allocation, allowing transparent resource sharing by identifying shareable resources and consolidating duplicates, thereby optimizing memory usage and increasing application density.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If applications manage their own memory allocations and resource bindings, then applications have greater control over resource management, but system drivers cannot access resource content to determine shareability
Solution Approach 1:
The patent introduces an intermediary component that sits between the application and the resource content. This intermediary allows the system to obtain resource identifiers and metadata without requiring direct access to the resource content itself, thus maintaining application control while enabling shareability detection
Solution Approach 2:
The patent replaces the mechanical approach of directly accessing resource content with a computational system that uses resource identifiers, hashes, and metadata to determine shareability. This substitution allows the system to function without breaking the application's control over its resources
2Reliability
If multiple copies of resources are stored in physical memory for different application instances, then each application has dedicated resources, but memory utilization is inefficient
Solution Approach 1:
The patent merges multiple identical resource copies into a single shared physical memory location. By using resource identifiers and hashing, the system can determine when different applications have identical resources and consolidate them, maintaining dedicated access for each application while reducing overall memory consumption
Solution Approach 2:
The patent makes physical memory locations universal by allowing them to serve multiple applications simultaneously. Through virtual memory mapping and resource identification, a single physical memory location can be shared across multiple application instances that have identical resource requirements
3Ease of operation
If system drivers manage resource associations, then resource sharing is easier to implement, but modern graphics APIs require application-level control
Solution Approach 1:
The patent introduces an intermediary layer that bridges the gap between system driver resource sharing capabilities and application-level control requirements. This intermediary component enables resource sharing functionality while maintaining the modern graphics API architecture where applications control their own resources
Solution Approach 2:
The patent enables applications to self-identify their resource shareability through metadata and resource identifiers. Rather than requiring complex system driver intervention, applications can declare their own shareability status, reducing the complexity of system-wide resource management
Data Source
AI summary
In various examples, static resources—or physical memory locations storing the static resources—may be shared between instances of an application(s) running in a distributed environment. For instance, the disclosed systems and methods may determine whether application resources are shareable (e.g., static or dynamic) by evaluating metadata associated with the resources. In some examples, the systems may allocate a portion (e.g., a range) of a virtual memory associated with an instance of the application for use as a binding target for a static resource. The portion of the virtual memory may then be mapped to a physical memory allocation storing the static resource. In this way, multiple virtual memory portions for multiple instances of the application may be mapped to a same physical memory allocation, and the static resource may be shared between the different application instances.