Benchmarks for dotnet/runtime#131470 (for @EgorBo)

[EgorBot]

Processing benchmark request from PR dotnet/runtime#131470.

Targets: macos15_helix_arm64, ubuntu24_azure_genoa, windows_azure_cobalt100, windows_azure_emeraldrapids
Commits: main;PR_131470

• macos15_helix_arm64: live logs
• ubuntu24_azure_genoa: live logs
• windows_azure_cobalt100: live logs
• windows_azure_emeraldrapids: live logs

Results will be posted here once they are ready.

[EgorBot]

Results for macos15_helix_arm64

@EgorBo

BenchmarkDotNet v0.16.0-preview.1, macOS Sequoia 15.7 (24G222) [Darwin 24.6.0]
Apple M1, 1 CPU, 8 logical and 8 physical cores
Memory: 8 GB Total, 0.2 GB Available
.NET SDK 11.0.100-preview.7.26366.102
  [Host]     : .NET 11.0.0 (11.0.0-preview.7.26366.102, 11.0.26.36702), Arm64 RyuJIT armv8.0-a

Method	Toolchain	WritePercent	Mean	Error	Ratio
CacheOps	main**	0	1,022.6 ns	5.83 ns	2.33
CacheOps	PR #131470	0	439.3 ns	1.14 ns	1.00
CacheOps	main**	5	858.6 ns	17.13 ns	1.65
CacheOps	PR #131470	5	519.9 ns	4.14 ns	1.00
CacheOps	main**	25	1,263.0 ns	24.83 ns	1.38
CacheOps	PR #131470	25	914.5 ns	18.13 ns	1.00

BDN profiler traces (speedscope)

• MemoryCacheBench.CacheOps(WritePercent_ 0)-_main_corerun-20260728-091549
• MemoryCacheBench.CacheOps(WritePercent_ 0)-_PR #131470_corerun-20260728-091614
• MemoryCacheBench.CacheOps(WritePercent_ 25)-_main_corerun-20260728-091730
• MemoryCacheBench.CacheOps(WritePercent_ 25)-_PR #131470_corerun-20260728-091840
• MemoryCacheBench.CacheOps(WritePercent_ 5)-_main_corerun-20260728-091637
• MemoryCacheBench.CacheOps(WritePercent_ 5)-_PR #131470_corerun-20260728-091707

Full logs

[EgorBot]

ubuntu24_azure_genoa — Failed

@EgorBo

Cancelled by admin.

Job

[EgorBot]

windows_azure_cobalt100 — Failed

@EgorBo

Cancelled by admin.

Job

[EgorBot]

windows_azure_emeraldrapids — Failed

@EgorBo

Cancelled by admin.

Job

[EgorBot]

Benchmark job submitted. The results will be posted here once they are ready.

• ubuntu24_azure_genoa: live logs
• windows_azure_cobalt100: live logs
• windows_azure_emeraldrapids: live logs

[EgorBo]

@EgorBot -linux_genoa -windows_arm -windows_intel -profiler

using System;
using System.Runtime.Caching;
using System.Threading;
using System.Threading.Tasks;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

BenchmarkSwitcher.FromAssembly(typeof(MemoryCacheBench).Assembly).Run(args);

public class MemoryCacheBench
{
    // MemoryCache shards its entries into several stores so the per-store locks stay scalable, but all
    // of those stores share a single Counters instance, which makes the counters the only process-wide
    // serialization point on the Get/Set paths. A representative workload therefore needs many keys (so
    // the per-store locks are not themselves the bottleneck) and several threads (so the shared counters
    // are actually contended). Only the public API is used, so this is what an application really pays.
    //
    // WritePercent sweeps from a pure read cache to a write-heavy one, because how much the counters
    // matter depends entirely on how much other work each operation does.

    private const int KeyCount = 4096;
    private const int OpsPerThread = 25_000;

    [Params(0, 5, 25)]
    public int WritePercent { get; set; }

    private const int MissPercent = 7;

    private MemoryCache _cache;
    private string[] _present;
    private string[] _absent;
    private CacheItemPolicy _policy;
    private ParallelOptions _parallel;
    private object _value;
    private int _threads;

    [GlobalSetup]
    public void Setup()
    {
        _threads = Environment.ProcessorCount;
        ThreadPool.SetMinThreads(_threads + 8, _threads + 8);
        _parallel = new ParallelOptions { MaxDegreeOfParallelism = _threads };
        _value = "cached-value";
        _policy = new CacheItemPolicy { AbsoluteExpiration = DateTimeOffset.UtcNow.AddHours(1) };
        _cache = new MemoryCache("bench");
        _present = new string[KeyCount];
        _absent = new string[KeyCount];
        for (int i = 0; i < KeyCount; i++)
        {
            _present[i] = "key-" + i;
            _absent[i] = "missing-" + i;
            _cache.Set(_present[i], _value, _policy);
        }
    }

