com.wallstop-studios.unity-helpers 2.0.0-rc80.5 → 2.0.0-rc80.7

package/Runtime/Core/Helper/ReflectionHelpers.cs

@@ -1013,6 +1013,33 @@ namespace WallstopStudios.UnityHelpers.Core.Helper
             }
         }
 
+        public static Action<T> BuildParameterlessInstanceMethodIfExists<T>(string methodName)
+        {
+            try
+            {
+                Type type = typeof(T);
+                foreach (
+                    MethodInfo method in type.GetMethods(
+                        BindingFlags.Instance | BindingFlags.Public
+                    )
+                )
+                {
+                    if (
+                        string.Equals(method.Name, methodName, StringComparison.Ordinal)
+                        && method.GetParameters().Length == 0
+                    )
+                    {
+                        return (Action<T>)Delegate.CreateDelegate(typeof(Action<T>), method);
+                    }
+                }
+            }
+            catch
+            {
+                // Swallow
+            }
+            return null;
+        }
+
         public static bool HasAttributeSafe(
             ICustomAttributeProvider provider,
             Type attributeType,

package/Runtime/Core/Threading/SingleThreadedThreadPool.cs

@@ -1,5 +1,6 @@
 namespace WallstopStudios.UnityHelpers.Core.Threading
 {
+#if !SINGLE_THREADED
     using System;
     using System.Collections.Concurrent;
     using System.Threading;
@@ -223,4 +224,5 @@ namespace WallstopStudios.UnityHelpers.Core.Threading
             }
         }
     }
+#endif
 }

package/Runtime/Utils/Buffers.cs

