youmuliu/stgsharp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

stuck on task pack design

Browse Source
This commit is contained in:
Youmu Liu
2025-09-05 21:35:24 +08:00
parent c9442d2b4f
commit bfe3ada4fc
3 changed files with 163 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files
StgSharp.Common/Mathematics/Linear/MatrixParallel.Execute.cs
+138
View File
@@ -0,0 +1,138 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="MatrixParallel.Execute.cs"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. 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.HighPerformance;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Mathematics
{
internal static partial class MatrixParallel
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static unsafe void Compute(MatrixKernel* right, MatrixKernel* ans, IntPtr computeHandle)
{
((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);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static unsafe void ComputeRow(
MatrixKernel* right,
MatrixKernel* ans,
ScalarDataPacket* scalar,
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*, ScalarDataPacket*, void>)computeHandle)(right + ri, ans + ai, scalar);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static unsafe void ComputeRow(
MatrixKernel* left,
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*, MatrixKernel*, void>)computeHandle)(left + li, right + ri, ans + ai);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static unsafe void ComputeRow(
MatrixKernel* left,
MatrixKernel* right,
MatrixKernel* ans,
ScalarDataPacket* scalar,
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*, MatrixKernel*, ScalarDataPacket*, void>)computeHandle)(left + li, right + ri, ans + ai, scalar);
}
}
}
}
StgSharp.Common/Mathematics/Linear/MatrixParallel.Task.cs
+10 -11
View File
@@ -49,10 +49,9 @@ namespace StgSharp.Mathematics
[FieldOffset(08)] public int begin; [FieldOffset(08)] public int begin;
[FieldOffset(12)] public int end; [FieldOffset(12)] public int end;
[FieldOffset(16)] public int primCount; [FieldOffset(16)] public int offset;
[FieldOffset(20)] public int primStride; [FieldOffset(20)] public int primStride;
[FieldOffset(24)] public int secCount; [FieldOffset(24)] public int secStride;
[FieldOffset(28)] public int secStride;
} }
@@ -60,18 +59,18 @@ namespace StgSharp.Mathematics
public unsafe struct MatrixParallelTaskPackage public unsafe struct MatrixParallelTaskPackage
{ {
[FieldOffset(72)] public MatrixKernel* kernel;
[FieldOffset(0)] public MatrixKernel* Left; [FieldOffset(0)] public MatrixKernel* Left;
[FieldOffset(32)] public MatrixKernel* Result; [FieldOffset(24)] public MatrixKernel* Result;
[FieldOffset(64)] public MatrixKernel* Right; [FieldOffset(48)] public MatrixKernel* Right;
[FieldOffset(96)] public ScalarDataPacket* scalerPacket; [FieldOffset(72)] public ScalarDataPacket* scalerPacket;
[FieldOffset(100)] public int ComputeMode; [FieldOffset(80)] public int ComputeMode;
[FieldOffset(104)] public int count; [FieldOffset(84)] public int primCount;
[FieldOffset(88)] public int secCount;
[FieldOffset(108)] public IntPtr executionHandle; [FieldOffset(108)] public IntPtr executionHandle;
[FieldOffset(0)] public MatrixParallelEnumeration LeftEnum; [FieldOffset(0)] public MatrixParallelEnumeration LeftEnum;
[FieldOffset(32)] public MatrixParallelEnumeration ResultEnum; [FieldOffset(24)] public MatrixParallelEnumeration ResultEnum;
[FieldOffset(64)] public MatrixParallelEnumeration RightEnum; [FieldOffset(48)] public MatrixParallelEnumeration RightEnum;
} }
StgSharp.Common/Mathematics/Linear/MatrixParallel.cs
+15 -35
View File
@@ -62,7 +62,7 @@ namespace StgSharp.Mathematics
* we allow each wrap to contain either 3 or 4 threads, providing flexibility while maintaining efficiency. * we allow each wrap to contain either 3 or 4 threads, providing flexibility while maintaining efficiency.
*/ */
internal static class MatrixParallel internal static partial class MatrixParallel
{ {
private static Thread[] _threads; private static Thread[] _threads;
@@ -214,48 +214,28 @@ namespace StgSharp.Mathematics
private static unsafe void ExecuteTaskPackage(MatrixParallelTaskPackage* p) private static unsafe void ExecuteTaskPackage(MatrixParallelTaskPackage* p)
{ {
MatrixKernel* left = p->left, right = p->left, result = p->result; MatrixKernel* left = p->Left, right = p->Left, result = p->Result;
ref MatrixParallelEnumeration leftParam = ref p->LeftEnum, rightParam = ref p->RightEnum, resultParam = ref p->ResultEnum;
int count = p->count; int count = p->count;
ScalarDataPacket* scalar = p->scalerPacket; ScalarDataPacket* scalar = p->scalerPacket;
switch (p->ComputeMode) switch (p->ComputeMode)
{ {
case 0: case 1: // Unary operation
delegate*<MatrixKernel*, MatrixKernel*, void> op_0 = (delegate*<MatrixKernel*, MatrixKernel*, void>)p->executionHandle; for (int i = 0; i < length; i++) { }
for (int i = 0; i < count; i++)
{
op_0(left, result);
left += p->leftStride;
result += p->resultStride;
}
break;
case 1:
delegate*<MatrixKernel*, MatrixKernel*, ScalarDataPacket*, void> op_1 = (delegate*<MatrixKernel*, MatrixKernel*, ScalarDataPacket*, void>)p->executionHandle;
for (int i = 0; i < count; i++)
{
op_1(left, result, scalar);
left += p->leftStride;
result += p->resultStride;
}
break; break;
case 2: case 2:
delegate*<MatrixKernel*, MatrixKernel*, MatrixKernel*, void> op_2 = (delegate*<MatrixKernel*, MatrixKernel*, MatrixKernel*, void>)p->executionHandle;
for (int i = 0; i < count; i++)
{
op_2(left, right, result);
right += p->rightStride;
left += p->leftStride;
result += p->resultStride;
}
break; break;
case 3: case 3:
delegate*<MatrixKernel*, MatrixKernel*, MatrixKernel*, ScalarDataPacket*, void> op_3 = (delegate*<MatrixKernel*, MatrixKernel*, MatrixKernel*, ScalarDataPacket*, void>)p->executionHandle; break;
for (int i = 0; i < count; i++) case 4:
{ break;
op_3(left, right, result, scalar); case -1:
right += p->rightStride; break;
left += p->leftStride; case -2:
result += p->resultStride; break;
} case -3:
break;
case -4:
break; break;
default: default:
break; break;