Fix "Unknown Processor" on Windows if WMIC is not present

src/BenchmarkDotNet/Detectors/Cpu/Linux/LinuxCpuDetector.cs

@@ -24,8 +24,12 @@ internal class LinuxCpuDetector : ICpuDetector
             ["LANGUAGE"] = "C"
         };
 
-        string cpuInfo = ProcessHelper.RunAndReadOutput("cat", "/proc/cpuinfo") ?? "";
-        string lscpu = ProcessHelper.RunAndReadOutput("/bin/bash", "-c \"lscpu\"", environmentVariables: languageInvariantEnvironment);
+        string? cpuInfo = ProcessHelper.RunAndReadOutput("cat", "/proc/cpuinfo") ?? string.Empty;
+        string? lscpu = ProcessHelper.RunAndReadOutput("/bin/bash", "-c \"lscpu\"", environmentVariables: languageInvariantEnvironment) ?? string.Empty;
+
+        if (cpuInfo == string.Empty && lscpu == string.Empty)
+            return null;
+
         return LinuxCpuInfoParser.Parse(cpuInfo, lscpu);
     }
 }

src/BenchmarkDotNet/Detectors/Cpu/Linux/LinuxCpuInfoParser.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
 using BenchmarkDotNet.Extensions;
@@ -17,6 +18,8 @@ private static class ProcCpu
         internal const string CpuCores = "cpu cores";
         internal const string ModelName = "model name";
         internal const string MaxFrequency = "max freq";
+        internal const string NominalFrequencyBackup = "nominal freq";
+        internal const string NominalFrequency = "cpu MHz";
     }
 
     private static class Lscpu
@@ -28,12 +31,13 @@ private static class Lscpu
 
     /// <param name="cpuInfo">Output of `cat /proc/cpuinfo`</param>
     /// <param name="lscpu">Output of `lscpu`</param>
-    internal static CpuInfo Parse(string? cpuInfo, string? lscpu)
+    internal static CpuInfo Parse(string cpuInfo, string lscpu)
     {
         var processorModelNames = new HashSet<string>();
         var processorsToPhysicalCoreCount = new Dictionary<string, int>();
         int logicalCoreCount = 0;
-        Frequency? maxFrequency = null;
+        double maxFrequency = 0.0;
+        double nominalFrequency = 0.0;
 
         var logicalCores = SectionsHelper.ParseSections(cpuInfo, ':');
         foreach (var logicalCore in logicalCores)
@@ -51,14 +55,43 @@ internal static CpuInfo Parse(string? cpuInfo, string? lscpu)
             }
 
             if (logicalCore.TryGetValue(ProcCpu.MaxFrequency, out string maxCpuFreqValue) &&
-                Frequency.TryParseMHz(maxCpuFreqValue, out var maxCpuFreq))
+                Frequency.TryParseMHz(maxCpuFreqValue.Replace(',', '.'), out Frequency maxCpuFreq)
+                && maxCpuFreq > 0)
             {
-                maxFrequency = maxCpuFreq;
+                maxFrequency = Math.Max(maxFrequency, maxCpuFreq.ToMHz());
+            }
+
+            bool nominalFrequencyHasValue = logicalCore.TryGetValue(ProcCpu.NominalFrequency, out string nominalFreqValue);
+            bool nominalFrequencyBackupHasValue = logicalCore.TryGetValue(ProcCpu.NominalFrequencyBackup, out string nominalFreqBackupValue);
+
+            double nominalCpuFreq = 0.0;
+            double nominalCpuBackupFreq = 0.0;
+
+            if (nominalFrequencyHasValue &&
+                double.TryParse(nominalFreqValue, out nominalCpuFreq)
+                && nominalCpuFreq > 0)
+            {
+                nominalCpuFreq = nominalFrequency == 0 ? nominalCpuFreq : Math.Min(nominalFrequency, nominalCpuFreq);
+            }
+            if (nominalFrequencyBackupHasValue &&
+                     double.TryParse(nominalFreqBackupValue, out nominalCpuBackupFreq)
+                     && nominalCpuBackupFreq > 0)
+            {
+                nominalCpuBackupFreq = nominalFrequency == 0 ? nominalCpuBackupFreq : Math.Min(nominalFrequency, nominalCpuBackupFreq);
+            }
+
+            if (nominalFrequencyHasValue && nominalFrequencyBackupHasValue)
+            {
+                nominalFrequency = Math.Min(nominalCpuFreq, nominalCpuBackupFreq);
+            }
+            else
+            {
+                nominalFrequency = nominalCpuFreq == 0.0 ? nominalCpuBackupFreq : nominalCpuFreq;
             }
         }
 
         int? coresPerSocket = null;