@@ -1,11 +1,11 @@
 namespace WallstopStudios.UnityHelpers.Utils
 {
     using System;
+    using System.Collections.Concurrent;
     using System.Collections.Generic;
-    using System.Reflection;
     using System.Text;
+    using System.Threading;
     using UnityEngine;
-    using WallstopStudios.UnityHelpers.Core.Helper;
 
     public static class Buffers
     {
@@ -36,33 +36,42 @@ namespace WallstopStudios.UnityHelpers.Utils
         public static readonly Stack<T> Stack = new();
     }
 
-    public static class WallstopGenericPool<T>
-        where T : new()
+#if SINGLE_THREADED
+    public sealed class WallstopGenericPool<T> : IDisposable
     {
-        public static Action<T> clearAction;
+        private readonly Func<T> _producer;
+        private readonly Action<T> _onGet;
+        private readonly Action<T> _onRelease;
+        private readonly Action<T> _onDispose;
 
-        private static readonly List<T> _pool = new();
-        private static readonly Action<T> _onDispose = Release;
+        private readonly Stack<T> _pool = new();
 
-        static WallstopGenericPool()
+        public WallstopGenericPool(
+            Func<T> producer,
+            Action<T> onGet = null,
+            Action<T> onRelease = null,
+            Action<T> onDisposal = null
+        )
         {
-            clearAction = GetClearAction();
+            _producer = producer ?? throw new ArgumentNullException(nameof(producer));
+            _onGet = onGet;
+            _onRelease = onRelease ?? (_ => { });
+            _onRelease += _pool.Push;
+            _onDispose = onDisposal;
         }
 
-        public static PooledResource<T> Get()
+        public PooledResource<T> Get()
         {
-            if (_pool.Count == 0)
+            if (!_pool.TryPop(out T value))
             {
-                return new PooledResource<T>(new T(), _onDispose);
+                value = _producer();
             }
 
-            int lastIndex = _pool.Count - 1;
-            T instance = _pool[lastIndex];
-            _pool.RemoveAt(lastIndex);
-            return new PooledResource<T>(instance, _onDispose);
+            _onGet?.Invoke(value);
+            return new PooledResource<T>(value, _onRelease);
         }
 
-        private static Action<T> GetClearAction()
+        public static Action<T> GetClearAction()
         {
             try
             {
@@ -89,13 +98,72 @@ namespace WallstopStudios.UnityHelpers.Utils
             return null;
         }
 
-        private static void Release(T resource)
+        public void Dispose()
         {
-            clearAction?.Invoke(resource);
-            _pool.Add(resource);
+            if (_onDispose == null)
+            {
+                _pool.Clear();
+                return;
+            }
+
+            while (_pool.TryPop(out T value))
+            {
+                _onDispose(value);
+            }
         }
     }
+#else
+    public sealed class WallstopGenericPool<T> : IDisposable
+    {
+        private readonly Func<T> _producer;
+        private readonly Action<T> _onGet;
+        private readonly Action<T> _onRelease;
+        private readonly Action<T> _onDispose;
+
+        private readonly ConcurrentStack<T> _pool = new();
 
+        public WallstopGenericPool(
+            Func<T> producer,
+            Action<T> onGet = null,
+            Action<T> onRelease = null,
+            Action<T> onDisposal = null
+        )
+        {
+            _producer = producer ?? throw new ArgumentNullException(nameof(producer));
+            _onGet = onGet;
+            _onRelease = onRelease ?? (_ => { });
+            _onRelease += _pool.Push;
+            _onDispose = onDisposal;
+        }
+
+        public PooledResource<T> Get()
+        {
+            if (!_pool.TryPop(out T value))
+            {
+                value = _producer();
+            }
+
+            _onGet?.Invoke(value);
+            return new PooledResource<T>(value, _onRelease);
+        }
+
+        public void Dispose()
+        {
+            if (_onDispose == null)
+            {
+                _pool.Clear();
+                return;
+            }
+
+            while (_pool.TryPop(out T value))
+            {
+                _onDispose(value);
+            }
+        }
+    }
+#endif
+
+#if SINGLE_THREADED
     public static class WallstopArrayPool<T>
     {
         private static readonly Dictionary<int, List<T[]>> _pool = new();
@@ -148,6 +216,240 @@ namespace WallstopStudios.UnityHelpers.Utils
             pool.Add(resource);
         }
     }
+#else
+    public static class WallstopArrayPool<T>
+    {
+        private static readonly ConcurrentDictionary<int, ConcurrentStack<T[]>> _pool = new();
+        private static readonly Action<T[]> _onRelease = Release;
+
+        public static PooledResource<T[]> Get(int size)
+        {
+            switch (size)
+            {
+                case < 0:
+                {
+                    throw new ArgumentOutOfRangeException(
+                        nameof(size),
+                        size,
+                        "Must be non-negative."
+                    );
+                }
+                case 0:
+                {
+                    return new PooledResource<T[]>(Array.Empty<T>(), _ => { });
+                }
+            }
+
+            ConcurrentStack<T[]> result = _pool.GetOrAdd(size, _ => new ConcurrentStack<T[]>());
+            if (!result.TryPop(out T[] array))
+            {
+                array = new T[size];
+            }
+
+            return new PooledResource<T[]>(array, _onRelease);
+        }
+
+        private static void Release(T[] resource)
+        {
+            int length = resource.Length;
+            Array.Clear(resource, 0, length);
+            ConcurrentStack<T[]> result = _pool.GetOrAdd(length, _ => new ConcurrentStack<T[]>());
+            result.Push(resource);
+        }
+    }
+#endif
+
+#if SINGLE_THREADED
+    public static class WallstopFastArrayPool<T>
+    {
+        private static readonly List<Stack<T[]>> _pool = new();
+        private static readonly Action<T[]> _onRelease = Release;
+
+        public static PooledResource<T[]> Get(int size)
+        {
+            switch (size)
+            {
+                case < 0:
+                {
+                    throw new ArgumentOutOfRangeException(
+                        nameof(size),
+                        size,
+                        "Must be non-negative."
+                    );
+                }
+                case 0:
+                {
+                    return new PooledResource<T[]>(Array.Empty<T>(), _ => { });
+                }
+            }
+
+            while (_pool.Count <= size)
+            {
+                _pool.Add(null);
+            }
+
+            Stack<T[]> pool = _pool[size];
+            if (pool == null)
+            {
+                pool = new Stack<T[]>();
+                _pool[size] = pool;
+            }
+
+            if (!pool.TryPop(out T[] instance))
+            {
+                instance = new T[size];
+            }
+
+            return new PooledResource<T[]>(instance, _onRelease);
+        }
+
+        private static void Release(T[] resource)
+        {
+            _pool[resource.Length].Push(resource);
+        }
+    }
+#else
+
+    public static class WallstopFastArrayPool<T>
+    {
+        private static readonly ReaderWriterLockSlim _lock = new();
+        private static readonly List<ConcurrentStack<T[]>> _pool = new();
+        private static readonly Action<T[]> _onRelease = Release;
+
+        public static PooledResource<T[]> Get(int size)
+        {
+            switch (size)
+            {
+                case < 0:
+                {
+                    throw new ArgumentOutOfRangeException(
+                        nameof(size),
+                        size,
+                        "Must be non-negative."
+                    );
+                }
+                case 0:
+                {
+                    return new PooledResource<T[]>(Array.Empty<T>(), _ => { });
+                }
+            }
+
+            bool withinRange;
+            ConcurrentStack<T[]> pool = null;
+            _lock.EnterReadLock();
+            try
+            {
+                withinRange = size < _pool.Count;
+                if (withinRange)
+                {
+                    pool = _pool[size];
+                }
+            }
+            finally
+            {
+                _lock.ExitReadLock();
+            }
+
+            if (withinRange)
+            {
+                if (pool == null)
+                {
+                    _lock.EnterUpgradeableReadLock();
+                    try
+                    {
+                        pool = _pool[size];
+                        if (pool == null)
+                        {
+                            _lock.EnterWriteLock();
+                            try
+                            {
+                                pool = _pool[size];
+                                if (pool == null)
+                                {
+                                    pool = new ConcurrentStack<T[]>();
+                                    _pool[size] = pool;
+                                }
+                            }
+                            finally
+                            {
+                                _lock.ExitWriteLock();
+                            }
+                        }
+                    }
+                    finally
+                    {
+                        _lock.ExitUpgradeableReadLock();
+                    }
+                }
+            }
+            else
+            {
+                _lock.EnterUpgradeableReadLock();
+                try
+                {
+                    if (size < _pool.Count)
+                    {
+                        pool = _pool[size];
+                        if (pool == null)
+                        {
+                            _lock.EnterWriteLock();
+                            try
+                            {
+                                pool = _pool[size];
+                                if (pool == null)
+                                {
+                                    pool = new ConcurrentStack<T[]>();
+                                    _pool[size] = pool;
+                                }
+                            }
+                            finally
+                            {
+                                _lock.ExitWriteLock();
+                            }
+                        }
+                    }
+                    else
+                    {
+                        _lock.EnterWriteLock();
+                        try
+                        {
+                            while (_pool.Count <= size)
+                            {
+                                _pool.Add(null);
+                            }
+                            pool = _pool[size];
+                            if (pool == null)
+                            {
+                                pool = new ConcurrentStack<T[]>();
+                                _pool[size] = pool;
+                            }
+                        }
+                        finally
+                        {
+                            _lock.ExitWriteLock();
+                        }
+                    }
+                }
+                finally
+                {
+                    _lock.ExitUpgradeableReadLock();
+                }
+            }
+
+            if (!pool.TryPop(out T[] instance))
+            {
+                instance = new T[size];
+            }
+
+            return new PooledResource<T[]>(instance, _onRelease);
+        }
+
+        private static void Release(T[] resource)
+        {
+            _pool[resource.Length].Push(resource);
+        }
+    }
+#endif
 
     public readonly struct PooledResource<T> : IDisposable
     {

package/Tests/Runtime/Core/Threading/SingleThreadedThreadPoolTests.cs

@@ -1,5 +1,6 @@
 namespace WallstopStudios.UnityHelpers.Tests.Core.Threading
 {
+#if !SINGLE_THREADED
     using System.Collections;
     using System.Collections.Generic;
     using NUnit.Framework;
@@ -51,4 +52,5 @@ namespace WallstopStudios.UnityHelpers.Tests.Core.Threading
             }
         }
     }
