Fix GPU Stats not cycling through multiple GPUs

Author: pratnala

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.PerformanceMonitor/DevHome/Helpers/GPUStats.cs

@@ -16,12 +16,11 @@ internal sealed partial class GPUStats : PerformanceCounterSourceBase, IDisposab
     private const string GpuEngineCategoryName = "GPU Engine";
     private const string UtilizationPercentageCounter = "Utilization Percentage";
 
-    private static readonly CompositeFormat TemperatureFormat = CompositeFormat.Parse("{0:0.} \u00B0C");
+    private static readonly CompositeFormat TemperatureFormat = CompositeFormat.Parse("{0:0.} °C");
 
     // Instance-name key tokens
     private const string KeyPid = "pid";
     private const string KeyLuid = "luid";
-    private const string KeyPhys = "phys";
     private const string KeyEngineType = "engtype";
 
     // Engine type filter
@@ -34,8 +33,12 @@ internal sealed partial class GPUStats : PerformanceCounterSourceBase, IDisposab
     // Batch read via category - single kernel transition per tick
     private readonly PerformanceCounterCategory? _gpuEngineCategory;
 
-    // Discovered physical GPU IDs
-    private readonly HashSet<int> _knownPhysIds = [];
+    // Friendly adapter names (and software flag) keyed by LUID, resolved via DXGI.
+    private readonly Dictionary<long, GpuAdapterNames.AdapterInfo> _adaptersByLuid;
+
+    // LUIDs we've already turned into a _stats entry, or deliberately skipped
+    // (e.g. software adapters). Used to discover GPUs at most once each.
+    private readonly HashSet<long> _knownLuids = [];
 
     private readonly List<Data> _stats = [];
 
@@ -48,7 +51,7 @@ public sealed class Data
     {
         public string? Name { get; set; }
 
-        public int PhysId { get; set; }
+        public long LuidKey { get; set; }
 
         public float Usage { get; set; }
 
@@ -60,12 +63,12 @@ public sealed class Data
     public GPUStats()
     {
         _gpuEngineCategory = CreatePerformanceCounterCategory(GpuEngineCategoryName);
+        _adaptersByLuid = GpuAdapterNames.GetByLuid();
 
-        GetGPUPerfCounters();
-        LoadGPUsFromCounters();
+        DiscoverGPUsFromCounters();
     }
 
-    public void GetGPUPerfCounters()
+    public void DiscoverGPUsFromCounters()
     {
         if (_gpuEngineCategory is null)
         {
@@ -74,21 +77,12 @@ public void GetGPUPerfCounters()
 
         try
         {
-            // There are really 4 different things we should be tracking the usage
-            // of. Similar to how the instance name ends with `3D`, the following
-            // suffixes are important.
-            //
-            // * `3D`
-            // * `VideoEncode`
-            // * `VideoDecode`
-            // * `VideoProcessing`
-            //
-            // We could totally put each of those sets of counters into their own
-            // set. That's what we should do, so that we can report the sum of those
-            // numbers as the total utilization, and then have them broken out in
-            // the card template and in the details metadata.
-            _knownPhysIds.Clear();
-
+            // The old Dev Home code keyed GPUs by the "phys_N" token in the
+            // instance name, assuming it enumerated physical adapters. On modern
+            // Windows that token is effectively always "phys_0" - even on machines
+            // with multiple discrete GPUs - so every adapter collapsed into a
+            // single bucket and Prev/Next GPU had nothing to cycle through. The
+            // real per-adapter identifier is the LUID, so we key on that instead.
             var instanceNames = _gpuEngineCategory.GetInstanceNames();
 
             foreach (var instanceName in instanceNames)
@@ -98,15 +92,9 @@ public void GetGPUPerfCounters()
                     continue;
                 }
 
-                var counterKey = instanceName;
-
-                // skip these values
-                GetKeyValueFromCounterKey(KeyPid, ref counterKey);
-                GetKeyValueFromCounterKey(KeyLuid, ref counterKey);
-
-                if (int.TryParse(GetKeyValueFromCounterKey(KeyPhys, ref counterKey), out var phys))
+                if (TryGetLuidKey(instanceName, out var luidKey))
                 {
-                    _knownPhysIds.Add(phys);
+                    AddGpuIfNew(luidKey);
                 }
             }
         }
@@ -116,23 +104,6 @@ public void GetGPUPerfCounters()
         }
     }
 