-        if (lscpu != null)
+        if (string.IsNullOrEmpty(lscpu) == false)
         {
             var lscpuParts = lscpu.Split('\n')
                 .Where(line => line.Contains(':'))
@@ -70,8 +103,8 @@ internal static CpuInfo Parse(string? cpuInfo, string? lscpu)
                 string value = lscpuParts[i + 1].Trim();
 
                 if (name.EqualsWithIgnoreCase(Lscpu.MaxFrequency) &&
-                    Frequency.TryParseMHz(value.Replace(',', '.'), out var maxFrequencyParsed)) // Example: `CPU max MHz: 3200,0000`
-                    maxFrequency = maxFrequencyParsed;
+                    Frequency.TryParseMHz(value.Replace(',', '.'), out Frequency maxFrequencyParsed)) // Example: `CPU max MHz: 3200,0000`
+                    maxFrequency = Math.Max(maxFrequency, maxFrequencyParsed.ToMHz());
 
                 if (name.EqualsWithIgnoreCase(Lscpu.ModelName))
                     processorModelNames.Add(value);
@@ -82,21 +115,33 @@ internal static CpuInfo Parse(string? cpuInfo, string? lscpu)
             }
         }
 
-        var nominalFrequency = processorModelNames
-            .Select(ParseFrequencyFromBrandString)
-            .WhereNotNull()
-            .FirstOrDefault() ?? maxFrequency;
         string processorName = processorModelNames.Count > 0 ? string.Join(", ", processorModelNames) : null;
         int? physicalProcessorCount = processorsToPhysicalCoreCount.Count > 0 ? processorsToPhysicalCoreCount.Count : null;
         int? physicalCoreCount = processorsToPhysicalCoreCount.Count > 0 ? processorsToPhysicalCoreCount.Values.Sum() : coresPerSocket;
+
+        Frequency? maxFrequencyActual = maxFrequency > 0 && physicalProcessorCount > 0
+            ? Frequency.FromMHz(maxFrequency) : null;
+
+        Frequency? nominalFrequencyActual = nominalFrequency > 0 && physicalProcessorCount > 0
+            ? Frequency.FromMHz(nominalFrequency) : null;
+
+        if (nominalFrequencyActual is null)
+        {
+            bool nominalFrequencyInBrandString = processorModelNames.Any(x => ParseFrequencyFromBrandString(x) is not null);
+
+            if (nominalFrequencyInBrandString)
+                nominalFrequencyActual = processorModelNames.Select(x => ParseFrequencyFromBrandString(x))
+                    .First(x => x is not null);
+        }
+
         return new CpuInfo
         {
             ProcessorName = processorName,
             PhysicalProcessorCount = physicalProcessorCount,
             PhysicalCoreCount = physicalCoreCount,
             LogicalCoreCount = logicalCoreCount > 0 ? logicalCoreCount : null,
-            NominalFrequencyHz = nominalFrequency?.Hertz.RoundToLong(),
-            MaxFrequencyHz = maxFrequency?.Hertz.RoundToLong()
+            NominalFrequencyHz = nominalFrequencyActual?.Hertz.RoundToLong(),
+            MaxFrequencyHz = maxFrequencyActual?.Hertz.RoundToLong()
         };
     }
 
@@ -107,7 +152,7 @@ internal static CpuInfo Parse(string? cpuInfo, string? lscpu)
         if (matches.Count > 0 && matches[0].Groups.Count > 1)
         {
             string match = Regex.Matches(brandString, pattern, RegexOptions.IgnoreCase)[0].Groups[1].ToString();
-            return Frequency.TryParseGHz(match, out var result) ? result : null;
+            return Frequency.TryParseGHz(match, out Frequency result) ? result : null;
         }
 
         return null;

src/BenchmarkDotNet/Detectors/Cpu/Windows/MosCpuDetector.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Management;
 using BenchmarkDotNet.Extensions;
@@ -28,7 +29,8 @@ public bool IsApplicable() => OsDetector.IsWindows() &&
         int physicalCoreCount = 0;
         int logicalCoreCount = 0;
         int processorsCount = 0;