+#endif
 }

package/Tests/Runtime/Utils/BuffersTests.cs

@@ -1,18 +1,32 @@
 namespace WallstopStudios.UnityHelpers.Tests.Utils
 {
+    using System;
+    using System.Collections;
     using System.Collections.Generic;
+    using System.Linq;
     using NUnit.Framework;
+    using UnityEngine.TestTools;
+    using WallstopStudios.UnityHelpers.Core.Extension;
     using WallstopStudios.UnityHelpers.Core.Random;
     using WallstopStudios.UnityHelpers.Utils;
+#if !SINGLETHREADED
+    using System.Threading;
+    using System.Threading.Tasks;
+#endif
 
     public sealed class BuffersTests
     {
+        private readonly WallstopGenericPool<List<int>> _intPool = new(
+            () => new List<int>(),
+            onRelease: list => list.Clear()
+        );
+
         [Test]
         public void GenericPoolListTests()
         {
             {
-                using PooledResource<List<int>> firstList = WallstopGenericPool<List<int>>.Get();
-                using PooledResource<List<int>> secondList = WallstopGenericPool<List<int>>.Get();
+                using PooledResource<List<int>> firstList = _intPool.Get();
+                using PooledResource<List<int>> secondList = _intPool.Get();
                 Assert.AreNotEqual(firstList, secondList);
                 firstList.resource.Add(1);
                 Assert.AreEqual(1, firstList.resource.Count);
@@ -23,7 +37,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Utils
             }
             {
                 // Ensure cleared
-                using PooledResource<List<int>> firstList = WallstopGenericPool<List<int>>.Get();
+                using PooledResource<List<int>> firstList = _intPool.Get();
                 Assert.AreEqual(0, firstList.resource.Count);
             }
         }
@@ -51,5 +65,661 @@ namespace WallstopStudios.UnityHelpers.Tests.Utils
                 }
             }
         }
