Add support for custom hardware counter names

src/BenchmarkDotNet.Diagnostics.Windows/EtwProfiler.cs

@@ -92,10 +92,18 @@ public void DisplayResults(ILogger logger)
 
         private void Start(DiagnoserActionParameters parameters)
         {
-            var counters = benchmarkToCounters[parameters.BenchmarkCase] = parameters.Config
+            // Collect both built-in hardware counters and custom counters
+            var hardwareCountersList = parameters.Config
                 .GetHardwareCounters()
                 .Select(counter => HardwareCounters.FromCounter(counter, config.IntervalSelectors.TryGetValue(counter, out var selector) ? selector : GetInterval))
-                .ToArray();
+                .ToList();
+
+            var customCountersList = parameters.Config
+                .GetCustomCounters()
+                .Select(customCounter => HardwareCounters.FromCustomCounter(customCounter, GetInterval))
+                .ToList();
+
+            var counters = benchmarkToCounters[parameters.BenchmarkCase] = hardwareCountersList.Concat(customCountersList).ToArray();
 
             if (counters.Any()) // we need to enable the counters before starting the kernel session
                 HardwareCounters.Enable(counters);
@@ -145,11 +153,16 @@ private IReadOnlyDictionary<BenchmarkCase, PmcStats> BuildPmcStats()
 
             foreach (var benchmarkToCounter in benchmarkToCounters)
             {
-                var uniqueCounters = benchmarkToCounter.Value.Select(x => x.Counter).Distinct().ToImmutableArray();
+                var allCounters = benchmarkToCounter.Value;
+                var builtInCounters = allCounters.Where(x => x.Counter != HardwareCounter.NotSet).ToList();
+                var customCounters = allCounters.Where(x => x.CustomCounter != null).ToList();
+
+                var uniqueHwCounters = builtInCounters.Select(x => x.Counter).Distinct().ToImmutableArray();
 
                 var pmcStats = new PmcStats(
-                    uniqueCounters,
-                    counter => benchmarkToCounter.Value.Single(pmc => pmc.Counter == counter)
+                    uniqueHwCounters,
+                    customCounters,
+                    counter => builtInCounters.Single(pmc => pmc.Counter == counter)
                 );
 
                 builder.Add(benchmarkToCounter.Key, pmcStats);

src/BenchmarkDotNet.Diagnostics.Windows/HardwareCounters.cs

@@ -38,7 +38,10 @@ public static IEnumerable<ValidationError> Validate(ValidationParameters validat
                 yield break;
             }
 
-            if (!validationParameters.Config.GetHardwareCounters().Any() && mandatory)
+            var hasHardwareCounters = validationParameters.Config.GetHardwareCounters().Any();
+            var hasCustomCounters = validationParameters.Config.GetCustomCounters().Any();
+
+            if (!hasHardwareCounters && !hasCustomCounters && mandatory)
             {
                 yield return new ValidationError(true, "No Hardware Counters defined, probably a bug");
                 yield break;
@@ -64,6 +67,17 @@ public static IEnumerable<ValidationError> Validate(ValidationParameters validat
                     yield return new ValidationError(true, $"The counter {counterName} is not available. Please make sure you are Windows 8+ without Hyper-V");
             }
 
+            // Validate custom counters
+            foreach (var customCounter in validationParameters.Config.GetCustomCounters())
+            {
+                if (!availableCpuCounters.ContainsKey(customCounter.ProfileSourceName))
+                {
+                    yield return new ValidationError(true,
+                        $"Custom counter '{customCounter.ProfileSourceName}' is not available on this machine. " +
+                        $"Available counters: {string.Join(", ", availableCpuCounters.Keys.Take(20))}...");
+                }
+            }
+
             foreach (var benchmark in validationParameters.Benchmarks)
             {
                 if (benchmark.Job.Infrastructure.TryGetToolchain(out var toolchain) && toolchain is InProcessEmitToolchain)
@@ -80,6 +94,17 @@ internal static PreciseMachineCounter FromCounter(HardwareCounter counter, Func<
             return new PreciseMachineCounter(profileSource.ID, profileSource.Name, counter, intervalSelector(profileSource));
         }
 
+        internal static PreciseMachineCounter FromCustomCounter(CustomCounter customCounter, Func<ProfileSourceInfo, int> intervalSelector)
+        {
+            var profileSource = TraceEventProfileSources.GetInfo()[customCounter.ProfileSourceName];
+            // Use the custom counter's interval if specified, otherwise use the intervalSelector
+            var interval = customCounter.Interval != CustomCounter.DefaultInterval 
+                ? customCounter.Interval 
+                : intervalSelector(profileSource);
+
+            return new PreciseMachineCounter(profileSource.ID, profileSource.Name, customCounter, interval);
+        }
+
         internal static void Enable(IEnumerable<PreciseMachineCounter> counters)
         {
             TraceEventProfileSources.Set( // it's a must have to get the events enabled!!

src/BenchmarkDotNet.Diagnostics.Windows/Sessions.cs

@@ -69,7 +69,7 @@ internal override Session EnableProviders()
                 | KernelTraceEventParser.Keywords.ImageLoad // handles stack frames from native modules, SUPER IMPORTANT!
                 | KernelTraceEventParser.Keywords.Profile; // CPU stacks
 
-            if (Details.Config.GetHardwareCounters().Any())
+            if (Details.Config.GetHardwareCounters().Any() || Details.Config.GetCustomCounters().Any())
                 keywords |= KernelTraceEventParser.Keywords.PMCProfile; // Precise Machine Counters
 
             TraceEventSession.StackCompression = true;

src/BenchmarkDotNet/Attributes/CustomCountersAttribute.cs

@@ -0,0 +1,40 @@
+using System;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Diagnosers;
+using JetBrains.Annotations;
+
+namespace BenchmarkDotNet.Attributes
+{
+    /// <summary>
+    /// Specifies custom hardware counters to be collected during benchmarking.
+    /// Use this when the predefined HardwareCounter enum values don't match the counters 
+    /// available on your machine (e.g., AMD-specific counters like DcacheMisses, IcacheMisses).
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Assembly)]
+    public class CustomCountersAttribute : Attribute, IConfigSource
+    {
+        // CLS-Compliant Code requires a constructor without an array in the argument list
+        [PublicAPI]
+        protected CustomCountersAttribute()
+        {
+            Config = ManualConfig.CreateEmpty();
+        }
+
+        /// <summary>
+        /// Creates a CustomCountersAttribute with the specified counter names.
+        /// Counter names must match the ETW profile source names available on the machine.
+        /// Use TraceEventProfileSources.GetInfo().Keys to discover available counters.
+        /// </summary>
+        /// <param name="counterNames">The ETW profile source names (e.g., "DcacheMisses", "IcacheMisses")</param>
+        public CustomCountersAttribute(params string[] counterNames)
+        {
+            var config = ManualConfig.CreateEmpty();
+            foreach (var name in counterNames)
+            {
+                config.AddCustomCounters(new CustomCounter(name));
+            }
+            Config = config;
+        }
+        public IConfig Config { get; }
+    }
+}

src/BenchmarkDotNet/Configs/DebugConfig.cs

@@ -57,6 +57,7 @@ public abstract class DebugConfig : IConfig
         public IEnumerable<IDiagnoser> GetDiagnosers() => [];
         public IEnumerable<IAnalyser> GetAnalysers() => [];
         public IEnumerable<HardwareCounter> GetHardwareCounters() => [];
+        public IEnumerable<CustomCounter> GetCustomCounters() => [];
         public IEnumerable<EventProcessor> GetEventProcessors() => [];
         public IEnumerable<IFilter> GetFilters() => [];
         public IEnumerable<IColumnHidingRule> GetColumnHidingRules() => [];

src/BenchmarkDotNet/Configs/DefaultConfig.cs

@@ -119,6 +119,8 @@ public string ArtifactsPath
 
         public IEnumerable<HardwareCounter> GetHardwareCounters() => Array.Empty<HardwareCounter>();
 
+        public IEnumerable<CustomCounter> GetCustomCounters() => Array.Empty<CustomCounter>();
+
         public IEnumerable<IFilter> GetFilters() => Array.Empty<IFilter>();
 
         public IEnumerable<EventProcessor> GetEventProcessors() => Array.Empty<EventProcessor>();

src/BenchmarkDotNet/Configs/IConfig.cs

@@ -26,6 +26,7 @@ public interface IConfig
         IEnumerable<Job> GetJobs();
         IEnumerable<IValidator> GetValidators();
         IEnumerable<HardwareCounter> GetHardwareCounters();
+        IEnumerable<CustomCounter> GetCustomCounters();
         IEnumerable<IFilter> GetFilters();
         IEnumerable<BenchmarkLogicalGroupRule> GetLogicalGroupRules();
         IEnumerable<EventProcessor> GetEventProcessors();

src/BenchmarkDotNet/Configs/ImmutableConfig.cs

@@ -30,6 +30,7 @@ public sealed class ImmutableConfig : IConfig
         private readonly ImmutableHashSet<IValidator> validators;
         private readonly ImmutableHashSet<Job> jobs;
         private readonly ImmutableHashSet<HardwareCounter> hardwareCounters;
+        private readonly ImmutableHashSet<CustomCounter> customCounters;
         private readonly ImmutableHashSet<IFilter> filters;
         private readonly ImmutableArray<BenchmarkLogicalGroupRule> rules;
         private readonly ImmutableHashSet<EventProcessor> eventProcessors;
@@ -39,6 +40,7 @@ internal ImmutableConfig(
             ImmutableArray<IColumnProvider> uniqueColumnProviders,
             ImmutableHashSet<ILogger> uniqueLoggers,
             ImmutableHashSet<HardwareCounter> uniqueHardwareCounters,
+            ImmutableHashSet<CustomCounter> uniqueCustomCounters,
             ImmutableHashSet<IDiagnoser> uniqueDiagnosers,
             ImmutableArray<IExporter> uniqueExporters,
             ImmutableHashSet<IAnalyser> uniqueAnalyzers,
@@ -62,6 +64,7 @@ internal ImmutableConfig(
             columnProviders = uniqueColumnProviders;
             loggers = uniqueLoggers;
             hardwareCounters = uniqueHardwareCounters;
+            customCounters = uniqueCustomCounters;
             diagnosers = uniqueDiagnosers;
             exporters = uniqueExporters;
             analysers = uniqueAnalyzers;
@@ -101,6 +104,7 @@ internal ImmutableConfig(
         public IEnumerable<Job> GetJobs() => jobs;
         public IEnumerable<IValidator> GetValidators() => validators;
         public IEnumerable<HardwareCounter> GetHardwareCounters() => hardwareCounters;
+        public IEnumerable<CustomCounter> GetCustomCounters() => customCounters;
         public IEnumerable<IFilter> GetFilters() => filters;
         public IEnumerable<BenchmarkLogicalGroupRule> GetLogicalGroupRules() => rules;
         public IEnumerable<EventProcessor> GetEventProcessors() => eventProcessors;

src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs

@@ -42,7 +42,8 @@ public static ImmutableConfig Create(IConfig source)
             var configAnalyse = new List<Conclusion>();
 
             var uniqueHardwareCounters = source.GetHardwareCounters().Where(counter => counter != HardwareCounter.NotSet).ToImmutableHashSet();
-            var uniqueDiagnosers = GetDiagnosers(source.GetDiagnosers(), uniqueHardwareCounters);
+            var uniqueCustomCounters = source.GetCustomCounters().ToImmutableHashSet();
+            var uniqueDiagnosers = GetDiagnosers(source.GetDiagnosers(), uniqueHardwareCounters, uniqueCustomCounters);
             var uniqueExporters = GetExporters(source.GetExporters(), uniqueDiagnosers, configAnalyse);
             var uniqueAnalyzers = GetAnalysers(source.GetAnalysers(), uniqueDiagnosers);
 
@@ -59,6 +60,7 @@ public static ImmutableConfig Create(IConfig source)
                 uniqueColumnProviders,
                 uniqueLoggers,
                 uniqueHardwareCounters,
+                uniqueCustomCounters,
                 uniqueDiagnosers,
                 uniqueExporters,
                 uniqueAnalyzers,
@@ -81,15 +83,15 @@ public static ImmutableConfig Create(IConfig source)
             );
         }
 
-        private static ImmutableHashSet<IDiagnoser> GetDiagnosers(IEnumerable<IDiagnoser> diagnosers, ImmutableHashSet<HardwareCounter> uniqueHardwareCounters)
+        private static ImmutableHashSet<IDiagnoser> GetDiagnosers(IEnumerable<IDiagnoser> diagnosers, ImmutableHashSet<HardwareCounter> uniqueHardwareCounters, ImmutableHashSet<CustomCounter> uniqueCustomCounters)
         {
             var builder = ImmutableHashSet.CreateBuilder(new TypeComparer<IDiagnoser>());
 
             foreach (var diagnoser in diagnosers)
                 if (!builder.Contains(diagnoser))
                     builder.Add(diagnoser);
 
-            if (!uniqueHardwareCounters.IsEmpty && !diagnosers.OfType<IHardwareCountersDiagnoser>().Any())
+            if ((!uniqueHardwareCounters.IsEmpty || !uniqueCustomCounters.IsEmpty) && !diagnosers.OfType<IHardwareCountersDiagnoser>().Any())
             {
                 // if users define hardware counters via [HardwareCounters] we need to dynamically load the right diagnoser
                 var hardwareCountersDiagnoser = DiagnosersLoader.GetImplementation<IHardwareCountersDiagnoser>();

src/BenchmarkDotNet/Configs/ManualConfig.cs

@@ -32,6 +32,7 @@ public class ManualConfig : IConfig
         private readonly List<IValidator> validators = new List<IValidator>();
         private readonly List<Job> jobs = new List<Job>();
         private readonly HashSet<HardwareCounter> hardwareCounters = new HashSet<HardwareCounter>();
+        private readonly HashSet<CustomCounter> customCounters = new HashSet<CustomCounter>();
         private readonly List<IFilter> filters = new List<IFilter>();
         private readonly List<BenchmarkLogicalGroupRule> logicalGroupRules = new List<BenchmarkLogicalGroupRule>();
         private readonly List<EventProcessor> eventProcessors = new List<EventProcessor>();
@@ -45,6 +46,7 @@ public class ManualConfig : IConfig
         public IEnumerable<IValidator> GetValidators() => validators;
         public IEnumerable<Job> GetJobs() => jobs;
         public IEnumerable<HardwareCounter> GetHardwareCounters() => hardwareCounters;
+        public IEnumerable<CustomCounter> GetCustomCounters() => customCounters;
         public IEnumerable<IFilter> GetFilters() => filters;
         public IEnumerable<BenchmarkLogicalGroupRule> GetLogicalGroupRules() => logicalGroupRules;
         public IEnumerable<EventProcessor> GetEventProcessors() => eventProcessors;
@@ -170,6 +172,12 @@ public ManualConfig AddHardwareCounters(params HardwareCounter[] newHardwareCoun
             return this;
         }
 
+        public ManualConfig AddCustomCounters(params CustomCounter[] newCustomCounters)
+        {
+            customCounters.AddRange(newCustomCounters);
+            return this;
+        }
+
         public ManualConfig AddFilter(params IFilter[] newFilters)
         {
             filters.AddRange(newFilters);
@@ -225,6 +233,7 @@ public void Add(IConfig config)
             jobs.AddRange(config.GetJobs());
             validators.AddRange(config.GetValidators());
             hardwareCounters.AddRange(config.GetHardwareCounters());
+            customCounters.AddRange(config.GetCustomCounters());
             filters.AddRange(config.GetFilters());
             eventProcessors.AddRange(config.GetEventProcessors());
             Orderer = config.Orderer ?? Orderer;

src/BenchmarkDotNet/Diagnosers/CustomCounter.cs

@@ -0,0 +1,71 @@
+using System;
+using JetBrains.Annotations;
+
+namespace BenchmarkDotNet.Diagnosers
+{
+    /// <summary>
+    /// Represents a custom hardware performance counter that can be specified by its ETW profile source name.
+    /// Use this when the predefined <see cref="HardwareCounter"/> enum values don't match the counters 
+    /// available on your machine (e.g., AMD-specific counters like DcacheMisses, IcacheMisses).
+    /// Run <c>TraceEventProfileSources.GetInfo().Keys</c> to discover available counters on your system.
+    /// </summary>
+    public class CustomCounter
+    {
+        /// <summary>
+        /// Default sampling interval for custom counters.
+        /// </summary>
+        public const int DefaultInterval = 1_000_003;
+
+        /// <summary>
+        /// The exact name of the ETW profile source as returned by TraceEventProfileSources.GetInfo().
+        /// </summary>
+        [PublicAPI]
+        public string ProfileSourceName { get; }
+
+        /// <summary>
+        /// A short name used for display in reports and columns.
+        /// </summary>
+        [PublicAPI]
+        public string ShortName { get; }
+
+        /// <summary>
+        /// The sampling interval for this counter.
+        /// </summary>
+        [PublicAPI]
+        public int Interval { get; }
+
+        /// <summary>
+        /// Indicates whether higher values are better for this counter.
+        /// Default is false (lower is better, e.g., cache misses).
+        /// </summary>
+        [PublicAPI]
+        public bool HigherIsBetter { get; }
+
+        /// <summary>
+        /// Creates a new custom hardware counter.
+        /// </summary>
+        /// <param name="profileSourceName">The exact name of the ETW profile source (e.g., "DcacheMisses", "IcacheMisses").</param>
+        /// <param name="shortName">Optional short name for display. If null, uses the profile source name.</param>
+        /// <param name="interval">Sampling interval. If not specified, uses DefaultInterval (1,000,003).</param>
+        /// <param name="higherIsBetter">Whether higher values are better for this counter.</param>
+        public CustomCounter(string profileSourceName, string? shortName = null, int interval = DefaultInterval, bool higherIsBetter = false)
+        {
+            if (profileSourceName == null)
+                throw new ArgumentNullException(nameof(profileSourceName));
+            if (string.IsNullOrWhiteSpace(profileSourceName))
+                throw new ArgumentException("Profile source name cannot be empty or whitespace.", nameof(profileSourceName));
+
+            ProfileSourceName = profileSourceName;
+            ShortName = shortName ?? profileSourceName;
+            Interval = interval;
+            HigherIsBetter = higherIsBetter;
+        }
+
+        public override string ToString() => ProfileSourceName;
+
+        public override bool Equals(object? obj)
+            => obj is CustomCounter other && ProfileSourceName == other.ProfileSourceName;
+
+        public override int GetHashCode() => ProfileSourceName.GetHashCode();
+    }
+}

src/BenchmarkDotNet/Diagnosers/PmcMetricDescriptor.cs

@@ -8,9 +8,9 @@ internal class PmcMetricDescriptor : IMetricDescriptor
         internal PmcMetricDescriptor(PreciseMachineCounter counter)
         {
             Id = counter.Name;
-            DisplayName = $"{counter.Name}/Op";
+            DisplayName = $"{counter.ShortName}/Op";
             Legend = $"Hardware counter '{counter.Name}' per single operation";
-            TheGreaterTheBetter = counter.Counter.TheGreaterTheBetter();
+            TheGreaterTheBetter = counter.HigherIsBetter;
         }
 
         public string Id { get; }