add pool helpers

Author: lucasteles

src/Backdash/Core/Extensions.cs

@@ -45,6 +45,10 @@ public static double NextGaussian(this Random @this)
     public static bool NextBool(this Random random, double percentage) =>
         random.NextDouble() < Math.Clamp(percentage, 0.0, 1.0);
 
+    /// <inheritdoc cref="System.Random.Shuffle{T}(T[])"/>
+    public static void Shuffle<T>(this Random random, List<T> values) =>
+        random.Shuffle(CollectionsMarshal.AsSpan(values));
+
     /// <summary>
     /// Fill <paramref name="value"/> with random values.
     /// </summary>

src/Backdash/Data/ObjectPool.cs

@@ -1,4 +1,5 @@
 using System.Collections;
+using System.Collections.Immutable;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -15,10 +16,25 @@ public interface IObjectPool<T>
     /// </summary>
     T Rent();
 
+    /// <inheritdoc cref="Rent()"/>
+    void Rent(ICollection<T> values, int count);
+
     /// <summary>
     ///     Return <paramref name="value" /> to the pool
     /// </summary>
     bool Return(T value);
+
+    /// <inheritdoc cref="Return(T)"/>
+    bool Return(ref T? value);
+
+    /// <inheritdoc cref="Return(T)"/>
+    bool ReturnAll(List<T> list);
+
+    /// <inheritdoc cref="Return(T)"/>
+    bool ReturnMany(ReadOnlySpan<T> values);
+
+    /// <inheritdoc cref="Return(T)"/>
+    bool ReturnMany(IEnumerable<T> values);
 }
 
 /// <summary>
@@ -78,6 +94,13 @@ public T Rent()
         return item;
     }
 
+    /// <inheritdoc />
+    public void Rent(ICollection<T> values, int count)
+    {
+        for (var i = 0; i < count; i++)
+            values.Add(Rent());
+    }
+
     /// <inheritdoc />
     public bool Return(T value)
     {
@@ -101,26 +124,72 @@ public bool Return(T value)
         return true;
     }
 
-    /// <inheritdoc cref="Return"/>
-    public bool ReturnMany(params T[] values)
+    /// <inheritdoc />
+    public bool Return(ref T? value)
+    {
+        if (value is null || !Return(value)) return false;
+        value = null;
+        return true;
+    }
+
+    /// <inheritdoc cref="Return(T)"/>
+    public bool ReturnAll(List<T> list)
     {
         var result = true;
+        var values = CollectionsMarshal.AsSpan(list);
+        ref var current = ref MemoryMarshal.GetReference(values);
+        ref var limit = ref Unsafe.Add(ref current, values.Length);
 
-        ref var current = ref MemoryMarshal.GetReference(values.AsSpan());
+        while (Unsafe.IsAddressLessThan(ref current, ref limit))
+        {
+            var returned = Return(current);
+            ref var next = ref Unsafe.Add(ref current, 1)!;
+            if (returned)
+                current = null!;
+            else
+                result = false;
+
+            current = ref next;
+        }
+
+        if (result)
+            list.Clear();
+        else
+            list.RemoveAll(x => (object?)x is null);
+
+        return result;
+    }
+
+    /// <inheritdoc cref="Return(T)"/>
+    public bool ReturnMany(ReadOnlySpan<T> values)
+    {
+        var result = true;
+        ref var current = ref MemoryMarshal.GetReference(values);
         ref var limit = ref Unsafe.Add(ref current, values.Length);
 
         while (Unsafe.IsAddressLessThan(ref current, ref limit))
         {
-            result = result && Return(current);
+            var returned = Return(current);
+            result = result && returned;
             current = ref Unsafe.Add(ref current, 1)!;
         }
 
         return result;
     }
 
-    /// <inheritdoc cref="ReturnMany(T[])"/>
+    /// <inheritdoc cref="ReturnMany(System.ReadOnlySpan{T})"/>
     public bool ReturnMany(IEnumerable<T> values) =>
-        values.Aggregate(true, (result, current) => result && Return(current));
+        values switch
+        {
+            T[] array => ReturnMany(array.AsSpan()),
+            ImmutableArray<T> array => ReturnMany(array.AsSpan()),
+            List<T> list => ReturnMany(CollectionsMarshal.AsSpan(list)),
+            _ => values.Aggregate(true, (result, current) =>
+            {
+                var returned = Return(current);
+                return result && returned;
+            }),
+        };
 
     /// <summary>
     ///     Clear the object pool