    [GlobalCleanup]
    public void Cleanup() => _cache.Dispose();

    // Reported time is the per-operation latency seen by one thread while all threads run.
    // A Set over an existing key replaces it, so writes also exercise the eviction counters.
    [Benchmark(OperationsPerInvoke = OpsPerThread)]
    public void CacheOps()
    {
        MemoryCache cache = _cache;
        string[] present = _present, absent = _absent;
        CacheItemPolicy policy = _policy;
        object value = _value;
        int writePct = WritePercent;
        int readMissPct = writePct + MissPercent;

        Parallel.For(0, _threads, _parallel, t =>
        {
            // Per-thread xorshift so threads walk the key space independently instead of
            // marching in lockstep over the same entry.
            uint x = (uint)(t + 1) * 2654435761u | 1u;

            for (int i = 0; i < OpsPerThread; i++)
            {
                x ^= x << 13;
                x ^= x >> 17;
                x ^= x << 5;

                // Take the key from the high bits so it is independent of the op selector.
                int k = (int)((x >> 16) % KeyCount);
                uint op = x % 100;
                if (op < writePct)
                    cache.Set(present[k], value, policy); // evict + insert
                else if (op < readMissPct)
                    cache.Get(absent[k]); // miss
                else
                    cache.Get(present[k]); // hit
            }
        });
    }
}

[EgorBot]

Benchmark job submitted. The results will be posted here once they are ready.

• ubuntu24_azure_genoa: live logs
• windows_azure_cobalt100: live logs
• windows_azure_emeraldrapids: live logs

[EgorBot]

Results for ubuntu24_azure_genoa

@EgorBo

BenchmarkDotNet v0.16.0-preview.1, Linux Ubuntu 24.04.4 LTS (Noble Numbat)
AMD EPYC 9V74 2.60GHz, 1 CPU, 8 logical and 4 physical cores
Memory: 31.34 GB Total, 8.16 GB Available
.NET SDK 11.0.100-preview.7.26366.102
  [Host]     : .NET 11.0.0 (11.0.0-preview.7.26366.102, 11.0.26.36702), X64 RyuJIT x86-64-v4

Method	Toolchain	WritePercent	Mean	Error	Ratio
CacheOps	main**	0	370.1 ns	1.98 ns	2.20
CacheOps	PR #131470	0	168.4 ns	2.02 ns	1.00
CacheOps	main**	5	412.1 ns	1.64 ns	1.63
CacheOps	PR #131470	5	253.5 ns	2.44 ns	1.00
CacheOps	main**	25	585.7 ns	4.58 ns	1.22
CacheOps	PR #131470	25	482.0 ns	2.89 ns	1.00

Full logs

[EgorBot]

Results for windows_azure_cobalt100

@EgorBo

BenchmarkDotNet v0.16.0-preview.1, Windows 11 (10.0.26200.8875/25H2/2025Update/HudsonValley2) (Hyper-V)
Cobalt 100 3.40GHz, 1 CPU, 8 logical and 8 physical cores
Memory: 31.99 GB Total, 26.89 GB Available
.NET SDK 11.0.100-preview.7.26366.102
  [Host]     : .NET 11.0.0 (11.0.0-preview.7.26366.102, 11.0.26.36702), Arm64 RyuJIT armv8.0-a

Method	Toolchain	WritePercent	Mean	Error	Ratio
CacheOps	main**	0	881.2 ns	5.10 ns	1.93
CacheOps	PR #131470	0	456.9 ns	5.26 ns	1.00
CacheOps	main**	5	518.6 ns	7.15 ns	1.16
CacheOps	PR #131470	5	448.8 ns	6.90 ns	1.00
CacheOps	main**	25	1,504.4 ns	6.71 ns	1.69
CacheOps	PR #131470	25	889.8 ns	4.89 ns	1.00

BDN profiler traces (speedscope)

• MemoryCacheBench.CacheOps(WritePercent_ 0)-_main_corerun.exe-20260728-174141
• MemoryCacheBench.CacheOps(WritePercent_ 0)-_PR #131470_corerun.exe-20260728-174207
• MemoryCacheBench.CacheOps(WritePercent_ 25)-_main_corerun.exe-20260728-174316
• MemoryCacheBench.CacheOps(WritePercent_ 25)-_PR #131470_corerun.exe-20260728-174338
• MemoryCacheBench.CacheOps(WritePercent_ 5)-_main_corerun.exe-20260728-174231
• MemoryCacheBench.CacheOps(WritePercent_ 5)-_PR #131470_corerun.exe-20260728-174254

