IRQ Priority Optimization for Gaming on Windows 11

Every time your GPU finishes rendering a frame or your network card receives a packet, it raises an interrupt — a hardware signal that tells the CPU to stop what it is doing and handle an urgent event. How quickly the CPU responds to these interrupts, and in what order competing interrupts are serviced, is determined by the Interrupt Request (IRQ) system. Optimizing IRQ priority so your GPU and NIC get faster CPU attention can reduce display latency and network jitter in ways that benchmark profiles rarely capture.

What Are IRQs?

An IRQ is a numbered signal line that hardware devices use to get the CPU’s attention. Legacy systems had 15 IRQ lines (IRQ 0–15) with fixed assignments (IRQ 1 = keyboard, IRQ 14 = IDE controller, etc.). Modern systems use Message Signaled Interrupts (MSI) and MSI-X, which are more flexible — devices send interrupt data directly over the PCIe bus rather than using dedicated signal lines.

Despite this evolution, Windows still represents all interrupts as IRQs in its management layer. The kernel’s HAL (Hardware Abstraction Layer) manages interrupt dispatching and priority through an IRQL (Interrupt Request Level) system with 32 levels on x64 Windows.

For gaming, the key devices are:

• GPU: Needs fast interrupt response to signal frame completion and handle DX12/Vulkan fence events.
• Network Interface Card (NIC): Each received packet generates an interrupt; delay adds jitter.
• USB controller: Mouse and keyboard input paths run through USB interrupts.
• Audio controller: Buffer underruns cause audio glitches if interrupts are delayed.

Viewing IRQ Assignments

Method 1: Device Manager

1. Press Win + X → Device Manager.
2. Click View → Resources by type.
3. Expand Interrupt request (IRQ).

This shows every device and its IRQ number. Look for devices sharing the same IRQ — shared IRQs mean the interrupt handler must poll multiple devices for each interrupt, adding latency.

Method 2: msinfo32

# Open System Information
msinfo32

Navigate to Hardware Resources → IRQs in the left pane. This provides a cleaner list than Device Manager and shows the IRQ number, device name, and bus type.

Method 3: PowerShell

