Subjects.cs

using System.Buffers;
using System.Numerics;
using System.Runtime.CompilerServices;

namespace PoolProof;

/// <summary>
/// Все измеряемые методы: аренда и возврат массива через ArrayPool.Shared,
/// через пул из ArrayPool.Create и обычный new. Отдельно - возврат с очисткой
/// и без, аренда из другого потока и вспомогательные расчёты для отчётов.
/// Каждый способ вынесен в отдельный метод с NoInlining, чтобы компилятор
/// не встроил его в тело замера и не выбросил как ненужную работу.
///
/// Исходники пулов в dotnet/runtime:
///   ArrayPool.cs, ConfigurableArrayPool.cs, TlsOverPerCoreLockedStacksArrayPool.cs
/// Порог больших объектов:
///   https://learn.microsoft.com/dotnet/standard/garbage-collection/large-object-heap
/// </summary>
public static class Subjects
{
    /// <summary>
    /// Порог из документации, с которого массив попадает в кучу больших
    /// объектов. Настоящая граница по длине массива меньше на размер заголовка
    /// объекта, поэтому отчёт ищет её перебором и сверяет с этой величиной.
    /// https://learn.microsoft.com/dotnet/standard/garbage-collection/large-object-heap
    /// </summary>
    public const int LargeObjectThreshold = 85_000;

    /// <summary>
    /// Размер буфера по умолчанию у Stream.CopyTo.
    /// </summary>
    public const int StreamCopyBuffer = 81_920;

    /// <summary>
    /// Пул из ArrayPool.Create с параметрами по умолчанию: максимум 1 048 576
    /// элементов и 50 массивов в бакете.
    /// </summary>
    public static readonly ArrayPool<byte> Created = ArrayPool<byte>.Create();

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int RentShared(int size)
    {
        byte[] array = ArrayPool<byte>.Shared.Rent(size);
        int length = array.Length;
        
        ArrayPool<byte>.Shared.Return(array);
        return length;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int RentCreated(int size)
    {
        byte[] array = Created.Rent(size);
        
        int length = array.Length;
        Created.Return(array);

        return length;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int AllocateNew(int size)
    {
        byte[] array = new byte[size];
        return array.Length;
    }

    // Возврат с очисткой. Return не чистит массив по умолчанию, и следующий
    // арендатор получает данные предыдущего. Замер показывает, сколько
    // очистка занимает на разных размерах.

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int RentSharedClear(int size)
    {
        byte[] array = ArrayPool<byte>.Shared.Rent(size);
        
        int length = array.Length;
        ArrayPool<byte>.Shared.Return(array, clearArray: true);

        return length;
    }

    // Аренда и возврат в разных потоках. Первый уровень хранения у общего
    // пула - слот, локальный для потока.

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int RentSharedCrossThread(int size)
    {
        byte[] array = ArrayPool<byte>.Shared.Rent(size);
        int length = array.Length;

        Task.Run(() => ArrayPool<byte>.Shared.Return(array)).Wait();
        return length;
    }

    // То же самое, но возврат в своём потоке. Контрольная строка: переход
    // между потоками входит в оба метода.

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int RentSharedSameThread(int size)
    {
        byte[] array = ArrayPool<byte>.Shared.Rent(size);
        int length = array.Length;

        Task.Run(() => { }).Wait();
        ArrayPool<byte>.Shared.Return(array);

        return length;
    }

    // Аренда сразу нескольких массивов и возврат всех разом. Число массивов
    // каждого размера у общего пула ограничено, и за этой границей аренда
    // выделяет память.

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int RentSharedMany(int size, byte[][] buffer)
    {
        for (int i = 0; i < buffer.Length; i++)
        {
            buffer[i] = ArrayPool<byte>.Shared.Rent(size);
        }

        int total = 0;
        for (int i = 0; i < buffer.Length; i++)
        {
            total += buffer[i].Length;

            ArrayPool<byte>.Shared.Return(buffer[i]);

            buffer[i] = null!;
        }

        return total;
    }

    // Выделение без обнуления, появилось в .NET 5. На больших массивах
    // обнуление занимает заметную часть времени new.

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int AllocateUninitialized(int size)
    {
        byte[] array = GC.AllocateUninitializedArray<byte>(size);
        return array.Length;
    }

    // Аренда и возврат в нескольких потоках сразу.

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int RentSharedParallel(int size, int threads, int iterations)
    {
        int total = 0;

        Parallel.For(0, threads, _ =>
        {
            int local = 0;
            for (int i = 0; i < iterations; i++)
            {
                byte[] array = ArrayPool<byte>.Shared.Rent(size);
                local += array.Length;

                ArrayPool<byte>.Shared.Return(array);
            }

            Interlocked.Add(ref total, local);
        });

        return total;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int AllocateNewParallel(int size, int threads, int iterations)
    {
        int total = 0;

        Parallel.For(0, threads, _ =>
        {
            int local = 0;
            for (int i = 0; i < iterations; i++)
            {
                local += new byte[size].Length;
            }

            Interlocked.Add(ref total, local);
        });

        return total;
    }

    // Те же три способа, но массив после получения заполняется целиком.
    //
    // Без записи сравнение с AllocateUninitializedArray неполное: new обнуляет
    // массив и тем самым обращается ко всем его страницам, а выделение без
    // обнуления переносит эту работу на первую запись в массив.
    //
    // У пула массив может оказаться длиннее запрошенного, поэтому заполняются
    // ровно size байт: иначе пул делал бы больше работы, чем остальные два.

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int AllocateNewFilled(int size)
    {
        byte[] array = new byte[size];
        Array.Fill(array, (byte)1);

        return array.Length;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int AllocateUninitializedFilled(int size)
    {
        byte[] array = GC.AllocateUninitializedArray<byte>(size);
        Array.Fill(array, (byte)1);

        return array.Length;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int RentSharedFilled(int size)
    {
        byte[] array = ArrayPool<byte>.Shared.Rent(size);
        Array.Fill(array, (byte)1, 0, size);

        int length = array.Length;
        ArrayPool<byte>.Shared.Return(array);

        return length;
    }

    /// <summary>
    /// Заполнение массива, который уже есть. Нижняя граница для замера
    /// с записью: сколько занимает запись без получения памяти.
    /// </summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int FillExisting(byte[] array, int size)
    {
        Array.Fill(array, (byte)1, 0, size);
        return array.Length;
    }

    /// <summary>
    /// Размер бакета, в который попадёт запрос: минимум 16 элементов, дальше
    /// ближайшая степень двойки вверх. Повторяет расчёт из пула, чтобы отчёты
    /// не зависели от internal-методов рантайма.
    /// </summary>
    public static int BucketSize(int size) => size <= 16 ? 16 : (int)BitOperations.RoundUpToPowerOf2((uint)size);
}