Molecular Dynamics Kernel Dispatch Across Partitioned Cache Slices
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing molecular dynamics (MD) simulation methods waste time waiting between the starts of dispatchable kernel functions, leading to inefficiencies in computing time.
Innovation Solution
The method involves generating dispatchable streams and binding them one-to-one with pre-partitioned cache slices, duplicating and starting dispatchable kernel functions asynchronously across these slices, ensuring efficient use of accelerated cache resources.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If dispatchable kernel functions are executed sequentially in traditional MD simulation, then execution order is simple and easy to control, but computing time increases and resource utilization decreases due to waiting between starts
Solution Approach 1:
The patent segments the execution of dispatchable kernel functions by creating multiple dispatchable streams (first dispatchable stream, second dispatchable stream, etc.) that can execute independently. Each stream is bound to specific cache slices, allowing parallel processing of different kernel functions without sequential waiting, thus improving computing speed while maintaining manageable control through structured stream management.
Solution Approach 2:
The patent applies preliminary action by pre-partitioning the accelerated cache into multiple cache slices before execution begins. This pre-partitioning allows the system to prepare and bind dispatchable kernel functions to specific cache slices in advance, enabling overlapping of duplication and execution times. The system determines the size of each kernel function and allocates cache slices accordingly, reducing waiting time and improving resource utilization before actual computation starts.
2Productivity
If dispatchable kernel functions are duplicated and started asynchronously across cache slices, then resource utilization improves and computing time decreases, but the complexity of managing multiple streams and cache slices increases
Solution Approach 1:
The patent implements universality by creating a unified binding mechanism that binds dispatchable streams to cache slices and dispatchable kernel functions to streams in a consistent manner. The same binding process handles multiple kernel functions across different streams and cache slices, simplifying management. The system uses event objects and occupation status tracking to uniformly manage asynchronous operations, reducing the complexity of handling multiple concurrent streams.
Solution Approach 2:
The patent employs feedback mechanisms through event objects that track the occupation status of cache slices by duplicated bound dispatchable kernel functions. The system monitors whether cache slices are occupied or unoccupied and uses this feedback to determine when to duplicate the next kernel function. This feedback loop automatically manages the asynchronous execution process, reducing manual intervention and simplifying the management of multiple streams and cache slices.
Data Source
AI summary
Disclosed is an apparatus and method. The method includes generating dispatchable streams and binding the dispatchable streams one-to-one to cache slices, where the cache slices are pre-partitioned from an accelerated cache, and, for each of dispatchable streams binding a dispatchable kernel function, determined for a corresponding dispatchable stream, to the corresponding dispatchable stream, for a first cache slice, of the cache slices, first duplicating the dispatchable kernel function to the first cache slice and starting the first duplicated dispatchable kernel function with respect to the first cache slice, and for a second cache slice, of the cache slices, second duplicating the dispatchable kernel function to the second cache slice and starting the second duplicated dispatchable kernel function with respect to the second cache slice, wherein the starting of the first duplicated dispatchable kernel function is performed asynchronously with the starting of the second duplicated dispatchable kernel function.