-    public void LoadGPUsFromCounters()
-    {
-        // The old dev home code tracked GPU stats by querying WMI for the list
-        // of GPUs, and then matching them up with the performance counter IDs.
-        //
-        // We can't use WMI here, because it drags in a dependency on
-        // Microsoft.Management.Infrastructure, which is not compatible with
-        // AOT.
-        //
-        // For now, we'll just use the indices as the GPU names.
-        _stats.Clear();
-        foreach (var id in _knownPhysIds)
-        {
-            _stats.Add(new Data() { PhysId = id, Name = GpuNamePrefix + id });
-        }
-    }
-
     public void GetData()
     {
         if (_gpuEngineCategory is null)
@@ -152,8 +123,8 @@ public void GetData()
 
             var utilizationData = categoryData[UtilizationPercentageCounter];
 
-            // Accumulate usage per physical GPU
-            var gpuUsage = new Dictionary<int, float>();
+            // Accumulate usage per physical GPU, keyed by adapter LUID.
+            var gpuUsage = new Dictionary<long, float>();
             var currentSamples = new Dictionary<string, CounterSample>();
 
             foreach (InstanceData instance in utilizationData.Values)
@@ -164,15 +135,16 @@ public void GetData()
                     continue;
                 }
 
-                var counterKey = instanceName;
-                GetKeyValueFromCounterKey(KeyPid, ref counterKey);
-                GetKeyValueFromCounterKey(KeyLuid, ref counterKey);
-
-                if (!int.TryParse(GetKeyValueFromCounterKey(KeyPhys, ref counterKey), out var phys))
+                if (!TryGetLuidKey(instanceName, out var luidKey))
                 {
                     continue;
                 }
 
+                // A GPU can register counter instances after we were constructed
+                // (e.g. a discrete GPU coming out of an idle low-power state), so
+                // keep discovering here rather than only in the constructor.
+                AddGpuIfNew(luidKey);
+
                 var sample = instance.Sample;
                 currentSamples[instanceName] = sample;
 