-        int sumMaxFrequency = 0;
+        double maxFrequency = 0;
+        double nominalFrequency = 0;
 
         using (var mosProcessor = new ManagementObjectSearcher("SELECT * FROM Win32_Processor"))
         {
@@ -41,14 +43,23 @@ public bool IsApplicable() => OsDetector.IsWindows() &&
                     processorsCount++;
                     physicalCoreCount += (int)(uint)moProcessor[WmicCpuInfoKeyNames.NumberOfCores];
                     logicalCoreCount += (int)(uint)moProcessor[WmicCpuInfoKeyNames.NumberOfLogicalProcessors];
-                    sumMaxFrequency = (int)(uint)moProcessor[WmicCpuInfoKeyNames.MaxClockSpeed];
+                    double tempMaxFrequency = (uint)moProcessor[WmicCpuInfoKeyNames.MaxClockSpeed];
+
+                    if (tempMaxFrequency > 0)
+                    {
+                        nominalFrequency = nominalFrequency == 0 ? tempMaxFrequency : Math.Min(nominalFrequency, tempMaxFrequency);
+                    }
+                    maxFrequency = Math.Max(maxFrequency, tempMaxFrequency);
                 }
             }
         }
 
         string processorName = processorModelNames.Count > 0 ? string.Join(", ", processorModelNames) : null;
-        Frequency? maxFrequency = sumMaxFrequency > 0 && processorsCount > 0
-            ? Frequency.FromMHz(sumMaxFrequency * 1.0 / processorsCount)
+        Frequency? maxFrequencyActual = maxFrequency > 0 && processorsCount > 0
+            ? Frequency.FromMHz(maxFrequency)
+            : null;
+        Frequency? nominalFrequencyActual = nominalFrequency > 0 && processorsCount > 0
+            ? Frequency.FromMHz(nominalFrequency)
             : null;
 
         return new CpuInfo
@@ -57,8 +68,8 @@ public bool IsApplicable() => OsDetector.IsWindows() &&
             PhysicalProcessorCount = processorsCount > 0 ? processorsCount : null,
             PhysicalCoreCount = physicalCoreCount > 0 ? physicalCoreCount : null,
             LogicalCoreCount = logicalCoreCount > 0 ? logicalCoreCount : null,
-            NominalFrequencyHz = maxFrequency?.Hertz.RoundToLong(),
-            MaxFrequencyHz = maxFrequency?.Hertz.RoundToLong()
+            NominalFrequencyHz = nominalFrequencyActual?.Hertz.RoundToLong(),
+            MaxFrequencyHz = maxFrequencyActual?.Hertz.RoundToLong()
         };
     }
 }

src/BenchmarkDotNet/Detectors/Cpu/Windows/PowershellWmiCpuDetector.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.Versioning;
+using System.Text.RegularExpressions;
+using BenchmarkDotNet.Helpers;
+using Perfolizer.Models;
+
+namespace BenchmarkDotNet.Detectors.Cpu.Windows;
+
+/// <summary>
+/// CPU information from output of the `wmic cpu get Name, NumberOfCores, NumberOfLogicalProcessors /Format:List` command.
+/// Windows only.
+/// </summary>
+internal class PowershellWmiCpuDetector : ICpuDetector
+{
+    private readonly string windowsPowershellPath =
+        $"{Environment.SystemDirectory}{Path.DirectorySeparatorChar}WindowsPowerShell{Path.DirectorySeparatorChar}" +
+        $"v1.0{Path.DirectorySeparatorChar}powershell.exe";
+
+    public bool IsApplicable() => OsDetector.IsWindows();
+
+    #if NET6_0_OR_GREATER
+    [SupportedOSPlatform("windows")]
+    #endif
+    public CpuInfo? Detect()
+    {
+        if (!IsApplicable()) return null;
+
+        const string argList = $"{WmicCpuInfoKeyNames.Name}, " +
+                               $"{WmicCpuInfoKeyNames.NumberOfCores}, " +
+                               $"{WmicCpuInfoKeyNames.NumberOfLogicalProcessors}, " +
+                               $"{WmicCpuInfoKeyNames.MaxClockSpeed}";
+
+        string output = ProcessHelper.RunAndReadOutput(PowerShellLocator.LocateOnWindows() ?? "PowerShell",
+            "Get-CimInstance Win32_Processor -Property " + argList);
+
+        if (string.IsNullOrEmpty(output))
+            return null;
+
+        return PowershellWmiCpuInfoParser.Parse(output);
+    }
+}

