Virtual Interrupt Delivery from GPU Without Hardware Support
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In computing systems with non-SR-IOV based GPUs, delivering interrupts to virtual machines (VMs) is challenging due to reduced performance and high implementation complexity, as the hypervisor lacks contextual information to steer virtual interrupts accurately without hardware support.
Innovation Solution
A method involving loading a driver component on the hypervisor and each VM, allocating a memory page for work completion, sharing it with the hypervisor, and delivering interrupts based on inspecting the memory page to ensure accurate interrupt delivery from the GPU to the appropriate VM.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If a single driver stack executes on the hypervisor for non-SR-IOV based GPU, then interrupt delivery to hypervisor is enabled, but performance is reduced because applications in VMs are no longer closely coupled to GPU hardware
Solution Approach 1:
The driver functionality is segmented between the hypervisor level (for interrupt delivery and resource management) and the VM level (for application coupling). Each VM receives a driver component that maintains close coupling to GPU hardware while the hypervisor handles interrupt steering, thus separating concerns to achieve both reliability and performance.
Solution Approach 2:
A driver component is introduced as an intermediary layer between the GPU hardware and VMs. This component resides in each VM but is coordinated by the hypervisor, allowing applications to maintain close hardware coupling while the hypervisor mediates interrupt delivery to the appropriate VMs based on contextual information.
2Productivity
If a GPU driver stack executes in each VM for non SR-IOV based GPU, then performance is improved, but multiplexing hardware for interrupt delivery becomes challenging
Solution Approach 1:
The driver stack functionality is segmented such that lightweight driver components execute in each VM while the heavy lifting of interrupt management and hardware interaction is segmented to the hypervisor level. This segmentation reduces the complexity of interrupt multiplexing in each VM while maintaining performance benefits.
Solution Approach 2:
The hypervisor's driver stack is designed to be universal, handling interrupt delivery for multiple VMs simultaneously. It provides multi-functional capabilities including interrupt steering, contextual information management, and coordination with multiple driver components across different VMs, thus simplifying the overall system architecture.
3Reliability
If GPU interrupts are serviced in the hypervisor and virtual interrupts are steered to VMs, then interrupt delivery is enabled, but it is impossible without contextual information normally held within the GPU driver stack
Solution Approach 1:
The critical contextual information needed for interrupt steering is extracted from the traditional monolithic driver stack and placed in the hypervisor's driver component. This extracted information includes VM identification, interrupt routing tables, and device state context, enabling the hypervisor to perform interrupt steering without losing essential information.
Solution Approach 2:
A feedback mechanism is established where the driver component in each VM provides contextual information back to the hypervisor, and the hypervisor uses this feedback to make informed decisions about interrupt routing. This continuous information exchange ensures that interrupt steering accuracy is maintained despite the distributed architecture.
Data Source
AI summary
A method includes loading a driver component on a hypervisor of a computing system including a Graphics Processing Unit (GPU) without hardware support for virtual interrupt delivery, and loading an instance of the driver component on each of a number of VMs consolidated on a computing platform of the computing system. The method also includes allocating a memory page associated with work completion by the each of the number of VMs thereto through a driver stack executing on the hypervisor, and sharing the memory page with the driver component executing on the hypervisor. Further, the method includes delivering, through the hypervisor, an interrupt from the GPU to an appropriate VM based on inspecting the memory page associated with the work completion by the each of the number of VMs.