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

mpl going on good process

Browse Source
This commit is contained in:
Youmu Liu
2025-09-24 20:38:15 +08:00
parent 8abc82ae08
commit 0cafe9fd4d
15 changed files with 179 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files
StgSharp.Common/Mathematics/Linear/Matrix.GC.cs
+2 -2
View File
@@ -61,7 +61,7 @@ namespace StgSharp.Mathematics
int kernelColumn = column / 4, c = column % 4;
int kernelRow = row / t_count, r = row % t_count;
ref MatrixKernel<T> kernel = ref _buffer[kernelColumn + KernelColumnLength * kernelRow];
return ref kernel.UnsafeIndex(c, r);
return ref kernel[c, r];
}
}
@@ -90,7 +90,7 @@ namespace StgSharp.Mathematics
int kernelColumn = column / 4, c = column % 4;
int kernelRow = row / t_count, r = row % t_count;
ref MatrixKernel<T> kernel = ref _buffer[kernelColumn + (KernelColumnLength * kernelRow)];
return ref kernel.UnsafeIndex(c, r);
return ref kernel[c, r];
}
#region enumeration
StgSharp.Common/Mathematics/Linear/Matrix.HLSF.cs
+2 -2
View File
@@ -65,7 +65,7 @@ namespace StgSharp.Mathematics
int kernelColumn = column / 4, c = column % 4;
int kernelRow = row / t_count, r = row % t_count;
ref MatrixKernel<T> kernel = ref k_buffer[(kernelColumn * kernelColumn) + kernelRow];
return ref kernel.UnsafeIndex(c, r);
return ref kernel[c, r];
}
}
@@ -94,7 +94,7 @@ namespace StgSharp.Mathematics
int kernelColumn = column / 4, c = column % 4;
int kernelRow = row / t_count, r = row % t_count;
ref MatrixKernel<T> kernel = ref k_buffer[(kernelColumn * kernelColumn) + kernelRow];
return ref kernel.UnsafeIndex(c, r);
return ref kernel[c, r];
}
~HlsfMatrix()
StgSharp.Common/Mathematics/Linear/MatrixParallel.Publish.cs
+28 -24
View File
@@ -51,31 +51,35 @@ namespace StgSharp.Mathematics
{
int length = _threads.Length,
columnCount = left.PrimSize,
rowCount = right.PrimSize,
cAverage = left.PrimSize / length, cRemain = left.PrimSize % length,
rAverage = right.PrimSize / length, rRemain = right.PrimSize % length;
rowCount = right.PrimSize;
(int c3, int c4) = FastDecompose(columnCount);
MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
package->Left = left.Source;
package->Right = right.Source;
package->Result = ans.Source;
package->LeftPrimOffset = left.PrimOffset;
package->RightPrimOffset = right.PrimOffset;
package->ResultPrimOffset = ans.PrimOffset;
package->LeftPrimStride = left.PrimStride;
package->RightPrimStride = right.PrimStride;
package->ResultPrimStride = ans.PrimStride;
package->LeftSecOffset = left.SecondaryOffset;
package->RightSecOffset = right.SecondaryOffset;
package->ResultSecOffset = ans.SecondaryOffset;
package->LeftSecStride = left.SecondaryStride;
package->RightSecStride = right.SecondaryStride;
package->ResultSecStride = ans.SecondaryStride;
package->PrimCount = left.PrimSize;
package->SecCount = left.SecondarySize;
package->ComputeHandle = (nint)Operation;
package->ElementSize = sizeof(T);
package->ComputeMode = 3;
int
small_4 = c4 / length,
larget_4
MatrixParallelTaskPackage<T> package = new()
{
Left = left.Source,
Right = right.Source,
Result = ans.Source,
LeftPrimOffset = left.PrimOffset,
RightPrimOffset = right.PrimOffset,
ResultPrimOffset = ans.PrimOffset,
LeftPrimStride = left.PrimStride,
RightPrimStride = right.PrimStride,
ResultPrimStride = ans.PrimStride,
LeftSecOffset = left.SecondaryOffset,
RightSecOffset = right.SecondaryOffset,
ResultSecOffset = ans.SecondaryOffset,
LeftSecStride = left.SecondaryStride,
RightSecStride = right.SecondaryStride,
ResultSecStride = ans.SecondaryStride,
PrimCount = left.PrimSize,
SecCount = left.SecondarySize,
ComputeHandle = (nint)Operation
};
}
}
StgSharp.Common/Mathematics/Linear/MatrixParallel.TaskFactory.cs
+6 -10
View File
@@ -58,7 +58,7 @@ namespace StgSharp.Mathematics
private static SlabAllocator<ScalarPacket> _scalarAllocator ;
private static SlabAllocator<MatrixParallelTaskPackageNonGeneric> _wrapAllocator ;
private static SlabAllocator<MatrixParallelTaskPackageNonGeneric> _wrapAllocator;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static MatrixParallelTaskPackage<T>* CreateBaseTask<T>() where T: unmanaged, INumber<T>
@@ -76,17 +76,13 @@ namespace StgSharp.Mathematics
return p;
}
public static MatrixParallelTaskPackage<T>* FromTaskWrap<T>(MatrixParallelTaskPackage<T>* source, int offset)
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static unsafe MatrixParallelTaskPackage<T>* FromExistPackage<T>(MatrixParallelTaskPackage<T>* exist)
where T: unmanaged, INumber<T>
{
MatrixParallelTaskPackage<T>* p = (MatrixParallelTaskPackage<T>*)_wrapAllocator.Allocate();
/*
*p = *source;
p->Left += offset * p->LeftStride;
p->Right += offset * p->RightStride;
p->Result += offset * p->ResultStride;
/**/
return p;
MatrixParallelTaskPackage<T>* ptr = (MatrixParallelTaskPackage<T>*)_wrapAllocator.Allocate();
MatrixParallelTaskPackage<T>.Copy(exist, ptr);
return ptr;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
StgSharp.Common/Mathematics/Linear/MatrixParallel.cs
+33 -5
View File
@@ -69,15 +69,33 @@ namespace StgSharp.Mathematics
private static Thread[] _threads;
private static MatrixParallelWrap[] _wraps;
private static readonly (int a, int b)[] LookupTable = [ (1, 1), (0, 2), (3, 0), (2, 1), (1, 2), (0, 3), (3, 1), (2, 2), (1, 3), (0, 4), (3, 2), (2, 3), (1, 4), (0, 5), ];
private static volatile int RemainThreadCount = 0;
private static readonly (int a, int b)[] LookupTable = [
(1, 1),
(0, 2),
(3, 0),
(2, 1),
(1, 2),
(0, 3),
(3, 1),
(2, 2),
(1, 3),
(0, 4),
(3, 2),
(2, 3),
(1, 4),
(0, 5),
];
private static bool _meaningful;
private static int LargeWrapCount;
private static volatile int RemainThreadCount = 0;
private static int SmallWrapCount;
private static readonly object _lock = new();
private static ThreadPriority _AfterWork = ThreadPriority.Lowest;
public static bool SupportParallel { get; } = Environment.ProcessorCount > 6;
public static bool IsParallelMeaningful { get; } = Environment.ProcessorCount > 6 && IsInitialized;
public static bool IsParallelMeaningful => Environment.ProcessorCount > 6 && IsInitialized;
public static MatrixParallelWrap.Handle LeaderHandle { get; private/**/ set; }
@@ -91,7 +109,7 @@ namespace StgSharp.Mathematics
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static (int a, int b) FastDecompose(int c)
public static (int count_3, int count_4) FastDecompose(int c)
{
if (c < 7) {
return (0, 0);
@@ -111,15 +129,25 @@ namespace StgSharp.Mathematics
return;
}
MatrixParallelFactory.Init();
if (!SupportParallel)
{
IsInitialized = true;
return;
}
int count = Environment.ProcessorCount - 4;
count = count == 5 ? 4 : count;
_threads = new Thread[count];
if (count < 6)
{
count = count == 3 ? 3 : 4;
_wraps = [ new MatrixParallelWrap(0, count, true) ];
(LargeWrapCount, SmallWrapCount) = count == 3 ? (1,0) : (0,1);
} else if (count == 6)
{
_wraps = [ new MatrixParallelWrap(0, 3, true), new MatrixParallelWrap(3, 3, false) ];
_wraps = [
new MatrixParallelWrap(0, 3, true),
new MatrixParallelWrap(3, 3, false)
];
} else
{
(int _3wrap, int _4wrap) = FastDecompose(count);