Dynamic Accelerator Offloading via Virtual Function Table
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current computer systems face inefficiencies in performance due to traditional system architectures, where compute power is not optimally positioned relative to data, leading to bottlenecks and suboptimal performance.
Innovation Solution
The Open Coherent Accelerator Processor Interface (OpenCAPI) specification allows processors to attach to coherent accelerators and I/O devices, enabling the dynamic generation and deployment of hardware accelerators within programmable devices, such as FPGAs, to offload compute-intensive tasks, thereby improving performance by placing compute power closer to data.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If compute power is positioned away from data in traditional system architectures, then system complexity is reduced and ease of operation is improved, but system performance deteriorates due to bottlenecks and suboptimal data access
Solution Approach 1:
The system is segmented into distinct components: a processor executing computer program code, a programmable device containing multiple accelerators, and a software library. This segmentation allows compute-intensive tasks to be offloaded to specialized hardware accelerators while maintaining a clean separation between control logic and execution, thus improving performance without overwhelming system complexity
Solution Approach 2:
A software library acts as an intermediary between the processor and the accelerators in the programmable device. The processor calls functions in the software library, which then dynamically generate and deploy appropriate accelerator images to handle compute-intensive operations. This intermediary layer simplifies the interface for the processor while enabling complex hardware acceleration capabilities
2Speed
If hardware accelerators are dynamically generated and deployed, then processing speed and run-time efficiency are improved, but device complexity and manufacturing complexity increase
Solution Approach 1:
The system employs dynamic generation and deployment of accelerator images based on runtime requirements. When the processor executes code that calls the software library, the appropriate accelerator is dynamically created and deployed to the programmable device. This dynamic approach allows the system to adapt to varying computational needs without requiring all possible accelerators to be pre-configured, thus improving processing speed while managing manufacturing complexity
Solution Approach 2:
The system changes the state of the programmable device by loading different accelerator images into it based on the computational task at hand. The accelerator image generation module transforms code portions into hardware descriptions and configures the programmable device accordingly. This parameter change approach allows the same hardware platform to be reconfigured for different tasks, improving processing speed without requiring multiple fixed hardware designs
3Productivity
If compute power is placed closer to data using accelerators, then bottlenecks are eliminated and run-time efficiency is improved, but system architecture complexity and device complexity increase
Solution Approach 1:
The system merges the processor, software library, and programmable device with multiple accelerators into an integrated architecture. The processor and programmable device communicate through a standardized interface, allowing compute power to be placed closer to data while maintaining a unified system view. This merging reduces the need for complex intermediate interfaces and simplifies the overall system architecture despite the added computational capabilities
Solution Approach 2:
The programmable device serves multiple functions by hosting different types of accelerators that can handle various compute-intensive tasks. The same programmable device can be reconfigured to provide different acceleration capabilities based on the computational requirements. This multi-functionality reduces the need for multiple specialized devices, thereby managing system complexity while providing versatile compute power close to data
Data Source
AI summary
A computer program includes calls to a software library. A virtual function table is built that includes the calls to the software library in the computer program. A programmable device includes one or more currently-implemented accelerators. The available accelerators that are currently-implemented are determined. The calls in the software library that correspond to a currently-implemented accelerator are determined. One or more calls to the software library in the virtual function table are replaced with one or more corresponding calls to a corresponding currently-implemented accelerator. When a call in the software library could be implemented in a new accelerator, an accelerator image for the new accelerator is dynamically generated. The accelerator image is then deployed to create the new accelerator. One or more calls to the software library in the virtual function table are replaced with one or more corresponding calls to the new accelerator.