Add NoInlining to ArrayPool Rent/Return by jakobbotsch · Pull Request #129319 · dotnet/runtime

jakobbotsch · 2026-06-12T07:49:18Z

These methods result in inlining based on a lot of questionable heuristics. For example, the benchmark in #124285 went from 200 bytes in .NET 9 to 1567 bytes in .NET 10 because of inlining these two methods. Additionally Return has a tendency to appear in finally clauses, and we do not penalize inlining into these (even though we probably should), so this can also disable finally cloning.

As a surgical fix late in the cycle this just marks these methods NoInlining.

Fix#124285

These methods result in inlining based on a lot of questionable heuristics. For example, the benchmark in dotnet#124285 went from 200 bytes in .NET 9 to 1567 bytes in .NET 10 because of inlining these two methods. Additionally `Return` has a tendency to appear in `finally` clauses, and we do not penalize inlining into these (even though we probably should), so this can also disable finally cloning. As a surgical fix late in the cycle this just marks these methods `NoInlining`.

dotnet-policy-service · 2026-06-12T07:50:31Z

Tagging subscribers to this area: @dotnet/area-system-buffers
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR applies [MethodImpl(MethodImplOptions.NoInlining)] to the Rent and Return overrides on the primary ArrayPool<T> implementations in System.Private.CoreLib, to prevent the JIT from inlining these relatively large methods into callers.

Changes:

Mark SharedArrayPool<T>.Rent / Return as NoInlining.
Mark ConfigurableArrayPool<T>.Rent / Return as NoInlining (and add the required System.Runtime.CompilerServices using).

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated no comments.

File	Description
src/libraries/System.Private.CoreLib/src/System/Buffers/SharedArrayPool.cs	Adds `NoInlining` to `Rent` / `Return` on the shared pool implementation.
src/libraries/System.Private.CoreLib/src/System/Buffers/ConfigurableArrayPool.cs	Adds `NoInlining` to `Rent` / `Return` on the configurable pool implementation and adds the needed using.

tannergooding

Overall LGTM.

It'd be good to get some SPMI and/or perf numbers included here and showcasing the improvement.

The general downside of NoInlining is of course that the JIT will not attempt to observe the IL and infer any heuristics about the method in question, but that should be fine here.

jakobbotsch · 2026-06-17T13:24:37Z

@EgorBot

usingBenchmarkDotNet.Attributes;usingBenchmarkDotNet.Jobs;usingSystem;usingSystem.Buffers;usingSystem.Runtime.InteropServices;namespaceRentSpanUnmanagedPerfTests;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark(Description="ArrayPool + Span - foreach (SLOW on .NET 10 and .NET 9)")]publicintArrayPool_Foreach(){varpool=ArrayPool<int>.Shared;vararray=pool.Rent(Size);try{varspan=newSpan<int>(array,0,Size);// Writefor(vari=0;i<Size;i++){span[i]=i*2;}// Read with foreachvarsum=0;foreach(ref readonly varvalueinspan){sum+=value;}returnsum;}finally{pool.Return(array);}}[Benchmark(Description="ArrayPool + Span - for loop (OK on .NET 10 and .NET 9)")]publicintArrayPool_ForLoop(){varpool=ArrayPool<int>.Shared;vararray=pool.Rent(Size);try{varspan=newSpan<int>(array,0,Size);// Writefor(vari=0;i<Size;i++){span[i]=i*2;}// Read with for loopvarsum=0;for(vari=0;i<span.Length;i++){sum+=span[i];}returnsum;}finally{pool.Return(array);}}[Benchmark(Description="RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)")]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);// Writefor(vari=0;i<Size;i++){wrapper.Span[i]=i*2;}// Read with foreachvarsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan){sum+=value;}returnsum;}[Benchmark(Description="RefStruct + Span field - for loop (OK on .NET 10 and .NET 9)")]publicintRefStruct_ForLoop(){usingvarwrapper=newSpanWrapper(Size);// Writefor(vari=0;i<Size;i++){wrapper.Span[i]=i*2;}// Read with for loopvarsum=0;for(vari=0;i<wrapper.Span.Length;i++){sum+=wrapper.Span[i];}returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose(){ArrayPool<int>.Shared.Return(m_Array);}}}

jakobbotsch · 2026-06-17T13:28:43Z

@EgorBot -intel

usingBenchmarkDotNet.Attributes;usingSystem;usingSystem.Buffers;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);for(vari=0;i<Size;i++)wrapper.Span[i]=i*2;varsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan)sum+=value;returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose()=>ArrayPool<int>.Shared.Return(m_Array);}}

jakobbotsch · 2026-06-17T16:20:23Z

On my machine the results look like:

Method	Job	Toolchain	Mean	Error	StdDev	Ratio
'RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)'	Job-ZICBXN	\main\corerun.exe	749.4 ns	4.62 ns	3.61 ns	1.00
'RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)'	Job-QENHHP	\pr\corerun.exe	467.5 ns	2.08 ns	1.74 ns	0.62

Oddly Egorbot does not see an improvement, and when I look at its disassembly it has a well-optimized inner loop of

2026-06-1715:24:04.417 G_M000_IG08: ;; offset=0x00E02026-06-1715:24:04.417addecx, dword ptr [r14+rax]2026-06-1715:24:04.417addrax,42026-06-1715:24:04.417decedx2026-06-1715:24:04.417jne SHORT G_M000_IG08

whereas my inner loop without this fix looks like

G_M000_IG08: ;; offset=0x00E0moveax, dword ptr [rbp-0x3C]addecx, dword ptr [r14+4*rax]moveax, dword ptr [rbp-0x3C]inceaxmov dword ptr [rbp-0x3C],eaxcmp dword ptr [rbp-0x3C],0x3E8jl SHORT G_M000_IG08

Need to investigate a bit further what's different in the bot's environment.

jakobbotsch · 2026-07-17T09:51:31Z

@EgorBot --envvars DOTNET_JitDisasm:RefStruct_Foreach

usingBenchmarkDotNet.Attributes;usingSystem;usingSystem.Buffers;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);for(vari=0;i<Size;i++)wrapper.Span[i]=i*2;varsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan)sum+=value;returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose()=>ArrayPool<int>.Shared.Return(m_Array);}}

jakobbotsch · 2026-07-17T10:24:06Z

Still not seeing the perf improvement on egorbot, but I have validated this locally. I do see the large inlining happening even in egorbot's version, though the inner loop is efficient even with it. I am not totally sure what the difference is, but since the customer also has the perf problem I think we can roll with it.

azure-pipelines · 2026-07-17T10:24:43Z

Azure Pipelines: Successfully started running 3 pipeline(s). 12 pipeline(s) were filtered out due to trigger conditions. There may be pipelines that require an authorized user to comment /azp run to run.

Copilot

Pull request overview

Copilot reviewed 2 out of 2 changed files in this pull request and generated no new comments.

tannergooding · 2026-07-17T14:17:05Z

@jakobbotsch given you see a large improvement and EgorBot at best sees a small 5ns regression (generally within noise given the overall runtime), I'd say we take this and look at official perf lab results

jakobbotsch · 2026-07-17T17:06:58Z

/ba-g Timeouts

jakobbotsch · 2026-06-12T07:49:18Z

These methods result in inlining based on a lot of questionable heuristics. For example, the benchmark in #124285 went from 200 bytes in .NET 9 to 1567 bytes in .NET 10 because of inlining these two methods. Additionally Return has a tendency to appear in finally clauses, and we do not penalize inlining into these (even though we probably should), so this can also disable finally cloning.

