Runtime Instruction Buffer Refill via DMA Queue and Semaphore
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In computing systems, integrated circuit devices face challenges in efficiently executing program code due to limited internal register or instruction buffer space, requiring frequent retrieval and refilling of instructions from memory, and lack of visibility into execution engine states for seamless application switching.
Innovation Solution
A runtime driver program generates preamble and postamble instruction blocks, along with DMA descriptors, to manage instruction refilling and application switching by utilizing a refill DMA queue and semaphore to ensure all execution engines reach a 'safe to switch' state, allowing for efficient execution and switching between applications.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Speed
If instructions are stored in internal register or buffer, then execution speed is improved, but buffer space is limited requiring frequent refilling from memory
Solution Approach 1:
The patent segments the instruction buffer into multiple regions or slots that can be independently managed and refilled. The runtime driver program can load instructions into different buffer regions sequentially, allowing the execution engine to continue processing while other regions are being refilled, thus reducing the impact of limited buffer space on execution speed.
Solution Approach 2:
The runtime driver program performs preliminary actions by pre-loading instructions into the buffer before the execution engine needs them. The system anticipates future instruction requirements and proactively refills the buffer, ensuring that instructions are ready when needed and minimizing execution pauses due to buffer exhaustion.
2Productivity
If runtime driver manages instruction loading, then execution efficiency is improved, but system complexity increases
Solution Approach 1:
The execution engine is designed to autonomously monitor its own buffer status and trigger refilling operations when needed. The runtime driver responds to requests from the execution engine rather than continuously managing it, allowing the execution engine to serve itself and reducing the overall system complexity while maintaining execution efficiency.
Solution Approach 2:
The system implements a feedback mechanism where the execution engine monitors its instruction buffer status and provides feedback to the runtime driver when refilling is needed. This feedback loop allows the runtime driver to manage instruction loading efficiently based on actual execution needs, improving productivity while keeping the management mechanism simple and responsive.
3Adaptability or versatility
If application switching is implemented, then versatility is improved, but reliability of switching decreases due to lack of visibility into execution engine states
Solution Approach 1:
The patent implements a feedback mechanism where the runtime driver program receives status information from the execution engine about its current state and buffer contents. This feedback allows the runtime driver to determine the appropriate moment to switch applications, ensuring that switching occurs at safe points and improving the reliability of application transitions while maintaining versatility.
Solution Approach 2:
Before switching applications, the runtime driver performs preliminary actions to ensure the execution engine is in a safe state for switching. This may include completing current instruction batches, flushing buffers, or synchronizing states, thereby ensuring reliable application switching while maintaining the ability to switch between multiple applications.
Data Source
AI summary
Methods for repeated execution of program code by an execution engine are provided. In order to execute large programs, the instruction buffer of an execution engine may be refilled may times with program code to complete one execution of the program. At completion of program execution, the program code needed to begin re-execution of the program is no longer in the instruction buffer. A runtime driver program can load instructions into the instruction buffer, or can cause instructions to be loaded. Once the instructions are loaded, the execution engine may be able to re-execute the instructions without needing further assistance from the runtime driver.