Full logs

[EgorBot]

Results for windows_azure_emeraldrapids

@EgorBo

BenchmarkDotNet v0.16.0-preview.1, Windows 11 (10.0.26100.33158/24H2/2024Update/HudsonValley) (Hyper-V)
INTEL XEON PLATINUM 8573C 2.30GHz, 1 CPU, 8 logical and 4 physical cores
Memory: 31.99 GB Total, 27.12 GB Available
.NET SDK 11.0.100-preview.7.26366.102
  [Host]     : .NET 11.0.0 (11.0.0-preview.7.26366.102, 11.0.26.36702), X64 RyuJIT x86-64-v4

Method	Toolchain	WritePercent	Mean	Error	Ratio
CacheOps	main**	0	711.5 ns	5.81 ns	2.40
CacheOps	PR #131470	0	298.3 ns	8.31 ns	1.00
CacheOps	main**	5	837.2 ns	16.47 ns	1.75
CacheOps	PR #131470	5	479.0 ns	9.25 ns	1.00
CacheOps	main**	25	1,249.1 ns	5.14 ns	1.17
CacheOps	PR #131470	25	1,065.8 ns	6.64 ns	1.00

BDN profiler traces (speedscope)

• MemoryCacheBench.CacheOps(WritePercent_ 0)-_main_corerun.exe-20260728-174059
• MemoryCacheBench.CacheOps(WritePercent_ 0)-_PR #131470_corerun.exe-20260728-174120
• MemoryCacheBench.CacheOps(WritePercent_ 25)-_main_corerun.exe-20260728-174312
• MemoryCacheBench.CacheOps(WritePercent_ 25)-_PR #131470_corerun.exe-20260728-174344
• MemoryCacheBench.CacheOps(WritePercent_ 5)-_main_corerun.exe-20260728-174218
• MemoryCacheBench.CacheOps(WritePercent_ 5)-_PR #131470_corerun.exe-20260728-174246

Full logs

[EgorBo]

@EgorBot -aws_arm -profiler

using System;
using System.Runtime.Caching;
using System.Threading;
using System.Threading.Tasks;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

BenchmarkSwitcher.FromAssembly(typeof(MemoryCacheBench).Assembly).Run(args);

public class MemoryCacheBench
{
    // MemoryCache shards its entries into several stores so the per-store locks stay scalable, but all
    // of those stores share a single Counters instance, which makes the counters the only process-wide
    // serialization point on the Get/Set paths. A representative workload therefore needs many keys (so
    // the per-store locks are not themselves the bottleneck) and several threads (so the shared counters
    // are actually contended). Only the public API is used, so this is what an application really pays.
    //
    // WritePercent sweeps from a pure read cache to a write-heavy one, because how much the counters
    // matter depends entirely on how much other work each operation does.

    private const int KeyCount = 4096;
    private const int OpsPerThread = 25_000;

    [Params(0/*, 5, 25*/)]
    public int WritePercent { get; set; }

    private const int MissPercent = 7;

    private MemoryCache _cache;
    private string[] _present;
    private string[] _absent;
    private CacheItemPolicy _policy;
    private ParallelOptions _parallel;
    private object _value;
    private int _threads;

    [GlobalSetup]
    public void Setup()
    {
        _threads = Environment.ProcessorCount;
        ThreadPool.SetMinThreads(_threads + 8, _threads + 8);
        _parallel = new ParallelOptions { MaxDegreeOfParallelism = _threads };
        _value = "cached-value";
        _policy = new CacheItemPolicy { AbsoluteExpiration = DateTimeOffset.UtcNow.AddHours(1) };
        _cache = new MemoryCache("bench");
        _present = new string[KeyCount];
        _absent = new string[KeyCount];
        for (int i = 0; i < KeyCount; i++)
        {
            _present[i] = "key-" + i;
            _absent[i] = "missing-" + i;
            _cache.Set(_present[i], _value, _policy);
        }
    }

    [GlobalCleanup]
    public void Cleanup() => _cache.Dispose();

    // Reported time is the per-operation latency seen by one thread while all threads run.
    // A Set over an existing key replaces it, so writes also exercise the eviction counters.
    [Benchmark(OperationsPerInvoke = OpsPerThread)]
    public void CacheOps()
    {
        MemoryCache cache = _cache;
        string[] present = _present, absent = _absent;
        CacheItemPolicy policy = _policy;
        object value = _value;
        int writePct = WritePercent;
        int readMissPct = writePct + MissPercent;

        Parallel.For(0, _threads, _parallel, t =>
        {
            // Per-thread xorshift so threads walk the key space independently instead of
            // marching in lockstep over the same entry.
            uint x = (uint)(t + 1) * 2654435761u | 1u;

            for (int i = 0; i < OpsPerThread; i++)
            {
                x ^= x << 13;
                x ^= x >> 17;
                x ^= x << 5;

                // Take the key from the high bits so it is independent of the op selector.
                int k = (int)((x >> 16) % KeyCount);
                uint op = x % 100;
                if (op < writePct)
                    cache.Set(present[k], value, policy); // evict + insert
                else if (op < readMissPct)
                    cache.Get(absent[k]); // miss
                else
                    cache.Get(present[k]); // hit
            }
        });
    }
}