As a surgical fix late in the cycle this just marks these methods NoInlining.

Fix#124285

These methods result in inlining based on a lot of questionable heuristics. For example, the benchmark in dotnet#124285 went from 200 bytes in .NET 9 to 1567 bytes in .NET 10 because of inlining these two methods. Additionally `Return` has a tendency to appear in `finally` clauses, and we do not penalize inlining into these (even though we probably should), so this can also disable finally cloning. As a surgical fix late in the cycle this just marks these methods `NoInlining`.

dotnet-policy-service · 2026-06-12T07:50:31Z

Tagging subscribers to this area: @dotnet/area-system-buffers
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR applies [MethodImpl(MethodImplOptions.NoInlining)] to the Rent and Return overrides on the primary ArrayPool<T> implementations in System.Private.CoreLib, to prevent the JIT from inlining these relatively large methods into callers.

Changes:

Mark SharedArrayPool<T>.Rent / Return as NoInlining.
Mark ConfigurableArrayPool<T>.Rent / Return as NoInlining (and add the required System.Runtime.CompilerServices using).

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated no comments.

File	Description
src/libraries/System.Private.CoreLib/src/System/Buffers/SharedArrayPool.cs	Adds `NoInlining` to `Rent` / `Return` on the shared pool implementation.
src/libraries/System.Private.CoreLib/src/System/Buffers/ConfigurableArrayPool.cs	Adds `NoInlining` to `Rent` / `Return` on the configurable pool implementation and adds the needed using.

tannergooding

Overall LGTM.

It'd be good to get some SPMI and/or perf numbers included here and showcasing the improvement.

The general downside of NoInlining is of course that the JIT will not attempt to observe the IL and infer any heuristics about the method in question, but that should be fine here.

jakobbotsch · 2026-06-17T13:24:37Z

@EgorBot

usingBenchmarkDotNet.Attributes;usingBenchmarkDotNet.Jobs;usingSystem;usingSystem.Buffers;usingSystem.Runtime.InteropServices;namespaceRentSpanUnmanagedPerfTests;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark(Description="ArrayPool + Span - foreach (SLOW on .NET 10 and .NET 9)")]publicintArrayPool_Foreach(){varpool=ArrayPool<int>.Shared;vararray=pool.Rent(Size);try{varspan=newSpan<int>(array,0,Size);// Writefor(vari=0;i<Size;i++){span[i]=i*2;}// Read with foreachvarsum=0;foreach(ref readonly varvalueinspan){sum+=value;}returnsum;}finally{pool.Return(array);}}[Benchmark(Description="ArrayPool + Span - for loop (OK on .NET 10 and .NET 9)")]publicintArrayPool_ForLoop(){varpool=ArrayPool<int>.Shared;vararray=pool.Rent(Size);try{varspan=newSpan<int>(array,0,Size);// Writefor(vari=0;i<Size;i++){span[i]=i*2;}// Read with for loopvarsum=0;for(vari=0;i<span.Length;i++){sum+=span[i];}returnsum;}finally{pool.Return(array);}}[Benchmark(Description="RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)")]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);// Writefor(vari=0;i<Size;i++){wrapper.Span[i]=i*2;}// Read with foreachvarsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan){sum+=value;}returnsum;}[Benchmark(Description="RefStruct + Span field - for loop (OK on .NET 10 and .NET 9)")]publicintRefStruct_ForLoop(){usingvarwrapper=newSpanWrapper(Size);// Writefor(vari=0;i<Size;i++){wrapper.Span[i]=i*2;}// Read with for loopvarsum=0;for(vari=0;i<wrapper.Span.Length;i++){sum+=wrapper.Span[i];}returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose(){ArrayPool<int>.Shared.Return(m_Array);}}}

jakobbotsch · 2026-06-17T13:28:43Z

@EgorBot -intel

usingBenchmarkDotNet.Attributes;usingSystem;usingSystem.Buffers;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);for(vari=0;i<Size;i++)wrapper.Span[i]=i*2;varsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan)sum+=value;returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose()=>ArrayPool<int>.Shared.Return(m_Array);}}

jakobbotsch · 2026-06-17T16:20:23Z

On my machine the results look like:

Method	Job	Toolchain	Mean	Error	StdDev	Ratio
'RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)'	Job-ZICBXN	\main\corerun.exe	749.4 ns	4.62 ns	3.61 ns	1.00
'RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)'	Job-QENHHP	\pr\corerun.exe	467.5 ns	2.08 ns	1.74 ns	0.62

Oddly Egorbot does not see an improvement, and when I look at its disassembly it has a well-optimized inner loop of

2026-06-1715:24:04.417 G_M000_IG08: ;; offset=0x00E02026-06-1715:24:04.417addecx, dword ptr [r14+rax]2026-06-1715:24:04.417addrax,42026-06-1715:24:04.417decedx2026-06-1715:24:04.417jne SHORT G_M000_IG08

whereas my inner loop without this fix looks like

G_M000_IG08: ;; offset=0x00E0moveax, dword ptr [rbp-0x3C]addecx, dword ptr [r14+4*rax]moveax, dword ptr [rbp-0x3C]inceaxmov dword ptr [rbp-0x3C],eaxcmp dword ptr [rbp-0x3C],0x3E8jl SHORT G_M000_IG08

Need to investigate a bit further what's different in the bot's environment.

jakobbotsch · 2026-07-17T09:51:31Z

@EgorBot --envvars DOTNET_JitDisasm:RefStruct_Foreach

usingBenchmarkDotNet.Attributes;usingSystem;usingSystem.Buffers;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);for(vari=0;i<Size;i++)wrapper.Span[i]=i*2;varsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan)sum+=value;returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose()=>ArrayPool<int>.Shared.Return(m_Array);}}

jakobbotsch · 2026-07-17T10:24:06Z

Still not seeing the perf improvement on egorbot, but I have validated this locally. I do see the large inlining happening even in egorbot's version, though the inner loop is efficient even with it. I am not totally sure what the difference is, but since the customer also has the perf problem I think we can roll with it.

azure-pipelines · 2026-07-17T10:24:43Z

Azure Pipelines: Successfully started running 3 pipeline(s). 12 pipeline(s) were filtered out due to trigger conditions. There may be pipelines that require an authorized user to comment /azp run to run.

Copilot

Pull request overview

Copilot reviewed 2 out of 2 changed files in this pull request and generated no new comments.

tannergooding · 2026-07-17T14:17:05Z

@jakobbotsch given you see a large improvement and EgorBot at best sees a small 5ns regression (generally within noise given the overall runtime), I'd say we take this and look at official perf lab results

jakobbotsch · 2026-07-17T17:06:58Z

/ba-g Timeouts

jakobbotsch · 2026-06-12T07:49:18Z

These methods result in inlining based on a lot of questionable heuristics. For example, the benchmark in #124285 went from 200 bytes in .NET 9 to 1567 bytes in .NET 10 because of inlining these two methods. Additionally Return has a tendency to appear in finally clauses, and we do not penalize inlining into these (even though we probably should), so this can also disable finally cloning.

As a surgical fix late in the cycle this just marks these methods NoInlining.

Fix#124285

These methods result in inlining based on a lot of questionable heuristics. For example, the benchmark in dotnet#124285 went from 200 bytes in .NET 9 to 1567 bytes in .NET 10 because of inlining these two methods. Additionally `Return` has a tendency to appear in `finally` clauses, and we do not penalize inlining into these (even though we probably should), so this can also disable finally cloning. As a surgical fix late in the cycle this just marks these methods `NoInlining`.

