JIT emits an array access bounds check during the value update via the for

Start with the ArrayBenchmarks.For and ForEachRef methods and run the BenchmarkDotNet command shown in the issue on .NET 9 and .NET 10. Compare the generated disassembly and performance; done means the ordinary array for loop no longer emits the additional bounds check and approaches the foreach ref code generation without regressing the reported cases.

Description

One of the familiar ways to update values in an array is to use a standard for loop. Currently, JIT generates an additional bounds check even for obvious variants (tests and details below).

for (var index = 0; index < _testArray.Length; index++)
{
   _testArray[index] = arg;
}

To avoid this, you can use this approach:

foreach (ref var x in _testArray.AsSpan())
{
   x = arg;
}

In my tests, the performance difference is 3..5% for .NET 10, and 13..23% for .NET 9.

.NET 10 has a lot of improvements in the code generation, but maybe there is a way to make it almost equivalent for and foreach ref?

// To test .NET 10 Preview 2 used BenchmarkDotNet v0.14.1-nightly.
// To test .NET 9 used BenchmarkDotNet v0.14.0

// dotnet run -c Release -f net9.0 --filter "*" --runtimes net10.0

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

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

[MinIterationCount(15)]
[HideColumns("Job", "Error", "StdDev", "RatioSD", "arg")]
[MeanColumn, MinColumn, MaxColumn, OperationsPerSecond]
[JsonExporter]
[DisassemblyDiagnoser]
public class ArrayBenchmarks
{
   private int[] _testArray = null!;

   [Params(10_000, 100_000, 1_000_000)]
   public int Length { get; set; }

   [GlobalSetup]
   public void Setup()
   {
       _testArray = new int[Length];

       var rnd = new Random(12345);

       foreach (ref var x in _testArray.AsSpan())
       {
           x = rnd.Next();
       }
   }

   [Benchmark(Baseline = true)]
   [Arguments(42)]
   public int For(int arg)
   {
       for (var index = 0; index < _testArray.Length; index++)
       {
           _testArray[index] = arg;
       }

       return _testArray.Length;
   }

   [Benchmark]
   [Arguments(42)]
   public int ForEachRef(int arg)
   {
       foreach (ref var x in _testArray.AsSpan())
       {
           x = arg;
       }

       return _testArray.Length;
   }
}

Configuration

.NET 10 benchmark:

BenchmarkDotNet v0.14.1-nightly.20250107.205, Windows 10 (10.0.19045.5608/22H2/2022Update)
12th Gen Intel Core i9-12900K 3.19GHz, 1 CPU, 24 logical and 16 physical cores
.NET SDK 10.0.100-preview.2.25164.34

.NET 9 benchmark:

BenchmarkDotNet v0.14.0, Windows 10 (10.0.19045.5608/22H2/2022Update)
12th Gen Intel Core i9-12900K, 1 CPU, 24 logical and 16 physical cores
.NET SDK 10.0.100-preview.2.25164.34

Regression?

No

Data

.NET 10 Preview 2

ArrayBenchmarks-report-NET10.json

ArrayBenchmarks-asm-NET10.md

.NET 9

ArrayBenchmarks-report-NET9.json

ArrayBenchmarks-asm-NET9.md

Analysis

for codegen:

; ArrayBenchmarks.For(Int32)
       sub       rsp,28
       xor       eax,eax
       mov       rcx,[rcx+8]
       cmp       dword ptr [rcx+8],0
       jle       short M00_L01
M00_L00:
       mov       r8,rcx
       cmp       eax,[r8+8]
       jae       short M00_L02
       mov       [r8+rax*4+10],edx
       inc       eax
       cmp       [rcx+8],eax
       jg        short M00_L00
M00_L01:
       mov       eax,[rcx+8]
       add       rsp,28
       ret
M00_L02:
       call      CORINFO_HELP_RNGCHKFAIL
       int       3

foreach ref codegen:

; ArrayBenchmarks.ForEachRef(Int32)
       mov       rax,[rcx+8]
       test      rax,rax
       je        short M00_L03
       lea       r8,[rax+10]
       mov       eax,[rax+8]
M00_L00:
       test      eax,eax
       jle       short M00_L02
       xor       r10d,r10d
       nop       word ptr [rax+rax]
M00_L01:
       mov       [r8+r10],edx
       add       r10,4
       dec       eax
       jne       short M00_L01
M00_L02:
       mov       rax,[rcx+8]
       mov       eax,[rax+8]
       ret
M00_L03:
       xor       r8d,r8d
       xor       eax,eax
       jmp       short M00_L00
; Total bytes of code 59