LSRA: Register spilling issue when using AsSpan and Slice causing slow performance

[ahsonkhan]

public static Span<byte> TestAsSpan(int length)
{
    Stopwatch sw = new Stopwatch();
    var array = new byte[length];
    int halfLength = length / 2;
    Span<byte> span;
    sw.Restart();
    for (int i = 0; i < BaseIterations; i++)
    {
        span = array.AsSpan().Slice(halfLength, 10);
    }
    sw.Stop();
    var time = sw.ElapsedMilliseconds;
    Console.WriteLine(time + " : " + span.Length);
    return span;
}

public static Span<byte> TestSliceAsSpan(int length)
{
    Stopwatch sw = new Stopwatch();
    var array = new byte[length];
    int halfLength = length / 2;
    Span<byte> span;
    sw.Restart();
    for (int i = 0; i < BaseIterations; i++)
    {
        span = array.SliceAsSpan(halfLength, 10);
    }
    sw.Stop();
    var time = sw.ElapsedMilliseconds;
    Console.WriteLine(time + " : " + span.Length);
    return span;
}

[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Span<T> AsSpan<T>(this T[] array)
{
    return new Span<T>(array);
}

[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Span<T> SliceAsSpan<T>(this T[] array, int index, int length)
{
    return new Span<T>(array, index, length);
}

Runtime:
AsSpan().Slice() - 1094 ms (approximately 30% slower)
SliceAsSpan() - 827 ms

            span = array.AsSpan().Slice(halfLength, 10);

00007FFCB39B24F9 lea rax,[rbp+10h]
00007FFCB39B24FD mov qword ptr [rsp+30h],rax
00007FFCB39B2502 mov eax,dword ptr [rbp+8]
00007FFCB39B2505 mov rdx,qword ptr [rsp+30h]
00007FFCB39B250A cmp edi,eax
00007FFCB39B250C ja 00007FFCB39B25C8
00007FFCB39B2512 sub eax,edi
00007FFCB39B2514 cmp eax,0Ah
00007FFCB39B2517 jb 00007FFCB39B25C8
00007FFCB39B251D movsxd rax,edi
00007FFCB39B2520 add rax,rdx
00007FFCB39B2523 mov qword ptr [rsp+28h],rax
00007FFCB39B2528 mov r14d,0Ah
00007FFCB39B252E mov r15,qword ptr [rsp+28h]

            span = array.SliceAsSpan(halfLength, 10);

00007FFCB39B2C85 mov eax,dword ptr [rbp+8]
00007FFCB39B2C88 cmp eax,edi
00007FFCB39B2C8A jb 00007FFCB39B2D4A
00007FFCB39B2C90 sub eax,edi
00007FFCB39B2C92 cmp eax,0Ah
00007FFCB39B2C95 jb 00007FFCB39B2D4A
00007FFCB39B2C9B lea rax,[rbp+10h]
00007FFCB39B2C9F movsxd rdx,edi
00007FFCB39B2CA2 add rax,rdx
00007FFCB39B2CA5 mov qword ptr [rsp+20h],rax
00007FFCB39B2CAA mov r14d,0Ah
00007FFCB39B2CB0 mov r15,qword ptr [rsp+20h]

From: https://github.com/dotnet/corefx/issues/17414#issuecomment-290182549

They show different register allocation. Minor deficiency in the JIT optimizations.
category:cq
theme:register-allocator
skill-level:expert
cost:medium

[ahsonkhan]

cc @russellhadley, @JosephTremoulet

[AndyAyersMS]

This isn't in SpanBench yet, is it? If not, I'll go ahead and add it.

[JosephTremoulet]

It's not in SpanBench, and it's one of the "we should add these" APIs mentioned in dotnet/coreclr#10954.

[kunalspathak]

I can clearly see the perf difference, but it is also because slight different code is executed between TestAsSpan() and TestSliceAsSpan().

Benchmark code

    static class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Main");
            TestAsSpan(21);
            TestSliceAsSpan(21);
        }

        private static int BaseIterations = 100;

        public static Span<byte> TestAsSpan(int length)
        {
            //Stopwatch sw = new Stopwatch();
            var array = new byte[length];
            int halfLength = length / 2;
            Span<byte> span;
            int i = 0;
            //sw.Restart();
            do
            {
                span = array.AsSpan().Slice(halfLength, 10);
            } while (i++ < BaseIterations);
            //sw.Stop();
            //var time = sw.ElapsedMilliseconds;
            //Console.WriteLine(time + " : " + span.Length);
            return span;
        }

        public static Span<byte> TestSliceAsSpan(int length)
        {
            //Stopwatch sw = new Stopwatch();
            var array = new byte[length];
            int halfLength = length / 2;
            Span<byte> span;
            int i = 0;
            //sw.Restart();

            do
            {
                span = array.SliceAsSpan(halfLength, 10);
            } while (i++ < BaseIterations);
            //sw.Stop();
            //var time = sw.ElapsedMilliseconds;
            //Console.WriteLine(time + " : " + span.Length);
            return span;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Span<T> AsSpan<T>(this T[] array)
        {
            return new Span<T>(array);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Span<T> SliceAsSpan<T>(this T[] array, int index, int length)
        {
            return new Span<T>(array, index, length);
        }
    }

Assembly code

; Assembly listing for method EncodingRepro.Program:TestAsSpan(int):System.Span`1[Byte]
; Emitting BLENDED_CODE for X64 CPU with AVX - Windows
; optimized code
; rsp based frame
; fully interruptible
; No PGO data
; 2 inlinees with PGO data; 5 single block inlinees; 1 inlinees without PGO data
; Final local variable assignments
;
;  V00 RetBuf       [V00,T06] (  5,  5   )   byref  ->  rsi
;  V01 arg0         [V01,T07] (  5,  5   )     int  ->  rdi
;  V02 loc0         [V02,T00] (  3, 17   )     ref  ->  rbx         class-hnd exact
;  V03 loc1         [V03,T04] (  3, 10   )     int  ->  rdi
;* V04 loc2         [V04    ] (  0,  0   )  struct (16) zero-ref
;  V05 loc3         [V05,T09] (  3,  3   )     int  ->  registers
;* V06 loc4         [V06    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op
;  V07 OutArgs      [V07    ] (  1,  1   )  lclBlk (32) [rsp+00H]   "OutgoingArgSpace"
;  V08 tmp1         [V08,T08] (  3,  6   )     int  ->  rbp         "impSpillLclRefs"
;* V09 tmp2         [V09    ] (  0,  0   )  struct (16) zero-ref    "NewObj constructor temp"
;* V10 tmp3         [V10    ] (  0,  0   )  struct ( 8) zero-ref    "NewObj constructor temp"
;* V11 tmp4         [V11    ] (  0,  0   )  struct (16) zero-ref    "NewObj constructor temp"
;* V12 tmp5         [V12    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
;* V13 tmp6         [V13    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
;* V14 tmp7         [V14    ] (  0,  0   )  struct ( 8) zero-ref    "NewObj constructor temp"
;  V15 tmp8         [V15,T10] (  2,  2   )   byref  ->  r14         V04._pointer(offs=0x00) P-INDEP "field V04._pointer (fldOffset=0x0)"
;* V16 tmp9         [V16,T13] (  0,  0   )     int  ->  zero-ref    V04._length(offs=0x08) P-INDEP "field V04._length (fldOffset=0x8)"
;  V17 tmp10        [V17,T05] (  2,  9   )   byref  ->  r14         V06._pointer(offs=0x00) P-INDEP "field V06._pointer (fldOffset=0x0)"
;* V18 tmp11        [V18    ] (  0,  0   )     int  ->  zero-ref    V06._length(offs=0x08) P-INDEP "field V06._length (fldOffset=0x8)"
;  V19 tmp12        [V19,T01] (  2, 16   )   byref  ->  r14         V09._pointer(offs=0x00) P-INDEP "field V09._pointer (fldOffset=0x0)"
;  V20 tmp13        [V20,T03] (  2, 16   )     int  ->  rcx         V09._length(offs=0x08) P-INDEP "field V09._length (fldOffset=0x8)"
;  V21 tmp14        [V21,T02] (  2, 16   )   byref  ->  r14         V10._value(offs=0x00) P-INDEP "field V10._value (fldOffset=0x0)"
;  V22 tmp15        [V22,T11] (  2,  2   )   byref  ->  r14         V11._pointer(offs=0x00) P-INDEP "field V11._pointer (fldOffset=0x0)"
;* V23 tmp16        [V23,T14] (  0,  0   )     int  ->  zero-ref    V11._length(offs=0x08) P-INDEP "field V11._length (fldOffset=0x8)"
;  V24 tmp17        [V24,T12] (  2,  2   )   byref  ->  r14         V14._value(offs=0x00) P-INDEP "field V14._value (fldOffset=0x0)"
;
; Lcl frame size = 40

G_M41049_IG01:              ;; offset=0000H
       4157                 push     r15
       4156                 push     r14
       57                   push     rdi
       56                   push     rsi
       55                   push     rbp
       53                   push     rbx
       4883EC28             sub      rsp, 40
       488BF1               mov      rsi, rcx
       8BFA                 mov      edi, edx
                                                ;; bbWeight=1    PerfScore 6.75
G_M41049_IG02:              ;; offset=0011H
       4863D7               movsxd   rdx, edi
       48B9B8FCB0B2FE7F0000 mov      rcx, 0x7FFEB2B0FCB8
       E89D4BA75F           call     CORINFO_HELP_NEWARR_1_VC
       488BD8               mov      rbx, rax
       8BEF                 mov      ebp, edi
       C1ED1F               shr      ebp, 31
       03FD                 add      edi, ebp
       D1FF                 sar      edi, 1
       33ED                 xor      ebp, ebp
                                                ;; bbWeight=1    PerfScore 3.50
G_M41049_IG03:              ;; offset=0031H
       4C8D7310             lea      r14, bword ptr [rbx+16]
       8B4B08               mov      ecx, dword ptr [rbx+8]
       8BD7                 mov      edx, edi
       4883C20A             add      rdx, 10
       8BC9                 mov      ecx, ecx
       483BD1               cmp      rdx, rcx
       7745                 ja       SHORT G_M41049_IG06
                                                ;; bbWeight=8    PerfScore 36.00
G_M41049_IG04:              ;; offset=0045H
       4C63FF               movsxd   r15, edi
       4D03F7               add      r14, r15
       8D4D01               lea      ecx, [rbp+1]
       448BF9               mov      r15d, ecx
       48B9E83AA6B2FE7F0000 mov      rcx, 0x7FFEB2A63AE8
       BA01000000           mov      edx, 1
       E80B4CA75F           call     CORINFO_HELP_GETSHARED_NONGCSTATIC_BASE
       3B2DD1941E00         cmp      ebp, dword ptr [reloc classVar[0xb2a657e0]]
       418BEF               mov      ebp, r15d
       7CC1                 jl       SHORT G_M41049_IG03
       4C8936               mov      bword ptr [rsi], r14
       C746080A000000       mov      dword ptr [rsi+8], 10
       488BC6               mov      rax, rsi
                                                ;; bbWeight=1    PerfScore 7.25
G_M41049_IG05:              ;; offset=007DH
       4883C428             add      rsp, 40
       5B                   pop      rbx
       5D                   pop      rbp
       5E                   pop      rsi
       5F                   pop      rdi
       415E                 pop      r14
       415F                 pop      r15
       C3                   ret
                                                ;; bbWeight=1    PerfScore 4.25
G_M41049_IG06:              ;; offset=008AH
       E839FDFFFF           call     System.ThrowHelper:ThrowArgumentOutOfRangeException()
       CC                   int3
                                                ;; bbWeight=0    PerfScore 0.00

; Total bytes of code 144, prolog size 17, PerfScore 72.15, instruction count 48, allocated bytes for code 144 (MethodHash=aae95fa6) for method EncodingRepro.Program:TestAsSpan(int):System.Span`1[Byte]
; ============================================================

; Assembly listing for method EncodingRepro.Program:TestSliceAsSpan(int):System.Span`1[Byte]
; Emitting BLENDED_CODE for X64 CPU with AVX - Windows
; optimized code
; rsp based frame
; fully interruptible
; No PGO data
; 1 inlinees with PGO data; 3 single block inlinees; 0 inlinees without PGO data
; Final local variable assignments
;
;  V00 RetBuf       [V00,T00] (  5,  5   )   byref  ->  rsi
;  V01 arg0         [V01,T01] (  5,  5   )     int  ->  rdi
;  V02 loc0         [V02,T04] (  3,  3   )     ref  ->  rax         class-hnd exact
;  V03 loc1         [V03,T05] (  3,  3   )     int  ->  rdx
;* V04 loc2         [V04    ] (  0,  0   )  struct (16) zero-ref
;  V05 loc3         [V05,T06] (  3,  3   )     int  ->  registers
;  V06 OutArgs      [V06    ] (  1,  1   )  lclBlk (32) [rsp+00H]   "OutgoingArgSpace"
;  V07 tmp1         [V07,T02] (  3,  6   )     int  ->  rcx         "impSpillLclRefs"
;* V08 tmp2         [V08    ] (  0,  0   )  struct (16) zero-ref    "NewObj constructor temp"
;* V09 tmp3         [V09    ] (  0,  0   )  struct ( 8) zero-ref    "NewObj constructor temp"
;  V10 tmp4         [V10,T03] (  2,  4   )   byref  ->   r8         "Inlining Arg"
;  V11 tmp5         [V11,T07] (  2,  2   )   byref  ->   r8         V04._pointer(offs=0x00) P-INDEP "field V04._pointer (fldOffset=0x0)"
;* V12 tmp6         [V12,T10] (  0,  0   )     int  ->  zero-ref    V04._length(offs=0x08) P-INDEP "field V04._length (fldOffset=0x8)"
;  V13 tmp7         [V13,T08] (  2,  2   )   byref  ->   r8         V08._pointer(offs=0x00) P-INDEP "field V08._pointer (fldOffset=0x0)"
;* V14 tmp8         [V14,T11] (  0,  0   )     int  ->  zero-ref    V08._length(offs=0x08) P-INDEP "field V08._length (fldOffset=0x8)"
;  V15 tmp9         [V15,T09] (  2,  2   )   byref  ->   r8         V09._value(offs=0x00) P-INDEP "field V09._value (fldOffset=0x0)"
;
; Lcl frame size = 40

G_M1321_IG01:              ;; offset=0000H
       57                   push     rdi
       56                   push     rsi
       4883EC28             sub      rsp, 40
       488BF1               mov      rsi, rcx
       8BFA                 mov      edi, edx
                                                ;; bbWeight=1    PerfScore 2.75
G_M1321_IG02:              ;; offset=000BH
       4863D7               movsxd   rdx, edi
       48B9B8FCB0B2FE7F0000 mov      rcx, 0x7FFEB2B0FCB8
       E8C346A75F           call     CORINFO_HELP_NEWARR_1_VC
       8BD7                 mov      edx, edi
       C1EA1F               shr      edx, 31
       03D7                 add      edx, edi
       D1FA                 sar      edx, 1
       33C9                 xor      ecx, ecx
                                                ;; bbWeight=1    PerfScore 3.25
G_M1321_IG03:              ;; offset=0028H
       448B4008             mov      r8d, dword ptr [rax+8]
       448BCA               mov      r9d, edx
       4983C10A             add      r9, 10
       4D3BC1               cmp      r8, r9
       722D                 jb       SHORT G_M1321_IG05
       4C8D4010             lea      r8, bword ptr [rax+16]
       4C63CA               movsxd   r9, edx
       4D03C1               add      r8, r9
       448D4901             lea      r9d, [rcx+1]
       3B0D10901E00         cmp      ecx, dword ptr [reloc classVar[0xb2a657e0]]
       418BC9               mov      ecx, r9d
       7CD7                 jl       SHORT G_M1321_IG03
       4C8906               mov      bword ptr [rsi], r8
       C746080A000000       mov      dword ptr [rsi+8], 10
       488BC6               mov      rax, rsi
                                                ;; bbWeight=1    PerfScore 9.75
G_M1321_IG04:              ;; offset=005EH
       4883C428             add      rsp, 40
       5E                   pop      rsi
       5F                   pop      rdi
       C3                   ret
                                                ;; bbWeight=1    PerfScore 2.25
G_M1321_IG05:              ;; offset=0065H
       E87EF8FFFF           call     System.ThrowHelper:ThrowArgumentOutOfRangeException()
       CC                   int3
                                                ;; bbWeight=0    PerfScore 0.00

; Total bytes of code 107, prolog size 11, PerfScore 28.70, instruction count 34, allocated bytes for code 107 (MethodHash=23b1fad6) for method EncodingRepro.Program:TestSliceAsSpan(int):System.Span`1[Byte]
; ============================================================

TestAsSpan() calls the Span(T[]?) ctor followed by Slice. that in turn calls Span(ref T ptr, int length) ctor. But, SliceAsSpan is straight forward and just calls ctor Span(T[]? array, int start, int length). So defintely more code is executed in TestAsSpan() compared to TestSliceAsSpan(). So the slowness in .Slice() is expected.

[ahsonkhan]

@kunalspathak the goal of the initial issue was to eliminate or reduce this perf difference, even though the two benchmarks are taking slightly different code paths (intentionally). Are you saying this is not something that can be fixed just by JIT improvements alone?

[kunalspathak]

Ok, it was not clear from the title. I will reopen the issue and do some more analysis.