dotnet-policy-service · 2026-06-12T07:50:31Z

Tagging subscribers to this area: @dotnet/area-system-buffers
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR applies [MethodImpl(MethodImplOptions.NoInlining)] to the Rent and Return overrides on the primary ArrayPool<T> implementations in System.Private.CoreLib, to prevent the JIT from inlining these relatively large methods into callers.

Changes:

Mark SharedArrayPool<T>.Rent / Return as NoInlining.
Mark ConfigurableArrayPool<T>.Rent / Return as NoInlining (and add the required System.Runtime.CompilerServices using).

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated no comments.

File	Description
src/libraries/System.Private.CoreLib/src/System/Buffers/SharedArrayPool.cs	Adds `NoInlining` to `Rent` / `Return` on the shared pool implementation.
src/libraries/System.Private.CoreLib/src/System/Buffers/ConfigurableArrayPool.cs	Adds `NoInlining` to `Rent` / `Return` on the configurable pool implementation and adds the needed using.

tannergooding

Overall LGTM.

It'd be good to get some SPMI and/or perf numbers included here and showcasing the improvement.

The general downside of NoInlining is of course that the JIT will not attempt to observe the IL and infer any heuristics about the method in question, but that should be fine here.

jakobbotsch · 2026-06-17T13:24:37Z

@EgorBot

usingBenchmarkDotNet.Attributes;usingBenchmarkDotNet.Jobs;usingSystem;usingSystem.Buffers;usingSystem.Runtime.InteropServices;namespaceRentSpanUnmanagedPerfTests;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark(Description="ArrayPool + Span - foreach (SLOW on .NET 10 and .NET 9)")]publicintArrayPool_Foreach(){varpool=ArrayPool<int>.Shared;vararray=pool.Rent(Size);try{varspan=newSpan<int>(array,0,Size);// Writefor(vari=0;i<Size;i++){span[i]=i*2;}// Read with foreachvarsum=0;foreach(ref readonly varvalueinspan){sum+=value;}returnsum;}finally{pool.Return(array);}}[Benchmark(Description="ArrayPool + Span - for loop (OK on .NET 10 and .NET 9)")]publicintArrayPool_ForLoop(){varpool=ArrayPool<int>.Shared;vararray=pool.Rent(Size);try{varspan=newSpan<int>(array,0,Size);// Writefor(vari=0;i<Size;i++){span[i]=i*2;}// Read with for loopvarsum=0;for(vari=0;i<span.Length;i++){sum+=span[i];}returnsum;}finally{pool.Return(array);}}[Benchmark(Description="RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)")]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);// Writefor(vari=0;i<Size;i++){wrapper.Span[i]=i*2;}// Read with foreachvarsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan){sum+=value;}returnsum;}[Benchmark(Description="RefStruct + Span field - for loop (OK on .NET 10 and .NET 9)")]publicintRefStruct_ForLoop(){usingvarwrapper=newSpanWrapper(Size);// Writefor(vari=0;i<Size;i++){wrapper.Span[i]=i*2;}// Read with for loopvarsum=0;for(vari=0;i<wrapper.Span.Length;i++){sum+=wrapper.Span[i];}returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose(){ArrayPool<int>.Shared.Return(m_Array);}}}

jakobbotsch · 2026-06-17T13:28:43Z

@EgorBot -intel

usingBenchmarkDotNet.Attributes;usingSystem;usingSystem.Buffers;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);for(vari=0;i<Size;i++)wrapper.Span[i]=i*2;varsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan)sum+=value;returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose()=>ArrayPool<int>.Shared.Return(m_Array);}}

jakobbotsch · 2026-06-17T16:20:23Z

On my machine the results look like:

Method	Job	Toolchain	Mean	Error	StdDev	Ratio
'RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)'	Job-ZICBXN	\main\corerun.exe	749.4 ns	4.62 ns	3.61 ns	1.00
'RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)'	Job-QENHHP	\pr\corerun.exe	467.5 ns	2.08 ns	1.74 ns	0.62

Oddly Egorbot does not see an improvement, and when I look at its disassembly it has a well-optimized inner loop of

2026-06-1715:24:04.417 G_M000_IG08: ;; offset=0x00E02026-06-1715:24:04.417addecx, dword ptr [r14+rax]2026-06-1715:24:04.417addrax,42026-06-1715:24:04.417decedx2026-06-1715:24:04.417jne SHORT G_M000_IG08

whereas my inner loop without this fix looks like

G_M000_IG08: ;; offset=0x00E0moveax, dword ptr [rbp-0x3C]addecx, dword ptr [r14+4*rax]moveax, dword ptr [rbp-0x3C]inceaxmov dword ptr [rbp-0x3C],eaxcmp dword ptr [rbp-0x3C],0x3E8jl SHORT G_M000_IG08

Need to investigate a bit further what's different in the bot's environment.

jakobbotsch · 2026-07-17T09:51:31Z

@EgorBot --envvars DOTNET_JitDisasm:RefStruct_Foreach

usingBenchmarkDotNet.Attributes;usingSystem;usingSystem.Buffers;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);for(vari=0;i<Size;i++)wrapper.Span[i]=i*2;varsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan)sum+=value;returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose()=>ArrayPool<int>.Shared.Return(m_Array);}}

jakobbotsch · 2026-07-17T10:24:06Z

Still not seeing the perf improvement on egorbot, but I have validated this locally. I do see the large inlining happening even in egorbot's version, though the inner loop is efficient even with it. I am not totally sure what the difference is, but since the customer also has the perf problem I think we can roll with it.

azure-pipelines · 2026-07-17T10:24:43Z

Azure Pipelines: Successfully started running 3 pipeline(s). 12 pipeline(s) were filtered out due to trigger conditions. There may be pipelines that require an authorized user to comment /azp run to run.

Copilot

Pull request overview

Copilot reviewed 2 out of 2 changed files in this pull request and generated no new comments.

tannergooding · 2026-07-17T14:17:05Z

@jakobbotsch given you see a large improvement and EgorBot at best sees a small 5ns regression (generally within noise given the overall runtime), I'd say we take this and look at official perf lab results

jakobbotsch · 2026-07-17T17:06:58Z

/ba-g Timeouts

jakobbotsch · 2026-06-12T07:49:18Z

These methods result in inlining based on a lot of questionable heuristics. For example, the benchmark in #124285 went from 200 bytes in .NET 9 to 1567 bytes in .NET 10 because of inlining these two methods. Additionally Return has a tendency to appear in finally clauses, and we do not penalize inlining into these (even though we probably should), so this can also disable finally cloning.

As a surgical fix late in the cycle this just marks these methods NoInlining.

Fix#124285

These methods result in inlining based on a lot of questionable heuristics. For example, the benchmark in dotnet#124285 went from 200 bytes in .NET 9 to 1567 bytes in .NET 10 because of inlining these two methods. Additionally `Return` has a tendency to appear in `finally` clauses, and we do not penalize inlining into these (even though we probably should), so this can also disable finally cloning. As a surgical fix late in the cycle this just marks these methods `NoInlining`.

dotnet-policy-service · 2026-06-12T07:50:31Z

Tagging subscribers to this area: @dotnet/area-system-buffers
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR applies [MethodImpl(MethodImplOptions.NoInlining)] to the Rent and Return overrides on the primary ArrayPool<T> implementations in System.Private.CoreLib, to prevent the JIT from inlining these relatively large methods into callers.

