Daily update on 20250907-184649 by Nitload Youmu. Additional Message : Matrix parallel task packet is done, parallel task executer is done. Now is working on building parallel wrap and pool.

Signed-off-by: Nitload <YoumuLiu_NSI@whv0t.onmicrosoft.com>
2025-09-07 18:46:49 +08:00
parent bfe3ada4fc
commit a7f82c04ea
5 changed files with 241 additions and 168 deletions
@@ -31,6 +31,7 @@
 using StgSharp.HighPerformance;
 using System;
 using System.Collections.Generic;
+using System.Formats.Asn1;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Text;
@@ -42,95 +43,150 @@ namespace StgSharp.Mathematics
    {

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static unsafe void Compute(MatrixKernel* right, MatrixKernel* ans, IntPtr computeHandle)
+        internal static unsafe void Compute_Binary(MatrixParallelTaskPackage* p)
        {
-            ((delegate*<MatrixKernel*, MatrixKernel*, void>)computeHandle)(right, ans);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static unsafe void Compute(
-                                    MatrixKernel* left,
-                                    MatrixKernel* right,
-                                    MatrixKernel* ans,
-                                    IntPtr computeHandle)
-        {
-            ((delegate*<MatrixKernel*, MatrixKernel*, MatrixKernel*, void>)computeHandle)(left, right, ans);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static unsafe void Compute(
-                                    MatrixKernel* right,
-                                    MatrixKernel* ans,
-                                    ScalarDataPacket* scalar,
-                                    IntPtr computeHandle)
-        {
-            ((delegate*<MatrixKernel*, MatrixKernel*, ScalarDataPacket*, void>)computeHandle)(right, ans, scalar);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static unsafe void Compute(
-                                    MatrixKernel* left,
-                                    MatrixKernel* right,
-                                    MatrixKernel* ans,
-                                    ScalarDataPacket* scalar,
-                                    IntPtr computeHandle)
-        {
-            ((delegate*<MatrixKernel*, MatrixKernel*, MatrixKernel*,ScalarDataPacket*, void>)computeHandle)(left, right, ans, scalar);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static unsafe void ComputeRow(
-                                    MatrixKernel* right,
-                                    MatrixKernel* ans,
-                                    IntPtr computeHandle,
-                                    MatrixParallelTaskPackage* task)
-        {
-            long l = task->LeftEnum.secStride, r = task->RightEnum.secStride, a = task->ResultEnum.secStride, li = 0, ri = 0, ai = 0;
-            for (int i = 0; i < task->secCount; i++) {
-                ((delegate*<MatrixKernel*, MatrixKernel*, void>)computeHandle)(right + ri, ans + ai);
+            MatrixKernel* l = p->Left, r = p->Right, a = p->Result;
+            long
+                lCount = p->LeftPrimOffset * p->LeftPrimStride,
+                rCount = p->RightPrimOffset * p->RightPrimStride,
+                aCount = p->ResultPrimOffset * p->ResultPrimStride,
+                pCount = p->PrimCount;
+            long
+                lLimit = pCount - p->LeftPrimOffset,
+                rLimit = pCount - p->RightPrimOffset,
+                aLimit = pCount - p->ResultPrimOffset;
+            delegate* unmanaged[Cdecl]<MatrixKernel*, MatrixKernel*, MatrixKernel*, void> op =
+                    (delegate* unmanaged[Cdecl]<MatrixKernel*, MatrixKernel*, MatrixKernel*, void>)p->ComputeHandle;
+            for (long i = 0; i < pCount; i++)
+            {
+                lCount = i < lLimit ? lCount + p->LeftPrimOffset : 0;
+                rCount = i < rLimit ? rCount + p->RightPrimOffset : 0;
+                aCount = i < rLimit ? aCount + p->ResultPrimOffset : 0;
+                MatrixKernel* left = l + lCount;
+                MatrixKernel* right = r + rCount;
+                MatrixKernel* ans = a + aCount;
+                long
+                    lc = p->LeftSecOffset * p->LeftSecStride,
+                    rc = p->RightSecOffset * p->RightSecStride,
+                    ac = p->ResultSecOffset * p->ResultSecStride,
+                    sCount = p->SecCount;
+                long
+                    ll = sCount - p->LeftSecOffset,
+                    rl = sCount - p->RightSecOffset,
+                    al = sCount - p->ResultSecOffset;
+                for (int j = 0; j < sCount; j++)
+                {
+                    lc = j < ll ? lc + p->LeftSecOffset : 0;
+                    rc = j < rl ? rc + p->RightSecOffset : 0;
+                    ac = j < al ? ac + p->ResultSecOffset : 0;
+                    op(left + lc, right + rc, ans + ac);
+                }
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static unsafe void ComputeRow(
-                                    MatrixKernel* right,
-                                    MatrixKernel* ans,
-                                    ScalarDataPacket* scalar,
-                                    IntPtr computeHandle,
-                                    MatrixParallelTaskPackage* task)
+        internal static unsafe void Compute_BinaryScalar(MatrixParallelTaskPackage* p)
        {
-            long l = task->LeftEnum.secStride, r = task->RightEnum.secStride, a = task->ResultEnum.secStride, li = 0, ri = 0, ai = 0;
-            for (int i = 0; i < task->secCount; i++) {
-                ((delegate*<MatrixKernel*, MatrixKernel*, ScalarDataPacket*, void>)computeHandle)(right + ri, ans + ai, scalar);
+            MatrixKernel* l = p->Left, r = p->Right, a = p->Result;
+            long
+                lCount = p->LeftPrimOffset * p->LeftPrimStride,
+                rCount = p->RightPrimOffset * p->RightPrimStride,
+                aCount = p->ResultPrimOffset * p->ResultPrimStride,
+                pCount = p->PrimCount;
+            long
+                lLimit = pCount - p->LeftPrimOffset,
+                rLimit = pCount - p->RightPrimOffset,
+                aLimit = pCount - p->ResultPrimOffset;
+            delegate* unmanaged[Cdecl]<MatrixKernel*, MatrixKernel*, MatrixKernel*, ScalarPacket*, void> op =
+                    (delegate* unmanaged[Cdecl]<MatrixKernel*, MatrixKernel*, MatrixKernel*, ScalarPacket*, void>)p->ComputeHandle;
+            ScalarPacket* scalar = p->Scalar;
+            for (long i = 0; i < pCount; i++)
+            {
+                lCount = i < lLimit ? lCount + p->LeftPrimOffset : 0;
+                rCount = i < rLimit ? rCount + p->RightPrimOffset : 0;
+                aCount = i < rLimit ? aCount + p->ResultPrimOffset : 0;
+                MatrixKernel* left = l + lCount;
+                MatrixKernel* right = r + rCount;
+                MatrixKernel* ans = a + aCount;
+                long
+                    lc = p->LeftSecOffset * p->LeftSecStride,
+                    rc = p->RightSecOffset * p->RightSecStride,
+                    ac = p->ResultSecOffset * p->ResultSecStride,
+                    sCount = p->SecCount;
+                long
+                    ll = sCount - p->LeftSecOffset,
+                    rl = sCount - p->RightSecOffset,
+                    al = sCount - p->ResultSecOffset;
+                for (int j = 0; j < sCount; j++)
+                {
+                    lc = j < ll ? lc + p->LeftSecOffset : 0;
+                    rc = j < rl ? rc + p->RightSecOffset : 0;
+                    ac = j < al ? ac + p->ResultSecOffset : 0;
+                    op(left + lc, right + rc, ans + ac, scalar);
+                }
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static unsafe void ComputeRow(
-                                    MatrixKernel* left,
-                                    MatrixKernel* right,
-                                    MatrixKernel* ans,
-                                    IntPtr computeHandle,
-                                    MatrixParallelTaskPackage* task)
+        internal static unsafe void Compute_Unary(MatrixParallelTaskPackage* p)
        {
-            long l = task->LeftEnum.secStride, r = task->RightEnum.secStride, a = task->ResultEnum.secStride, li = 0, ri = 0, ai = 0;
-            for (int i = 0; i < task->secCount; i++) {
-                ((delegate*<MatrixKernel*, MatrixKernel*, MatrixKernel*, void>)computeHandle)(left + li, right + ri, ans + ai);
+            MatrixKernel* s = p->Right, a = p->Result;
+            long rCount = p->RightPrimOffset * p->RightPrimStride,
+                     aCount = p->ResultPrimOffset * p->ResultPrimStride,
+                     pCount = p->PrimCount;
+            long rLimit = pCount - p->RightPrimOffset,
+                     aLimit = pCount - p->ResultPrimOffset;
+            delegate* unmanaged[Cdecl]<MatrixKernel*, MatrixKernel*, void> op =
+                    (delegate* unmanaged[Cdecl]<MatrixKernel*, MatrixKernel*, void>)p->ComputeHandle;
+            for (long i = 0; i < pCount; i++)
+            {
+                rCount = i < rLimit ? rCount + p->RightPrimOffset : 0;
+                aCount = i < rLimit ? aCount + p->ResultPrimOffset : 0;
+                MatrixKernel* source = s + rCount;
+                MatrixKernel* ans = a + aCount;
+                long rc = p->RightSecOffset * p->RightSecStride,
+                         ac = p->ResultSecOffset * p->ResultSecStride,
+                         sCount = p->SecCount;
+                long rl = sCount - p->RightSecOffset,
+                         al = sCount - p->ResultSecOffset;
+                for (int j = 0; j < sCount; j++)
+                {
+                    rc = j < rl ? rc + p->RightSecOffset : 0;
+                    ac = j < al ? ac + p->ResultSecOffset : 0;
+                    op(source + rc, ans + ac);
+                }
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static unsafe void ComputeRow(
-                                    MatrixKernel* left,
-                                    MatrixKernel* right,
-                                    MatrixKernel* ans,
-                                    ScalarDataPacket* scalar,
-                                    IntPtr computeHandle,
-                                    MatrixParallelTaskPackage* task)
+        internal static unsafe void Compute_UnaryScalar(MatrixParallelTaskPackage* p)
        {
-            long l = task->LeftEnum.secStride, r = task->RightEnum.secStride, a = task->ResultEnum.secStride, li = 0, ri = 0, ai = 0;
-            for (int i = 0; i < task->secCount; i++) {
-                ((delegate*<MatrixKernel*, MatrixKernel*, MatrixKernel*, ScalarDataPacket*, void>)computeHandle)(left + li, right + ri, ans + ai, scalar);
+            MatrixKernel* s = p->Right, a = p->Result;
+            long rCount = p->RightPrimOffset * p->RightPrimStride,
+                     aCount = p->ResultPrimOffset * p->ResultPrimStride,
+                     pCount = p->PrimCount;
+            long rLimit = pCount - p->RightPrimOffset,
+                     aLimit = pCount - p->ResultPrimOffset;
+            delegate* unmanaged[Cdecl]<MatrixKernel*, MatrixKernel*, ScalarPacket*, void> op =
+                    (delegate* unmanaged[Cdecl]<MatrixKernel*, MatrixKernel*, ScalarPacket*, void>)p->ComputeHandle;
+            ScalarPacket* scalar = p->Scalar;
+            for (long i = 0; i < pCount; i++)
+            {
+                rCount = i < rLimit ? rCount + p->RightPrimOffset : 0;
+                aCount = i < rLimit ? aCount + p->ResultPrimOffset : 0;
+                MatrixKernel* source = s + rCount;
+                MatrixKernel* ans = a + aCount;
+                long rc = p->RightSecOffset * p->RightSecStride,
+                         ac = p->ResultSecOffset * p->ResultSecStride,
+                         sCount = p->SecCount;
+                long rl = sCount - p->RightSecOffset,
+                         al = sCount - p->ResultSecOffset;
+                for (int j = 0; j < sCount; j++)
+                {
+                    rc = j < rl ? rc + p->RightSecOffset : 0;
+                    ac = j < al ? ac + p->ResultSecOffset : 0;
+                    op(source + rc, ans + ac, scalar);
+                }
            }
        }