GPU Private Memory Mapping Thread for Dynamic Page Allocation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing graphics processing unit (GPU) technologies face inefficiencies in private memory allocation due to fixed allocations that do not account for varying memory footprints and requirements across different execution paths, leading to suboptimal resource utilization and inflexible memory management.
Innovation Solution
Implementing a persistent mapping thread to dynamically allocate and manage private memory using a translation table, allowing on-demand allocation and efficient mapping of virtual pages to physical memory, thereby optimizing memory usage and reducing software footprints.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of manufacture
If fixed memory allocation is used for private memory space, then memory management is simplified, but memory utilization efficiency deteriorates due to inability to adapt to varying memory footprints across different execution paths
Solution Approach 1:
The patent implements dynamic memory allocation by introducing a mapping thread that translates virtual memory addresses to physical memory addresses at runtime. This allows private memory allocation to adapt to different execution paths and memory requirements, transforming the static fixed allocation system into a dynamic one that optimizes memory utilization based on actual needs.
Solution Approach 2:
The mapping thread acts as an intermediary between the shader processor and the memory system. It receives memory access requests from the shader processor, performs address translation, and retrieves data from the appropriate memory location. This intermediary layer enables flexible memory management without requiring changes to the shader processor architecture.
2Productivity
If dynamic memory allocation is implemented, then memory utilization efficiency improves, but system complexity increases due to additional mapping thread and translation table requirements
Solution Approach 1:
The mapping thread is designed to handle multiple functions: it manages private memory allocation, performs address translation, and coordinates with the memory system. By consolidating these functions into a single thread, the patent reduces overall system complexity compared to having separate mechanisms for each function.
Solution Approach 2:
The system implements self-service memory management where the mapping thread automatically handles address translation and memory allocation requests without requiring external intervention. The translation table is automatically updated and maintained by the mapping thread, reducing the need for complex external control mechanisms.
3Quantity of substance
If on-demand memory allocation is used, then overall memory use is reduced, but allocation time increases due to dynamic translation and allocation processes
Solution Approach 1:
The system performs preliminary actions by pre-allocating virtual memory spaces and maintaining translation tables in advance. When memory access is required, the mapping thread can quickly translate addresses using pre-computed translation information, reducing the actual allocation time during execution.
Solution Approach 2:
The patent changes the parameter of memory allocation from static fixed-size blocks to dynamic variable-size allocations based on actual execution needs. The mapping thread adjusts memory allocation parameters in real-time, allocating only the necessary memory for each execution path, thereby reducing overall memory usage without significantly impacting allocation time.
Data Source
AI summary
Techniques are disclosed relating to private memory management using a mapping thread, which may be persistent. In some embodiments, a graphics processor is configured to generate a pool of private memory pages for a set of graphics work that includes multiple threads. The processor may maintain a translation table configured to map private memory addresses to virtual addresses based on identifiers of the threads. The processor may execute a mapping thread to receive a request to allocate a private memory page for a requesting thread, select a private memory page from the pool in response to the request, and map the selected page in the translation table for the requesting. The processor may then execute one or more instructions of the requesting thread to access a private memory space, wherein the execution includes translation of a private memory address to a virtual address based on the mapped page in the translation table. The mapping thread may be a persistent thread for which resources are allocated for an entirety of a time interval over which the set of graphics work is executed.