@@ -181,7 +153,7 @@ public void GetData()
                     try
                     {
                         var cookedValue = CounterSampleCalculator.ComputeCounterValue(prevSample, sample);
-                        gpuUsage[phys] = gpuUsage.GetValueOrDefault(phys) + cookedValue;
+                        gpuUsage[luidKey] = gpuUsage.GetValueOrDefault(luidKey) + cookedValue;
                     }
                     catch (Exception)
                     {
@@ -196,7 +168,7 @@ public void GetData()
             // Update stats
             foreach (var gpu in _stats)
             {
-                var sum = gpuUsage.TryGetValue(gpu.PhysId, out var usage) ? usage : 0f;
+                var sum = gpuUsage.TryGetValue(gpu.LuidKey, out var usage) ? usage : 0f;
                 gpu.Usage = sum / 100;
                 lock (gpu.GpuChartValues)
                 {
@@ -210,6 +182,29 @@ public void GetData()
         }
     }
 
+    private void AddGpuIfNew(long luidKey)
+    {
+        if (!_knownLuids.Add(luidKey))
+        {
+            return;
+        }
+
+        _adaptersByLuid.TryGetValue(luidKey, out var info);
+
+        // Hide software adapters (e.g. the Microsoft Basic Render Driver / WARP):
+        // they report 3D engine activity but aren't a GPU the user cares about.
+        if (info.IsSoftware)
+        {
+            return;
+        }
+
+        var name = string.IsNullOrEmpty(info.Description)
+            ? GpuNamePrefix + _stats.Count
+            : info.Description;
+
+        _stats.Add(new Data() { LuidKey = luidKey, Name = name });
+    }
+
     internal string CreateGPUImageUrl(int gpuChartIndex)
     {
         if (_stats.Count <= gpuChartIndex)
@@ -292,7 +287,51 @@ internal string GetGPUTemperature(int gpuActiveIndex)
         return string.Format(CultureInfo.InvariantCulture, TemperatureFormat.Format, temperature);
     }
 
-    private string GetKeyValueFromCounterKey(string key, ref string counterKey)
+    private static bool TryGetLuidKey(string instanceName, out long luidKey)
+    {
+        // Instance names look like:
+        //   pid_1234_luid_0x00000000_0x0001766D_phys_0_eng_0_engtype_3D
+        // We only need the LUID; advance past the pid token, then read the luid.
+        var counterKey = instanceName;
+        GetKeyValueFromCounterKey(KeyPid, ref counterKey);
+        var luid = GetKeyValueFromCounterKey(KeyLuid, ref counterKey);
+
+        return TryParseLuidKey(luid, out luidKey);
+    }
+
+    private static bool TryParseLuidKey(string luid, out long luidKey)
+    {
+        luidKey = 0;
+
+        // The luid token is "0x{HighPart}_0x{LowPart}", matching DXGI's
+        // LUID.HighPart / LUID.LowPart so the key lines up with GpuAdapterNames.
+        var separator = luid.IndexOf('_');
+        if (separator < 0)
+        {
+            return false;
+        }
+
+        if (!TryParseHex(luid.AsSpan(0, separator), out var high) ||
+            !TryParseHex(luid.AsSpan(separator + 1), out var low))
+        {
+            return false;
+        }
+
+        luidKey = ((long)high << 32) | low;
+        return true;
+    }
+
+    private static bool TryParseHex(ReadOnlySpan<char> token, out uint value)
+    {
+        if (token.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
+        {
+            token = token[2..];
+        }
+
+        return uint.TryParse(token, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out value);
+    }
+
+    private static string GetKeyValueFromCounterKey(string key, ref string counterKey)
     {
         if (!counterKey.StartsWith(key, StringComparison.InvariantCulture))
         {

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.PerformanceMonitor/DevHome/Helpers/GpuAdapterNames.cs

@@ -0,0 +1,94 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using Microsoft.CmdPal.Common;
+using Windows.Win32;
+using Windows.Win32.Graphics.Dxgi;
+
+namespace CoreWidgetProvider.Helpers;
+
+/// <summary>
+/// Resolves friendly GPU adapter names (and whether an adapter is a software
+/// renderer) keyed by adapter LUID, using DXGI.
+///
+/// The "GPU Engine" performance counters identify each physical adapter by its
+/// LUID, but not by name, so we enumerate DXGI adapters once and match them up.
+/// We can't use WMI for this (it isn't AOT-compatible), but DXGI via CsWin32 is.
+/// </summary>
+internal static class GpuAdapterNames
+{
+    // DXGI_ADAPTER_FLAG_SOFTWARE - marks the Microsoft Basic Render Driver (WARP).
+    private const uint DxgiAdapterFlagSoftware = 0x2;
+
+    internal readonly record struct AdapterInfo(string Description, bool IsSoftware);
+
+    /// <summary>
+    /// Enumerates the system's DXGI adapters and returns their descriptions keyed
+    /// by LUID. The key matches <see cref="GPUStats"/>'s LUID parsing:
+    /// <c>(HighPart &lt;&lt; 32) | LowPart</c>. Returns an empty map on any failure;
+    /// callers fall back to generic names.
+    /// </summary>
+    internal static unsafe Dictionary<long, AdapterInfo> GetByLuid()
+    {
+        var adapters = new Dictionary<long, AdapterInfo>();
+
+        IDXGIFactory1* factory = null;
+
+        try
+        {
+            if (PInvoke.CreateDXGIFactory1(IDXGIFactory1.IID_Guid, out var factoryPtr).Failed || factoryPtr is null)
+            {
+                return adapters;
+            }
+
+            factory = (IDXGIFactory1*)factoryPtr;
+
+            for (uint index = 0; ; index++)
+            {
+                IDXGIAdapter1* adapter = null;
+
+                // EnumAdapters1 returns DXGI_ERROR_NOT_FOUND once we walk past the
+                // last adapter, which surfaces here as a failed HRESULT.
+                if (factory->EnumAdapters1(index, &adapter).Failed || adapter is null)
+                {
+                    break;
+                }
+
+                try
+                {
+                    DXGI_ADAPTER_DESC1 desc = default;
+                    if (adapter->GetDesc1(&desc).Failed)
+                    {
+                        continue;
+                    }
+
+                    var luidKey = ((long)(uint)desc.AdapterLuid.HighPart << 32) | desc.AdapterLuid.LowPart;
+                    var isSoftware = ((uint)desc.Flags & DxgiAdapterFlagSoftware) != 0;
+                    var description = desc.Description.ToString().TrimEnd('\0');
+
+                    adapters[luidKey] = new AdapterInfo(description, isSoftware);
+                }
+                finally
+                {
+                    adapter->Release();
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            CoreLogger.LogError("Failed to enumerate DXGI adapters for GPU names.", ex);
+        }
+        finally
+        {
+            if (factory is not null)
+            {
+                factory->Release();
+            }
+        }
+
+        return adapters;
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.PerformanceMonitor/NativeMethods.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://aka.ms/CsWin32.schema.json",
+  "allowMarshaling": false,
+  "comInterop": {
+    "preserveSigMethods": [ "*" ]
+  }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.PerformanceMonitor/NativeMethods.txt

@@ -1,2 +1,6 @@
 GlobalMemoryStatusEx
 GetSystemPowerStatus
+CreateDXGIFactory1
+IDXGIFactory1
+IDXGIAdapter1
+DXGI_ADAPTER_DESC1

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.PerformanceMonitor/PerformanceWidgetsPage.cs

@@ -156,6 +156,14 @@ public PerformanceWidgetsPage(SettingsManager settingsManager, bool isBandPage =
             _gpuPage.Updated += (s, e) =>
             {
                 _gpuItem.Title = _gpuPage.GetItemTitle(isBandPage);
+                if (_isBandPage)
+                {
+                    // Bands only show the usage percentage as the title, so put
+                    // the active GPU's name in the subtitle - otherwise cycling
+                    // Prev/Next GPU between two idle adapters looks like nothing
+                    // changed.
+                    _gpuItem.Subtitle = _gpuPage.GetBandSubtitle();
+                }
             };
         }
 
@@ -1040,6 +1048,16 @@ public string GetItemTitle(bool isBandPage)
         }
     }
 
+    public string GetBandSubtitle()
+    {
+        if (ContentData.TryGetValue("gpuName", out var name) && !string.IsNullOrEmpty(name))
+        {
+            return name;
+        }
+
+        return Resources.GetResource("GPU_Usage_Subtitle");
+    }
+
     internal override void PushActivate()
     {
         base.PushActivate();