com.amanotes.gdk 0.2.70 → 0.2.71

package/Runtime/Core/GDKPool.cs

@@ -1,103 +1,385 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Reflection;
 using System.Text;
-
+using Unity.Collections.LowLevel.Unsafe;
+using UnityEngine;
+using UnityEngine.Assertions;
+using UnityEngine.Profiling;
 namespace Amanotes.Core.Internal
 {
-    public interface IPoolItem
+    internal static class GDKPoolExtension
     {
-        void Reset();
+        internal static T Pop<T>(this List<T> list)
+        {
+            if (list == null || list.Count == 0) return default;
+
+            T result = list[list.Count - 1];
+            list.RemoveAt(list.Count - 1);
+            return result;
+        }
+    }
+
+    public static partial class GDKPool // TypeHandler 
+    {
+        private const int STRING_BUILDER_DEFAULT_LEN = 64;
+        private static readonly Dictionary<Type, object> typeHandlerMap = new Dictionary<Type, object>
+        {
+            { typeof(StringBuilder), new TypeHandler<StringBuilder>(() => new StringBuilder(), h => h.Clear()) },
+            { typeof(HashSet<string>), new TypeHandler<HashSet<string>>(() => new HashSet<string>(), h => h.Clear()) },
+            { typeof(Dictionary<string, object>), new TypeHandler<Dictionary<string, object>>(() => new Dictionary<string, object>(), d => d.Clear()) }
+        };
+
+        public static TypeHandler<T> GetTypeHandler<T>() where T : class
+        {
+            return typeHandlerMap.TryGetValue(typeof(T), out object result)
+                ? UnsafeUtility.As<object, TypeHandler<T>>(ref result)
+                : null;
+        }
+
+        public static TypeHandler<T> AddTypeHandler<T>(Func<T> newT, Action<T> resetT = null) where T : class
+        {
+            if (typeof(IPoolItem).IsAssignableFrom(typeof(T)))
+            {
+                if (resetT != null) Debug.LogWarning("Unsupported custom resetT() when T: IPoolItem!");
+                resetT = item => { (item as IPoolItem)?.Reset(); };
+            }
+
+            var result = new TypeHandler<T>(newT, resetT);
+            typeHandlerMap.Add(typeof(T), result);
+            return result;
+        }
+        public static TypeHandler<T> AddTypeHandler<T>(Action<T> resetT = null) where T : class, new()
+        {
+            return AddTypeHandler(() => new T(), resetT);
+        }
+        public class TypeHandler<T> where T : class
+        {
+            public readonly Func<T> newT;
+            public readonly Action<T> resetT;
+
+            public TypeHandler(Func<T> newT, Action<T> resetT)
+            {
+                this.newT = newT;
+                this.resetT = resetT;
+            }
+        }
     }
 
-    public static class GDKPool
+    public static partial class GDKPool // Interface 
+    {
+        public interface IPoolItem
+        {
+            void Reset();
+        }
+        public interface IPool<T> where T : class
+        {
+            int Count { get; } // Added to get the number of items currently in the pool
+            T Take();
+            void Return(T item);
+        }
+        public interface IPoolMap
+        {
+            IPool<T> GetPool<T>() where T : class;
+            IPool<T> CreatePool<T>(TypeHandler<T> handler = null) where T : class;
+            IPool<T> GetOrCreatePool<T>(TypeHandler<T> handler = null) where T : class;
+        }
+    }
+    public static partial class GDKPool // POOLs 
     {
-        internal class Pool<T> where T : new()
+        internal abstract class BasePool<T, T1> : IPool<T>
+            where T : class
+            where T1 : new()
         {
-            private readonly ConcurrentQueue<T> _pool;
-            public Pool(int initialCapacity = 4)
+            internal readonly TypeHandler<T> handler;
+            internal readonly T1 pool;
+            protected BasePool(TypeHandler<T> handler)
             {
-                _pool = new ConcurrentQueue<T>();
-                for (var i = 0; i < initialCapacity; i++)
+                pool = new T1();
+                this.handler = handler;
+            }
+
+            public abstract T Take();
+            public abstract void Return(T item);
+            public abstract int Count { get; }
+        }
+        internal sealed class ListPool<T> : BasePool<T, List<T>> where T : class
+        {
+            public ListPool(TypeHandler<T> handler, int capacity) : base(handler)
+            {
+                for (var i = 0; i < capacity; i++)
                 {
-                    _pool.Enqueue(new T());
+                    Return(handler.newT());
                 }
             }
-        
-            public Pool(int initialCapacity, Func<T> newT)
+            public override int Count => pool.Count;
+
+            public override T Take()
             {
-                _pool = new ConcurrentQueue<T>();
-                for (var i = 0; i < initialCapacity; i++)
+                if (pool.Count == 0) return handler.newT();
+                T last = pool.Pop();
+                handler.resetT?.Invoke(last); // Take from pool: Do Reset
+                return last;
+            }
+
+            internal T TakeAt(int idx)
+            {
+                if (idx < 0 || idx >= pool.Count - 1) return Take();
+
+                // swap last item to index
+                T item = pool[idx];
+                pool[idx] = pool.Pop();
+                handler.resetT?.Invoke(item);
+                return item;
+            }
+
+            public override void Return(T item)
+            {
+                if (item == null) return;
+                pool.Add(item);
+            }
+        }
+        internal sealed class ConcurrentPool<T> : BasePool<T, ConcurrentBag<T>> where T : class
+        {
+            public ConcurrentPool(TypeHandler<T> handler, int capacity) : base(handler)
+            {
+                for (var i = 0; i < capacity; i++)
                 {
-                    _pool.Enqueue(newT());
+                    Return(handler.newT());
                 }
             }
-        
-            public T Get()
+
+            public override int Count => pool.Count;
+
+            public override T Take()
+            {
+                if (!pool.TryTake(out T result)) return handler.newT();
+                handler.resetT?.Invoke(result);
+                return result;
+            }
+
+            public override void Return(T item)
+            {
+                if (item == null) return;
+                pool.Add(item);
+            }
+        }
+    }
+
+    public static partial class GDKPool // POOL MAP 
+    {
+        internal abstract class BasePoolMap<TDict> : IPoolMap where TDict : IDictionary<Type, object>, new()
+        {
+            internal readonly TDict map = new TDict();
+
+            // IPoolMap
+            public IPool<T> GetPool<T>() where T : class
             {
-                if (!_pool.TryDequeue(out var obj)) return new T();
-                if (obj is IPoolItem poolItem) poolItem.Reset();
-                return obj;
+                return map.TryGetValue(typeof(T), out object result)
+                    ? UnsafeUtility.As<object, IPool<T>>(ref result)
+                    : null;
             }
 
-            public void Return(T obj)
+            public IPool<T> CreatePool<T>(TypeHandler<T> handler = null) where T : class
             {
-                _pool.Enqueue(obj);
+                return CreatePoolInternal(handler ?? GetTypeHandler<T>());
             }
 
-            public int Count => _pool.Count;
+            public IPool<T> GetOrCreatePool<T>(TypeHandler<T> handler = null) where T : class
+            {
+                return GetPool<T>() ?? CreatePoolInternal(handler ?? GetTypeHandler<T>());
+            }
+            internal abstract IPool<T> CreatePoolInternal<T>(TypeHandler<T> handler) where T : class;
         }
-        private static readonly Pool<StringBuilder> sbPool1KB = new Pool<StringBuilder>(8, () => new StringBuilder(1024));
-        private static readonly Pool<StringBuilder> sbPool8KB = new Pool<StringBuilder>(8, () => new StringBuilder(8*1024));
-        private static readonly Pool<HashSet<string>> hashsetPool = new Pool<HashSet<string>>(4);
-        
-        public static StringBuilder GetStringBuilder(int capacityInKb = 1)
+        internal class ListPoolMap : BasePoolMap<Dictionary<Type, object>>
         {
-            StringBuilder result = capacityInKb <= 1 ? sbPool1KB.Get() : sbPool8KB.Get();
-            result.Clear();
-            return result;
+            internal override IPool<T> CreatePoolInternal<T>(TypeHandler<T> handler) where T : class
+            {
+                var result = new ListPool<T>(handler, 1);
+                map.Add(typeof(T), result);
+                return result;
+            }
+        }
+        internal class ConcurrentPoolMap : BasePoolMap<ConcurrentDictionary<Type, object>>
+        {
+            internal override IPool<T> CreatePoolInternal<T>(TypeHandler<T> handler) where T : class
+            {
+                var result = new ConcurrentPool<T>(handler, 1);
+                map.TryAdd(typeof(T), result);
+                return result;
+            }
+        }
+    }
+
+    public static partial class GDKPool
+    {
+        private static readonly ListPoolMap mainPM = new ListPoolMap();
+        private static readonly ConcurrentPoolMap threadPM = new ConcurrentPoolMap();
+
+        // HashSet<T> support
+        private static readonly ListPool<HashSet<string>> hPool; // cached reference for main-thread
+        private static readonly ListPool<StringBuilder> sbPool;
+
+        // StringBuilder support
+        private static readonly ListPool<StringBuilder> fixedSBPool;
+
+        // Dictionary support
+        private static readonly ListPool<Dictionary<string, object>> dictPool;
+
+        // SPECIAL APIs
+        static GDKPool()
+        {
+            // Main-thread: Use fixed-length StringBuilder
+            sbPool = (ListPool<StringBuilder>) mainPM.CreatePool<StringBuilder>();
+            hPool = (ListPool<HashSet<string>>) mainPM.CreatePool<HashSet<string>>();
+            dictPool = (ListPool<Dictionary<string, object>>)mainPM.CreatePool<Dictionary<string, object>>();
+            fixedSBPool = new ListPool<StringBuilder>(new TypeHandler<StringBuilder>(null, sb => sb.Clear()), 0);
         }
         
-        public static HashSet<string> GetHashSet()
+        private static IPoolMap poolMap => GDKUtils.isOnMainThread ? mainPM : (IPoolMap)threadPM;
+        internal static void ClearAndReset()
         {
-            HashSet<string> result = hashsetPool.Get();
-            result.Clear();
-            return result;
+            // main thread
+            mainPM.map.Clear();
+            mainPM.map.Add(typeof(StringBuilder), sbPool);
+            mainPM.map.Add(typeof(HashSet<string>), hPool);
+            mainPM.map.Add(typeof(Dictionary<string, object>), dictPool);
+            
+            // other threads
+            threadPM.map.Clear();
+        }
+
+        public static T Take<T>(bool autoCreatePool = true) where T : class, new()
+        {
+            IPool<T> pool = poolMap.GetPool<T>() ?? CreatePool<T>();
+            return pool.Take();
         }
         
-        public static string ReturnString(StringBuilder sb)
+        public static T Take<T>(Action<T> resetT) where T : class, new()
         {
-            if (sb == null) return null;
-            var result = sb.ToString();
-            Return(sb);
-            return result;
+            IPool<T> pool = poolMap.GetPool<T>() ?? CreatePool(() => new T(), resetT);
+            return pool.Take();
         }
         
-        public static void Return(StringBuilder sb)
+        public static void Return<T>(T item) where T : class
         {
-            if (sb == null) return;
-            int capacity = sb.Capacity;
-            
-            if (capacity == 1024)
+            if (typeof(T) == typeof(StringBuilder))
             {
-                sbPool1KB.Return(sb);
-                return;
+                StringBuilder sb = UnsafeUtility.As<T, StringBuilder>(ref item);
+                if (sb.Capacity == sb.MaxCapacity)
+                {
+                    fixedSBPool.Return(sb);
+                    return;
+                }
             }
             
-            sbPool8KB.Return(sb);
+            poolMap.GetPool<T>()?.Return(item);
         }
-        
-        public static void Return(HashSet<string> hashset)
+
+        public static IPool<T> GetPool<T>(bool autoCreatePool = false) where T : class, new()
         {
-            if (hashset == null) return;
-            hashsetPool.Return(hashset);
+            IPool<T> result = poolMap.GetPool<T>();
+            if (result != null) return result;
+            return autoCreatePool ? CreatePool<T>() : null;
         }
-        
+        private static IPool<T> TryCreatePoolUsingTypeHandler<T>() where T : class
+        {
+            TypeHandler<T> handler = GetTypeHandler<T>();
+            return handler != null ? poolMap.CreatePool(handler) : null;
+        }
+        public static IPool<T> CreatePool<T>(Func<T> newT, Action<T> resetT) where T : class
+        {
+            IPool<T> result = TryCreatePoolUsingTypeHandler<T>();
+            if (result != null) return result;
+            return poolMap.CreatePool(AddTypeHandler(newT, resetT));
+        }
+
+        public static IPool<T> CreatePool<T>(Action<T> resetT = null) where T : class, new()
+        {
+            IPool<T> result = TryCreatePoolUsingTypeHandler<T>();
+            if (result != null) return result;
+            return poolMap.CreatePool(AddTypeHandler(() => new T(), resetT));
+        }
+        public static HashSet<T> TakeHashSet<T>()
+        {
+            var result = Take<HashSet<T>>();
+            return result ?? CreatePool<HashSet<T>>(h => h.Clear()).Take();
+        }
+        public static HashSet<string> TakeHashSet()
+        {
+            return GDKUtils.isOnMainThread ? hPool.Take() : TakeHashSet<string>();
+        }
+
         public static void ReturnAndNullize(ref HashSet<string> hashset)
         {
             if (hashset == null) return;
-            hashsetPool.Return(hashset);
+            hashset.Clear();
+            Return(hashset);
             hashset = null;
         }
+
+        public static StringBuilder TakeStringBuilder(int fixedLength = 0)
+        {
+            if (!GDKUtils.isOnMainThread)
+            {
+                if (fixedLength != 0) Logging.LogWarningOnce("Fixed length StringBuilder only work for Main Thread!");
+                return Take<StringBuilder>();
+            }
+            
+            if (fixedLength == 0) return Take<StringBuilder>();
+            
+            if (fixedSBPool.Count == 0) return new StringBuilder(fixedLength, fixedLength);
+            List<StringBuilder> pool = fixedSBPool.pool;
+            for (var i = 0; i < pool.Count; i++)
+            {
+                if (pool[i].Capacity != fixedLength) continue;
+                return fixedSBPool.TakeAt(i);
+            }
+            
+            return new StringBuilder(fixedLength, fixedLength);
+        }
+
+        private static FieldInfo sbStringValueField;
+        private static readonly Dictionary<StringBuilder, string> internalSB = new Dictionary<StringBuilder, string>();
+        public static string ReturnAndStringify(StringBuilder sb)
+        {
+            if (sb == null) return null;
+            
+            // if (GDKUtils.isOnMainThread && sb.Capacity == sb.MaxCapacity)
+            // {
+            //     string str;
+            //     Profiler.BeginSample("GDKPool.ReturnAndStringify()");
+            //     {
+            //         if (!internalSB.TryGetValue(sb, out str))
+            //         {
+            //             sbStringValueField ??= typeof(StringBuilder)
+            //                 .GetField("m_StringValue", BindingFlags.NonPublic | BindingFlags.Instance);
+            //             
+            //             str = (string)sbStringValueField?.GetValue(sb);
+            //             internalSB.Add(sb, str);
+            //         }
+            //         
+            //         fixedSBPool.Return(sb);
+            //     }
+            //     Profiler.EndSample();
+            //     return str;
+            // }
+            
+            string result = null;
+            Profiler.BeginSample("GDKPool.ReturnAndStringify()");
+            {
+                result = sb.ToString();
+                sb.Clear();
+                Return(sb);
+            }
+            Profiler.EndSample();
+
+            return result;
+        }
+        public static Dictionary<string, object> TakeDictionary()
+        {
+            return GDKUtils.isOnMainThread ? dictPool.Take() : Take<Dictionary<string, object>>();
+        }
     }
 }

package/Runtime/Fps/AmaFPS.Utils.cs

@@ -27,7 +27,7 @@ namespace Amanotes.Core
                 var resolution = Screen.currentResolution;
                 dictionary.Add("system_memory_size", SystemInfo.systemMemorySize);
                 dictionary.Add("graphics_memory_size", SystemInfo.graphicsMemorySize);
-                dictionary.Add("graphics_device_type", SystemInfo.graphicsDeviceType);
+                dictionary.Add("graphics_device_type", SystemInfo.graphicsDeviceType.ToString());
                 dictionary.Add("graphics_shader_level", SystemInfo.graphicsShaderLevel);
                 dictionary.Add("processor_count", SystemInfo.processorCount);
                 dictionary.Add("processor_frequency", SystemInfo.processorFrequency);