Merge pull request #100 from AnnulusGames/optimization-collections

Improve: optimize collections, add LinkedPool

src/LitMotion/Assets/LitMotion/Runtime/Internal/MinimumList.cs → src/LitMotion/Assets/LitMotion/Runtime/Collections/FastListCore.cs

@@ -1,16 +1,24 @@
 using System;
-using System.Diagnostics;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
-namespace LitMotion
+namespace LitMotion.Collections
 {
-    internal sealed class MinimumList<T>
+    /// <summary>
+    /// A list of minimal features. Note that it is NOT thread-safe and must NOT be marked readonly as it is a mutable struct.
+    /// </summary>
+    /// <typeparam name="T">Element type</typeparam>
+    [StructLayout(LayoutKind.Auto)]
+    public struct FastListCore<T>
     {
-        public MinimumList(int initialCapacity = 16)
+        public FastListCore(int initialCapacity)
         {
             array = new T[initialCapacity];
+            tailIndex = 0;
         }
 
+        public static readonly FastListCore<T> Empty = new(0);
+
         T[] array;
         int tailIndex;
 
@@ -51,26 +59,26 @@ public void EnsureCapacity(int capacity)
             }
         }
 
-        public T this[int index]
+        public readonly T this[int index]
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get => array[index];
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             set => array[index] = value;
         }
 
-        public int Length
+        public readonly int Length
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get => tailIndex;
         }
 
-        public Span<T> AsSpan() => array.AsSpan(0, tailIndex);
+        public readonly Span<T> AsSpan() => array.AsSpan(0, tailIndex);
+        public readonly T[] AsArray() => array;
 
-        [Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
-        void CheckIndex(int index)
+        readonly void CheckIndex(int index)
         {
             if (index < 0 || index > tailIndex) throw new IndexOutOfRangeException();
         }
     }
-}
+}

src/LitMotion/Assets/LitMotion/Runtime/Collections/ILinkedPoolNode.cs

@@ -0,0 +1,11 @@
+namespace LitMotion.Collections
+{
+    /// <summary>
+    /// An object pool node consisting of a linked list
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public interface ILinkedPoolNode<T> where T : class
+    {
+        ref T NextNode { get; }
+    }
+}

src/LitMotion/Assets/LitMotion/Runtime/Internal/Tasks/TaskSourcePool.cs → src/LitMotion/Assets/LitMotion/Runtime/Collections/LinkedPool.cs

@@ -2,13 +2,14 @@
 using System.Runtime.InteropServices;
 using System.Threading;
 