src/BenchmarkDotNet/Detectors/Cpu/Windows/PowershellWmiCpuInfoParser.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using BenchmarkDotNet.Extensions;
+using BenchmarkDotNet.Helpers;
+using Perfolizer.Horology;
+using Perfolizer.Models;
+
+namespace BenchmarkDotNet.Detectors.Cpu.Windows;
+
+internal static class PowershellWmiCpuInfoParser
+{
+    internal static CpuInfo Parse(string powershellWmiOutput)
+    {
+        HashSet<string> processorModelNames = new HashSet<string>();
+
+        int physicalCoreCount = 0;
+        int logicalCoreCount = 0;
+        int processorCount = 0;
+        double maxFrequency = 0.0;
+        double nominalFrequency = 0.0;
+
+        List<Dictionary<string, string>> processors = SectionsHelper.ParseSectionsForPowershellWmi(powershellWmiOutput, ':');
+        foreach (Dictionary<string, string> processor in processors)
+        {
+            if (processor.TryGetValue(WmicCpuInfoKeyNames.NumberOfCores, out string numberOfCoresValue) &&
+                int.TryParse(numberOfCoresValue, out int numberOfCores) &&
+                numberOfCores > 0)
+                physicalCoreCount += numberOfCores;
+
+            if (processor.TryGetValue(WmicCpuInfoKeyNames.NumberOfLogicalProcessors, out string numberOfLogicalValue) &&
+                int.TryParse(numberOfLogicalValue, out int numberOfLogical) &&
+                numberOfLogical > 0)
+                logicalCoreCount += numberOfLogical;
+
+            if (processor.TryGetValue(WmicCpuInfoKeyNames.Name, out string name))
+            {
+                processorModelNames.Add(name);
+                processorCount++;
+            }
+
+            if (processor.TryGetValue(WmicCpuInfoKeyNames.MaxClockSpeed, out string frequencyValue)
+                && double.TryParse(frequencyValue, out double frequency)
+                && frequency > 0)
+            {
+               nominalFrequency = nominalFrequency == 0 ? frequency : Math.Min(nominalFrequency, frequency);
+               maxFrequency = Math.Max(maxFrequency, frequency);
+            }
+        }
+
+        string? processorName = processorModelNames.Count > 0 ? string.Join(", ", processorModelNames) : null;
+        Frequency? maxFrequencyActual = maxFrequency > 0 && processorCount > 0
+            ? Frequency.FromMHz(maxFrequency) : null;
+
+        Frequency? nominalFrequencyActual = nominalFrequency > 0 && processorCount > 0 ?
+            Frequency.FromMHz(nominalFrequency) : null;
+
+        return new CpuInfo
+        {
+            ProcessorName = processorName,
+            PhysicalProcessorCount = processorCount > 0 ? processorCount : null,
+            PhysicalCoreCount = physicalCoreCount > 0 ? physicalCoreCount : null,
+            LogicalCoreCount = logicalCoreCount > 0 ? logicalCoreCount : null,
+            NominalFrequencyHz = nominalFrequencyActual?.Hertz.RoundToLong(),
+            MaxFrequencyHz = maxFrequencyActual?.Hertz.RoundToLong()
+        };
+    }
+}

src/BenchmarkDotNet/Detectors/Cpu/Windows/WindowsCpuDetector.cs

@@ -1,3 +1,4 @@
 namespace BenchmarkDotNet.Detectors.Cpu.Windows;
 
-internal class WindowsCpuDetector() : CpuDetector(new MosCpuDetector(), new WmicCpuDetector());
+internal class WindowsCpuDetector() : CpuDetector(new MosCpuDetector(), new PowershellWmiCpuDetector(),
+    new WmicCpuDetector());

src/BenchmarkDotNet/Detectors/Cpu/Windows/WmicCpuDetector.cs

@@ -9,6 +9,8 @@ namespace BenchmarkDotNet.Detectors.Cpu.Windows;
 /// CPU information from output of the `wmic cpu get Name, NumberOfCores, NumberOfLogicalProcessors /Format:List` command.
 /// Windows only.
 /// </summary>
+/// <remarks>WMIC is deprecated by Microsoft starting with Windows 10 21H1 (including Windows Server), and it is not known whether it still ships with Windows by default.
+/// <para>WMIC may be removed in a future version of Windows. See <see href="https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic"/> </para></remarks>
 internal class WmicCpuDetector : ICpuDetector
 {
     private const string DefaultWmicPath = @"C:\Windows\System32\wbem\WMIC.exe";
@@ -24,7 +26,11 @@ internal class WmicCpuDetector : ICpuDetector
                                $"{WmicCpuInfoKeyNames.NumberOfLogicalProcessors}, " +
                                $"{WmicCpuInfoKeyNames.MaxClockSpeed}";
         string wmicPath = File.Exists(DefaultWmicPath) ? DefaultWmicPath : "wmic";
-        string wmicOutput = ProcessHelper.RunAndReadOutput(wmicPath, $"cpu get {argList} /Format:List");
+        string? wmicOutput = ProcessHelper.RunAndReadOutput(wmicPath, $"cpu get {argList} /Format:List");
+
+        if (string.IsNullOrEmpty(wmicOutput))
+            return null;
+
         return WmicCpuInfoParser.Parse(wmicOutput);
     }
 }