From 88ed5a95c5189027e2d1913d1be3e55b150d410a Mon Sep 17 00:00:00 2001 From: Youmu Liu <105042599+Nitload-NSI@users.noreply.github.com> Date: Tue, 16 Dec 2025 16:15:30 +0800 Subject: [PATCH] Mat mul mat is now on full function --- .../Internal/Intrinsic/IntrinsicContext.cs | 2 +- .../Numeric/MatrixCompute.Additional.cs | 33 +- .../Numeric/MatrixCompute.Basic.cs | 281 ------------------ StgSharp.Mathematics/Numeric/MatrixCompute.cs | 252 +++++++++++++++- .../Numeric/MatrixComputeModel.cs | 28 +- .../Numeric/MatrixParallel.Publish.cs | 77 +---- .../Numeric/MatrixParallel.cs | 2 +- .../Numeric/MatrixParallelTaskPackage.cs | 21 +- .../Numeric/MatrixParallelThread.cs | 37 +-- StgSharp.Native/sn-head/sn_matkernel.h | 4 +- StgSharp.Native/sn-src/k_basicop.c | 14 +- StgSharp.Native/sn-src/k_panel.c | 24 +- StgSharp.Native/sn-src/load_intrinsic.c | 5 +- StgSharpDebug/Program.cs | 65 ++-- 14 files changed, 357 insertions(+), 488 deletions(-) delete mode 100644 StgSharp.Mathematics/Numeric/MatrixCompute.Basic.cs diff --git a/StgSharp.Common/Internal/Intrinsic/IntrinsicContext.cs b/StgSharp.Common/Internal/Intrinsic/IntrinsicContext.cs index 064daceb..40fb3f2e 100644 --- a/StgSharp.Common/Internal/Intrinsic/IntrinsicContext.cs +++ b/StgSharp.Common/Internal/Intrinsic/IntrinsicContext.cs @@ -44,7 +44,7 @@ namespace StgSharp.Internal.Intrinsic public delegate* unmanaged[Cdecl] f32_buffer_scalar_mul; //f32_buffer_s_m public delegate* unmanaged[Cdecl] f32_buffer_sub; //f32_kernel_sub public delegate* unmanaged[Cdecl] f32_buffer_transpose; //f32_kernel_transpose - public delegate* unmanaged[Cdecl] f32_build_panel; //f32_build_panel + public delegate* unmanaged[Cdecl] f32_build_panel; //f32_build_panel public delegate* unmanaged[Cdecl] f32_clear_panel; public delegate* unmanaged[Cdecl] f32_normalize_3; //f32_normalize_3 public delegate* unmanaged[Cdecl] f32_panel_fma; //f32_panel_fma diff --git a/StgSharp.Mathematics/Numeric/MatrixCompute.Additional.cs b/StgSharp.Mathematics/Numeric/MatrixCompute.Additional.cs index beccf2c2..24e7e2b7 100644 --- a/StgSharp.Mathematics/Numeric/MatrixCompute.Additional.cs +++ b/StgSharp.Mathematics/Numeric/MatrixCompute.Additional.cs @@ -26,6 +26,7 @@ // ----------------------------------------------------------------------- // ----------------------------------------------------------------------- using StgSharp.HighPerformance; +using StgSharp.Internal; using System; using System.Collections.Generic; using System.Linq; @@ -40,17 +41,39 @@ namespace StgSharp.Mathematics.Numeric internal static unsafe void ComputeFmaPanelF32(MatrixParallelTaskPackage* p) { + int size = p->ElementSize; + MatrixKernel* leftBuffer = (MatrixKernel*)p->Left; + MatrixKernel* rightBuffer = (MatrixKernel*)p->Right; + MatrixKernel* ansBuffer = (MatrixKernel*)p->Answer; MatrixPanel* leftPanel = MatrixPanel.Create(); MatrixPanel* rightPanel = MatrixPanel.Create(); MatrixPanel* ansPanel = MatrixPanel.Create(); ref long offsetRef = ref Unsafe.As(ref p->PrimTileOffset); ref long lengthRef = ref Unsafe.As(ref p->PrimCount); - int i_length = p->PrimCount; - int j_length = p->SecCount; - int k_length = 0; - for (long i = 0; i < lengthRef; i++) + int ansWidth = p-> AnsPrimOffset; + int ansHeight = p->AnsSecOffset; + int commonK = p->LeftPrimOffset; + int blocksPerRow = ansWidth / size; + + for (long c = offsetRef; c < offsetRef + lengthRef; c++) { - for (int k = 0; k < k_length; k++) { } + int i = (int)(c / blocksPerRow) * size; + int j = (int)(c % blocksPerRow) * size; + NativeIntrinsic.Intrinsic.f32_clear_panel((MatrixPanel*)ansPanel); + for (int k = 0; k < commonK; k += size) + { + NativeIntrinsic.Intrinsic + .f32_build_panel((MatrixPanel*)leftPanel, leftBuffer, commonK, + ansHeight, k, i); + NativeIntrinsic.Intrinsic + .f32_build_panel((MatrixPanel*)rightPanel, rightBuffer, ansWidth, + commonK, j, k); + NativeIntrinsic.Intrinsic + .f32_panel_fma((MatrixPanel*)leftPanel, (MatrixPanel*)rightPanel, (MatrixPanel*)ansPanel); + } + NativeIntrinsic.Intrinsic + .f32_store_panel((MatrixPanel*)ansPanel, ansBuffer, ansWidth, + ansHeight, j, i); } MatrixPanel.Destroy(leftPanel); MatrixPanel.Destroy(rightPanel); diff --git a/StgSharp.Mathematics/Numeric/MatrixCompute.Basic.cs b/StgSharp.Mathematics/Numeric/MatrixCompute.Basic.cs deleted file mode 100644 index 71bade0c..00000000 --- a/StgSharp.Mathematics/Numeric/MatrixCompute.Basic.cs +++ /dev/null @@ -1,281 +0,0 @@ -//----------------------------------------------------------------------- -// ----------------------------------------------------------------------- -// file="MatrixCompute.Basic" -// Project: StgSharp -// AuthorGroup: Nitload -// Copyright (c) Nitload. All rights reserved. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -// SOFTWARE. -// -// ----------------------------------------------------------------------- -// ----------------------------------------------------------------------- -using StgSharp.Collections; -using StgSharp.HighPerformance; -using StgSharp.Internal; -using System; -using System.Collections.Generic; -using System.ComponentModel.DataAnnotations.Schema; -using System.Linq; -using System.Numerics; -using System.Security.AccessControl; -using System.Text; -using System.Threading.Tasks; - -namespace StgSharp.Mathematics.Numeric -{ - public static partial class MatrixCompute - { - - public static unsafe void Add(Matrix left, Matrix right, Matrix ans) - { - if (left.ColumnLength != right.ColumnLength || - left.RowLength != right.RowLength || - left.ColumnLength != ans.ColumnLength || - left.RowLength != ans.RowLength) { - throw new IndexOutOfRangeException("Matrix dimensions must agree."); - } - long count = (long)left.KernelColumnLength * left.KernelRowLength; - if (count <= 256) - { - MatrixKernel* leftPtr = left.Buffer; - MatrixKernel* rightPtr = right.Buffer; - MatrixKernel* ansPtr = ans.Buffer; - NativeIntrinsic.Intrinsic.f32_buffer_add(leftPtr, rightPtr, ansPtr, count); - - return; - } else if (count <= 1024) - { - MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1); - - MatrixKernel* leftPtr = left.Buffer; - MatrixKernel* rightPtr = right.Buffer; - MatrixKernel* ansPtr = ans.Buffer; - NativeIntrinsic.Intrinsic.f32_buffer_add(leftPtr, rightPtr, ansPtr, count); - - MatrixParallel.ReturnParallelResources(ref pool); - return; - } - MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask(); - package->Left = (nint)left.Buffer; - package->Right = (nint)right.Buffer; - package->Result = (nint)ans.Buffer; - package->ElementSize = sizeof(float); - package->PrimCount = ans.KernelColumnLength; - package->SecCount = ans.KernelRowLength; - package->ComputeMode = new MatrixOpMode(MatrixOperationStyle.BUFFER_OP, MatrixOperationParam.LEFT_RIGHT_ANS_PARAM); - package->ComputeHandle = (IntPtr)NativeIntrinsic.Intrinsic.f32_buffer_add; - MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package); - - MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep); - taskGroup.Dispose(); - return; - } - - public static unsafe void Fill(Matrix ans, float value) - { - long count = (long)ans.KernelColumnLength * ans.KernelRowLength; - ScalarPacket* scalar = MatrixParallelFactory.CreateScalarPacket(); - scalar->Data(0) = value; - if (count <= 256) - { - NativeIntrinsic.Intrinsic.f32_buffer_fill(ans.Buffer, scalar, count); - return; - } else if (count <= 1024) - { - MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1); - NativeIntrinsic.Intrinsic.f32_buffer_fill(ans.Buffer, scalar, count); - MatrixParallel.ReturnParallelResources(ref pool); - return; - } - MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask(); - package->Result = (nint)ans.Buffer; - package->ElementSize = sizeof(float); - package->PrimCount = ans.KernelColumnLength; - package->SecCount = ans.KernelRowLength; - package->ComputeMode = new MatrixOpMode(MatrixOperationStyle.BUFFER_OP, MatrixOperationParam.ANS_SCALAR_PARAM); - package->ComputeHandle = (IntPtr)NativeIntrinsic.Intrinsic.f32_buffer_fill; - package->Scalar = scalar; - MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package); - MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep); - MatrixParallelFactory.Release(scalar); - taskGroup.Dispose(); - } - - public static unsafe void Mul(Matrix left, Matrix right, Matrix ans) - { - // For matrix multiplication (left: MxK) * (right: KxN) => ans: MxN - // ColumnLength = number of columns (N), RowLength = number of rows (M) - if (left.ColumnLength != right.RowLength || - ans.ColumnLength != right.ColumnLength || - ans.RowLength != left.RowLength) - { - throw new IndexOutOfRangeException("Matrix dimensions must agree."); - } - long count = (long)left.KernelColumnLength * left.KernelRowLength; - if (count <= 1024) - { - MatrixParallelThread[] pool = null; - if (count > 256) { - pool = MatrixParallel.LeadParallel(1); - } - MatrixPanel* leftPanel = MatrixPanel.Create(); - MatrixPanel* rightPanel = MatrixPanel.Create(); - MatrixPanel* ansPanel = MatrixPanel.Create(); - int size = MatrixPanel.KernelSideCount(); - for (int i = 0; i < left.RowLength; i += size) - { - for (int j = 0; j < right.ColumnLength; j += size) - { - NativeIntrinsic.Intrinsic.f32_clear_panel((MatrixPanel*)ansPanel); - for (int k = 0; k < left.ColumnLength; k += size) - { - NativeIntrinsic.Intrinsic - .f32_build_panel((MatrixKernel*)left.Buffer, - (MatrixPanel*)leftPanel, - left.ColumnLength, left.RowLength, i, - k); - NativeIntrinsic.Intrinsic - .f32_build_panel((MatrixKernel*)right.Buffer, - (MatrixPanel*)rightPanel, - right.ColumnLength, right.RowLength, k, - j); - NativeIntrinsic.Intrinsic - .f32_panel_fma((MatrixPanel*)leftPanel, - (MatrixPanel*)rightPanel, - (MatrixPanel*)ansPanel); - } - NativeIntrinsic.Intrinsic - .f32_store_panel((MatrixKernel*)ans.Buffer, - (MatrixPanel*)ansPanel, ans.ColumnLength, - ans.RowLength, i, j); - } - } - MatrixPanel.Destroy(leftPanel); - MatrixPanel.Destroy(rightPanel); - MatrixPanel.Destroy(ansPanel); - if (count > 256) { - MatrixParallel.ReturnParallelResources(ref pool!); - } - return; - } - MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask(); - package->Right = (nint)left.Buffer; - package->Result = (nint)ans.Buffer; - package->ElementSize = sizeof(float); - package->PrimCount = left.KernelColumnLength; - package->SecCount = left.KernelRowLength; - package->ComputeMode = new MatrixOpMode(MatrixOperationStyle.BUFFER_OP, MatrixOperationParam.RIGHT_ANS_SCALAR_PARAM); - package->ComputeHandle = (IntPtr)NativeIntrinsic.Intrinsic.f32_buffer_scalar_mul; - MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package); - - MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep); - taskGroup.Dispose(); - return; - } - - public static unsafe void Mul(Matrix left, float right, Matrix ans) - { - if (left.ColumnLength != ans.ColumnLength || left.RowLength != ans.RowLength) { - throw new IndexOutOfRangeException("Matrix dimensions must agree."); - } - long count = (long)left.KernelColumnLength * left.KernelRowLength; - ScalarPacket* scalar = MatrixParallelFactory.CreateScalarPacket(); - scalar->Data(0) = right; - if (count <= 256) - { - MatrixKernel* leftPtr = left.Buffer; - MatrixKernel* ansPtr = ans.Buffer; - NativeIntrinsic.Intrinsic.f32_buffer_scalar_mul(leftPtr, ansPtr, scalar, count); - - return; - } else if (count <= 1024) - { - MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1); - - MatrixKernel* leftPtr = left.Buffer; - MatrixKernel* ansPtr = ans.Buffer; - NativeIntrinsic.Intrinsic.f32_buffer_scalar_mul(leftPtr, ansPtr, scalar, count); - - MatrixParallel.ReturnParallelResources(ref pool); - return; - } - MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask(); - package->Right = (nint)left.Buffer; - package->Result = (nint)ans.Buffer; - package->ElementSize = sizeof(float); - package->PrimCount = left.KernelColumnLength; - package->SecCount = left.KernelRowLength; - package->Scalar = scalar; - package->ComputeMode = new MatrixOpMode(MatrixOperationStyle.BUFFER_OP, MatrixOperationSpecial.SEQ_FMA); - package->ComputeHandle = (IntPtr)NativeIntrinsic.Intrinsic.f32_buffer_scalar_mul; - MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package); - - MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep); - taskGroup.Dispose(); - MatrixParallelFactory.Release(scalar); - return; - } - - public static unsafe void Sub(Matrix left, Matrix right, Matrix ans) - { - if (left.ColumnLength != right.ColumnLength || - left.RowLength != right.RowLength || - left.ColumnLength != ans.ColumnLength || - left.RowLength != ans.RowLength) { - throw new IndexOutOfRangeException("Matrix dimensions must agree."); - } - long count = (long)left.KernelColumnLength * left.KernelRowLength; - if (count <= 256) - { - MatrixKernel* leftPtr = left.Buffer; - MatrixKernel* rightPtr = right.Buffer; - MatrixKernel* ansPtr = ans.Buffer; - NativeIntrinsic.Intrinsic.f32_buffer_sub(leftPtr, rightPtr, ansPtr, count); - - return; - } else if (count <= 1024) - { - MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1); - - MatrixKernel* leftPtr = left.Buffer; - MatrixKernel* rightPtr = right.Buffer; - MatrixKernel* ansPtr = ans.Buffer; - NativeIntrinsic.Intrinsic.f32_buffer_sub(leftPtr, rightPtr, ansPtr, count); - - MatrixParallel.ReturnParallelResources(ref pool); - return; - } - MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask(); - package->Left = (nint)left.Buffer; - package->Right = (nint)right.Buffer; - package->Result = (nint)ans.Buffer; - package->ElementSize = sizeof(float); - package->PrimCount = left.KernelColumnLength; - package->SecCount = left.KernelRowLength; - package->ComputeMode = new MatrixOpMode(MatrixOperationStyle.BUFFER_OP, MatrixOperationParam.LEFT_RIGHT_ANS_PARAM); - package->ComputeHandle = (IntPtr)NativeIntrinsic.Intrinsic.f32_buffer_sub; - MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package); - - MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep); - taskGroup.Dispose(); - return; - } - - } -} diff --git a/StgSharp.Mathematics/Numeric/MatrixCompute.cs b/StgSharp.Mathematics/Numeric/MatrixCompute.cs index 829d6fc1..587df5c4 100644 --- a/StgSharp.Mathematics/Numeric/MatrixCompute.cs +++ b/StgSharp.Mathematics/Numeric/MatrixCompute.cs @@ -25,13 +25,263 @@ // // ----------------------------------------------------------------------- // ----------------------------------------------------------------------- +using StgSharp.Collections; +using StgSharp.HighPerformance; +using StgSharp.Internal; using System; using System.Collections.Generic; +using System.ComponentModel.DataAnnotations.Schema; using System.Linq; +using System.Numerics; +using System.Security.AccessControl; using System.Text; using System.Threading.Tasks; namespace StgSharp.Mathematics.Numeric { - public static partial class MatrixCompute { } + public static partial class MatrixCompute + { + + public static unsafe void Add(Matrix left, Matrix right, Matrix ans) + { + if (left.ColumnLength != right.ColumnLength || + left.RowLength != right.RowLength || + left.ColumnLength != ans.ColumnLength || + left.RowLength != ans.RowLength) { + throw new IndexOutOfRangeException("Matrix dimensions must agree."); + } + long count = (long)left.KernelColumnLength * left.KernelRowLength; + if (count <= 256) + { + MatrixKernel* leftPtr = left.Buffer; + MatrixKernel* rightPtr = right.Buffer; + MatrixKernel* ansPtr = ans.Buffer; + NativeIntrinsic.Intrinsic.f32_buffer_add(leftPtr, rightPtr, ansPtr, count); + + return; + } else if (count <= 1024) + { + MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1); + + MatrixKernel* leftPtr = left.Buffer; + MatrixKernel* rightPtr = right.Buffer; + MatrixKernel* ansPtr = ans.Buffer; + NativeIntrinsic.Intrinsic.f32_buffer_add(leftPtr, rightPtr, ansPtr, count); + + MatrixParallel.ReturnParallelResources(ref pool); + return; + } + MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask(); + package->Left = (nint)left.Buffer; + package->Right = (nint)right.Buffer; + package->Answer = (nint)ans.Buffer; + package->ElementSize = sizeof(float); + package->PrimCount = ans.KernelColumnLength; + package->SecCount = ans.KernelRowLength; + package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.LEFT_RIGHT_ANS_PARAM); + package->ComputeHandle = (IntPtr)NativeIntrinsic.Intrinsic.f32_buffer_add; + MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package); + + MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep); + taskGroup.Dispose(); + return; + } + + public static unsafe void Fill(Matrix ans, float value) + { + long count = (long)ans.KernelColumnLength * ans.KernelRowLength; + ScalarPacket* scalar = MatrixParallelFactory.CreateScalarPacket(); + scalar->Data(0) = value; + if (count <= 256) + { + NativeIntrinsic.Intrinsic.f32_buffer_fill(ans.Buffer, scalar, count); + return; + } else if (count <= 1024) + { + MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1); + NativeIntrinsic.Intrinsic.f32_buffer_fill(ans.Buffer, scalar, count); + MatrixParallel.ReturnParallelResources(ref pool); + return; + } + MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask(); + package->Answer = (nint)ans.Buffer; + package->ElementSize = sizeof(float); + package->PrimCount = ans.KernelColumnLength; + package->SecCount = ans.KernelRowLength; + package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.ANS_SCALAR_PARAM); + package->ComputeHandle = (IntPtr)NativeIntrinsic.Intrinsic.f32_buffer_fill; + package->Scalar = scalar; + MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package); + MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep); + MatrixParallelFactory.Release(scalar); + taskGroup.Dispose(); + } + + public static unsafe void Mul(Matrix left, Matrix right, Matrix ans) + { + // For matrix multiplication (left: MxK) * (right: KxN) => ans: MxN + // ColumnLength = number of columns (N), RowLength = number of rows (M) + if (left.ColumnLength != right.RowLength || + ans.ColumnLength != right.ColumnLength || + ans.RowLength != left.RowLength) + { + throw new IndexOutOfRangeException("Matrix dimensions must agree."); + } + long count = (long)left.KernelColumnLength * left.KernelRowLength; + int size = MatrixPanel.KernelSideCount(); + if (count <= 1024) + { + MatrixParallelThread[] pool = null; + if (count > 256) { + pool = MatrixParallel.LeadParallel(1); + } + MatrixPanel* leftPanel = MatrixPanel.Create(); + MatrixPanel* rightPanel = MatrixPanel.Create(); + MatrixPanel* ansPanel = MatrixPanel.Create(); + for (int i = 0; i < ans.KernelRowLength; i += size) + { + for (int j = 0; j < ans.KernelColumnLength; j += size) + { + NativeIntrinsic.Intrinsic.f32_clear_panel((MatrixPanel*)ansPanel); + + // Console.WriteLine($"{i}{j}"); + for (int k = 0; k < left.KernelColumnLength; k += size) + { + NativeIntrinsic.Intrinsic + .f32_build_panel((MatrixPanel*)leftPanel, + (MatrixKernel*)left.Buffer, + left.KernelColumnLength, + left.KernelRowLength, i, k); + NativeIntrinsic.Intrinsic + .f32_build_panel((MatrixPanel*)rightPanel, + (MatrixKernel*)right.Buffer, + right.KernelColumnLength, + right.KernelRowLength, k, j); + NativeIntrinsic.Intrinsic + .f32_panel_fma((MatrixPanel*)leftPanel, + (MatrixPanel*)rightPanel, + (MatrixPanel*)ansPanel); + } + NativeIntrinsic.Intrinsic + .f32_store_panel((MatrixPanel*)ansPanel, + (MatrixKernel*)ans.Buffer, + ans.KernelColumnLength, ans.KernelRowLength, + i, j); + } + } + MatrixPanel.Destroy(leftPanel); + MatrixPanel.Destroy(rightPanel); + MatrixPanel.Destroy(ansPanel); + if (count > 256) { + MatrixParallel.ReturnParallelResources(ref pool!); + } + return; + } + MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask(); + package->Left = (nint)left.Buffer; + package->Right = (nint)right.Buffer; + package->Answer = (nint)ans.Buffer; + package->AnsPrimOffset = ans.KernelRowLength; + package->AnsSecOffset = ans.KernelColumnLength; + package->LeftPrimOffset = left.KernelColumnLength; + package->PrimCount = ans.KernelColumnLength / size; + package->SecCount = ans.KernelRowLength / size; + package->ElementSize = size; + package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationSpecial.SEQ_FMA); + MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package); + + MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep); + taskGroup.Dispose(); + return; + } + + public static unsafe void Mul(Matrix left, float right, Matrix ans) + { + if (left.ColumnLength != ans.ColumnLength || left.RowLength != ans.RowLength) { + throw new IndexOutOfRangeException("Matrix dimensions must agree."); + } + long count = (long)left.KernelColumnLength * left.KernelRowLength; + ScalarPacket* scalar = MatrixParallelFactory.CreateScalarPacket(); + scalar->Data(0) = right; + if (count <= 256) + { + MatrixKernel* leftPtr = left.Buffer; + MatrixKernel* ansPtr = ans.Buffer; + NativeIntrinsic.Intrinsic.f32_buffer_scalar_mul(leftPtr, ansPtr, scalar, count); + + return; + } else if (count <= 1024) + { + MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1); + + MatrixKernel* leftPtr = left.Buffer; + MatrixKernel* ansPtr = ans.Buffer; + NativeIntrinsic.Intrinsic.f32_buffer_scalar_mul(leftPtr, ansPtr, scalar, count); + + MatrixParallel.ReturnParallelResources(ref pool); + return; + } + MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask(); + package->Right = (nint)left.Buffer; + package->Answer = (nint)ans.Buffer; + package->ElementSize = sizeof(float); + package->PrimCount = left.KernelColumnLength; + package->SecCount = left.KernelRowLength; + package->Scalar = scalar; + package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.RIGHT_ANS_SCALAR_PARAM); + package->ComputeHandle = (IntPtr)NativeIntrinsic.Intrinsic.f32_buffer_scalar_mul; + MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package); + + MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep); + taskGroup.Dispose(); + MatrixParallelFactory.Release(scalar); + return; + } + + public static unsafe void Sub(Matrix left, Matrix right, Matrix ans) + { + if (left.ColumnLength != right.ColumnLength || + left.RowLength != right.RowLength || + left.ColumnLength != ans.ColumnLength || + left.RowLength != ans.RowLength) { + throw new IndexOutOfRangeException("Matrix dimensions must agree."); + } + long count = (long)left.KernelColumnLength * left.KernelRowLength; + if (count <= 256) + { + MatrixKernel* leftPtr = left.Buffer; + MatrixKernel* rightPtr = right.Buffer; + MatrixKernel* ansPtr = ans.Buffer; + NativeIntrinsic.Intrinsic.f32_buffer_sub(leftPtr, rightPtr, ansPtr, count); + + return; + } else if (count <= 1024) + { + MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1); + + MatrixKernel* leftPtr = left.Buffer; + MatrixKernel* rightPtr = right.Buffer; + MatrixKernel* ansPtr = ans.Buffer; + NativeIntrinsic.Intrinsic.f32_buffer_sub(leftPtr, rightPtr, ansPtr, count); + + MatrixParallel.ReturnParallelResources(ref pool); + return; + } + MatrixParallelTaskPackage* package = MatrixParallelFactory.CreateBaseTask(); + package->Left = (nint)left.Buffer; + package->Right = (nint)right.Buffer; + package->Answer = (nint)ans.Buffer; + package->ElementSize = sizeof(float); + package->PrimCount = left.KernelColumnLength; + package->SecCount = left.KernelRowLength; + package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.LEFT_RIGHT_ANS_PARAM); + package->ComputeHandle = (IntPtr)NativeIntrinsic.Intrinsic.f32_buffer_sub; + MatrixParallelHandle taskGroup = MatrixParallel.ScheduleTask(package); + + MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep); + taskGroup.Dispose(); + return; + } + + } } diff --git a/StgSharp.Mathematics/Numeric/MatrixComputeModel.cs b/StgSharp.Mathematics/Numeric/MatrixComputeModel.cs index 7878055f..ef479c26 100644 --- a/StgSharp.Mathematics/Numeric/MatrixComputeModel.cs +++ b/StgSharp.Mathematics/Numeric/MatrixComputeModel.cs @@ -34,7 +34,7 @@ namespace StgSharp.Mathematics.Numeric internal static class MatrixComputeModel { - internal static unsafe void KernelComputeBinary(MatrixParallelTaskPackage* p) + internal static unsafe void BufferComputeBinary(MatrixParallelTaskPackage* p) { int size = p->ElementSize * 16; long count = Unsafe.As(ref p->PrimCount); @@ -42,12 +42,12 @@ namespace StgSharp.Mathematics.Numeric ((delegate* unmanaged[Cdecl])p->ComputeHandle)((void*)(p->Left + offset), (void*)(p->Right + offset), - (void*)(p->Result + offset), + (void*)(p->Answer + offset), count); MatrixParallelFactory.Release(p); } - internal static unsafe void KernelComputeBinaryScalar(MatrixParallelTaskPackage* p) + internal static unsafe void BufferComputeBinaryScalar(MatrixParallelTaskPackage* p) { int size = p->ElementSize * 16; long count = Unsafe.As(ref p->PrimCount); @@ -55,57 +55,55 @@ namespace StgSharp.Mathematics.Numeric ScalarPacket* scalar = p->Scalar; ((delegate* unmanaged[Cdecl])p->ComputeHandle)((void*)(p->Left + offset), (void*)(p->Right + offset), - (void*)(p->Result + offset), + (void*)(p->Answer + offset), scalar, count); MatrixParallelFactory.Release(p); } - internal static unsafe void KernelComputeNoOperatorScalar(MatrixParallelTaskPackage* p) + internal static unsafe void BufferComputeNoOperatorScalar(MatrixParallelTaskPackage* p) { int size = p->ElementSize * 16; long count = Unsafe.As(ref p->PrimCount); long offset = Unsafe.As(ref p->PrimTileOffset) * size; - ((delegate* unmanaged[Cdecl])p->ComputeHandle)((void*)(p->Result + offset), + ((delegate* unmanaged[Cdecl])p->ComputeHandle)((void*)(p->Answer + offset), p->Scalar, count); MatrixParallelFactory.Release(p); } - internal static unsafe void KernelComputeUnary(MatrixParallelTaskPackage* p) + internal static unsafe void BufferComputeUnary(MatrixParallelTaskPackage* p) { int size = p->ElementSize * 16; long count = Unsafe.As(ref p->PrimCount); long offset = Unsafe.As(ref p->PrimTileOffset) * size; ((delegate* unmanaged[Cdecl])p->ComputeHandle)((void*)(p->Right + offset), - (void*)(p->Result + offset), + (void*)(p->Answer + offset), count); MatrixParallelFactory.Release(p); } - internal static unsafe void KernelComputeUnaryScalar(MatrixParallelTaskPackage* p) + internal static unsafe void BufferComputeUnaryScalar(MatrixParallelTaskPackage* p) { int size = p->ElementSize * 16; long count = Unsafe.As(ref p->PrimCount); long offset = Unsafe.As(ref p->PrimTileOffset) * size; ((delegate* unmanaged[Cdecl]< void*, void*, ScalarPacket*, long, void>)p->ComputeHandle)((void*)(p->Right + offset), - (void*)(p->Result + offset), + (void*)(p->Answer + offset), p->Scalar, count); MatrixParallelFactory.Release(p); } - internal static unsafe void PanelComputeBinary(MatrixParallelTaskPackage* p) { } - - internal static unsafe void SpecialCompute(MatrixParallelTaskPackage* p) + internal static unsafe void SpecialBufferCompute(MatrixParallelTaskPackage* p) { - switch ((MatrixOperationSpecial)p->ComputeMode.OperationStyle) + switch ((MatrixOperationSpecial)p->ComputeMode.ParameterStyle) { case MatrixOperationSpecial.SEQ_FMA: MatrixCompute.ComputeFmaPanelF32(p); break; default: - throw new NotSupportedException("The special matrix operation style is not supported."); + break; } } diff --git a/StgSharp.Mathematics/Numeric/MatrixParallel.Publish.cs b/StgSharp.Mathematics/Numeric/MatrixParallel.Publish.cs index de3f2b3d..a082d737 100644 --- a/StgSharp.Mathematics/Numeric/MatrixParallel.Publish.cs +++ b/StgSharp.Mathematics/Numeric/MatrixParallel.Publish.cs @@ -51,7 +51,7 @@ namespace StgSharp.Mathematics.Numeric MatrixParallelTaskPackage* nonGeneric = package; switch (nonGeneric->ComputeMode.OperationStyle) { - case MatrixOperationStyle.BUFFER_INDEX: + case MatrixIndexStyle.BUFFER_INDEX: return ScheduleBufferTask(nonGeneric); default: throw new InvalidOperationException($"Unknown mode {nonGeneric->ComputeMode.OperationStyle}."); @@ -110,80 +110,5 @@ namespace StgSharp.Mathematics.Numeric return handle; } - private static unsafe MatrixParallelHandle ScheduleKernelTask( - MatrixParallelTaskPackage* package) - { - int primCount = package->PrimCount; - int secCount = package->SecCount; - int tileWidth = (1024 / secCount) + 1; - int tileCount = (primCount + tileWidth - 1) / tileWidth; - - MatrixParallelThread[] pool = LeadParallel(tileCount); - /* - if (pool.Length == 0) - { - // no need - // LeadParallel has contained capacity check - } - /**/ - MatrixParallelHandle handle = new MatrixParallelHandle(pool); - if (handle.Wraps.Length == 1) - { - handle.Wraps[0].WrapTask.Enqueue((nint)package); - return handle; - } - int threadCount = pool.Length; - int tilePerThreadLess = tileCount / threadCount; // tiles per thread without extra slice - int columnAfterBaseTile = tileCount % threadCount * tileWidth; // tile sliced into columns - int extraColumnPerThread = columnAfterBaseTile / threadCount; - int extraColumnCount = columnAfterBaseTile % threadCount; // columns to be sliced - - int total = primCount; - MatrixParallelTaskPackage* current = package; - foreach (MatrixParallelWrap wrap in handle.Wraps) - { - bool hasSlice = columnAfterBaseTile > 0; - bool isLargeSlice = extraColumnCount > 0; - - // _count tiles for wrap - int wrapWidth = wrap!.WrapTaskCapacity/**/; - int columnFromSlicingCount = (hasSlice ? extraColumnPerThread : 0) * wrapWidth; - int baseColumn = wrapWidth * tilePerThreadLess * tileWidth; - int columnInWrap = baseColumn + columnFromSlicingCount + (isLargeSlice ? 1 : 0); - - // set tasks - if (columnInWrap == 0) - { -#if DEBUG - throw new InvalidOperationException("Zero tasks published."); -#else - break; -#endif - } - - // update current task - current->PrimColumnCountInTile = columnInWrap; - current->SecColumnCountInTile = current->SecCount; - current->SecTileOffset = 0; - - // remove tiles _count - extraColumnCount--; - columnAfterBaseTile -= columnFromSlicingCount; - total -= columnInWrap; - - // set to wrap and push - wrap.WrapTask.Enqueue((nint)current); - - if (total <= 0) - { - break; - } - current = MatrixParallelFactory.FromExistPackage(current); - current->PrimTileOffset += columnInWrap; - } - - return handle; - } - } } diff --git a/StgSharp.Mathematics/Numeric/MatrixParallel.cs b/StgSharp.Mathematics/Numeric/MatrixParallel.cs index b2619463..10a3efbe 100644 --- a/StgSharp.Mathematics/Numeric/MatrixParallel.cs +++ b/StgSharp.Mathematics/Numeric/MatrixParallel.cs @@ -34,7 +34,7 @@ using System.Threading.Tasks; namespace StgSharp.Mathematics.Numeric { - public static class MatrixParallel + public static partial class MatrixParallel { private static bool _meaningful; diff --git a/StgSharp.Mathematics/Numeric/MatrixParallelTaskPackage.cs b/StgSharp.Mathematics/Numeric/MatrixParallelTaskPackage.cs index 71a9eb32..4db2273f 100644 --- a/StgSharp.Mathematics/Numeric/MatrixParallelTaskPackage.cs +++ b/StgSharp.Mathematics/Numeric/MatrixParallelTaskPackage.cs @@ -59,7 +59,7 @@ namespace StgSharp.Mathematics.Numeric } - public enum MatrixOperationStyle : short + public enum MatrixIndexStyle : short { BUFFER_INDEX = 1, @@ -78,13 +78,14 @@ namespace StgSharp.Mathematics.Numeric } [StructLayout(LayoutKind.Sequential)] - public struct MatrixOpMode(MatrixOperationStyle style, MatrixOperationParam paramLayout) + public struct MatrixOpMode(MatrixIndexStyle style, MatrixOperationParam paramLayout) { - public MatrixOperationParam ParameterStyle = paramLayout; - public MatrixOperationStyle OperationStyle = style; + public MatrixIndexStyle OperationStyle = style; - public MatrixOpMode(MatrixOperationStyle style, MatrixOperationSpecial paramLayout) + public MatrixOperationParam ParameterStyle = paramLayout; + + public MatrixOpMode(MatrixIndexStyle style, MatrixOperationSpecial paramLayout) : this(style, (MatrixOperationParam)paramLayout) { } } @@ -113,7 +114,7 @@ namespace StgSharp.Mathematics.Numeric #region ans // Group 2: Result kernel base address + reserved - [FieldOffset(16)] public IntPtr Result; // 8 + [FieldOffset(16)] public IntPtr Answer; // 8 [FieldOffset(24)] public int ElementSize; [FieldOffset(28)] public int ReservedPtr0; // 4 (extension/reserved) @@ -139,10 +140,10 @@ namespace StgSharp.Mathematics.Numeric #region ans enum - [FieldOffset(64)]public int ResultPrimOffset; // 4 - [FieldOffset(68)]public int ResultPrimStride; // 4 - [FieldOffset(72)]public int ResultSecOffset; // 4 - [FieldOffset(76)] public int ResultSecStride; // 4 + [FieldOffset(64)]public int AnsPrimOffset; // 4 + [FieldOffset(68)]public int AnsPrimStride; // 4 + [FieldOffset(72)]public int AnsSecOffset; // 4 + [FieldOffset(76)] public int AnsSecStride; // 4 #endregion diff --git a/StgSharp.Mathematics/Numeric/MatrixParallelThread.cs b/StgSharp.Mathematics/Numeric/MatrixParallelThread.cs index d16e3422..64e01834 100644 --- a/StgSharp.Mathematics/Numeric/MatrixParallelThread.cs +++ b/StgSharp.Mathematics/Numeric/MatrixParallelThread.cs @@ -85,49 +85,28 @@ namespace StgSharp.Mathematics.Numeric while (taskQueue.TryDequeue(out nint handle)) { MatrixParallelTaskPackage* p = (MatrixParallelTaskPackage*)handle; - if ((int)p->ComputeMode.ParameterStyle < 0) { - MatrixComputeModel.SpecialCompute(p); + if ((short)p->ComputeMode.ParameterStyle < 0) { + MatrixComputeModel.SpecialBufferCompute(p); } switch (p->ComputeMode.OperationStyle) { - case MatrixOperationStyle.PANEL_OP: + case MatrixIndexStyle.BUFFER_INDEX: switch (p->ComputeMode.ParameterStyle) { case MatrixOperationParam.RIGHT_ANS_PARAM: - - // MatrixComputeModel.PanelComputeUnary(p); + MatrixComputeModel.BufferComputeUnary(p); break; case MatrixOperationParam.LEFT_RIGHT_ANS_PARAM: - MatrixComputeModel.PanelComputeBinary(p); + MatrixComputeModel.BufferComputeBinary(p); break; case MatrixOperationParam.RIGHT_ANS_SCALAR_PARAM: - - // MatrixComputeModel.PanelComputeUnaryScalar(p); + MatrixComputeModel.BufferComputeUnaryScalar(p); break; case MatrixOperationParam.LEFT_RIGHT_ANS_SCALAR_PARAM: + MatrixComputeModel.BufferComputeBinaryScalar(p); break; case MatrixOperationParam.ANS_SCALAR_PARAM: - - // MatrixComputeModel.PanelComputeNoOperatorScalar(p); - break; - default: - break; - } - break; - case MatrixOperationStyle.KERNEL_OP: - switch (p->ComputeMode.ParameterStyle) - { - case MatrixOperationParam.RIGHT_ANS_PARAM: - MatrixComputeModel.KernelComputeUnary(p); - break; - case MatrixOperationParam.RIGHT_ANS_SCALAR_PARAM: - MatrixComputeModel.KernelComputeUnaryScalar(p); - break; - case MatrixOperationParam.LEFT_RIGHT_ANS_PARAM: - MatrixComputeModel.KernelComputeBinary(p); - break; - case MatrixOperationParam.LEFT_RIGHT_ANS_SCALAR_PARAM: - MatrixComputeModel.KernelComputeBinaryScalar(p); + MatrixComputeModel.BufferComputeNoOperatorScalar(p); break; default: break; diff --git a/StgSharp.Native/sn-head/sn_matkernel.h b/StgSharp.Native/sn-head/sn_matkernel.h index c322f983..52b58d11 100644 --- a/StgSharp.Native/sn-head/sn_matkernel.h +++ b/StgSharp.Native/sn-head/sn_matkernel.h @@ -110,9 +110,9 @@ extern __declspec(align(64)) sn_zero_kernel_u64 SN_ZERO_KERNEL; MAT_KERNEL(element) const *const matrix, int col_length, int row_length, \ int col_index, int row_index) #define DECLARE_STORE_PANEL(arch, element) \ - INTERNAL void SN_DECL STORE_PANEL(arch, element)(MAT_KERNEL(element) *restrict matrix, \ - MAT_PANEL_##arch(element) \ + INTERNAL void SN_DECL STORE_PANEL(arch, element)(MAT_PANEL_##arch(element) \ const *const panel, \ + MAT_KERNEL(element) *restrict matrix, \ int col_length, int row_length, \ int col_index, int row_index) diff --git a/StgSharp.Native/sn-src/k_basicop.c b/StgSharp.Native/sn-src/k_basicop.c index 32b29092..07d2ef06 100644 --- a/StgSharp.Native/sn-src/k_basicop.c +++ b/StgSharp.Native/sn-src/k_basicop.c @@ -12,19 +12,17 @@ DECLARE_PNL_PROC_ANS(float, sse, clear) DECLARE_PNL_PROC_ANS(float, avx, clear) { register __m256 zero = _mm256_setzero_ps(); - PANEL_COL_VEC((*ans), 0, 0) = zero; - PANEL_COL_VEC((*ans), 1, 0) = zero; - PANEL_COL_VEC((*ans), 2, 0) = zero; - PANEL_COL_VEC((*ans), 3, 0) = zero; + for (size_t i = 0; i < 8; i++) { + PANEL_COL_VEC((*ans), i, 0) = zero; + } } DECLARE_PNL_PROC_ANS(float, 512, clear) { register __m512 zero = _mm512_setzero_ps(); - PANEL_COL_VEC((*ans), 0, 0) = zero; - PANEL_COL_VEC((*ans), 1, 0) = zero; - PANEL_COL_VEC((*ans), 2, 0) = zero; - PANEL_COL_VEC((*ans), 3, 0) = zero; + for (size_t i = 0; i < 16; i++) { + PANEL_COL_VEC((*ans), i, 0) = zero; + } } // Matrix transpose implementations diff --git a/StgSharp.Native/sn-src/k_panel.c b/StgSharp.Native/sn-src/k_panel.c index 4d3c8bb6..916a6f23 100644 --- a/StgSharp.Native/sn-src/k_panel.c +++ b/StgSharp.Native/sn-src/k_panel.c @@ -8,16 +8,16 @@ DECLARE_BUILD_PANEL(avx, float) const int has_right = (col_index + 1) < col_length; const int has_bottom = (row_index + 1) < row_length; - const MAT_KERNEL(float) *const k_lt = matrix + (col_index * row_length + row_index); + const MAT_KERNEL(float) *const k_lt = matrix + (row_index * col_length + col_index); const MAT_KERNEL(float) *const k_rt = - has_right ? (matrix + ((col_index + 1) * row_length + row_index)) : + has_right ? (matrix + (row_index * col_length + (col_index + 1))) : (const MAT_KERNEL(float) *)&SN_ZERO_KERNEL; const MAT_KERNEL(float) *const k_lb = - has_bottom ? (matrix + (col_index * row_length + (row_index + 1))) : + has_bottom ? (matrix + ((row_index + 1) * col_length + col_index)) : (const MAT_KERNEL(float) *)&SN_ZERO_KERNEL; const MAT_KERNEL(float) *const k_rb = (has_right && has_bottom) ? - (matrix + ((col_index + 1) * row_length + (row_index + 1))) : + (matrix + ((row_index + 1) * col_length + (col_index + 1))) : (const MAT_KERNEL(float) *)&SN_ZERO_KERNEL; register __m128 top128, bot128; @@ -44,7 +44,7 @@ DECLARE_BUILD_PANEL(avx, float) DECLARE_BUILD_PANEL(sse, float) { /* Single kernel -> 4 columns, each is one __m128 column vector. */ - const MAT_KERNEL(float) *src = matrix + (col_index * row_length + row_index); + const MAT_KERNEL(float) *src = matrix + (row_index * col_length + col_index); for (int pc = 0; pc < 4; ++pc) { PANEL_COL_VEC((*panel), pc, 0) = src->xmm[pc]; @@ -61,7 +61,7 @@ DECLARE_BUILD_PANEL(512, float) const int col = col_index + kc; const int row = row_index + kr; k[kc][kr] = (col < col_length && row < row_length) ? - (matrix + (col * row_length + row)) : + (matrix + (row * col_length + col)) : zero; } } @@ -97,19 +97,19 @@ DECLARE_STORE_PANEL(avx, float) const int has_bottom = (row_index + 1) < row_length; MAT_KERNEL(float) *const k_lt = (col_index < col_length && row_index < row_length) ? - (matrix + (col_index * row_length + row_index)) : + (matrix + (row_index * col_length + col_index)) : &zero; MAT_KERNEL(float) *const k_rt = has_right && (row_index < row_length) ? - (matrix + ((col_index + 1) * row_length + row_index)) : + (matrix + (row_index * col_length + (col_index + 1))) : &zero; MAT_KERNEL(float) *const k_lb = has_bottom && (col_index < col_length) ? - (matrix + (col_index * row_length + (row_index + 1))) : + (matrix + ((row_index + 1) * col_length + col_index)) : &zero; MAT_KERNEL(float) *const k_rb = (has_right && has_bottom) ? - (matrix + ((col_index + 1) * row_length + (row_index + 1))) : + (matrix + ((row_index + 1) * col_length + (col_index + 1))) : &zero; register __m128 top128, bot128; @@ -144,7 +144,7 @@ DECLARE_STORE_PANEL(avx, float) DECLARE_STORE_PANEL(sse, float) { - MAT_KERNEL(float) *dst = matrix + (col_index * row_length + row_index); + MAT_KERNEL(float) *dst = matrix + (row_index * col_length + col_index); for (int pc = 0; pc < 4; ++pc) { const __m128 col = PANEL_COL_VEC((*panel), pc, 0); @@ -162,7 +162,7 @@ DECLARE_STORE_PANEL(512, float) const int col = col_index + kc; const int row = row_index + kr; k[kc][kr] = (col < col_length && row < row_length) ? - (matrix + (col * row_length + row)) : + (matrix + (row * col_length + col)) : &zero; } } diff --git a/StgSharp.Native/sn-src/load_intrinsic.c b/StgSharp.Native/sn-src/load_intrinsic.c index 97ff5062..22b93f11 100644 --- a/StgSharp.Native/sn-src/load_intrinsic.c +++ b/StgSharp.Native/sn-src/load_intrinsic.c @@ -65,6 +65,7 @@ void load_intrinsic_sse(sn_intrinsic *context) context->city_hash_simplify = city_hash_simplify_sse; context->factorial_simd = factorial_simd_sse; context->index_pair = index_pair_sse; + context->f32_store_panel = STORE_PANEL(sse, float); context->f32_clear_panel = PNL_PROC(float, sse, clear); context->f32_build_panel = BUILD_PANEL(sse, float); context->f32_buffer_add = BUF_PROC(float, sse, add); @@ -82,6 +83,7 @@ void load_intrinsic_avx(sn_intrinsic *context) context->city_hash_simplify = city_hash_simplify_sse; context->factorial_simd = factorial_simd_sse; context->index_pair = index_pair_sse; + context->f32_store_panel = STORE_PANEL(avx, float); context->f32_clear_panel = PNL_PROC(float, avx, clear); context->f32_build_panel = BUILD_PANEL(avx, float); context->f32_buffer_add = BUF_PROC(float, avx, add); @@ -99,7 +101,8 @@ void load_intrinsic_512(sn_intrinsic *context) context->city_hash_simplify = city_hash_simplify_sse; context->factorial_simd = factorial_simd_sse; context->index_pair = index_pair_sse; - context->f32_clear_panel = PNL_PROC(float, sse, clear); + context->f32_store_panel = STORE_PANEL(512, float); + context->f32_clear_panel = PNL_PROC(float, 512, clear); context->f32_build_panel = BUILD_PANEL(512, float); context->f32_buffer_add = BUF_PROC(float, 512, add); context->f32_panel_fma = PNL_PROC(float, 512, fma); diff --git a/StgSharpDebug/Program.cs b/StgSharpDebug/Program.cs index 66b23bbb..11299973 100644 --- a/StgSharpDebug/Program.cs +++ b/StgSharpDebug/Program.cs @@ -1,4 +1,4 @@ -//----------------------------------------------------------------------- +//----------------------------------------------------------------------- // ----------------------------------------------------------------------- // file="Program" // Project: StgSharp @@ -53,71 +53,44 @@ namespace StgSharp // HlsfStressTest.Run(); - /* + /**/ HybridLayerSegregatedFitAllocator hlsf; unchecked { hlsf = new((nuint)(64 * (ulong)10000 * 10000)); } - Matrix m = Matrix.FromHlsf(1000, 1000, hlsf); + Matrix m = Matrix.FromHlsf(400, 400, hlsf); MatrixCompute.Fill(m, 1.0f); + Matrix n = Matrix.FromHlsf(400, 400, hlsf); + MatrixCompute.Fill(n, 1.0f); + Matrix p = Matrix.FromHlsf(400, 400, hlsf); - Console.WriteLine(); - Console.WriteLine(); - Console.WriteLine(); - Matrix n = Matrix.FromHlsf(1000, 1000, hlsf); - MatrixCompute.Fill(n, 0.0f); - for (int i = 0; i < 5; i++) + // MatrixCompute.Fill(p, 0.0f); + /* + for (int i = 0; i < 10; i++) { - for (int j = 0; j < 2; j++) + MatrixCompute.Add(n, m, n); + for (int j = 0; j < 5; j++) { - MatrixCompute.Add(n, m, n); - - // Console.WriteLine($"{i} {j}"); + for (int k = 0; k < 5; k++) { + Console.Write($"{n[j, k]:0.0E+00} \t"); + } + Console.WriteLine(); } + Console.WriteLine($"{i}"); GC.Collect(); } - - MatrixCompute.Mul(n, 12, n); + /**/ + MatrixCompute.Mul(n, m, p); for (int i = 0; i < 20; i++) { for (int j = 0; j < 20; j++) { - Console.Write($"{n[i, j]:0.0E+00} \t"); + Console.Write($"{p[i, j]:0.0E+00} \t"); } Console.WriteLine(); } /**/ // --- Logarithmic time sequence test: print seconds at each emitted span --- - - // Configure a simple sequence: - // initial slice = 0.5s, total = 5s, growth multiplier = 2, min slice = 0.75s - TimeSequence seq = - /**/ - TimeSequence.CreateLogarithmic(initialSliceSeconds:0.5, totalSeconds:5.0, - growthMultiplier:2.0, minSliceSeconds:0.75); - /* - TimeSequence.CreateLinear(5, 1); - /**/ - - // Bind to default time source provider. - TimeSpanProvider provider = new TimeSpanProvider(seq, TimeSpanProvider.DefaultProvider); - - // Print the second mark when a span is emitted. - provider.TimeSpanRefreshed += (s, e) => { - // CurrentSecond is PreviousFrameTick / Frequency - Console.WriteLine($"span @ {provider.CurrentSecond:0.000}s"); - }; - - // Start the time source and wait until sequence ends. - TimeSpanProvider.DefaultProvider.StartProvidingTime(); - - while (!provider.IsEnded) { - provider.WaitNextSpan(); - } - - TimeSpanProvider.DefaultProvider.StopProvidingTime(); - - // end of log-time sequence test } catch (Exception ex) {