[EgorBot]

Benchmark job submitted. The results will be posted here once they are ready.

• ubuntu24_aws_graviton4: live logs

[EgorBot]

Results for ubuntu24_aws_graviton4

@EgorBo

BenchmarkDotNet v0.16.0-preview.1, Linux Ubuntu 24.04 LTS (Noble Numbat)
Neoverse-V2, 8 physical cores
Memory: 15.31 GB Total, 3.03 GB Available
.NET SDK 11.0.100-preview.7.26366.102
  [Host]     : .NET 11.0.0 (11.0.0-preview.7.26366.102, 11.0.26.36702), Arm64 RyuJIT armv8.0-a

Method	Toolchain	WritePercent	Mean	Error	Ratio
CacheOps	main	0	779.6 ns	0.78 ns	2.45
CacheOps	PR #131470	0	318.4 ns	0.98 ns	1.00

Full logs

[EgorBo]

@EgorBot -aws_arm -profiler

using System;
using System.Runtime.Caching;
using System.Threading;
using System.Threading.Tasks;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

public class MemoryCacheBench
{
    // MemoryCache shards its entries into several stores so the per-store locks stay scalable, but all
    // of those stores share a single Counters instance, which makes the counters the only process-wide
    // serialization point on the Get/Set paths. A representative workload therefore needs many keys (so
    // the per-store locks are not themselves the bottleneck) and several threads (so the shared counters
    // are actually contended). Only the public API is used, so this is what an application really pays.
    //
    // WritePercent sweeps from a pure read cache to a write-heavy one, because how much the counters
    // matter depends entirely on how much other work each operation does.

    private const int KeyCount = 4096;
    private const int OpsPerThread = 25_000;

    [Params(0/*, 5, 25*/)]
    public int WritePercent { get; set; }

    private const int MissPercent = 7;

    private MemoryCache _cache;
    private string[] _present;
    private string[] _absent;
    private CacheItemPolicy _policy;
    private ParallelOptions _parallel;
    private object _value;
    private int _threads;

    [GlobalSetup]
    public void Setup()
    {
        _threads = Environment.ProcessorCount;
        ThreadPool.SetMinThreads(_threads + 8, _threads + 8);
        _parallel = new ParallelOptions { MaxDegreeOfParallelism = _threads };
        _value = "cached-value";
        _policy = new CacheItemPolicy { AbsoluteExpiration = DateTimeOffset.UtcNow.AddHours(1) };
        _cache = new MemoryCache("bench");
        _present = new string[KeyCount];
        _absent = new string[KeyCount];
        for (int i = 0; i < KeyCount; i++)
        {
            _present[i] = "key-" + i;
            _absent[i] = "missing-" + i;
            _cache.Set(_present[i], _value, _policy);
        }
    }

    [GlobalCleanup]
    public void Cleanup() => _cache.Dispose();

    // Reported time is the per-operation latency seen by one thread while all threads run.
    // A Set over an existing key replaces it, so writes also exercise the eviction counters.
    [Benchmark(OperationsPerInvoke = OpsPerThread)]
    public void CacheOps()
    {
        MemoryCache cache = _cache;
        string[] present = _present, absent = _absent;
        CacheItemPolicy policy = _policy;
        object value = _value;
        int writePct = WritePercent;
        int readMissPct = writePct + MissPercent;

        Parallel.For(0, _threads, _parallel, t =>
        {
            // Per-thread xorshift so threads walk the key space independently instead of
            // marching in lockstep over the same entry.
            uint x = (uint)(t + 1) * 2654435761u | 1u;

            for (int i = 0; i < OpsPerThread; i++)
            {
                x ^= x << 13;
                x ^= x >> 17;
                x ^= x << 5;

                // Take the key from the high bits so it is independent of the op selector.
                int k = (int)((x >> 16) % KeyCount);
                uint op = x % 100;
                if (op < writePct)
                    cache.Set(present[k], value, policy); // evict + insert
                else if (op < readMissPct)
                    cache.Get(absent[k]); // miss
                else
                    cache.Get(present[k]); // hit
            }
        });
    }
}