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

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System.Runtime.InteropServices;

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

[DisassemblyDiagnoser]
public class Tests
{
    private readonly List<string> _list = new() { "a", "b", "c" };

    [Benchmark]
    public Span<string> AsSpan() => CollectionsMarshal.AsSpan(_list);

    [Benchmark]
    public int Sum()
    {
        int total = 0;
        foreach (string s in CollectionsMarshal.AsSpan(_list))
        {
            total += s.Length;
        }
        return total;
    }
}

Why is the JIT not able to optimize the original code well?

cc @dotnet/jit-contrib

Why is the JIT not able to optimize the original code well?

For starters I assume because it doesn't know that it can elide the null check on the array and elide the variance check on the array, since it's not privvy to the information about how the list was constructed.

For the variance check, minimal repro:

public class MyList<T>
{
    public T[] arr;
}

bool Test(MyList<string> list) => list.arr.GetType() == typeof(string[]);

codegen:

; Method Program:Foo(MyList`1[System.String]):ubyte:this (FullOpts)
G_M55733_IG01:
G_M55733_IG02:
       mov      rax, gword ptr [rdx+0x08]
       mov      rcx, 0xD1FFAB1E      ; System.String[]
       cmp      qword ptr [rax], rcx
       sete     al
       movzx    rax, al
G_M55733_IG03:
       ret      
; Total bytes of code: 24

I bet it lost generic context somewhere during opts..

Querying runtime about current class of field MyList`1[System.__Canon]:arr (declared as System.__Canon[])
Field's current class not available


[000010] ---XG------                         *  RETURN    int   
[000009] ---XG------                         \--*  EQ        int   
[000008] #--XG------                            +--*  IND       long  
[000002] n--XG------                            |  \--*  IND       ref   
[000001] ---X-------                            |     \--*  FIELD_ADDR byref  MyList`1[System.__Canon]:arr
[000000] -----------                            |        \--*  LCL_VAR   ref    V00 arg0         
[000004] H----------                            \--*  CNS_INT(h) long   0xd1ffab1e class

For the variance check

Even if that's fixed for string, though, I imagine the JIT would have a lot more trouble doing it for an arbitrary non-sealed reference type.

For the variance check

Even if that's fixed for string, though, I imagine the JIT would have a lot more trouble doing it for an arbitrary non-sealed reference type.

Sure, but looks like it's should be a general goodness to improve this in JIT too if possible

Sure, but looks like it's should be a general goodness to improve this in JIT too if possible

Agreed. Just commenting that this change still improves upon what I imagine the JIT will be able to safely do, unless we build knowledge of List<T> into it directly.

this change still improves upon what I imagine the JIT will be able to safely

Yea, I agree. LGTM.

For the variance check

Even if that's fixed for string, though, I imagine the JIT would have a lot more trouble doing it for an arbitrary non-sealed reference type.

Sure, but looks like it's should be a general goodness to improve this in JIT too if possible

Handled via #96794