Use safe scalar code for UTF-8 Equals(OrdinalIgnoreCase)

[EgorBo]

Follow up to #134857

Ordinal.EqualsIgnoreCaseUtf8 is only used by UTF-8 floating-point parsing to match the NaN/Infinity symbols, so the vectorized ref/Unsafe-based implementation is replaced with safe span-based code:

• ASCII fast path: compares 8 bytes at a time via BinaryPrimitives.ReadUInt64LittleEndian and the UInt64OrdinalIgnoreCaseAscii SWAR helper, then byte by byte. It has no calls, so it's inlined into TryMatchSpecialValueSymbol.
• ASCII vs. non-ASCII byte: rejected inline, since no non-ASCII scalar equals an ASCII one under ordinal casing.
• Non-ASCII: falls back to the rune loop already used by StartsWithIgnoreCaseUtf8, which is unchanged.

The now unused Utf8Utility.UInt32OrdinalIgnoreCaseAscii and Vector128OrdinalIgnoreCaseAscii are removed.

Benchmark

double.TryParse on UTF-8 input; EgorBot results, benchmark source in this comment. Cells are main → PR (PR/main); below 1.00 is faster.

• Inv_*: invariant culture. Inv_Number (123.5) doesn't reach the changed code.
• Ru_*: ru-RU symbols; NaNSymbol is не число (16 bytes) and the infinity symbols are ∞/-∞.
• U2212_MinusNaN: NegativeSign is U+2212 (e.g. sv-SE).
• Lrm_PlusInfinity: signs wrapped in U+200E.
• Long_NaN: artificial 18-byte ASCII NaNSymbol.

Case	macOS arm64 (Apple M4)	Linux x64 (AMD EPYC 9V45)	Windows x64 (Intel Xeon 8573C)
Inv_Infinity	17.23 → 17.10 ns (0.99)	19.42 → 19.04 ns (0.98)	28.10 → 27.94 ns (0.99)
Inv_INFINITY	17.10 → 17.04 ns (1.00)	19.79 → 19.65 ns (0.99)	28.29 → 27.76 ns (0.98)
Inv_Invalid	20.86 → 20.22 ns (0.97)	24.38 → 22.84 ns (0.94)	35.12 → 38.96 ns (1.11)
Inv_MinusNaN	23.02 → 22.77 ns (0.99)	28.32 → 25.83 ns (0.91)	40.33 → 38.47 ns (0.95)
Inv_nan	18.84 → 19.35 ns (1.03)	22.29 → 21.97 ns (0.99)	31.69 → 36.34 ns (1.15)
Inv_NaN	18.43 → 19.03 ns (1.03)	21.52 → 21.48 ns (1.00)	31.02 → 31.50 ns (1.02)
Inv_NaN_WS	21.88 → 22.22 ns (1.02)	23.75 → 23.55 ns (0.99)	35.84 → 35.70 ns (1.00)
Inv_NegInfinity	18.30 → 18.04 ns (0.99)	22.15 → 21.49 ns (0.97)	32.51 → 32.26 ns (0.99)
Inv_Number	22.01 → 22.04 ns (1.00)	25.46 → 25.55 ns (1.00)	36.80 → 49.33 ns (1.34)
Inv_PlusInfinity	19.70 → 18.34 ns (0.93)	25.68 → 23.48 ns (0.91)	36.94 → 34.53 ns (0.93)
Long_NaN	22.26 → 21.19 ns (0.95)	25.43 → 25.53 ns (1.00)	38.19 → 36.65 ns (0.96)
Lrm_PlusInfinity	29.30 → 29.19 ns (1.00)	33.49 → 33.32 ns (0.99)	45.89 → 46.21 ns (1.01)
Ru_Infinity	23.50 → 21.30 ns (0.91)	27.91 → 25.02 ns (0.90)	39.16 → 35.72 ns (0.91)
Ru_Invalid	20.34 → 19.92 ns (0.98)	22.68 → 22.31 ns (0.98)	34.12 → 33.61 ns (0.99)
Ru_NaN	168.56 → 42.84 ns (0.25)	212.84 → 44.43 ns (0.21)	292.58 → 62.52 ns (0.21)
Ru_NaN_Upper	170.80 → 53.91 ns (0.32)	213.63 → 53.66 ns (0.25)	288.22 → 75.92 ns (0.26)
Ru_NegInfinity	39.66 → 26.30 ns (0.66)	47.61 → 25.48 ns (0.54)	66.83 → 40.63 ns (0.61)
U2212_MinusNaN	27.38 → 27.12 ns (0.99)	32.09 → 31.44 ns (0.98)	45.90 → 44.29 ns (0.96)

