testing dynamic array performance

Author: cathei

.idea/.idea.LinqGen/.idea/indexLayout.xml

@@ -0,0 +1,104 @@
+// LinqGen.Benchmarks, Maxwell Keonwoo Kang <code.athei@gmail.com>, 2022
+
+using BenchmarkDotNet.Attributes;
+using Cathei.LinqGen;
+using StructLinq;
+using NetFabric.Hyperlinq;
+using StructLinq.Range;
+
+namespace Cathei.LinqGen.Benchmarks.Cases;
+
+[MemoryDiagnoser]
+public class ArraySelectToArray
+{
+    private int[] TestData { get; set; } = null!;
+
+    [Params(100, 10_000, 1_000_000)]
+    public int Count { get; set; }
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        TestData = Utils.Generate(42, Count).ToArray();
+    }
+
+    [Benchmark(Baseline = true)]
+    public int[] Linq()
+    {
+        return TestData
+            .Select(x=> x * 2)
+            .ToArray();
+    }
+
+    [Benchmark]
+    public int[] LinqGenDelegate()
+    {
+        return TestData
+            .Specialize()
+            .Select(x => x * 2)
+            .ToArray();
+    }
+
+    [Benchmark]
+    public int[] LinqGenStruct()
+    {
+        return TestData
+            .Specialize()
+            .Select(new Selector())
+            .ToArray();
+    }
+
+    [Benchmark]
+    public int[] StructLinqDelegate()
+    {
+        return TestData
+            .ToStructEnumerable()
+            .Select(x => x * 2)
+            .ToArray();
+    }
+
+    [Benchmark]
+    public int[] StructLinqStruct()
+    {
+        var selector = new Selector();
+
+        return TestData
+            .ToStructEnumerable()
+            .Select(ref selector, x => x, x => x)
+            .ToArray(x => x);
+    }
+
+    [Benchmark]
+    public int[] HyperLinqDelegate()
+    {
+        return TestData
+            .AsValueEnumerable()
+            .Select(x => x * 2)
+            .ToArray();
+    }
+
+    [Benchmark]
+    public int[] HyperLinqStruct()
+    {
+        return TestData
+            .AsValueEnumerable()
+            .Select<int, Selector>()
+            .ToArray();
+    }
+
+    readonly struct Selector :
+        StructLinq.IFunction<int, int>,
+        NetFabric.Hyperlinq.IFunction<int, int>,
+        IStructFunction<int, int>
+    {
+        public int Eval(int element)
+        {
+            return element * 2;
+        }
+
+        public int Invoke(int arg)
+        {
+            return arg * 2;
+        }
+    }
+}

LinqGen.Benchmarks/Cases/ArraySelectToArray.cs

@@ -11,7 +11,6 @@ namespace Cathei.LinqGen.Tests;
 [TestFixture]
 public class ToArrayTests
 {
-
     [Test]
     public void Test_ArrayWhereToArray()
     {
@@ -21,12 +20,18 @@ public void Test_ArrayWhereToArray()
             .Where(x => x % 2 == 0)
             .Select(x => x * 2)
             .ToArray();
-
-
     }
 
+    [Test]
+    public void Test_BigArrayToArray()
+    {
+        int[] values = new int[1_000_000];
 
-
+        var arr =values.Specialize()
+            .Where(x => x % 2 == 0)
+            .Select(x => x * 2)
+            .ToArray();
+    }
 
     [TestCase(0, 0)]
     [TestCase(0, 10)]

LinqGen.Tests/Evaluations/ToArrayTests.cs

@@ -0,0 +1,25 @@
+// LinqGen, Maxwell Keonwoo Kang <code.athei@gmail.com>, 2022
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace Cathei.LinqGen.Hidden
+{
+    /// <summary>
+    /// This interface is guideline for dynamic array implementation
+    /// </summary>
+    public interface IDynamicArray<T> : IDisposable
+    {
+        void IncreaseCapacity(int newSize, int copyCount = 0);
+
+        void Clear();
+
+        void CopyTo(T[] array, int count);
+
+        ref T this[int index] { get; }
+
+        ref T this[uint index] { get; }
+
+        int Length { get; }
+    }
+}

LinqGen.Unity/Packages/com.cathei.linqgen/LinqGen.Generator.dll

@@ -0,0 +1,89 @@
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace Cathei.LinqGen.Hidden
+{
+    public struct DynamicArrayManaged<T> : IDynamicArray<T>
+    {
+        private T[] _array;
+
+        private static readonly T[] EmptyArray = Array.Empty<T>();
+
+        public ref T this[int index]
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => ref _array[index];
+        }
+
+        public ref T this[uint index]
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => ref _array[index];
+        }
+
+        public int Length
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => _array.Length;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public DynamicArrayManaged(int capacity) : this()
+        {
+            _array = capacity > 0 ? SharedArrayPool<T>.Rent(capacity) : EmptyArray;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void IncreaseCapacity(int newSize, int copyCount = 0)
+        {
+            var newItems = SharedArrayPool<T>.Rent(newSize);
+            if (copyCount > 0)
+                Array.Copy(_array, newItems, copyCount);
+            ReturnArray();
+            _array = newItems;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Clear()
+        {
+            Array.Clear(_array, 0, _array.Length);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void ReturnArray()
+        {
+            if (_array == null)
+                return;
+
+            try
+            {
+                // Clear the elements so that the gc can reclaim the references.
+                SharedArrayPool<T>.Return(_array, true);
+            }
+            catch (ArgumentException)
+            {
+                // oh well, the array pool didn't like our array
+            }
+
+            _array = null!;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CopyTo(T[] array, int count)
+        {
+            if (_array == null)
+                return;
+
+            Array.Copy(_array, array, count);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Dispose()
+        {
+            ReturnArray();
+        }
+    }
+}