Changes:

Mark SharedArrayPool<T>.Rent / Return as NoInlining.
Mark ConfigurableArrayPool<T>.Rent / Return as NoInlining (and add the required System.Runtime.CompilerServices using).

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated no comments.

File	Description
src/libraries/System.Private.CoreLib/src/System/Buffers/SharedArrayPool.cs	Adds `NoInlining` to `Rent` / `Return` on the shared pool implementation.
src/libraries/System.Private.CoreLib/src/System/Buffers/ConfigurableArrayPool.cs	Adds `NoInlining` to `Rent` / `Return` on the configurable pool implementation and adds the needed using.

tannergooding

Overall LGTM.

It'd be good to get some SPMI and/or perf numbers included here and showcasing the improvement.

The general downside of NoInlining is of course that the JIT will not attempt to observe the IL and infer any heuristics about the method in question, but that should be fine here.

jakobbotsch · 2026-06-17T13:24:37Z

@EgorBot

usingBenchmarkDotNet.Attributes;usingBenchmarkDotNet.Jobs;usingSystem;usingSystem.Buffers;usingSystem.Runtime.InteropServices;namespaceRentSpanUnmanagedPerfTests;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark(Description="ArrayPool + Span - foreach (SLOW on .NET 10 and .NET 9)")]publicintArrayPool_Foreach(){varpool=ArrayPool<int>.Shared;vararray=pool.Rent(Size);try{varspan=newSpan<int>(array,0,Size);// Writefor(vari=0;i<Size;i++){span[i]=i*2;}// Read with foreachvarsum=0;foreach(ref readonly varvalueinspan){sum+=value;}returnsum;}finally{pool.Return(array);}}[Benchmark(Description="ArrayPool + Span - for loop (OK on .NET 10 and .NET 9)")]publicintArrayPool_ForLoop(){varpool=ArrayPool<int>.Shared;vararray=pool.Rent(Size);try{varspan=newSpan<int>(array,0,Size);// Writefor(vari=0;i<Size;i++){span[i]=i*2;}// Read with for loopvarsum=0;for(vari=0;i<span.Length;i++){sum+=span[i];}returnsum;}finally{pool.Return(array);}}[Benchmark(Description="RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)")]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);// Writefor(vari=0;i<Size;i++){wrapper.Span[i]=i*2;}// Read with foreachvarsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan){sum+=value;}returnsum;}[Benchmark(Description="RefStruct + Span field - for loop (OK on .NET 10 and .NET 9)")]publicintRefStruct_ForLoop(){usingvarwrapper=newSpanWrapper(Size);// Writefor(vari=0;i<Size;i++){wrapper.Span[i]=i*2;}// Read with for loopvarsum=0;for(vari=0;i<wrapper.Span.Length;i++){sum+=wrapper.Span[i];}returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose(){ArrayPool<int>.Shared.Return(m_Array);}}}

jakobbotsch · 2026-06-17T13:28:43Z

@EgorBot -intel

usingBenchmarkDotNet.Attributes;usingSystem;usingSystem.Buffers;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);for(vari=0;i<Size;i++)wrapper.Span[i]=i*2;varsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan)sum+=value;returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose()=>ArrayPool<int>.Shared.Return(m_Array);}}

jakobbotsch · 2026-06-17T16:20:23Z

On my machine the results look like:

Method	Job	Toolchain	Mean	Error	StdDev	Ratio
'RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)'	Job-ZICBXN	\main\corerun.exe	749.4 ns	4.62 ns	3.61 ns	1.00
'RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)'	Job-QENHHP	\pr\corerun.exe	467.5 ns	2.08 ns	1.74 ns	0.62

Oddly Egorbot does not see an improvement, and when I look at its disassembly it has a well-optimized inner loop of

2026-06-1715:24:04.417 G_M000_IG08: ;; offset=0x00E02026-06-1715:24:04.417addecx, dword ptr [r14+rax]2026-06-1715:24:04.417addrax,42026-06-1715:24:04.417decedx2026-06-1715:24:04.417jne SHORT G_M000_IG08

whereas my inner loop without this fix looks like

G_M000_IG08: ;; offset=0x00E0moveax, dword ptr [rbp-0x3C]addecx, dword ptr [r14+4*rax]moveax, dword ptr [rbp-0x3C]inceaxmov dword ptr [rbp-0x3C],eaxcmp dword ptr [rbp-0x3C],0x3E8jl SHORT G_M000_IG08

Need to investigate a bit further what's different in the bot's environment.

jakobbotsch · 2026-07-17T09:51:31Z

@EgorBot --envvars DOTNET_JitDisasm:RefStruct_Foreach

usingBenchmarkDotNet.Attributes;usingSystem;usingSystem.Buffers;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);for(vari=0;i<Size;i++)wrapper.Span[i]=i*2;varsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan)sum+=value;returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose()=>ArrayPool<int>.Shared.Return(m_Array);}}

jakobbotsch · 2026-07-17T10:24:06Z

Still not seeing the perf improvement on egorbot, but I have validated this locally. I do see the large inlining happening even in egorbot's version, though the inner loop is efficient even with it. I am not totally sure what the difference is, but since the customer also has the perf problem I think we can roll with it.

azure-pipelines · 2026-07-17T10:24:43Z

Azure Pipelines: Successfully started running 3 pipeline(s). 12 pipeline(s) were filtered out due to trigger conditions. There may be pipelines that require an authorized user to comment /azp run to run.

Copilot

Pull request overview

Copilot reviewed 2 out of 2 changed files in this pull request and generated no new comments.

tannergooding · 2026-07-17T14:17:05Z

@jakobbotsch given you see a large improvement and EgorBot at best sees a small 5ns regression (generally within noise given the overall runtime), I'd say we take this and look at official perf lab results

jakobbotsch · 2026-07-17T17:06:58Z

/ba-g Timeouts

jakobbotsch · 2026-06-12T07:49:18Z

These methods result in inlining based on a lot of questionable heuristics. For example, the benchmark in #124285 went from 200 bytes in .NET 9 to 1567 bytes in .NET 10 because of inlining these two methods. Additionally Return has a tendency to appear in finally clauses, and we do not penalize inlining into these (even though we probably should), so this can also disable finally cloning.

As a surgical fix late in the cycle this just marks these methods NoInlining.

Fix#124285

These methods result in inlining based on a lot of questionable heuristics. For example, the benchmark in dotnet#124285 went from 200 bytes in .NET 9 to 1567 bytes in .NET 10 because of inlining these two methods. Additionally `Return` has a tendency to appear in `finally` clauses, and we do not penalize inlining into these (even though we probably should), so this can also disable finally cloning. As a surgical fix late in the cycle this just marks these methods `NoInlining`.

dotnet-policy-service · 2026-06-12T07:50:31Z

Tagging subscribers to this area: @dotnet/area-system-buffers
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR applies [MethodImpl(MethodImplOptions.NoInlining)] to the Rent and Return overrides on the primary ArrayPool<T> implementations in System.Private.CoreLib, to prevent the JIT from inlining these relatively large methods into callers.

Changes:

Mark SharedArrayPool<T>.Rent / Return as NoInlining.
Mark ConfigurableArrayPool<T>.Rent / Return as NoInlining (and add the required System.Runtime.CompilerServices using).

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated no comments.

