working on dynamic wrapping

StgSharp.Mathematics/Numeric/MatrixParallelPool.cs

@@ -36,79 +36,115 @@ using System.Threading.Tasks;
 
 namespace StgSharp.Mathematics.Numeric
 {
-    public class MatrixParallelPool
+    public struct MatrixParallelHandle : IDisposable
     {
 
-        private MatrixParallelPool()
-        {
-            throw new NotSupportedException();
-        }
-        /*
-        internal MatrixParallelPool(int threadCount, ReadOnlySpan<MatrixParallelWrap> wrapSpan)
-        {
-            SpareWrap = CapacityFixedStackBuilder.Create(wrapSpan);
-            SingleThreadAllocation = new CapacityFixedBag<MatrixParallelWrap>(wrapSpan.Length);
-            SpareThreadCount = threadCount;
-        }
-        /**/
+        private static readonly (int a, int b)[] LookupTable = [
+            (1, 1), // 7
+            (0, 2), // 8  (no non-zero solution)
+            (3, 0), // 9  (no non-zero solution)
+            (2, 1), // 10
+            (1, 2), // 11
+            (0, 3), // 12 (no non-zero solution)
+            (3, 1), // 13
+            (2, 2), // 14
+            (1, 3), // 15
+            (4, 1), // 16
+            (3, 2), // 17
+            (2, 3), // 18
+            (1, 4), // 19
+            (4, 2), // 20
+        ];
 
-        internal MatrixParallelPool(int threadCount, CapacityFixedStack<MatrixParallelWrap> wrapSpan)
+        private MatrixParallelThread[] _threads;
+        private bool _disposed = false;
+        private CapacityFixedStack<MatrixParallelWrap> _wraps;
+
+        internal MatrixParallelHandle(MatrixParallelThread[] threadArray)
         {
-            SpareWrap = wrapSpan;
-            SingleThreadAllocation = new CapacityFixedBag<MatrixParallelWrap>(wrapSpan.Count);
-            SpareThreadCount = threadCount;
+            _threads = threadArray;
+            IsMultithread = threadArray.Length > 1;
+            SliceToWraps();
         }
 
-        public int SpareThreadCount { get; set; }
-
-        internal CapacityFixedBag<MatrixParallelWrap> SingleThreadAllocation { get; set; }
-
-        internal CapacityFixedStack<MatrixParallelWrap> SpareWrap { get; set; }
-
-        /*
-        public void ReturnIndividualHandle(ref MatrixParallelWrap.Handle handle)
+        public ReadOnlySpan<MatrixParallelThread> Threads
         {
-            MatrixParallelWrap wrap = handle.Wrap;
-            handle.Role = 0;
-            if (wrap.IsAllAvailable)
+            get
             {
-                SingleThreadAllocation.RemoveAt(wrap.Magic);
-                SpareWrap.Push(wrap);
-                SpareThreadCount += wrap.WrapTaskCapacity;
-            }
-        }
-
-        public bool TryRentIndividualHandle(out MatrixParallelWrap.Handle handle)
-        {
-            foreach (MatrixParallelWrap item in SingleThreadAllocation)
-            {
-                if (item.TryGetLeaderHandle(out handle!)) {
-                    return true;
+                if (_disposed) {
+                    throw new ObjectDisposedException(typeof(MatrixParallelHandle).Name);
                 }
+                return _threads;
             }
-            if (TryRequestWrap(out MatrixParallelWrap wrap))
-            {
-                wrap!.Magic = SingleThreadAllocation.Count;
-                SingleThreadAllocation.Add(wrap);
-                if (wrap.TryGetLeaderHandle(out handle!)) {
-                    return true;
-                }
+        }
+
+        internal ReadOnlySpan<MatrixParallelThread> ThreadsUnsafe
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => _threads;
+        }
+
+        private bool IsMultithread { get; init; }
+
+        public void Dispose()
+        {
+            if (_disposed) {
+                return;
             }
-            handle = null!;
-            return false;
+            MatrixParallel.ReleaseParallelLeadership(ref _threads);
+            _disposed = true;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool TryRequestWrap([NotNull] out MatrixParallelWrap? wrap)
+        private static (int count_3, int count_4) FastDecompose(int c)
         {
-            if (SpareWrap.TryPop(out wrap))
+            /*
+            * Thread wrapping to accelerate matrix operations by dividing threads into groups (pool).
+            * For M pool, each containing an average of N threads, we satisfy the condition M * N = T - 4,
+            * where T is the total thread count of the CPU. Typically, for modern consumer CPUs, T is around 16.
+            * For simplicity, let M * N = 16.
+            *
+            * The total time complexity for publishing tasks is O(M + N):
+            * - O(M) accounts for distributing tasks across M pool.
+            * - O(N) accounts for threads within each wrap fetching tasks from the wrap queue.
+            *
+            * Using the inequality Sqrt(M * N) <= (M + N) / 2 (derived from the arithmetic-geometric mean inequality),
+            * the optimal configuration occurs when M = N. For M * N = 16, this gives M = N = 4.
+            * 
+            * To ensure compatibility across a wide range of CPU architectures, 
+            * we allow each wrap to contain either 3 or 4 threads, providing flexibility while maintaining efficiency.
+            */
+            if (c < 7)
             {
-                SpareThreadCount -= wrap.WrapTaskCapacity;
-                return true;
+                return (0, 0);
             }
-            wrap = null!;
-            return false;
+
+            int t = c - 7;
+            int k = t / 14;
+            int d = t % 14;
+
+            (int a0, int b0) = LookupTable[d];
+
+            return (a0 + (2 * k), b0 + (2 * k));
         }
-        /**/
+
+        private void SliceToWraps()
+        {
+            if (_disposed) {
+                throw new ObjectDisposedException(typeof(MatrixParallelHandle).Name);
+            }
+            if (_wraps is not null) {
+                return;
+            }
+            int count = _threads.Length;
+            if (count < 6)
+            {
+                MatrixParallelWrap wrap = new MatrixParallelWrap(_threads);
+                _wraps = [ wrap ];
+            }
+            (int c3,int c4) = FastDecompose(_threads.Length);
+            _wraps = new(c3 + c4);
+        }
+
     }
 }