# List all IRQ assignments
Get-WmiObject -Class Win32_IRQResource | Sort-Object IRQNumber | `
    Format-Table IRQNumber, Name, Availability -AutoSize

# Find your GPU's interrupt information
Get-WmiObject -Class Win32_VideoController | Select-Object Name, IRQNumber

Method 4: GPU-Z and HWiNFO64

HWiNFO64 (hwinfo64.com) provides a comprehensive IRQ and interrupt rate view under System Summary → Motherboard section. It shows real-time interrupt rates per device — crucial for confirming which device is your GPU.

Understanding MSI Mode

Most modern GPUs operate in MSI (Message Signaled Interrupt) mode by default, which is better than legacy INTx interrupts. MSI allows a device to write an interrupt message to the CPU directly over PCIe, avoiding shared IRQ lines entirely.

MSI-X (Extended) allows a device to use multiple interrupt vectors — allowing different GPU sub-functions (display, video decode, 3D engine) to each have their own interrupt, further reducing contention.

Verify your GPU is using MSI:

# Check if GPU is using MSI mode (look for "MessageBased" = True)
Get-WmiObject -Namespace root\wmi -Class MSIInfo -ErrorAction SilentlyContinue | Format-List

If not available via WMI, use MSI Mode Utility v3 (available on guru3d.com) for a GUI view and toggle.

Raising GPU Interrupt Priority via Registry

Windows assigns interrupt service routine (ISR) priorities. You can raise the GPU’s priority so it preempts lower-priority device interrupts:

# Find your GPU's device instance path first
$gpu = Get-PnpDevice | Where-Object {$_.Class -eq "Display"} | Select-Object -First 1
Write-Host "GPU Device ID: $($gpu.DeviceID)"

Once you have the device instance path (e.g., PCI\VEN_10DE&DEV_2684...):

# Navigate to the device's interrupt management key
# Replace the DevicePath with your actual GPU device instance path
$devicePath = "PCI\VEN_10DE&DEV_2684&SUBSYS_40963842&REV_A1\4&2A027DE4&0&0008"
$regPath = "HKLM:\SYSTEM\CurrentControlSet\Enum\$devicePath\Device Parameters\Interrupt Management\MessageSignaledInterruptProperties"

# Enable MSI if not already enabled
If (-not (Test-Path $regPath)) {
    New-Item -Path $regPath -Force | Out-Null
}
New-ItemProperty -Path $regPath -Name "MSISupported" -Value 1 -PropertyType DWord -Force

# Set MSI message limit (higher = more interrupt vectors)
New-ItemProperty -Path $regPath -Name "MessageNumberLimit" -Value 5 -PropertyType DWord -Force

Write-Host "GPU MSI settings updated. Restart required."

Raising NIC Interrupt Priority

The NIC path is similar. For Intel NICs, MSI-X is usually already active. The key optimization is ensuring the NIC’s interrupts land on a dedicated CPU core rather than core 0:

# Find NIC device path
$nic = Get-PnpDevice | Where-Object {$_.Class -eq "Net" -and $_.FriendlyName -like "*Intel*"} | Select-Object -First 1
Write-Host "NIC: $($nic.FriendlyName)"
Write-Host "Device ID: $($nic.DeviceID)"

# Enable MSI on NIC (same pattern as GPU)
$nicDevicePath = "PCI\VEN_8086&DEV_15F3..."  # Replace with your actual NIC device ID
$nicRegPath = "HKLM:\SYSTEM\CurrentControlSet\Enum\$nicDevicePath\Device Parameters\Interrupt Management\MessageSignaledInterruptProperties"

If (-not (Test-Path $nicRegPath)) {
    New-Item -Path $nicRegPath -Force | Out-Null
}
New-ItemProperty -Path $nicRegPath -Name "MSISupported" -Value 1 -PropertyType DWord -Force

GPU Interrupt Affinity — Pinning Interrupts to a Core

Interrupt affinity controls which CPU core handles a device’s interrupts. By default, Windows distributes interrupts across cores dynamically. For the GPU, pinning interrupts to a dedicated high-performance core reduces context switch variance:

# Set GPU interrupt affinity (pin to core 3 = affinity mask 0x8 = binary 1000)
$affinityPath = "HKLM:\SYSTEM\CurrentControlSet\Enum\$devicePath\Device Parameters\Interrupt Management\Affinity Policy"

If (-not (Test-Path $affinityPath)) {
    New-Item -Path $affinityPath -Force | Out-Null
}

# DevicePolicy 4 = IrqPolicySpecifiedProcessors (use specific core)
New-ItemProperty -Path $affinityPath -Name "DevicePolicy" -Value 4 -PropertyType DWord -Force

# AssignmentSetOverride is a bitmask of cores; 0x8 = core 3 only
New-ItemProperty -Path $affinityPath -Name "AssignmentSetOverride" -Value 8 -PropertyType Binary -Force

Write-Host "GPU interrupt affinity pinned to core 3. Restart required."

Choose a core that is not core 0 (used heavily by OS interrupts) and not your game’s primary render thread core. On an 8-core CPU, core 3 or core 5 is typically a good choice.

IRQ Priority via the HAL Dispatch Table

For advanced users, LatencyMon (resplendence.com) provides real-time interrupt latency analysis showing which drivers are causing the highest interrupt service latencies. This is the diagnostic tool to use before committing to registry changes — it shows you exactly which IRQ is your bottleneck.

Download and run LatencyMon → Start → let it run for 5 minutes while gaming → 
check "Drivers" tab for highest Interrupt Service Routine (ISR) times

Drivers with ISR times consistently above 100 µs are candidates for attention. Your GPU driver (nvlddmkm.sys or amdkmdag.sys) and NIC driver should both be under 50 µs in a healthy system.

Practical Results to Expect

Optimization	Impact
GPU MSI enabled (if not already)	Eliminates shared IRQ contention
GPU interrupt affinity pinned	0–1 ms reduction in frame delivery variance
NIC MSI-X with dedicated vectors	0.5–2 ms jitter reduction
All devices off core 0	More consistent OS response times

IRQ optimization is deep work — it rarely transforms a bad gaming experience into a good one, but it adds a layer of determinism to an already well-tuned system. Pair it with timer resolution tuning and NIC advanced settings for the full low-latency stack.

Safety and Reverting

All registry changes here are in HKLM:\SYSTEM\CurrentControlSet\Enum\ under device-specific paths. To revert:

# Remove GPU affinity policy (revert to Windows default)
Remove-Item -Path $affinityPath -Recurse -Force -ErrorAction SilentlyContinue

# Remove MSI overrides
$regPath = "...path to your GPU MSI key..."
Remove-ItemProperty -Path $regPath -Name "MessageNumberLimit" -ErrorAction SilentlyContinue

Always note the original values before changing them, and restart after each change to verify system stability before proceeding to the next modification.