File	Description
src/libraries/System.Private.CoreLib/src/System/Buffers/SharedArrayPool.cs	Adds `NoInlining` to `Rent` / `Return` on the shared pool implementation.
src/libraries/System.Private.CoreLib/src/System/Buffers/ConfigurableArrayPool.cs	Adds `NoInlining` to `Rent` / `Return` on the configurable pool implementation and adds the needed using.

tannergooding

Overall LGTM.

It'd be good to get some SPMI and/or perf numbers included here and showcasing the improvement.

The general downside of NoInlining is of course that the JIT will not attempt to observe the IL and infer any heuristics about the method in question, but that should be fine here.

jakobbotsch · 2026-06-17T13:24:37Z

@EgorBot

usingBenchmarkDotNet.Attributes;usingBenchmarkDotNet.Jobs;usingSystem;usingSystem.Buffers;usingSystem.Runtime.InteropServices;namespaceRentSpanUnmanagedPerfTests;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark(Description="ArrayPool + Span - foreach (SLOW on .NET 10 and .NET 9)")]publicintArrayPool_Foreach(){varpool=ArrayPool<int>.Shared;vararray=pool.Rent(Size);try{varspan=newSpan<int>(array,0,Size);// Writefor(vari=0;i<Size;i++){span[i]=i*2;}// Read with foreachvarsum=0;foreach(ref readonly varvalueinspan){sum+=value;}returnsum;}finally{pool.Return(array);}}[Benchmark(Description="ArrayPool + Span - for loop (OK on .NET 10 and .NET 9)")]publicintArrayPool_ForLoop(){varpool=ArrayPool<int>.Shared;vararray=pool.Rent(Size);try{varspan=newSpan<int>(array,0,Size);// Writefor(vari=0;i<Size;i++){span[i]=i*2;}// Read with for loopvarsum=0;for(vari=0;i<span.Length;i++){sum+=span[i];}returnsum;}finally{pool.Return(array);}}[Benchmark(Description="RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)")]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);// Writefor(vari=0;i<Size;i++){wrapper.Span[i]=i*2;}// Read with foreachvarsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan){sum+=value;}returnsum;}[Benchmark(Description="RefStruct + Span field - for loop (OK on .NET 10 and .NET 9)")]publicintRefStruct_ForLoop(){usingvarwrapper=newSpanWrapper(Size);// Writefor(vari=0;i<Size;i++){wrapper.Span[i]=i*2;}// Read with for loopvarsum=0;for(vari=0;i<wrapper.Span.Length;i++){sum+=wrapper.Span[i];}returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose(){ArrayPool<int>.Shared.Return(m_Array);}}}

jakobbotsch · 2026-06-17T13:28:43Z

@EgorBot -intel

usingBenchmarkDotNet.Attributes;usingSystem;usingSystem.Buffers;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);for(vari=0;i<Size;i++)wrapper.Span[i]=i*2;varsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan)sum+=value;returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose()=>ArrayPool<int>.Shared.Return(m_Array);}}

jakobbotsch · 2026-06-17T16:20:23Z

On my machine the results look like:

Method	Job	Toolchain	Mean	Error	StdDev	Ratio
'RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)'	Job-ZICBXN	\main\corerun.exe	749.4 ns	4.62 ns	3.61 ns	1.00
'RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)'	Job-QENHHP	\pr\corerun.exe	467.5 ns	2.08 ns	1.74 ns	0.62

Oddly Egorbot does not see an improvement, and when I look at its disassembly it has a well-optimized inner loop of

2026-06-1715:24:04.417 G_M000_IG08: ;; offset=0x00E02026-06-1715:24:04.417addecx, dword ptr [r14+rax]2026-06-1715:24:04.417addrax,42026-06-1715:24:04.417decedx2026-06-1715:24:04.417jne SHORT G_M000_IG08

whereas my inner loop without this fix looks like

G_M000_IG08: ;; offset=0x00E0moveax, dword ptr [rbp-0x3C]addecx, dword ptr [r14+4*rax]moveax, dword ptr [rbp-0x3C]inceaxmov dword ptr [rbp-0x3C],eaxcmp dword ptr [rbp-0x3C],0x3E8jl SHORT G_M000_IG08

Need to investigate a bit further what's different in the bot's environment.

jakobbotsch · 2026-07-17T09:51:31Z

@EgorBot --envvars DOTNET_JitDisasm:RefStruct_Foreach

usingBenchmarkDotNet.Attributes;usingSystem;usingSystem.Buffers;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);for(vari=0;i<Size;i++)wrapper.Span[i]=i*2;varsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan)sum+=value;returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose()=>ArrayPool<int>.Shared.Return(m_Array);}}

jakobbotsch · 2026-07-17T10:24:06Z

Still not seeing the perf improvement on egorbot, but I have validated this locally. I do see the large inlining happening even in egorbot's version, though the inner loop is efficient even with it. I am not totally sure what the difference is, but since the customer also has the perf problem I think we can roll with it.

azure-pipelines · 2026-07-17T10:24:43Z

Azure Pipelines: Successfully started running 3 pipeline(s). 12 pipeline(s) were filtered out due to trigger conditions. There may be pipelines that require an authorized user to comment /azp run to run.

Copilot

Pull request overview

Copilot reviewed 2 out of 2 changed files in this pull request and generated no new comments.

tannergooding · 2026-07-17T14:17:05Z

@jakobbotsch given you see a large improvement and EgorBot at best sees a small 5ns regression (generally within noise given the overall runtime), I'd say we take this and look at official perf lab results

jakobbotsch · 2026-07-17T17:06:58Z

/ba-g Timeouts

jakobbotsch · 2026-06-12T07:49:18Z

These methods result in inlining based on a lot of questionable heuristics. For example, the benchmark in #124285 went from 200 bytes in .NET 9 to 1567 bytes in .NET 10 because of inlining these two methods. Additionally Return has a tendency to appear in finally clauses, and we do not penalize inlining into these (even though we probably should), so this can also disable finally cloning.

As a surgical fix late in the cycle this just marks these methods NoInlining.

Fix#124285

These methods result in inlining based on a lot of questionable heuristics. For example, the benchmark in dotnet#124285 went from 200 bytes in .NET 9 to 1567 bytes in .NET 10 because of inlining these two methods. Additionally `Return` has a tendency to appear in `finally` clauses, and we do not penalize inlining into these (even though we probably should), so this can also disable finally cloning. As a surgical fix late in the cycle this just marks these methods `NoInlining`.

dotnet-policy-service · 2026-06-12T07:50:31Z

Tagging subscribers to this area: @dotnet/area-system-buffers
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR applies [MethodImpl(MethodImplOptions.NoInlining)] to the Rent and Return overrides on the primary ArrayPool<T> implementations in System.Private.CoreLib, to prevent the JIT from inlining these relatively large methods into callers.

Changes:

Mark SharedArrayPool<T>.Rent / Return as NoInlining.
Mark ConfigurableArrayPool<T>.Rent / Return as NoInlining (and add the required System.Runtime.CompilerServices using).

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated no comments.

File	Description
src/libraries/System.Private.CoreLib/src/System/Buffers/SharedArrayPool.cs	Adds `NoInlining` to `Rent` / `Return` on the shared pool implementation.
src/libraries/System.Private.CoreLib/src/System/Buffers/ConfigurableArrayPool.cs	Adds `NoInlining` to `Rent` / `Return` on the configurable pool implementation and adds the needed using.

tannergooding

Overall LGTM.

It'd be good to get some SPMI and/or perf numbers included here and showcasing the improvement.