[azure-pipelines]

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

[dotnet-policy-service]

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

[EgorBo]

@EgorBot -osx_arm64 -windows_intel -linux_amd

using System.Globalization;
using System.Text;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

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

public class Bench {
    static readonly NumberFormatInfo Inv = NumberFormatInfo.InvariantInfo;

    // ru-RU symbols: NaN is 16 UTF-8 bytes (non-ASCII)
    static readonly NumberFormatInfo Ru = new() {
        NaNSymbol = "\u043D\u0435\u00A0\u0447\u0438\u0441\u043B\u043E",
        PositiveInfinitySymbol = "\u221E",
        NegativeInfinitySymbol = "-\u221E",
    };

    // sv-SE style minus sign (U+2212)
    static readonly NumberFormatInfo U2212 = new() { NegativeSign = "\u2212" };

    // LRM-wrapped signs (U+200E), the longest signs across ICU cultures
    static readonly NumberFormatInfo Lrm = new() { PositiveSign = "\u200E+\u200E", NegativeSign = "\u200E-\u200E" };

    // Artificial long ASCII symbol (>= 16 bytes)
    static readonly NumberFormatInfo Long = new() { NaNSymbol = "Not-A-Number-Value" };

    static readonly Dictionary<string, (string Input, NumberFormatInfo Nfi, double Expected)> Data = new() {
        ["Inv_Infinity"] = ("Infinity", Inv, double.PositiveInfinity),
        ["Inv_INFINITY"] = ("INFINITY", Inv, double.PositiveInfinity),
        ["Inv_NegInfinity"] = ("-Infinity", Inv, double.NegativeInfinity),
        ["Inv_PlusInfinity"] = ("+infinity", Inv, double.PositiveInfinity),
        ["Inv_NaN"] = ("NaN", Inv, double.NaN),
        ["Inv_nan"] = ("nan", Inv, double.NaN),
        ["Inv_MinusNaN"] = ("-nan", Inv, double.NaN),
        ["Inv_NaN_WS"] = ("  NaN  ", Inv, double.NaN),
        ["Inv_Invalid"] = ("abc", Inv, 0),
        ["Inv_Number"] = ("123.5", Inv, 123.5),
        ["Ru_NaN"] = ("\u043D\u0435\u00A0\u0447\u0438\u0441\u043B\u043E", Ru, double.NaN),
        ["Ru_NaN_Upper"] = ("\u041D\u0415\u00A0\u0427\u0418\u0421\u041B\u041E", Ru, double.NaN),
        ["Ru_Infinity"] = ("\u221E", Ru, double.PositiveInfinity),
        ["Ru_NegInfinity"] = ("-\u221E", Ru, double.NegativeInfinity),
        ["Ru_Invalid"] = ("abc", Ru, 0),
        ["U2212_MinusNaN"] = ("\u2212nan", U2212, double.NaN),
        ["Lrm_PlusInfinity"] = ("\u200E+\u200EInfinity", Lrm, double.PositiveInfinity),
        ["Long_NaN"] = ("not-a-number-value", Long, double.NaN),
    };

    public static IEnumerable<string> Cases => Data.Keys;

    [ParamsSource(nameof(Cases))]
    public string Case { get; set; } = "";

    byte[] _input = default!;
    NumberFormatInfo _nfi = default!;

    [GlobalSetup]
    public void Setup() {
        var (input, nfi, expected) = Data[Case];
        _input = Encoding.UTF8.GetBytes(input);
        _nfi = nfi;
        if (!Parse().Equals(expected)) {
            throw new Exception($"{Case}: unexpected result");
        }
    }

    [Benchmark]
    public double Parse() {
        double.TryParse(_input, NumberStyles.Float, _nfi, out double result);
        return result;
    }
}

Note

This benchmark comment was generated with GitHub Copilot.

[EgorBo]

PTAL @MihaZupan follow up to #134857

[EgorBo]

Had to change the new test I added in #134857

Becuase it was not NLS-friendly

Mininal repro

Console.WriteLine("𐐀Infinity".StartsWith("𐐨", StringComparison.OrdinalIgnoreCase));

prints true for ICU and false for NLS (not my change related).

[MihaZupan]

Nice

[EgorBo]

/ba-g failures are #135031