+
+        [Test]
+        public void WallstopFastArrayPoolGetNegativeSizeThrowsArgumentOutOfRangeException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => WallstopFastArrayPool<int>.Get(-1));
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolGetZeroSizeReturnsEmptyArrayWithNoOpDispose()
+        {
+            using PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(0);
+            Assert.NotNull(pooled.resource);
+            Assert.AreEqual(0, pooled.resource.Length);
+            Assert.AreSame(Array.Empty<int>(), pooled.resource);
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolGetPositiveSizeReturnsArrayWithCorrectLength()
+        {
+            const int size = 10;
+            using PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(size);
+
+            Assert.NotNull(pooled.resource);
+            Assert.AreEqual(size, pooled.resource.Length);
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolGetSameSizeReusesArrayAfterDispose()
+        {
+            const int size = 5;
+            int[] firstArray;
+
+            using (PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(size))
+            {
+                firstArray = pooled.resource;
+                firstArray[0] = 42;
+            }
+
+            using PooledResource<int[]> pooledReused = WallstopFastArrayPool<int>.Get(size);
+            Assert.AreSame(firstArray, pooledReused.resource);
+            Assert.AreEqual(42, pooledReused.resource[0]);
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolGetDifferentSizesReturnsCorrectArrays()
+        {
+            int[] sizes = { 1, 5, 10, 100, 1000 };
+            List<PooledResource<int[]>> pooledArrays = new();
+
+            try
+            {
+                foreach (int size in sizes)
+                {
+                    PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(size);
+                    pooledArrays.Add(pooled);
+                    Assert.AreEqual(size, pooled.resource.Length);
+                }
+            }
+            finally
+            {
+                foreach (PooledResource<int[]> pooled in pooledArrays)
+                {
+                    pooled.Dispose();
+                }
+            }
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolArraysNotClearedOnRelease()
+        {
+            const int size = 10;
+
+            using (PooledResource<string[]> pooled = WallstopFastArrayPool<string>.Get(size))
+            {
+                for (int i = 0; i < size; i++)
+                {
+                    pooled.resource[i] = $"test{i}";
+                }
+            }
+
+            using PooledResource<string[]> pooledReused = WallstopFastArrayPool<string>.Get(size);
+            for (int i = 0; i < size; i++)
+            {
+                Assert.AreEqual($"test{i}", pooledReused.resource[i]);
+            }
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolPoolGrowsAsNeeded()
+        {
+            const int size = 7;
+            const int count = 5;
+            List<PooledResource<int[]>> pooledArrays = new();
+
+            try
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(size);
+                    pooledArrays.Add(pooled);
+                    Assert.AreEqual(size, pooled.resource.Length);
+                }
+
+                HashSet<int[]> distinctArrays = pooledArrays.Select(p => p.resource).ToHashSet();
+                Assert.AreEqual(count, distinctArrays.Count);
+            }
+            finally
+            {
+                foreach (PooledResource<int[]> pooled in pooledArrays)
+                {
+                    pooled.Dispose();
+                }
+            }
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolDifferentTypesUseDifferentPools()
+        {
+            const int size = 10;
+
+            using PooledResource<int[]> intPooled = WallstopFastArrayPool<int>.Get(size);
+            using PooledResource<string[]> stringPooled = WallstopFastArrayPool<string>.Get(size);
+            using PooledResource<float[]> floatPooled = WallstopFastArrayPool<float>.Get(size);
+
+            Assert.AreEqual(size, intPooled.resource.Length);
+            Assert.AreEqual(size, stringPooled.resource.Length);
+            Assert.AreEqual(size, floatPooled.resource.Length);
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolLargeArraysWork()
+        {
+            const int size = 100000;
+            using PooledResource<byte[]> pooled = WallstopFastArrayPool<byte>.Get(size);
+
+            Assert.AreEqual(size, pooled.resource.Length);
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolNestedUsageWorks()
+        {
+            const int outerSize = 5;
+            const int innerSize = 3;
+
+            using PooledResource<int[]> outer = WallstopFastArrayPool<int>.Get(outerSize);
+            Assert.AreEqual(outerSize, outer.resource.Length);
+            Array.Clear(outer.resource, 0, outer.resource.Length);
+            outer.resource[0] = 1;
+
+            using (PooledResource<int[]> inner = WallstopFastArrayPool<int>.Get(innerSize))
+            {
+                inner.resource[0] = 2;
+                Assert.AreEqual(innerSize, inner.resource.Length);
+                Assert.AreEqual(1, outer.resource[0]);
+                Assert.AreEqual(2, inner.resource[0]);
+            }
+
+            Assert.AreEqual(outerSize, outer.resource.Length);
+            Assert.AreEqual(1, outer.resource[0]);
+        }
+
+        [UnityTest]
+        public IEnumerator WallstopFastArrayPoolStressTest()
+        {
+            const int iterations = 1000;
+            const int maxSize = 100;
+            Random random = new(42);
+
+            for (int i = 0; i < iterations; i++)
+            {
+                int size = random.Next(1, maxSize);
+                using PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(size);
+
+                Assert.AreEqual(size, pooled.resource.Length);
+
+                for (int j = 0; j < Math.Min(10, size); j++)
+                {
+                    pooled.resource[j] = random.Next();
+                }
+
+                if (i % 100 == 0)
+                {
+                    yield return null;
+                }
+            }
+        }
+
+#if !SINGLETHREADED
+        [Test]
+        public void WallstopFastArrayPoolConcurrentAccessDifferentSizes()
+        {
+            const int threadCount = 10;
+            const int operationsPerThread = 100;
+            Task[] tasks = new Task[threadCount];
+            List<Exception> exceptions = new();
+
+            for (int t = 0; t < threadCount; t++)
+            {
+                int threadId = t;
+                tasks[t] = Task.Run(async () =>
+                {
+                    try
+                    {
+                        PcgRandom random = new(threadId);
+                        foreach (int i in Enumerable.Range(0, operationsPerThread).Shuffled(random))
+                        {
+                            int size = random.Next(1, 50) + threadId;
+                            using PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(
+                                size
+                            );
+
+                            Assert.AreEqual(size, pooled.resource.Length);
+
+                            for (int j = 0; j < Math.Min(5, size); j++)
+                            {
+                                pooled.resource[j] = threadId * 1000 + i * 10 + j;
+                            }
+
+                            await Task.Delay(TimeSpan.FromMilliseconds(random.NextDouble()));
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        lock (exceptions)
+                        {
+                            exceptions.Add(ex);
+                        }
+                    }
+                });
+            }
+
+            Task.WaitAll(tasks);
+
+            if (exceptions.Count > 0)
+            {
+                throw new AggregateException(exceptions);
+            }
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolConcurrentAccessSameSize()
+        {
+            const int threadCount = 8;
+            const int operationsPerThread = 200;
+            const int arraySize = 25;
+            Task[] tasks = new Task[threadCount];
+            List<Exception> exceptions = new();
+
+            for (int t = 0; t < threadCount; t++)
+            {
+                int threadId = t;
+                tasks[t] = Task.Run(() =>
+                {
+                    try
+                    {
+                        PcgRandom random = new(threadId);
+                        foreach (int i in Enumerable.Range(0, operationsPerThread).Shuffled(random))
+                        {
+                            using PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(
+                                arraySize
+                            );
+
+                            Array.Clear(pooled.resource, 0, pooled.resource.Length);
+                            Assert.AreEqual(arraySize, pooled.resource.Length);
+
+                            for (int j = 0; j < arraySize; j++)
+                            {
+                                Assert.AreEqual(0, pooled.resource[j]);
+                                pooled.resource[j] = threadId * 1000 + i;
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        lock (exceptions)
+                        {
+                            exceptions.Add(ex);
+                        }
+                    }
+                });
+            }
+
+            Task.WaitAll(tasks);
+
+            if (exceptions.Count > 0)
+            {
+                throw new AggregateException(exceptions);
+            }
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolConcurrentAccessMixedSizes()
+        {
+            const int threadCount = 6;
+            const int operationsPerThread = 150;
+            Task[] tasks = new Task[threadCount];
+            List<Exception> exceptions = new();
+            int[] sizes = { 1, 5, 10, 20, 50, 100 };
+
+            for (int t = 0; t < threadCount; t++)
+            {
+                int threadId = t;
+                tasks[t] = Task.Run(async () =>
+                {
+                    try
+                    {
+                        PcgRandom random = new(threadId + 100);
+                        foreach (int i in Enumerable.Range(0, operationsPerThread).Shuffled(random))
+                        {
+                            int size = random.NextOf(sizes);
+                            using PooledResource<string[]> pooled =
+                                WallstopFastArrayPool<string>.Get(size);
+                            Array.Clear(pooled.resource, 0, pooled.resource.Length);
+
+                            Assert.AreEqual(size, pooled.resource.Length);
+
+                            for (int j = 0; j < size; j++)
+                            {
+                                Assert.IsNull(pooled.resource[j]);
+                                pooled.resource[j] = $"T{threadId}-I{i}-J{j}";
+                            }
+
+                            if (i % 50 == 0)
+                            {
+                                await Task.Delay(TimeSpan.FromMilliseconds(random.NextDouble()));
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        lock (exceptions)
+                        {
+                            exceptions.Add(ex);
+                        }
+                    }
+                });
+            }
+
+            Task.WaitAll(tasks);
+
+            if (exceptions.Count > 0)
+            {
+                throw new AggregateException(exceptions);
+            }
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolConcurrentAccessRapidAllocationDeallocation()
+        {
+            const int threadCount = 12;
+            const int operationsPerThread = 500;
+            Task[] tasks = new Task[threadCount];
+            List<Exception> exceptions = new();
+
+            for (int t = 0; t < threadCount; t++)
+            {
+                int threadId = t;
+                tasks[t] = Task.Run(() =>
+                {
+                    try
+                    {
+                        PcgRandom random = new(threadId + 100);
+                        foreach (int i in Enumerable.Range(0, operationsPerThread).Shuffled(random))
+                        {
+                            int size = random.Next(1, 30);
+                            using PooledResource<byte[]> pooled = WallstopFastArrayPool<byte>.Get(
+                                size
+                            );
+
+                            Assert.AreEqual(size, pooled.resource.Length);
+
+                            for (int j = 0; j < size; j++)
+                            {
+                                pooled.resource[j] = (byte)(threadId + i + j);
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        lock (exceptions)
+                        {
+                            exceptions.Add(ex);
+                        }
+                    }
+                });
+            }
+
+            Task.WaitAll(tasks);
+
+            if (exceptions.Count > 0)
+            {
+                throw new AggregateException(exceptions);
+            }
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolThreadSafetyPoolExpansion()
+        {
+            const int threadCount = 8;
+            const int maxPoolSize = 1000;
+            Task[] tasks = new Task[threadCount];
+            List<Exception> exceptions = new();
+            Barrier barrier = new(threadCount);
+
+            for (int t = 0; t < threadCount; t++)
+            {
+                int threadId = t;
+                tasks[t] = Task.Run(() =>
+                {
+                    try
+                    {
+                        barrier.SignalAndWait();
+
+                        for (int size = threadId + 1; size <= maxPoolSize; size += threadCount)
+                        {
+                            using PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(
+                                size
+                            );
+                            Assert.AreEqual(size, pooled.resource.Length);
+
+                            pooled.resource[0] = threadId;
+                            pooled.resource[size - 1] = threadId;
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        lock (exceptions)
+                        {
+                            exceptions.Add(ex);
+                        }
+                    }
+                });
+            }
+
+            Task.WaitAll(tasks);
+
+            if (exceptions.Count > 0)
+            {
+                throw new AggregateException(exceptions);
+            }
+        }
+
+        [UnityTest]
+        public IEnumerator WallstopFastArrayPoolConcurrentStressTest()
+        {
+            const int threadCount = 4;
+            const int operationsPerThread = 250;
+            Task[] tasks = new Task[threadCount];
+            List<Exception> exceptions = new();
+            int completedThreads = 0;
+
+            for (int t = 0; t < threadCount; t++)
+            {
+                int threadId = t;
+                tasks[t] = Task.Run(() =>
+                {
+                    try
+                    {
+                        PcgRandom random = new(threadId + 100);
+                        foreach (int i in Enumerable.Range(0, operationsPerThread).Shuffled(random))
+                        {
+                            int size = random.Next(1, 100);
+                            using PooledResource<float[]> pooled = WallstopFastArrayPool<float>.Get(
+                                size
+                            );
+
+                            Assert.AreEqual(size, pooled.resource.Length);
+
+                            for (int j = 0; j < Math.Min(10, size); j++)
+                            {
+                                pooled.resource[j] = threadId * 1000.0f + i + j * 0.1f;
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        lock (exceptions)
+                        {
+                            exceptions.Add(ex);
+                        }
+                    }
+                    finally
+                    {
+                        Interlocked.Increment(ref completedThreads);
+                    }
+                });
+            }
+
+            while (completedThreads < threadCount)
+            {
+                yield return null;
+            }
+
+            Task.WaitAll(tasks);
+
+            if (exceptions.Count > 0)
+            {
+                throw new AggregateException(exceptions);
+            }
+        }
+#endif
+
+        [Test]
+        public void WallstopFastArrayPoolEdgeCaseVeryLargeSize()
+        {
+            const int veryLargeSize = 1000000;
+            using PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(veryLargeSize);
+
+            Assert.AreEqual(veryLargeSize, pooled.resource.Length);
+            Assert.AreEqual(0, pooled.resource[0]);
+            Assert.AreEqual(0, pooled.resource[veryLargeSize - 1]);
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolEdgeCaseSizeOne()
+        {
+            using PooledResource<string[]> pooled = WallstopFastArrayPool<string>.Get(1);
+            Array.Clear(pooled.resource, 0, pooled.resource.Length);
+            Assert.AreEqual(1, pooled.resource.Length);
+            Assert.IsNull(pooled.resource[0]);
+
+            pooled.resource[0] = "test";
+            Assert.AreEqual("test", pooled.resource[0]);
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolPoolingBehaviorLifo()
+        {
+            const int size = 15;
+            int[][] arrays = new int[3][];
+            {
+                using PooledResource<int[]> pooled1 = WallstopFastArrayPool<int>.Get(size);
+                arrays[0] = pooled1.resource;
+                using PooledResource<int[]> pooled2 = WallstopFastArrayPool<int>.Get(size);
+                arrays[1] = pooled2.resource;
+                using PooledResource<int[]> pooled3 = WallstopFastArrayPool<int>.Get(size);
+                arrays[2] = pooled3.resource;
+            }
+
+            using PooledResource<int[]> pooledReuse1 = WallstopFastArrayPool<int>.Get(size);
+            Assert.AreSame(arrays[0], pooledReuse1.resource);
+
+            using PooledResource<int[]> pooledReuse2 = WallstopFastArrayPool<int>.Get(size);
+            Assert.AreSame(arrays[1], pooledReuse2.resource);
+
+            using PooledResource<int[]> pooledReuse3 = WallstopFastArrayPool<int>.Get(size);
+            Assert.AreSame(arrays[2], pooledReuse3.resource);
+        }
+
+        [Test]
+        public void WallstopArrayPoolGetNegativeSizeThrowsArgumentOutOfRangeException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => WallstopArrayPool<int>.Get(-1));
+        }
+
+        [Test]
+        public void WallstopArrayPoolGetZeroSizeReturnsEmptyArrayWithNoOpDispose()
+        {
+            using PooledResource<int[]> pooled = WallstopArrayPool<int>.Get(0);
+            Assert.NotNull(pooled.resource);
+            Assert.AreEqual(0, pooled.resource.Length);
+            Assert.AreSame(Array.Empty<int>(), pooled.resource);
+        }
+
+        [Test]
+        public void WallstopArrayPoolGetPositiveSizeReturnsArrayWithCorrectLength()
+        {
+            const int size = 10;
+            using PooledResource<int[]> pooled = WallstopArrayPool<int>.Get(size);
+
+            Assert.NotNull(pooled.resource);
+            Assert.AreEqual(size, pooled.resource.Length);
+        }
+
+        [Test]
+        public void WallstopArrayPoolGetSameSizeReusesArrayAfterDispose()
+        {
+            const int size = 5;
+            int[] firstArray;
+
+            using (PooledResource<int[]> pooled = WallstopArrayPool<int>.Get(size))
+            {
+                firstArray = pooled.resource;
+                firstArray[0] = 42;
+            }
+
+            using PooledResource<int[]> pooledReused = WallstopArrayPool<int>.Get(size);
+            Assert.AreSame(firstArray, pooledReused.resource);
+            Assert.AreEqual(0, pooledReused.resource[0]);
+        }
+
+        [Test]
+        public void WallstopGenericPoolGetReturnsValidPooledResource()
+        {
+            using PooledResource<List<int>> pooled = _intPool.Get();
+
+            Assert.NotNull(pooled.resource);
+            Assert.AreEqual(0, pooled.resource.Count);
+        }
+
+        [Test]
+        public void WallstopGenericPoolGetReusesInstanceAfterDispose()
+        {
+            List<int> firstList;
+
+            using (PooledResource<List<int>> pooled = _intPool.Get())
+            {
+                firstList = pooled.resource;
+                firstList.Add(42);
+                firstList.Add(100);
+            }
+
+            using PooledResource<List<int>> pooledReused = _intPool.Get();
+            Assert.AreSame(firstList, pooledReused.resource);
+            Assert.AreEqual(0, pooledReused.resource.Count);
+        }
+
+        [Test]
+        public void WallstopGenericPoolClearActionWorksWithCustomType()
+        {
+            using WallstopGenericPool<HashSet<string>> pool = new(() => new HashSet<string>());
+            using PooledResource<HashSet<string>> pooled = pool.Get();
+
+            pooled.resource.Add("test1");
+            pooled.resource.Add("test2");
+            Assert.AreEqual(2, pooled.resource.Count);
+        }
+
+        [Test]
+        public void PooledResourceDisposeCallsOnDisposeAction()
+        {
+            bool clearCalled = false;
+            bool disposeCalled = false;
+            {
+                using WallstopGenericPool<List<int>> pool = new(
+                    () => new List<int>(),
+                    onRelease: list =>
+                    {
+                        list.Clear();
+                        clearCalled = true;
+                    },
+                    onDisposal: _ => disposeCalled = true
+                );
+
+                using (PooledResource<List<int>> pooled = pool.Get())
+                {
+                    Assert.NotNull(pooled.resource);
+                    Assert.IsFalse(clearCalled);
+                    Assert.IsFalse(disposeCalled);
+                }
+
+                Assert.IsTrue(clearCalled);
+            }
+
+            Assert.IsTrue(disposeCalled);
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.0-rc80.5",
+  "version": "2.0.0-rc80.7",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},
@@ -56,6 +56,8 @@
 
 
 
+
+