-namespace LitMotion
+namespace LitMotion.Collections
 {
-    // This implementation is based on UniTask's TaskPool<T>
-    // Reference: https://github.com/Cysharp/UniTask/blob/64792b672d35e43b3412fc74861f8bdbf41e3a6f/src/UniTask/Assets/Plugins/UniTask/Runtime/TaskPool.cs
-
+    /// <summary>
+    /// Thread-safe linked list object pool
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
     [StructLayout(LayoutKind.Auto)]
-    internal struct MotionTaskSourcePool<T> where T : class, IMotionTaskSourcePoolNode<T>
+    public struct LinkedPool<T> where T : class, ILinkedPoolNode<T>
     {
         static readonly int MaxPoolSize = int.MaxValue;
 

src/LitMotion/Assets/LitMotion/Runtime/Extensions/TextMeshPro/TextMeshProMotionAnimator.cs

@@ -4,6 +4,8 @@
 using System.Runtime.CompilerServices;
 using UnityEngine;
 using TMPro;
+using LitMotion.Collections;
+
 #if UNITY_EDITOR
 using UnityEditor;
 #endif
@@ -173,7 +175,7 @@ public TextMeshProMotionAnimator()
 
         TMP_Text target;
         internal CharInfo[] charInfoArray;
-        internal MinimumList<MotionHandle> motionHandleList = new();
+        internal FastListCore<MotionHandle> motionHandleList = new(16);
 
         TextMeshProMotionAnimator nextNode;
 

src/LitMotion/Assets/LitMotion/Runtime/Internal/MotionHandleLinker.cs

@@ -1,13 +1,14 @@
 using System.Runtime.CompilerServices;
 using UnityEngine;
+using LitMotion.Collections;
 
 namespace LitMotion
 {
     [DisallowMultipleComponent]
     [AddComponentMenu("")]
     internal sealed class MotionHandleLinker : MonoBehaviour
     {
-        readonly MinimumList<MotionHandle> handleList = new(8);
+        FastListCore<MotionHandle> handleList = new(8);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Register(MotionHandle handle)

src/LitMotion/Assets/LitMotion/Runtime/Internal/MotionStorageManager.cs

@@ -1,11 +1,12 @@
 using System;
 using System.Runtime.CompilerServices;
+using LitMotion.Collections;
 
 namespace LitMotion
 {
     internal static class MotionStorageManager
     {
-        static readonly MinimumList<IMotionStorage> storageList = new();
+        static FastListCore<IMotionStorage> storageList = new(16);
 
         public static int CurrentStorageId { get; private set; }
 

src/LitMotion/Assets/LitMotion/Runtime/Internal/Tasks/AwaitableMotionConfiguredSource.cs

@@ -2,12 +2,13 @@
 using System;
 using System.Threading;
 using UnityEngine;
+using LitMotion.Collections;
 
 namespace LitMotion
 {
-    internal sealed class AwaitableMotionConfiguredSource : IMotionTaskSourcePoolNode<AwaitableMotionConfiguredSource>
+    internal sealed class AwaitableMotionConfiguredSource : ILinkedPoolNode<AwaitableMotionConfiguredSource>
     {
-        static MotionTaskSourcePool<AwaitableMotionConfiguredSource> pool;
+        static LinkedPool<AwaitableMotionConfiguredSource> pool;
 
         AwaitableMotionConfiguredSource nextNode;
         public ref AwaitableMotionConfiguredSource NextNode => ref nextNode;

src/LitMotion/Assets/LitMotion/Runtime/Internal/Tasks/ValueTaskMotionConfiguredSource.cs

@@ -1,12 +1,13 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks.Sources;
+using LitMotion.Collections;
 
 namespace LitMotion
 {
-    internal sealed class ValueTaskMotionConfiguredSource : IValueTaskSource, IMotionTaskSourcePoolNode<ValueTaskMotionConfiguredSource>
+    internal sealed class ValueTaskMotionConfiguredSource : IValueTaskSource, ILinkedPoolNode<ValueTaskMotionConfiguredSource>
     {
-        static MotionTaskSourcePool<ValueTaskMotionConfiguredSource> pool;
+        static LinkedPool<ValueTaskMotionConfiguredSource> pool;
 
         ValueTaskMotionConfiguredSource nextNode;
         public ref ValueTaskMotionConfiguredSource NextNode => ref nextNode;

src/LitMotion/Assets/LitMotion/Runtime/ManualMotionDispatcher.cs

@@ -1,4 +1,5 @@
 using System;
+using LitMotion.Collections;
 
 namespace LitMotion
 {
@@ -27,7 +28,7 @@ public static MotionStorage<TValue, TOptions, TAdapter> GetOrCreate()
             }
         }
 
-        static readonly MinimumList<IUpdateRunner> updateRunners = new();
+        static FastListCore<IUpdateRunner> updateRunners = new(16);
 
         /// <summary>
         /// ManualMotionDispatcher time. It increases every time Update is called.

src/LitMotion/Assets/LitMotion/Runtime/MotionDispatcher.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Runtime.CompilerServices;
 using UnityEngine;
+using LitMotion.Collections;
+
 #if UNITY_EDITOR
 using UnityEditor;
 #endif
@@ -104,29 +106,41 @@ public static (UpdateRunner<TValue, TOptions, TAdapter> runner, bool isCreated)
             }
         }
 
-        static readonly MinimumList<IUpdateRunner> initializationRunners = new();
-        static readonly MinimumList<IUpdateRunner> earlyUpdateRunners = new();
-        static readonly MinimumList<IUpdateRunner> fixedUpdateRunners = new();
-        static readonly MinimumList<IUpdateRunner> preUpdateRunners = new();
-        static readonly MinimumList<IUpdateRunner> updateRunners = new();
-        static readonly MinimumList<IUpdateRunner> preLateUpdateRunners = new();
-        static readonly MinimumList<IUpdateRunner> postLateUpdateRunners = new();
-        static readonly MinimumList<IUpdateRunner> timeUpdateRunners = new();
+        static FastListCore<IUpdateRunner> initializationRunners = new(16);
+        static FastListCore<IUpdateRunner> earlyUpdateRunners = new(16);
+        static FastListCore<IUpdateRunner> fixedUpdateRunners = new(16);
+        static FastListCore<IUpdateRunner> preUpdateRunners = new(16);
+        static FastListCore<IUpdateRunner> updateRunners = new(16);
+        static FastListCore<IUpdateRunner> preLateUpdateRunners = new(16);
+        static FastListCore<IUpdateRunner> postLateUpdateRunners = new(16);
+        static FastListCore<IUpdateRunner> timeUpdateRunners = new(16);
+
+        internal static FastListCore<IUpdateRunner> EmptyList = new(0);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        static MinimumList<IUpdateRunner> GetRunnerList(PlayerLoopTiming playerLoopTiming)
+        static ref FastListCore<IUpdateRunner> GetRunnerList(PlayerLoopTiming playerLoopTiming)
         {
-            return playerLoopTiming switch
+            // FastListCore<T> must be passed as ref
+            switch (playerLoopTiming)
             {
-                PlayerLoopTiming.Initialization => initializationRunners,
-                PlayerLoopTiming.EarlyUpdate => earlyUpdateRunners,
-                PlayerLoopTiming.FixedUpdate => fixedUpdateRunners,
-                PlayerLoopTiming.PreUpdate => preUpdateRunners,
-                PlayerLoopTiming.Update => updateRunners,
-                PlayerLoopTiming.PreLateUpdate => preLateUpdateRunners,
-                PlayerLoopTiming.PostLateUpdate => postLateUpdateRunners,
-                PlayerLoopTiming.TimeUpdate => timeUpdateRunners,
-                _ => null
+                default:
+                    return ref EmptyList;
+                case PlayerLoopTiming.Initialization:
+                    return ref initializationRunners;
+                case PlayerLoopTiming.EarlyUpdate:
+                    return ref earlyUpdateRunners;
+                case PlayerLoopTiming.FixedUpdate:
+                    return ref fixedUpdateRunners;
+                case PlayerLoopTiming.PreUpdate:
+                    return ref preUpdateRunners;
+                case PlayerLoopTiming.Update:
+                    return ref updateRunners;
+                case PlayerLoopTiming.PreLateUpdate:
+                    return ref preLateUpdateRunners;
+                case PlayerLoopTiming.PostLateUpdate:
+                    return ref postLateUpdateRunners;
+                case PlayerLoopTiming.TimeUpdate:
+                    return ref timeUpdateRunners;
             };
         }
 
@@ -259,7 +273,7 @@ public static void InitUpdateRunner()
             }
         }
 
-        static readonly MinimumList<IUpdateRunner> updateRunners = new();
+        static FastListCore<IUpdateRunner> updateRunners = new(16);
 
         public static MotionHandle Schedule<TValue, TOptions, TAdapter>(in MotionData<TValue, TOptions> data, in MotionCallbackData callbackData)
             where TValue : unmanaged