Subjects.cs

using System.Runtime.CompilerServices;

namespace BoundsCheckProof;

/// <summary>
/// Подопытные циклы для проверки границ. Один JIT научился убирать
/// в .NET 9, ещё один - в .NET 10, обратные циклы дожаты в .NET 11,
/// а цикл с i != Length таскает проверку до сих пор. Плюс два контроля.
///
/// Пруфы (код взят дословно из первоисточников):
///   PR #100777 (jakobbotsch, JIT-команда) - цикл (uint)i, убит в .NET 9
///       https://github.com/dotnet/runtime/pull/100777
///   PR #115980 (EgorBo, JIT-команда) - доступ s[p.Length], убит в .NET 10
///       https://github.com/dotnet/runtime/pull/115980
///   Issue #84697 (xtqqczze) - цикл i != Length, там же в треде hughbe и
///   xtqqczze фиксируют обратные циклы, EgorBo сс-ит BruceForstall
///       https://github.com/dotnet/runtime/issues/84697
///   Issue #9505 - обратная итерация, открыт с 2017, дожат в .NET 11
///       https://github.com/dotnet/runtime/issues/9505
///   Сводный трекер пропусков у команды JIT - issue #109677 (EgorBo)
///       https://github.com/dotnet/runtime/issues/109677
///
/// NoInlining на методах - только чтобы каждый печатался в листинге
/// отдельно и под своим именем. На сам цикл и проверку инлайн не влияет.
/// </summary>
public static class Subjects
{
    // ------------------------------------------------------------------
    // ЭТАЛОН: классический цикл, проверка убрана с незапамятных времен
    // на всех рантаймах. Baseline для всего дальше.
    // ------------------------------------------------------------------
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int LessLoop(byte[] src)
    {
        int sum = 0;
        for (int i = 0; i < src.Length; i++)
        {
            sum += src[i];
        }

        return sum;
    }

    // ------------------------------------------------------------------
    // ВЫЖИВШИЙ: тот же перебор, но i != Length (issue #84697).
    // Делает то же самое, что LessLoop, а проверка на каждой итерации -
    // жива на всех рантаймах, включая .NET 11.
    // ------------------------------------------------------------------
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int NotEqualLoop(byte[] src)
    {
        int sum = 0;
        for (int i = 0; i != src.Length; i++)
        {
            sum += src[i];
        }

        return sum;
    }

    // ------------------------------------------------------------------
    // Обратный цикл (issue #9505, открыт с 2017). Повседневный код -
    // обход с хвоста, удаление с конца; hughbe в треде #84697: "This could
    // be a common pattern". Индекс идёт от Length-1 вниз до нуля - глазами
    // видно, что выход за границы невозможен, а JIT доказать не мог.
    // До .NET 10 включительно проверка живёт в запасной копии цикла
    // (loop cloning) и времени не отнимает, в .NET 11 копию выкинули.
    // ------------------------------------------------------------------
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int ReverseLoop(byte[] src)
    {
        int sum = 0;
        for (int i = src.Length - 1; i >= 0; i--)
        {
            sum += src[i];
        }

        return sum;
    }

    // ------------------------------------------------------------------
    // Родственный обратный while из того же треда #84697 (xtqqczze):
    // декремент до нуля. Дожат в .NET 11 вместе с ReverseLoop, а в .NET 9
    // стал быстрее за счёт IV widening (PR #97865).
    // ------------------------------------------------------------------
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int WhileDecLoop(byte[] src)
    {
        int sum = 0;

        int i = src.Length;
        while (i != 0)
        {
            sum += src[--i];
        }

        return sum;
    }

    // ------------------------------------------------------------------
    // УБИТ В .NET 9 (PR #100777, jakobbotsch). Беззнаковое сравнение
    // само доказывает 0 <= i < len, но до фикса анализ диапазонов это
    // доказать не мог - мешало слишком осторожное "а вдруг переполнение".
    // net8: cmp/jae в цикле есть, net9/10/11: нет.
    // ------------------------------------------------------------------
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int UnsignedWhile(int i, int[] indices)
    {
        while ((uint)i < (uint)indices.Length)
        {
            i = indices[i];
        }

        return i;
    }

    // ------------------------------------------------------------------
    // УБИТ В .NET 10 (PR #115980, EgorBo). Сравнение длин уже доказывает
    // валидность индекса. net8/9: проверка есть, net10/11: нет.
    // ------------------------------------------------------------------
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static bool PrefixSlash(string prefix, string path)
    {
        if (prefix.Length < path.Length)
        {
            return path[prefix.Length] == '/';
        }

        return false;
    }

    // ------------------------------------------------------------------
    // КОНТРОЛЬ-ПЛЮС: одна проверка вместо двух на любом рантайме.
    // Показывает: устранение проверок реально работает, инструменту
    // можно верить.
    // ------------------------------------------------------------------
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int FirstPlusLast(int[] arr) => arr[0] + arr[arr.Length - 1];

    // ------------------------------------------------------------------
    // КОНТРОЛЬ-МИНУС: проверку убрать нельзя, обязана остаться везде.
    // Показывает: отсутствие проверки в других методах - не случайность.
    // ------------------------------------------------------------------
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int AtUnknownIndex(int[] arr, int index)
    {
        if (arr.Length == 0)
        {
            return -1;
        }

        return arr[index];
    }
}