Benchmark for https://github.com/sebas77/Svelto.ECS/issues/104

Benchmark.cs

using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using BenchmarkDotNet.Attributes;

[MemoryDiagnoser]
public unsafe class UnsafeArray
{
    private const int Count = 100_000_000;

    private int* arrayPtr;
    private NB<int> nb;

    [StructLayout(LayoutKind.Sequential, Size = 1)]
    public struct TestThreadSafety : IDisposable
    {
        public void Dispose()
        {
        }
    }

    [StructLayout(LayoutKind.Sequential, Size = 1)]
    public readonly struct Sentinel
    {
        public TestThreadSafety TestThreadSafety() => new TestThreadSafety();
    }

    public struct NB<T> where T : unmanaged
    {
        private readonly uint _capacity;
        private readonly IntPtr _ptr;
        private readonly Sentinel _threadSentinel;
        private static readonly int SIZE = Unsafe.SizeOf<T>();

        public NB(IntPtr array, uint capacity)
            : this()
        {
            this._ptr = array;
            this._capacity = capacity;
            this._threadSentinel = new();
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public unsafe ref T GetFixed(int index)
        {
            // using (this._threadSentinel.TestThreadSafety())
            return ref Unsafe.AsRef<T>((void*)(this._ptr + (int)index * Unsafe.SizeOf<T>()));
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public unsafe ref T GetWithSize(int index)
        {
            // using (this._threadSentinel.TestThreadSafety())
            return ref Unsafe.AsRef<T>((void*)(this._ptr + (int)index * SIZE));
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public unsafe ref T GetWithSentinel(int index)
        {
            using (this._threadSentinel.TestThreadSafety())
                return ref Unsafe.AsRef<T>((void*)(this._ptr + (int)index * Unsafe.SizeOf<T>()));
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public unsafe ref T GetWithSentinelAndSize(int index)
        {
            using (this._threadSentinel.TestThreadSafety())
                return ref Unsafe.AsRef<T>((void*)(this._ptr + (int)index * SIZE));
        }
    }

    [GlobalSetup]
    public void GlobalSetup()
    {
        arrayPtr = (int*)Marshal.AllocHGlobal(Count * sizeof(int));

        for (int i = 0; i < Count; ++i)
            arrayPtr[i] = i;

        nb = new((IntPtr)arrayPtr, Count);
    }

    [GlobalCleanup]
    public void GlobalCleanup()
    {
        Marshal.FreeHGlobal((IntPtr)arrayPtr);
    }

    [Benchmark]
    public int PointerAccess()
    {
        int result = 0;

        for (int i = 0; i < Count; ++i)
        {
            result += arrayPtr[i];
        }

        return result;
    }

    [Benchmark]
    public int NBFixed()
    {
        int result = 0;

        for (int i = 0; i < Count; ++i)
        {
            result += nb.GetFixed(i);
        }

        return result;
    }

    [Benchmark]
    public int NBWithSize()
    {
        int result = 0;

        for (int i = 0; i < Count; ++i)
        {
            result += nb.GetWithSize(i);
        }

        return result;
    }

    [Benchmark]
    public int NBWithSentinel()
    {
        int result = 0;

        for (int i = 0; i < Count; ++i)
        {
            result += nb.GetWithSentinel(i);
        }

        return result;
    }

    [Benchmark(Baseline = true)]
    public int NBWithSentinelAndSize()
    {
        int result = 0;

        for (int i = 0; i < Count; ++i)
        {
            result += nb.GetWithSentinelAndSize(i);
        }

        return result;
    }
}

BenchmarkForUnity.cs

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using NUnit.Framework;
using Unity.Collections.LowLevel.Unsafe;
using Unity.PerformanceTesting;

public unsafe class UnsafeBenchmark
{
    private const int Count = 1_000_000;

    private int* arrayPtr;
    private NB<int> nb;

    private static int sink;

    [StructLayout(LayoutKind.Sequential, Size = 1)]
    public struct TestThreadSafety : IDisposable
    {
        public void Dispose()
        {
        }
    }

    [StructLayout(LayoutKind.Sequential, Size = 1)]
    public readonly struct Sentinel
    {
        public TestThreadSafety TestThreadSafety() => new TestThreadSafety();
    }

    public struct NB<T> where T : unmanaged
    {
        private readonly uint _capacity;
        private readonly IntPtr _ptr;
        private readonly Sentinel _threadSentinel;
        private static readonly int SIZE = Unsafe.SizeOf<T>();

        public NB(IntPtr array, uint capacity)
            : this()
        {
            this._ptr = array;
            this._capacity = capacity;
            this._threadSentinel = new();
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public ref T SystemUnsafe(int index)
        {
            // using (this._threadSentinel.TestThreadSafety())
            return ref Unsafe.AsRef<T>((void*)(this._ptr + (int)index * Unsafe.SizeOf<T>()));
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public ref T UnityUnsafe(int index)
        {
            return ref UnsafeUtility.AsRef<T>((void*)(this._ptr + (int)index * UnsafeUtility.SizeOf<T>()));
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public ref T WithSentinelAndSize(int index)
        {
            using (this._threadSentinel.TestThreadSafety())
                return ref Unsafe.AsRef<T>((void*)(this._ptr + (int)index * SIZE));
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public ref T WithSize(int index)
        {
            return ref Unsafe.AsRef<T>((void*)(this._ptr + (int)index * SIZE));
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public ref T WithSentinel(int index)
        {
            using (this._threadSentinel.TestThreadSafety())
                return ref Unsafe.AsRef<T>((void*)(this._ptr + (int)index * Unsafe.SizeOf<T>()));
        }
    }

    [OneTimeSetUp]
    public void GlobalSetup()
    {
        arrayPtr = (int*)Marshal.AllocHGlobal(Count * sizeof(int));

        for (int i = 0; i < Count; ++i)
            arrayPtr[i] = i;

        nb = new((IntPtr)arrayPtr, Count);
    }

    [OneTimeTearDown]
    public void GlobalCleanup()
    {
        Marshal.FreeHGlobal((IntPtr)arrayPtr);
    }

    [Test, Performance]
    public void AccessPointerDirectly()
    {
        Measure.Method(() =>
        {
            int result = 0;

            for (int i = 0; i < Count; ++i)
            {
                result += arrayPtr[i];
            }

            sink = result;
        }).MeasurementCount(1000).Run();
    }

    [Test, Performance]
    public void AccessWithSystemUnsafe()
    {
        Measure.Method(() =>
        {
            int result = 0;

            for (int i = 0; i < Count; ++i)
            {
                result += nb.SystemUnsafe(i);
            }

            sink = result;
        }).MeasurementCount(1000).Run();
    }

    [Test, Performance]
    public void AccessWithUnityUnsafe()
    {
        Measure.Method(() =>
        {
            int result = 0;

            for (int i = 0; i < Count; ++i)
            {
                result += nb.UnityUnsafe(i);
            }

            sink = result;
        }).MeasurementCount(1000).Run();
    }

    [Test, Performance]
    public void AccessWithSentinelAndSize()
    {
        Measure.Method(() =>
        {
            int result = 0;

            for (int i = 0; i < Count; ++i)
            {
                result += nb.WithSentinelAndSize(i);
            }

            sink = result;
        }).MeasurementCount(1000).Run();
    }

    [Test, Performance]
    public void AccessWithSentinel()
    {
        Measure.Method(() =>
        {
            int result = 0;

            for (int i = 0; i < Count; ++i)
            {
                result += nb.WithSentinel(i);
            }

            sink = result;
        }).MeasurementCount(1000).Run();
    }

    [Test, Performance]
    public void AccessWithSize()
    {
        Measure.Method(() =>
        {
            int result = 0;

            for (int i = 0; i < Count; ++i)
            {
                result += nb.WithSize(i);
            }

            sink = result;
        }).MeasurementCount(1000).Run();
    }
}

Result.md

Results (.NET 6.0)

BenchmarkDotNet=v0.13.2, OS=macOS Monterey 12.3 (21E230) [Darwin 21.4.0]
Apple M1 Pro, 1 CPU, 10 logical and 10 physical cores
.NET SDK=7.0.101
  [Host]     : .NET 6.0.2 (6.0.222.6406), Arm64 RyuJIT AdvSIMD
  DefaultJob : .NET 6.0.2 (6.0.222.6406), Arm64 RyuJIT AdvSIMD

Method	Mean	Error	StdDev	Ratio	Allocated	Alloc Ratio
PointerAccess	57.97 ms	0.772 ms	0.722 ms	0.46	154 B	0.23
NBFixed	59.77 ms	0.258 ms	0.215 ms	0.47	75 B	0.11
NBWithSize	240.70 ms	0.737 ms	0.689 ms	1.90	893 B	1.33
NBWithSentinel	127.20 ms	0.262 ms	0.233 ms	1.00	168 B	0.25
NBWithSentinelAndSize	126.93 ms	0.148 ms	0.123 ms	1.00	670 B	1.00

Results (.NET 7.0)

BenchmarkDotNet=v0.13.2, OS=macOS Monterey 12.3 (21E230) [Darwin 21.4.0]
Apple M1 Pro, 1 CPU, 10 logical and 10 physical cores
.NET SDK=7.0.101
  [Host]     : .NET 7.0.1 (7.0.122.56804), Arm64 RyuJIT AdvSIMD
  DefaultJob : .NET 7.0.1 (7.0.122.56804), Arm64 RyuJIT AdvSIMD

Method	Mean	Error	StdDev	Ratio	Allocated	Alloc Ratio
PointerAccess	41.42 ms	0.174 ms	0.154 ms	0.39	63 B	0.39
NBFixed	64.07 ms	0.209 ms	0.186 ms	0.61	102 B	0.63
NBWithSize	63.77 ms	0.284 ms	0.252 ms	0.60	102 B	0.63
NBWithSentinel	104.91 ms	0.344 ms	0.288 ms	0.99	163 B	1.00
NBWithSentinelAndSize	105.58 ms	0.339 ms	0.265 ms	1.00	163 B	1.00

Results (Mono)

BenchmarkDotNet=v0.13.2, OS=macOS Monterey 12.3 (21E230) [Darwin 21.4.0]
Apple M1 Pro 2.40GHz, 1 CPU, 10 logical and 10 physical cores
  [Host]     : Mono 6.12.0.162 (2020-02/2ca650f1f62 Tue), X64 VectorSize=128
  Job-CKTNGU : Mono 6.12.0.162 (2020-02/2ca650f1f62 Tue), X64 VectorSize=128

Runtime=Mono  

Method	Mean	Error	StdDev	Ratio	Allocated	Alloc Ratio
PointerAccess	72.67 ms	0.657 ms	0.614 ms	0.16	-	NA
NBFixed	239.03 ms	1.065 ms	0.996 ms	0.52	-	NA
NBWithSize	468.89 ms	0.411 ms	0.344 ms	1.02	-	NA
NBWithSentinel	720.25 ms	1.590 ms	1.488 ms	1.56	-	NA
NBWithSentinelAndSize	460.97 ms	2.005 ms	1.876 ms	1.00	-	NA