The general downside of NoInlining is of course that the JIT will not attempt to observe the IL and infer any heuristics about the method in question, but that should be fine here.

jakobbotsch · 2026-06-17T13:24:37Z

@EgorBot

usingBenchmarkDotNet.Attributes;usingBenchmarkDotNet.Jobs;usingSystem;usingSystem.Buffers;usingSystem.Runtime.InteropServices;namespaceRentSpanUnmanagedPerfTests;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark(Description="ArrayPool + Span - foreach (SLOW on .NET 10 and .NET 9)")]publicintArrayPool_Foreach(){varpool=ArrayPool<int>.Shared;vararray=pool.Rent(Size);try{varspan=newSpan<int>(array,0,Size);// Writefor(vari=0;i<Size;i++){span[i]=i*2;}// Read with foreachvarsum=0;foreach(ref readonly varvalueinspan){sum+=value;}returnsum;}finally{pool.Return(array);}}[Benchmark(Description="ArrayPool + Span - for loop (OK on .NET 10 and .NET 9)")]publicintArrayPool_ForLoop(){varpool=ArrayPool<int>.Shared;vararray=pool.Rent(Size);try{varspan=newSpan<int>(array,0,Size);// Writefor(vari=0;i<Size;i++){span[i]=i*2;}// Read with for loopvarsum=0;for(vari=0;i<span.Length;i++){sum+=span[i];}returnsum;}finally{pool.Return(array);}}[Benchmark(Description="RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)")]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);// Writefor(vari=0;i<Size;i++){wrapper.Span[i]=i*2;}// Read with foreachvarsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan){sum+=value;}returnsum;}[Benchmark(Description="RefStruct + Span field - for loop (OK on .NET 10 and .NET 9)")]publicintRefStruct_ForLoop(){usingvarwrapper=newSpanWrapper(Size);// Writefor(vari=0;i<Size;i++){wrapper.Span[i]=i*2;}// Read with for loopvarsum=0;for(vari=0;i<wrapper.Span.Length;i++){sum+=wrapper.Span[i];}returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose(){ArrayPool<int>.Shared.Return(m_Array);}}}

jakobbotsch · 2026-06-17T13:28:43Z

@EgorBot -intel

usingBenchmarkDotNet.Attributes;usingSystem;usingSystem.Buffers;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);for(vari=0;i<Size;i++)wrapper.Span[i]=i*2;varsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan)sum+=value;returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose()=>ArrayPool<int>.Shared.Return(m_Array);}}

jakobbotsch · 2026-06-17T16:20:23Z

On my machine the results look like:

Method	Job	Toolchain	Mean	Error	StdDev	Ratio
'RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)'	Job-ZICBXN	\main\corerun.exe	749.4 ns	4.62 ns	3.61 ns	1.00
'RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)'	Job-QENHHP	\pr\corerun.exe	467.5 ns	2.08 ns	1.74 ns	0.62

Oddly Egorbot does not see an improvement, and when I look at its disassembly it has a well-optimized inner loop of

2026-06-1715:24:04.417 G_M000_IG08: ;; offset=0x00E02026-06-1715:24:04.417addecx, dword ptr [r14+rax]2026-06-1715:24:04.417addrax,42026-06-1715:24:04.417decedx2026-06-1715:24:04.417jne SHORT G_M000_IG08

whereas my inner loop without this fix looks like

G_M000_IG08: ;; offset=0x00E0moveax, dword ptr [rbp-0x3C]addecx, dword ptr [r14+4*rax]moveax, dword ptr [rbp-0x3C]inceaxmov dword ptr [rbp-0x3C],eaxcmp dword ptr [rbp-0x3C],0x3E8jl SHORT G_M000_IG08

Need to investigate a bit further what's different in the bot's environment.

jakobbotsch · 2026-07-17T09:51:31Z

@EgorBot --envvars DOTNET_JitDisasm:RefStruct_Foreach

usingBenchmarkDotNet.Attributes;usingSystem;usingSystem.Buffers;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);for(vari=0;i<Size;i++)wrapper.Span[i]=i*2;varsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan)sum+=value;returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose()=>ArrayPool<int>.Shared.Return(m_Array);}}

jakobbotsch · 2026-07-17T10:24:06Z

Still not seeing the perf improvement on egorbot, but I have validated this locally. I do see the large inlining happening even in egorbot's version, though the inner loop is efficient even with it. I am not totally sure what the difference is, but since the customer also has the perf problem I think we can roll with it.

azure-pipelines · 2026-07-17T10:24:43Z

Azure Pipelines: Successfully started running 3 pipeline(s). 12 pipeline(s) were filtered out due to trigger conditions. There may be pipelines that require an authorized user to comment /azp run to run.

Copilot

Pull request overview

Copilot reviewed 2 out of 2 changed files in this pull request and generated no new comments.

tannergooding · 2026-07-17T14:17:05Z

@jakobbotsch given you see a large improvement and EgorBot at best sees a small 5ns regression (generally within noise given the overall runtime), I'd say we take this and look at official perf lab results

jakobbotsch · 2026-07-17T17:06:58Z

/ba-g Timeouts

jakobbotsch · 2026-06-12T07:49:18Z

These methods result in inlining based on a lot of questionable heuristics. For example, the benchmark in #124285 went from 200 bytes in .NET 9 to 1567 bytes in .NET 10 because of inlining these two methods. Additionally Return has a tendency to appear in finally clauses, and we do not penalize inlining into these (even though we probably should), so this can also disable finally cloning.

As a surgical fix late in the cycle this just marks these methods NoInlining.

Fix#124285

These methods result in inlining based on a lot of questionable heuristics. For example, the benchmark in dotnet#124285 went from 200 bytes in .NET 9 to 1567 bytes in .NET 10 because of inlining these two methods. Additionally `Return` has a tendency to appear in `finally` clauses, and we do not penalize inlining into these (even though we probably should), so this can also disable finally cloning. As a surgical fix late in the cycle this just marks these methods `NoInlining`.

dotnet-policy-service · 2026-06-12T07:50:31Z

Tagging subscribers to this area: @dotnet/area-system-buffers
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR applies [MethodImpl(MethodImplOptions.NoInlining)] to the Rent and Return overrides on the primary ArrayPool<T> implementations in System.Private.CoreLib, to prevent the JIT from inlining these relatively large methods into callers.

Changes:

Mark SharedArrayPool<T>.Rent / Return as NoInlining.
Mark ConfigurableArrayPool<T>.Rent / Return as NoInlining (and add the required System.Runtime.CompilerServices using).

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated no comments.

File	Description
src/libraries/System.Private.CoreLib/src/System/Buffers/SharedArrayPool.cs	Adds `NoInlining` to `Rent` / `Return` on the shared pool implementation.
src/libraries/System.Private.CoreLib/src/System/Buffers/ConfigurableArrayPool.cs	Adds `NoInlining` to `Rent` / `Return` on the configurable pool implementation and adds the needed using.

tannergooding

Overall LGTM.

It'd be good to get some SPMI and/or perf numbers included here and showcasing the improvement.

The general downside of NoInlining is of course that the JIT will not attempt to observe the IL and infer any heuristics about the method in question, but that should be fine here.

jakobbotsch · 2026-06-17T13:24:37Z

@EgorBot

