[WIP] Improve performance of Utf8Parser.TryParseInt32D

[GrabYourPitchforks]

Copied from dotnet#32843.

---

WIP because it's not plumbed through to other Utf8Parser APIs and because these same improvements are likely viable for other methods like int.Parse. I also need to clean up / comment the code a little bit.

There are a handful of patterns being used here that result in improved codegen. Some of these are things that really should be in the JIT's wheelhouse rather than worked around in this code base. Given that Utf8Parser.TryParse (and related APIs int.Parse) are such hot code paths, though, it may be worthwhile to take these code changes anyway while waiting for the JIT's changes to come through.

Overall perf results

Method	Toolchain	Mean	Error	StdDev	Ratio
TryParseInt32	master	1,217.5 ns	12.02 ns	10.03 ns	1.00
TryParseInt32	thisbranch	954.9 ns	8.77 ns	6.85 ns	0.78

Fast-track 'default' formats

Since we expect standardFormat = default to be the common case, it's fast-tracked at the start of the method rather than entering the switch statement. Additionally, entries in the switch statement are normalized to lowercase to minimize the number of if conditions present.

; BEFORE
movzx   ebx,r9w
cmp     ebx,4Eh
ja      System_Private_CoreLib!System.Buffers.Text.Utf8Parser.TryParse(System.ReadOnlySpan`1<Byte>, Int32 ByRef, Int32 ByRef, Char)+0xffffffff`a3c352f5 (00007ff9`b841a555)
cmp     ebx,44h
ja      System_Private_CoreLib!System.Buffers.Text.Utf8Parser.TryParse(System.ReadOnlySpan`1<Byte>, Int32 ByRef, Int32 ByRef, Char)+0xffffffff`a3c352cd (00007ff9`b841a52d)
test    ebx,ebx
je      System_Private_CoreLib!System.Buffers.Text.Utf8Parser.TryParse(System.ReadOnlySpan`1<Byte>, Int32 ByRef, Int32 ByRef, Char)+0xffffffff`a3c352af (00007ff9`b841a50f)
cmp     ebx,44h
jne     System_Private_CoreLib!System.Buffers.Text.Utf8Parser.TryParse(System.ReadOnlySpan`1<Byte>, Int32 ByRef, Int32 ByRef, Char)+0xffffffff`a3c35337 (00007ff9`b841a597)
lea     rcx,[rsp+20h]
mov     qword ptr [rcx],rsi
mov     dword ptr [rcx+8],edi
lea     rcx,[rsp+20h]
call    CLRStub[MethodDescPrestub]@7ff9b84188c0 (00007ff9`b84188c0)

; AFTER
movzx   eax,r9w
test    eax,eax
je      System_Private_CoreLib!System.Buffers.Text.Utf8Parser.TryParse(System.ReadOnlySpan`1<Byte>, Int32 ByRef, Int32 ByRef, Char)+0xffffffff`a3c78a18 (00007ff9`b843abb8)
or      eax,20h
cmp     eax,67h
je      System_Private_CoreLib!System.Buffers.Text.Utf8Parser.TryParse(System.ReadOnlySpan`1<Byte>, Int32 ByRef, Int32 ByRef, Char)+0xffffffff`a3c78a18 (00007ff9`b843abb8)
cmp     eax,64h
jne     System_Private_CoreLib!System.Buffers.Text.Utf8Parser.TryParse(System.ReadOnlySpan`1<Byte>, Int32 ByRef, Int32 ByRef, Char)+0xffffffff`a3c78a35 (00007ff9`b843abd5)
lea     rcx,[rsp+28h]
mov     qword ptr [rcx],rsi
mov     dword ptr [rcx+8],edi
lea     rcx,[rsp+28h]
call    CLRStub[MethodDescPrestub]@7ff9b8438388 (00007ff9`b8438388)

Repurpose some locals for more efficient register allocation

The answer local is repurposed to hold the running value from the very start of the method, no longer bouncing through num. The check for '+' and '-' is moved out of the common path because those characters should be uncommon.

Avoid expensive instructions

The span is indexed by native int rather than int. This avoids an expensive movsxd instruction in the hot path. Additionally, at the end of the method the imul instruction is removed in favor of cheaper xor and sub instructions.

Finally, the intermediate value resulting from the num - '0' operation is reused as the addend when building up the expression answer = answer * 10 + .... This avoids an expensive three-component lea instruction in the hot path.

; HOT PATH - BEFORE
cmp     r10d,ecx
jae     System_Private_CoreLib!System.Buffers.Text.Utf8Parser.TryParseInt32D(System.ReadOnlySpan`1<Byte>, Int32 ByRef, Int32 ByRef)+0xffffffff`beef5172 (00007ff9`e303a882)
movsxd  r11,r10d
movzx   r11d,byte ptr [rax+r11]
lea     edi,[r11-30h]
cmp     edi,9
ja      System_Private_CoreLib!System.Buffers.Text.Utf8Parser.TryParseInt32D(System.ReadOnlySpan`1<Byte>, Int32 ByRef, Int32 ByRef)+0xffffffff`beef5172 (00007ff9`e303a882)
inc     r10d
lea     esi,[rsi+rsi*4]
lea     esi,[r11+rsi*2-30h]

; HOT PATH - AFTER
cmp     r11,rdi
jae     System_Private_CoreLib!System.Buffers.Text.Utf8Parser.TryParseInt32D(System.ReadOnlySpan`1<Byte>, Int32 ByRef, Int32 ByRef)+0xffffffff`befc8605 (00007ff9`e30eac25)
movzx   eax,byte ptr [r9+r11]
add     eax,0FFFFFFD0h
cmp     eax,9
ja      System_Private_CoreLib!System.Buffers.Text.Utf8Parser.TryParseInt32D(System.ReadOnlySpan`1<Byte>, Int32 ByRef, Int32 ByRef)+0xffffffff`befc8605 (00007ff9`e30eac25)
inc     r11
lea     ecx,[rsi+rsi*4]
lea     esi,[rax+rcx*2]

Benchmark application

public class Utf8ParserRunner
{
    private byte[][] _intStrings;

    [GlobalSetup]
    public void Setup()
    {
        // Randomly create 200 strings "19472903" and similar.
        // Vary the lengths to throw off the branch predictor.
        Random rnd = new Random(0x12345);
        byte[][] intStrings = new byte[200][];
        for (int i = 0; i < intStrings.Length; i++)
        {
            byte[] thisIntString = new byte[rnd.Next(1, 10)];
            for (int j = 0; j < thisIntString.Length; j++)
            {
                thisIntString[j] = (byte)rnd.Next(0, 10);
            }
            intStrings[i] = thisIntString;
        }
        _intStrings = intStrings;
    }

    [Benchmark]
    public bool TryParseInt32()
    {
        bool retVal = false;

        byte[][] strs = _intStrings;
        for (int i = 0; i < strs.Length; i++)
        {
            byte[] str = strs[i];
            _ = str.Length; // deref now to avoid implicit span null check

            retVal = Utf8Parser.TryParse(str, out int _, out int _);
        }

        return retVal;
    }
}

Related issues: dotnet#28070, dotnet#12218, dotnet#12402