@@ -192,6 +261,23 @@ public static ObjectPool<T> Create<T>(int? capacity = null, Action<T>? returnWit
     /// </summary>
     public static ObjectPool<T> Singleton<T>() where T : class, new() => SingletonWrapper<T>.Instance;
 
+    /// <inheritdoc cref="IObjectPool{T}.Rent()"/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static T Rent<T>() where T : class, new() => Singleton<T>().Rent();
+
+    /// <inheritdoc cref="IObjectPool{T}.Rent(ICollection{T}, int)"/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void Rent<T>(ICollection<T> values, int count) where T : class, new() =>
+        Singleton<T>().Rent(values, count);
+
+    /// <inheritdoc cref="IObjectPool{T}.Return(T)"/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool Return<T>(T value) where T : class, new() => Singleton<T>().Return(value);
+
+    /// <inheritdoc cref="IObjectPool{T}.Return(ref T)"/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool Return<T>(ref T? value) where T : class, new() => Singleton<T>().Return(ref value);
+
     static class SingletonWrapper<T> where T : class, new()
     {
         public static readonly ObjectPool<T> Instance = Create<T>();

tests/Backdash.Tests/Specs/Unit/Data/ObjectPoolTests.cs

@@ -21,6 +21,19 @@ public void ShouldRentAndReturnSameObject()
         value2.Should().BeSameAs(value);
     }
 
+    [Fact]
+    public void ShouldRentAndReturnSettingNullRefObject()
+    {
+        var sut = ObjectPool.Create<TestObj>();
+        TestObj? value = sut.Rent();
+        value.Should().NotBeNull();
+        sut.Count.Should().Be(0);
+
+        sut.Return(ref value);
+        sut.Count.Should().Be(1);
+        value.Should().BeNull();
+    }
+
     [Fact]
     public void ShouldNotReturnSameObjectTwice()
     {
@@ -106,17 +119,67 @@ public void ShouldDisposeItems()
         rents.Should().AllSatisfy(r => r.Disposed.Should().BeTrue());
     }
 
+    [Fact]
+    public void ShouldReturnAndClearList()
+    {
+        const int cap = 10;
+        var sut = ObjectPool.Create<TestObj>();
+        List<TestObj> buffer = new(cap);
+        sut.Rent(buffer, cap);
+        buffer.Count.Should().Be(cap);
+        sut.Count.Should().Be(0);
+
+        sut.ReturnAll(buffer).Should().BeTrue();
+        buffer.Count.Should().Be(0);
+        sut.Count.Should().Be(cap);
+    }
+
+    [Fact]
+    public void ShouldReturnRepeatedListItems()
+    {
+        const int cap = 10;
+        var sut = ObjectPool.Create<TestObj>();
+        List<TestObj> buffer = new(cap);
+        sut.Rent(buffer, cap);
+        sut.Count.Should().Be(0);
+
+        var copy = buffer.ToList();
+        Random.Shared.Shuffle(copy);
+        buffer.AddRange(copy);
+        buffer.Distinct().Count().Should().Be(cap);
+
+        sut.ReturnAll(buffer).Should().BeTrue();
+        buffer.Count.Should().Be(0);
+        sut.Count.Should().Be(cap);
+    }
+
+    [Fact]
+    public void ShouldReturnAndKeepNonReturnedList()
+    {
+        const int cap = 5;
+        var sut = ObjectPool.Create<TestObj>(cap);
+        List<TestObj> buffer = new(cap + 1);
+        sut.Rent(buffer, buffer.Capacity);
+        sut.Count.Should().Be(0);
+
+        sut.ReturnAll(buffer).Should().BeFalse();
+        buffer.Count.Should().Be(1);
+        sut.Count.Should().Be(cap);
+    }
+
     static void FillPool(ObjectPool<TestObj> sut, int count) =>
         Enumerable.Repeat<object?>(null, count)
             .Select(_ => sut.Rent())
             .ToList()
             .ForEach(x => sut.Return(x));
 
-    [Serializable]
     sealed class TestObj
     {
-        public int Value { get; set; }
+        static int index;
+        public int Value { get; set; } = Interlocked.Increment(ref index);
         public bool Returned { get; set; }
+
+        public override string ToString() => $"{(Returned ? "###" : "")}Obj[{Value}]";
     }
 
     sealed class TestObjDisposable : IDisposable

tests/Backdash.Tests/Specs/Unit/Serialization/BinaryBufferReadWriteListTests.cs

@@ -540,10 +540,52 @@ public T Rent()
             return new();
         }
 
+        public void Rent(ICollection<T> values, int count)
+        {
+            for (var i = 0; i < count; i++)
+                values.Add(Rent());
+        }
+
         public bool Return(T value)
         {
             returned.Add(value);
             return true;
         }
+
+        public bool Return(ref T? value)
+        {
+            if (value is null || !Return(value)) return false;
+            value = default;
+            return true;
+        }
+
+        public bool ReturnAll(List<T> list)
+        {
+            var result = true;
+            List<int> removeIdx = [];
+
+            for (var i = 0; i < list.Count; i++)
+            {
+                var current = list[i];
+                if (Return(current))
+                    removeIdx.Add(i);
+                else
+                    result = false;
+            }
+
+            foreach (var idx in removeIdx)
+                list.RemoveAt(idx);
+
+            return result;
+        }
+
+        public bool ReturnMany(IEnumerable<T> values) =>
+            values.Aggregate(true, (result, current) =>
+            {
+                var ret = Return(current);
+                return result && ret;
+            });
+
+        public bool ReturnMany(ReadOnlySpan<T> values) => ReturnMany(values.ToArray().AsEnumerable());
     }
 }