usingBenchmarkDotNet.Attributes;usingBenchmarkDotNet.Jobs;usingSystem;usingSystem.Buffers;usingSystem.Runtime.InteropServices;namespaceRentSpanUnmanagedPerfTests;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark(Description="ArrayPool + Span - foreach (SLOW on .NET 10 and .NET 9)")]publicintArrayPool_Foreach(){varpool=ArrayPool<int>.Shared;vararray=pool.Rent(Size);try{varspan=newSpan<int>(array,0,Size);// Writefor(vari=0;i<Size;i++){span[i]=i*2;}// Read with foreachvarsum=0;foreach(ref readonly varvalueinspan){sum+=value;}returnsum;}finally{pool.Return(array);}}[Benchmark(Description="ArrayPool + Span - for loop (OK on .NET 10 and .NET 9)")]publicintArrayPool_ForLoop(){varpool=ArrayPool<int>.Shared;vararray=pool.Rent(Size);try{varspan=newSpan<int>(array,0,Size);// Writefor(vari=0;i<Size;i++){span[i]=i*2;}// Read with for loopvarsum=0;for(vari=0;i<span.Length;i++){sum+=span[i];}returnsum;}finally{pool.Return(array);}}[Benchmark(Description="RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)")]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);// Writefor(vari=0;i<Size;i++){wrapper.Span[i]=i*2;}// Read with foreachvarsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan){sum+=value;}returnsum;}[Benchmark(Description="RefStruct + Span field - for loop (OK on .NET 10 and .NET 9)")]publicintRefStruct_ForLoop(){usingvarwrapper=newSpanWrapper(Size);// Writefor(vari=0;i<Size;i++){wrapper.Span[i]=i*2;}// Read with for loopvarsum=0;for(vari=0;i<wrapper.Span.Length;i++){sum+=wrapper.Span[i];}returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose(){ArrayPool<int>.Shared.Return(m_Array);}}}

jakobbotsch · 2026-06-17T13:28:43Z

@EgorBot -intel

usingBenchmarkDotNet.Attributes;usingSystem;usingSystem.Buffers;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);for(vari=0;i<Size;i++)wrapper.Span[i]=i*2;varsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan)sum+=value;returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose()=>ArrayPool<int>.Shared.Return(m_Array);}}

jakobbotsch · 2026-06-17T16:20:23Z

On my machine the results look like:

Method	Job	Toolchain	Mean	Error	StdDev	Ratio
'RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)'	Job-ZICBXN	\main\corerun.exe	749.4 ns	4.62 ns	3.61 ns	1.00
'RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)'	Job-QENHHP	\pr\corerun.exe	467.5 ns	2.08 ns	1.74 ns	0.62

Oddly Egorbot does not see an improvement, and when I look at its disassembly it has a well-optimized inner loop of

2026-06-1715:24:04.417 G_M000_IG08: ;; offset=0x00E02026-06-1715:24:04.417addecx, dword ptr [r14+rax]2026-06-1715:24:04.417addrax,42026-06-1715:24:04.417decedx2026-06-1715:24:04.417jne SHORT G_M000_IG08

whereas my inner loop without this fix looks like

G_M000_IG08: ;; offset=0x00E0moveax, dword ptr [rbp-0x3C]addecx, dword ptr [r14+4*rax]moveax, dword ptr [rbp-0x3C]inceaxmov dword ptr [rbp-0x3C],eaxcmp dword ptr [rbp-0x3C],0x3E8jl SHORT G_M000_IG08

Need to investigate a bit further what's different in the bot's environment.

jakobbotsch · 2026-07-17T09:51:31Z

@EgorBot --envvars DOTNET_JitDisasm:RefStruct_Foreach

usingBenchmarkDotNet.Attributes;usingSystem;usingSystem.Buffers;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);for(vari=0;i<Size;i++)wrapper.Span[i]=i*2;varsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan)sum+=value;returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose()=>ArrayPool<int>.Shared.Return(m_Array);}}

jakobbotsch · 2026-07-17T10:24:06Z

Still not seeing the perf improvement on egorbot, but I have validated this locally. I do see the large inlining happening even in egorbot's version, though the inner loop is efficient even with it. I am not totally sure what the difference is, but since the customer also has the perf problem I think we can roll with it.

azure-pipelines · 2026-07-17T10:24:43Z

Azure Pipelines: Successfully started running 3 pipeline(s). 12 pipeline(s) were filtered out due to trigger conditions. There may be pipelines that require an authorized user to comment /azp run to run.

Copilot

Pull request overview

Copilot reviewed 2 out of 2 changed files in this pull request and generated no new comments.

tannergooding · 2026-07-17T14:17:05Z

@jakobbotsch given you see a large improvement and EgorBot at best sees a small 5ns regression (generally within noise given the overall runtime), I'd say we take this and look at official perf lab results

jakobbotsch · 2026-07-17T17:06:58Z

/ba-g Timeouts

jakobbotsch · 2026-06-12T07:49:18Z

These methods result in inlining based on a lot of questionable heuristics. For example, the benchmark in #124285 went from 200 bytes in .NET 9 to 1567 bytes in .NET 10 because of inlining these two methods. Additionally Return has a tendency to appear in finally clauses, and we do not penalize inlining into these (even though we probably should), so this can also disable finally cloning.

As a surgical fix late in the cycle this just marks these methods NoInlining.

Fix#124285

These methods result in inlining based on a lot of questionable heuristics. For example, the benchmark in dotnet#124285 went from 200 bytes in .NET 9 to 1567 bytes in .NET 10 because of inlining these two methods. Additionally `Return` has a tendency to appear in `finally` clauses, and we do not penalize inlining into these (even though we probably should), so this can also disable finally cloning. As a surgical fix late in the cycle this just marks these methods `NoInlining`.

dotnet-policy-service · 2026-06-12T07:50:31Z

Tagging subscribers to this area: @dotnet/area-system-buffers
See info in area-owners.md if you want to be subscribed.

Copilot

Pull request overview

This PR applies [MethodImpl(MethodImplOptions.NoInlining)] to the Rent and Return overrides on the primary ArrayPool<T> implementations in System.Private.CoreLib, to prevent the JIT from inlining these relatively large methods into callers.

Changes:

Mark SharedArrayPool<T>.Rent / Return as NoInlining.
Mark ConfigurableArrayPool<T>.Rent / Return as NoInlining (and add the required System.Runtime.CompilerServices using).

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated no comments.

File	Description
src/libraries/System.Private.CoreLib/src/System/Buffers/SharedArrayPool.cs	Adds `NoInlining` to `Rent` / `Return` on the shared pool implementation.
src/libraries/System.Private.CoreLib/src/System/Buffers/ConfigurableArrayPool.cs	Adds `NoInlining` to `Rent` / `Return` on the configurable pool implementation and adds the needed using.

tannergooding

Overall LGTM.

It'd be good to get some SPMI and/or perf numbers included here and showcasing the improvement.

The general downside of NoInlining is of course that the JIT will not attempt to observe the IL and infer any heuristics about the method in question, but that should be fine here.

jakobbotsch · 2026-06-17T13:24:37Z

@EgorBot

usingBenchmarkDotNet.Attributes;usingBenchmarkDotNet.Jobs;usingSystem;usingSystem.Buffers;usingSystem.Runtime.InteropServices;namespaceRentSpanUnmanagedPerfTests;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark(Description="ArrayPool + Span - foreach (SLOW on .NET 10 and .NET 9)")]publicintArrayPool_Foreach(){varpool=ArrayPool<int>.Shared;vararray=pool.Rent(Size);try{varspan=newSpan<int>(array,0,Size);// Writefor(vari=0;i<Size;i++){span[i]=i*2;}// Read with foreachvarsum=0;foreach(ref readonly varvalueinspan){sum+=value;}returnsum;}finally{pool.Return(array);}}[Benchmark(Description="ArrayPool + Span - for loop (OK on .NET 10 and .NET 9)")]publicintArrayPool_ForLoop(){varpool=ArrayPool<int>.Shared;vararray=pool.Rent(Size);try{varspan=newSpan<int>(array,0,Size);// Writefor(vari=0;i<Size;i++){span[i]=i*2;}// Read with for loopvarsum=0;for(vari=0;i<span.Length;i++){sum+=span[i];}returnsum;}finally{pool.Return(array);}}[Benchmark(Description="RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)")]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);// Writefor(vari=0;i<Size;i++){wrapper.Span[i]=i*2;}// Read with foreachvarsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan){sum+=value;}returnsum;}[Benchmark(Description="RefStruct + Span field - for loop (OK on .NET 10 and .NET 9)")]publicintRefStruct_ForLoop(){usingvarwrapper=newSpanWrapper(Size);// Writefor(vari=0;i<Size;i++){wrapper.Span[i]=i*2;}// Read with for loopvarsum=0;for(vari=0;i<wrapper.Span.Length;i++){sum+=wrapper.Span[i];}returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose(){ArrayPool<int>.Shared.Return(m_Array);}}}

jakobbotsch · 2026-06-17T13:28:43Z

@EgorBot -intel

usingBenchmarkDotNet.Attributes;usingSystem;usingSystem.Buffers;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);for(vari=0;i<Size;i++)wrapper.Span[i]=i*2;varsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan)sum+=value;returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose()=>ArrayPool<int>.Shared.Return(m_Array);}}

jakobbotsch · 2026-06-17T16:20:23Z

On my machine the results look like:

Method	Job	Toolchain	Mean	Error	StdDev	Ratio
'RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)'	Job-ZICBXN	\main\corerun.exe	749.4 ns	4.62 ns	3.61 ns	1.00
'RefStruct + Span field - foreach (SLOW on .NET 10, FAST on .NET 9)'	Job-QENHHP	\pr\corerun.exe	467.5 ns	2.08 ns	1.74 ns	0.62

Oddly Egorbot does not see an improvement, and when I look at its disassembly it has a well-optimized inner loop of

2026-06-1715:24:04.417 G_M000_IG08: ;; offset=0x00E02026-06-1715:24:04.417addecx, dword ptr [r14+rax]2026-06-1715:24:04.417addrax,42026-06-1715:24:04.417decedx2026-06-1715:24:04.417jne SHORT G_M000_IG08

whereas my inner loop without this fix looks like

G_M000_IG08: ;; offset=0x00E0moveax, dword ptr [rbp-0x3C]addecx, dword ptr [r14+4*rax]moveax, dword ptr [rbp-0x3C]inceaxmov dword ptr [rbp-0x3C],eaxcmp dword ptr [rbp-0x3C],0x3E8jl SHORT G_M000_IG08

Need to investigate a bit further what's different in the bot's environment.

jakobbotsch · 2026-07-17T09:51:31Z

@EgorBot --envvars DOTNET_JitDisasm:RefStruct_Foreach

usingBenchmarkDotNet.Attributes;usingSystem;usingSystem.Buffers;publicclassArrayPoolForeachRepro{privateconstintSize=1000;[Benchmark]publicintRefStruct_Foreach(){usingvarwrapper=newSpanWrapper(Size);for(vari=0;i<Size;i++)wrapper.Span[i]=i*2;varsum=0;varspan=wrapper.Span;foreach(ref readonly varvalueinspan)sum+=value;returnsum;}privatereadonlyrefstructSpanWrapper{privatereadonlyint[]m_Array;publicreadonlySpan<int>Span;publicSpanWrapper(intlength){m_Array=ArrayPool<int>.Shared.Rent(length);Span=newSpan<int>(m_Array,0,length);}publicvoidDispose()=>ArrayPool<int>.Shared.Return(m_Array);}}

jakobbotsch · 2026-07-17T10:24:06Z

Still not seeing the perf improvement on egorbot, but I have validated this locally. I do see the large inlining happening even in egorbot's version, though the inner loop is efficient even with it. I am not totally sure what the difference is, but since the customer also has the perf problem I think we can roll with it.

azure-pipelines · 2026-07-17T10:24:43Z

Azure Pipelines: Successfully started running 3 pipeline(s). 12 pipeline(s) were filtered out due to trigger conditions. There may be pipelines that require an authorized user to comment /azp run to run.

Copilot

Pull request overview

Copilot reviewed 2 out of 2 changed files in this pull request and generated no new comments.

tannergooding · 2026-07-17T14:17:05Z

@jakobbotsch given you see a large improvement and EgorBot at best sees a small 5ns regression (generally within noise given the overall runtime), I'd say we take this and look at official perf lab results

jakobbotsch · 2026-07-17T17:06:58Z

/ba-g Timeouts

CopilotAI review requested due to automatic review settings June 12, 2026 07:49

github-actionsBot added the area-System.Buffers label Jun 12, 2026

dotnet-policy-serviceBot assigned jakobbotsch Jun 12, 2026

Copilotstarted reviewing on behalf of jakobbotsch June 12, 2026 07:49 View session

CopilotAI reviewed Jun 12, 2026
View reviewed changes

EgorBo approved these changes Jun 12, 2026
View reviewed changes

build-analysisBot mentioned this pull request Jun 12, 2026
Multiple Helix work items fail on maccatalyst/tvos CoreCLR Release #126460
Closed

tannergooding approved these changes Jun 12, 2026
View reviewed changes

MihaZupan approved these changes Jun 12, 2026
View reviewed changes

EgorBot mentioned this pull request Jun 17, 2026
Benchmarks for dotnet/runtime#129319 (for @jakobbotsch) EgorBot/Benchmarks#250
Open

EgorBot mentioned this pull request Jun 17, 2026
Benchmarks for dotnet/runtime#129319 (for @jakobbotsch) EgorBot/Benchmarks#251
Open

EgorBot mentioned this pull request Jul 17, 2026
Benchmarks for dotnet/runtime#129319 (for @jakobbotsch) EgorBot/Benchmarks#353
Open

jakobbotsch marked this pull request as ready for review July 17, 2026 10:24

Merge branch 'main' into no-inline-arraypool
f1b3d2b

CopilotAI review requested due to automatic review settings July 17, 2026 10:24

Copilotstarted reviewing on behalf of jakobbotsch July 17, 2026 10:24 View session

CopilotAI reviewed Jul 17, 2026
View reviewed changes

tannergooding approved these changes Jul 17, 2026
View reviewed changes

build-analysisBot mentioned this pull request Jul 17, 2026
The Operation will be canceled. The next steps may not contain expected logs. dotnet/dnceng#3008
Open
3 tasks

jakobbotsch merged commit 2119b86 into dotnet:mainJul 17, 2026
136 of 143 checks passed

jakobbotsch deleted the no-inline-arraypool branch July 17, 2026 17:07

dotnet-maestroBot mentioned this pull request Jul 18, 2026
[main] Source code updates from dotnet/runtime dotnet/dotnet#7841
Merged

dotnet-milestone-botBot added this to the 11.0-preview7 milestone Jul 18, 2026

LoopedBard3 mentioned this pull request Jul 23, 2026
[Perf] Linux/arm64: 6 Regressions on 7/17/2026 11:45:18 PM +00:00 #131277
Open

github-actionsBot locked and limited conversation to collaborators Aug 17, 2026