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

Daily update on 20250921-173333 by Nitload Youmu. Additional Message : New design of matrix enumeration, capable for parallel task publication.

Browse Source 
Signed-off-by: Nitload <YoumuLiu_NSI@whv0t.onmicrosoft.com>
This commit is contained in:
Nitload
2025-09-21 17:33:33 +08:00
parent 0404ecf044
commit b8a51c13dd
15 changed files with 463 additions and 304 deletions
Download Patch File Download Diff File Expand all files Collapse all files
StgSharp.Common/Mathematics/Linear/Matrix.Basic.cs
+2 -2
View File
@@ -51,11 +51,11 @@ namespace StgSharp.Mathematics
Matrix<float> result = GCMatrix<float>.FromDefault(left.ColumnLength, left.RowLength);
unsafe
{
MatrixParallelTaskPackage* handle = MatrixParallelFactory.CreateBaseTask();
MatrixParallelTaskPackage<float>* handle = MatrixParallelFactory.CreateBaseTask<float>();
handle->Left = left.Buffer;
handle->Right = right.Buffer;
handle->Result = result.Buffer;
handle->ComputeHandle = (IntPtr)InternalIO.Intrinsic.kernel_add;
handle->ComputeHandle = (IntPtr)InternalIO.Intrinsic.f32_add;
handle->LeftPrimOffset = 0;
handle->RightPrimOffset = 0;
handle->LeftPrimStride = left.KernelColumnLength;
StgSharp.Common/Mathematics/Linear/Matrix.GC.cs
+14 -14
View File
@@ -44,13 +44,13 @@ namespace StgSharp.Mathematics
internal unsafe partial class GCMatrix<T> : Matrix<T> where T: unmanaged, INumber<T>
{
private readonly MatrixKernel* _buffer;
private readonly MatrixKernel<T>* _buffer;
public GCMatrix(int column, int row)
{
KernelColumnLength = (column + 3) / 4;
KernelRowLength = (row + 3) / t_count;
_buffer = (MatrixKernel*)NativeMemory.AlignedAlloc((nuint)(column * row * sizeof(T)), (nuint)World.DefaultSIMDAlignment);
_buffer = (MatrixKernel<T>*)NativeMemory.AlignedAlloc((nuint)(column * row * sizeof(T)), (nuint)World.DefaultSIMDAlignment);
}
public override ref T this[int column, int row]
@@ -60,8 +60,8 @@ namespace StgSharp.Mathematics
AssertIndex(column, row);
int kernelColumn = column / 4, c = column % 4;
int kernelRow = row / t_count, r = row % t_count;
ref MatrixKernel kernel = ref _buffer[kernelColumn + KernelColumnLength * kernelRow];
return ref kernel.UnsafeIndex<T>(c, r);
ref MatrixKernel<T> kernel = ref _buffer[kernelColumn + KernelColumnLength * kernelRow];
return ref kernel.UnsafeIndex(c, r);
}
}
@@ -71,13 +71,13 @@ namespace StgSharp.Mathematics
set => throw new NotImplementedException();
}
internal override unsafe MatrixKernel* Buffer
internal override unsafe MatrixKernel<T>* Buffer
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => _buffer;
}
public override unsafe ref MatrixKernel GetMatrixKernel(int column, int row)
public override unsafe ref MatrixKernel<T> GetMatrixKernel(int column, int row)
{
AssertIndex(column, row);
int kernelColumn = column / 4;
@@ -89,27 +89,27 @@ namespace StgSharp.Mathematics
{
int kernelColumn = column / 4, c = column % 4;
int kernelRow = row / t_count, r = row % t_count;
ref MatrixKernel kernel = ref _buffer[kernelColumn + (KernelColumnLength * kernelRow)];
return ref kernel.UnsafeIndex<T>(c, r);
ref MatrixKernel<T> kernel = ref _buffer[kernelColumn + (KernelColumnLength * kernelRow)];
return ref kernel.UnsafeIndex(c, r);
}
#region enumeration
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override unsafe MatrixSegmentEnumeration GetColumnEnumeration()
public override unsafe MatrixSegmentEnumeration<T> GetColumnEnumeration()
{
return new MatrixSegmentEnumeration(_buffer, KernelColumnLength, KernelColumnLength * KernelRowLength, 1, KernelColumnLength);
return new MatrixSegmentEnumeration<T>(_buffer, KernelColumnLength, KernelColumnLength * KernelRowLength, 1, KernelColumnLength);
}
public override unsafe MatrixSegmentEnumeration GetRowEnumeration()
public override unsafe MatrixSegmentEnumeration<T> GetRowEnumeration()
{
return new MatrixSegmentEnumeration(_buffer, 1, KernelColumnLength, KernelColumnLength, KernelRowLength);
return new MatrixSegmentEnumeration<T>(_buffer, 1, KernelColumnLength, KernelColumnLength, KernelRowLength);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override unsafe MatrixSegmentEnumeration GetSequentialEnumeration()
public override unsafe MatrixSegmentEnumeration<T> GetSequentialEnumeration()
{
return new MatrixSegmentEnumeration(_buffer, KernelRowLength * KernelColumnLength, KernelColumnLength * KernelRowLength, 1, KernelRowLength * KernelColumnLength);
return new MatrixSegmentEnumeration<T>(_buffer, KernelRowLength * KernelColumnLength, KernelColumnLength * KernelRowLength, 1, KernelRowLength * KernelColumnLength);
}
#endregion
StgSharp.Common/Mathematics/Linear/Matrix.HLSF.cs
+15 -15
View File
@@ -45,7 +45,7 @@ namespace StgSharp.Mathematics
internal unsafe partial class HlsfMatrix<T> : Matrix<T> where T: unmanaged, INumber<T>
{
private readonly MatrixKernel* k_buffer;
private readonly MatrixKernel<T>* k_buffer;
private readonly hlsfAllocator allocator;
private readonly hlsfHandle handle;
@@ -53,8 +53,8 @@ namespace StgSharp.Mathematics
{
KernelColumnLength = (column + 3) / 4;
KernelRowLength = (row + 3) / t_count;
this.handle = allocator.Alloc((uint)(KernelColumnLength * KernelRowLength * sizeof(MatrixKernel)));
k_buffer = (MatrixKernel*)handle.Pointer;
this.handle = allocator.Alloc((uint)(KernelColumnLength * KernelRowLength * sizeof(MatrixKernel<T>)));
k_buffer = (MatrixKernel<T>*)handle.Pointer;
}
public override ref T this[int column, int row]
@@ -64,8 +64,8 @@ namespace StgSharp.Mathematics
AssertIndex(column, row);
int kernelColumn = column / 4, c = column % 4;
int kernelRow = row / t_count, r = row % t_count;
ref MatrixKernel kernel = ref k_buffer[(kernelColumn * kernelColumn) + kernelRow];
return ref kernel.UnsafeIndex<T>(c, r);
ref MatrixKernel<T> kernel = ref k_buffer[(kernelColumn * kernelColumn) + kernelRow];
return ref kernel.UnsafeIndex(c, r);
}
}
@@ -75,13 +75,13 @@ namespace StgSharp.Mathematics
set => throw new NotImplementedException();
}
internal override unsafe MatrixKernel* Buffer
internal override unsafe MatrixKernel<T>* Buffer
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => k_buffer;
}
public override unsafe ref MatrixKernel GetMatrixKernel(int column, int row)
public override unsafe ref MatrixKernel<T> GetMatrixKernel(int column, int row)
{
AssertIndex(column, row);
int kernelColumn = column / 4, c = column % 4;
@@ -93,8 +93,8 @@ namespace StgSharp.Mathematics
{
int kernelColumn = column / 4, c = column % 4;
int kernelRow = row / t_count, r = row % t_count;
ref MatrixKernel kernel = ref k_buffer[(kernelColumn * kernelColumn) + kernelRow];
return ref kernel.UnsafeIndex<T>(c, r);
ref MatrixKernel<T> kernel = ref k_buffer[(kernelColumn * kernelColumn) + kernelRow];
return ref kernel.UnsafeIndex(c, r);
}
~HlsfMatrix()
@@ -105,20 +105,20 @@ namespace StgSharp.Mathematics
#region enumeration
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override unsafe MatrixSegmentEnumeration GetColumnEnumeration()
public override unsafe MatrixSegmentEnumeration<T> GetColumnEnumeration()
{
return new MatrixSegmentEnumeration(k_buffer, KernelColumnLength, KernelColumnLength * KernelRowLength, 1, KernelColumnLength);
return new MatrixSegmentEnumeration<T>(k_buffer, KernelColumnLength, KernelColumnLength * KernelRowLength, 1, KernelColumnLength);
}
public override unsafe MatrixSegmentEnumeration GetRowEnumeration()
public override unsafe MatrixSegmentEnumeration<T> GetRowEnumeration()
{
return new MatrixSegmentEnumeration(k_buffer, 1, KernelColumnLength, KernelColumnLength, KernelRowLength);
return new MatrixSegmentEnumeration<T>(k_buffer, 1, KernelColumnLength, KernelColumnLength, KernelRowLength);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override unsafe MatrixSegmentEnumeration GetSequentialEnumeration()
public override unsafe MatrixSegmentEnumeration<T> GetSequentialEnumeration()
{
return new MatrixSegmentEnumeration(k_buffer, KernelRowLength * KernelColumnLength, KernelColumnLength * KernelRowLength, 1, KernelRowLength * KernelColumnLength);
return new MatrixSegmentEnumeration<T>(k_buffer, KernelRowLength * KernelColumnLength, KernelColumnLength * KernelRowLength, 1, KernelRowLength * KernelColumnLength);
}
#endregion
StgSharp.Common/Mathematics/Linear/Matrix.cs
+63 -31
View File
@@ -32,6 +32,8 @@ using StgSharp.HighPerformance;
using System;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using hlsfAllocator = global::StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocator;
// using hlsfHandle = global::StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocationHandle;
@@ -135,55 +137,77 @@ namespace StgSharp.Mathematics
public readonly unsafe ref struct MatrixSegmentEnumeration<T>(
MatrixKernel<T>* source,
int stride,
int size,
int primStride,
int primSize,
int secondaryStride,
int secondarySize)
int secondarySize,
int primOffset = 0,
int secondaryOffset = 0)
where T: unmanaged, INumber<T>
{
private readonly MatrixKernel<T>* _source = source;
private readonly int _secondarySize = secondarySize;
private readonly int _secondaryStride = secondaryStride;
internal readonly int SecondaryStride = secondaryStride;
internal readonly int PrimOffset = primOffset;
private readonly int _size = size;
private readonly int _stride = stride;
internal readonly int PrimSize = primSize;
internal readonly int PrimStride = primStride;
internal readonly int SecondaryOffset = secondaryOffset;
internal readonly int SecondarySize = secondarySize;
public Enumerator<T> GetEnumerator()
internal readonly MatrixKernel<T>* Source
{
return new Enumerator<T>(in this);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => _source;
}
public ref struct Enumerator<T>(in MatrixSegmentEnumeration<T> enumeration) where T: unmanaged, INumber<T>
public Enumerator GetEnumerator()
{
return new Enumerator(in this);
}
public ref struct Enumerator(in MatrixSegmentEnumeration<T> enumeration)
{
private MatrixKernel<T>* _current = enumeration._source - enumeration._stride;
private readonly MatrixKernel<T>* _end = enumeration._source + enumeration._size;
private readonly int _secondarySize = enumeration._secondarySize;
private readonly int _secondaryStride = enumeration._secondaryStride;
private readonly int _stride = enumeration._stride;
private readonly MatrixKernel<T>* _source = enumeration._source;
private int _indexCount = 0;
private readonly int _stride = enumeration.PrimStride;
private readonly long _bound = (long)enumeration.PrimSize * enumeration.PrimStride;
private long _index = (long)enumeration.PrimOffset * enumeration.PrimStride;
private readonly MatrixSegmentEnumeration<T> _enumeration;
public readonly MatrixSegment<T> Current
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => new(_current, _secondarySize, _secondaryStride);
get => new(
_source + _index,
_enumeration.SecondarySize,
_enumeration.SecondaryStride,
_enumeration.PrimOffset);
}
public bool MoveNext()
{
_current += _stride;
return _current < _end;
_indexCount++;
_index += _stride;
if (_index >= _bound) {
_index = 0;
}
return _indexCount >= _enumeration.PrimSize;
}
}
}
public readonly unsafe ref struct MatrixSegment<T>(MatrixKernel<T>* source, int size, int stride)
public readonly unsafe ref struct MatrixSegment<T>(MatrixKernel<T>* source, int size, int stride, int offset)
where T: unmanaged, INumber<T>
{
private readonly MatrixKernel<T>* _source = source;
private readonly int _offset = offset;
private readonly int _secondarySize = size;
private readonly int _size = size;
private readonly int _stride = stride;
@@ -198,29 +222,37 @@ namespace StgSharp.Mathematics
}
}
public Enumerator<T> GetEnumerator()
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Enumerator GetEnumerator()
{
return new Enumerator<T>(_source, _size, _stride);
return new Enumerator(in this);
}
public ref struct Enumerator<T>(MatrixKernel<T>* source, int count, int stride) where T: unmanaged, INumber<T>
public ref struct Enumerator(in MatrixSegment<T> segment)
{
private readonly MatrixKernel<T>* _end = source + (count * stride);
private readonly int _stride = stride;
private readonly int _end = segment._size;
public MatrixKernel<T>* Current
private int _indexCount = 0;
private readonly long _bound = (long)segment._size * segment._stride;
private long _index = (long)segment._offset * segment._stride;
private readonly MatrixSegment<T> _segment = segment;
public readonly MatrixKernel<T>* Current
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private set;
} = source - stride;
get => _segment._source + _index;
}
public bool MoveNext()
{
Current += _stride;
return Current < _end;
_index += _segment._stride;
_indexCount++;
if (_index >= _bound) {
_index = 0;
}
return _indexCount < _end;
}
}
StgSharp.Common/Mathematics/Linear/MatrixParallel.Execute.cs
+43 -43
View File
@@ -33,42 +33,43 @@ using System;
using System.Collections.Generic;
using System.Formats.Asn1;
using System.Linq;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Mathematics
{
internal static partial class MatrixParallel
public static partial class MatrixParallel
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static unsafe void Compute_Binary(MatrixParallelTaskPackage* p)
internal static unsafe void Compute_Binary(MatrixParallelTaskPackageNonGeneric* p)
{
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;
int eSize = p->ElementSize;
nint l = p->Left, r = p->Right, a = p->Result;
long
lCount = (long)p->LeftPrimOffset * p->LeftPrimStride,
rCount = (long)p->RightPrimOffset * p->RightPrimStride,
aCount = (long)p->ResultPrimOffset * p->ResultPrimStride,
pCount = p->PrimCount,
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;
delegate* unmanaged[Cdecl]<IntPtr, IntPtr, IntPtr, void> op =
(delegate* unmanaged[Cdecl]<IntPtr, IntPtr, IntPtr, 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;
nint left = l + (nint)(lCount * eSize);
nint right = r + (nint)(rCount * eSize);
nint ans = a + (nint)(aCount * eSize);
long
lc = p->LeftSecOffset * p->LeftSecStride,
rc = p->RightSecOffset * p->RightSecStride,
ac = p->ResultSecOffset * p->ResultSecStride,
lc = (long)p->LeftSecOffset * p->LeftSecStride,
rc = (long)p->RightSecOffset * p->RightSecStride,
ac = (long)p->ResultSecOffset * p->ResultSecStride,
sCount = p->SecCount;
long
ll = sCount - p->LeftSecOffset,
@@ -79,15 +80,15 @@ namespace StgSharp.Mathematics
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);
op(left + (nint)lc, right + (nint)rc, ans + (nint)ac);
}
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static unsafe void Compute_BinaryScalar(MatrixParallelTaskPackage* p)
internal static unsafe void Compute_BinaryScalar(MatrixParallelTaskPackageNonGeneric* p)
{
MatrixKernel* l = p->Left, r = p->Right, a = p->Result;
nint l = p->Left, r = p->Right, a = p->Result;
long
lCount = p->LeftPrimOffset * p->LeftPrimStride,
rCount = p->RightPrimOffset * p->RightPrimStride,
@@ -97,23 +98,23 @@ namespace StgSharp.Mathematics
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;
delegate* unmanaged[Cdecl]<nint,nint,nint, ScalarPacket*, void> op =
(delegate* unmanaged[Cdecl]<nint, nint, nint, 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;
nint
left = l + (nint)lCount,
right = r + (nint)rCount,
ans = a + (nint)aCount;
long
lc = p->LeftSecOffset * p->LeftSecStride,
rc = p->RightSecOffset * p->RightSecStride,
ac = p->ResultSecOffset * p->ResultSecStride,
sCount = p->SecCount;
long
sCount = p->SecCount,
ll = sCount - p->LeftSecOffset,
rl = sCount - p->RightSecOffset,
al = sCount - p->ResultSecOffset;
@@ -122,28 +123,27 @@ namespace StgSharp.Mathematics
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);
op(left + (nint)lc, right + (nint)rc, ans + (nint)ac, scalar);
}
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static unsafe void Compute_Unary(MatrixParallelTaskPackage* p)
internal static unsafe void Compute_Unary(MatrixParallelTaskPackageNonGeneric* p)
{
MatrixKernel* s = p->Right, a = p->Result;
nint s = p->Right, a = p->Result;
long rCount = p->RightPrimOffset * p->RightPrimStride,
aCount = p->ResultPrimOffset * p->ResultPrimStride,
pCount = p->PrimCount;
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;
delegate* unmanaged[Cdecl]<nint, nint, void> op =
(delegate* unmanaged[Cdecl]<nint, nint, 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;
nint source = s + (nint)rCount, ans = a + (nint)aCount;
long rc = p->RightSecOffset * p->RightSecStride,
ac = p->ResultSecOffset * p->ResultSecStride,
sCount = p->SecCount;
@@ -153,29 +153,29 @@ namespace StgSharp.Mathematics
{
rc = j < rl ? rc + p->RightSecOffset : 0;
ac = j < al ? ac + p->ResultSecOffset : 0;
op(source + rc, ans + ac);
op(source + (nint)rc, ans + (nint)ac);
}
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static unsafe void Compute_UnaryScalar(MatrixParallelTaskPackage* p)
internal static unsafe void Compute_UnaryScalar(MatrixParallelTaskPackageNonGeneric* p)
{
MatrixKernel* s = p->Right, a = p->Result;
nint 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;
delegate* unmanaged[Cdecl]<nint, nint, ScalarPacket*, void> op =
(delegate* unmanaged[Cdecl]<nint, nint, 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;
nint source = s + (nint)rCount;
nint ans = a + (nint)aCount;
long rc = p->RightSecOffset * p->RightSecStride,
ac = p->ResultSecOffset * p->ResultSecStride,
sCount = p->SecCount;
@@ -185,7 +185,7 @@ namespace StgSharp.Mathematics
{
rc = j < rl ? rc + p->RightSecOffset : 0;
ac = j < al ? ac + p->ResultSecOffset : 0;
op(source + rc, ans + ac, scalar);
op(source + (nint)rc, ans + (nint)ac, scalar);
}
}
}
StgSharp.Common/Mathematics/Linear/MatrixParallel.Task.cs
+90 -16
View File
@@ -31,14 +31,9 @@
using StgSharp.HighPerformance;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Text.Json.Serialization;
using System.Threading;
namespace StgSharp.Mathematics
{
@@ -59,27 +54,106 @@ namespace StgSharp.Mathematics
}
[StructLayout(LayoutKind.Sequential)]
internal unsafe struct MatrixParallelTaskPackage
internal readonly unsafe struct MatrixParallelTaskPackageNonGeneric
{
public static unsafe void Copy(MatrixParallelTaskPackage* source, MatrixParallelTaskPackage* target)
{
Buffer.MemoryCopy(source, target, sizeof(MatrixParallelTaskPackage), sizeof(MatrixParallelTaskPackage));
}
#region source
// Group 1: Left/Right matrix kernel base address
public MatrixKernel* Left; // 8
public MatrixKernel* Right; // 8
public readonly IntPtr Left; // 8
public readonly IntPtr Right; // 8
#endregion
#region ans
// Group 2: Result kernel base address + reserved
public MatrixKernel* Result; // 8
public void* ReservedPtr0; // 8 (extension/reserved)
public readonly IntPtr Result; // 8
public readonly int ElementSize;
public readonly int ReservedPtr0; // 4 (extension/reserved)
#endregion
#region left enum
public readonly int LeftPrimOffset; // 4
public readonly int LeftPrimStride; // 4
public readonly int LeftSecOffset; // 4
public readonly int LeftSecStride; // 4
#endregion
#region right enum
public readonly int RightPrimOffset; // 4
public readonly int RightPrimStride; // 4
public readonly int RightSecOffset; // 4
public readonly int RightSecStride; // 4
#endregion
#region ans enum
public readonly int ResultPrimOffset; // 4
public readonly int ResultPrimStride; // 4
public readonly int ResultSecOffset; // 4
public readonly int ResultSecStride; // 4
#endregion
#region scalar/compute
public readonly ScalarPacket* Scalar; // 8
public readonly IntPtr ComputeHandle; // 8
#endregion
#region global profile
public readonly int PrimCount; // 4
public readonly int ComputeMode; // 4
public readonly int SecCount; // 4
private readonly int ReservedInt0; // 4
#endregion
#region reserve
public readonly long ReservedLong0; // 8
public readonly long ReservedLong1; // 8
#endregion
}
[StructLayout(LayoutKind.Sequential)]
internal unsafe struct MatrixParallelTaskPackage<T> where T: unmanaged, INumber<T>
{
public MatrixParallelTaskPackage()
{
Unsafe.SkipInit(out this);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static unsafe void Copy(MatrixParallelTaskPackage<T>* source, MatrixParallelTaskPackage<T>* target)
{
Buffer.MemoryCopy(source, target, sizeof(MatrixParallelTaskPackage<T>), sizeof(MatrixParallelTaskPackage<T>));
}
#region source
// Group 1: Left/Right matrix kernel base address
public MatrixKernel<T>* Left; // 8
public MatrixKernel<T>* Right; // 8
#endregion
#region ans
// Group 2: Result kernel base address + reserved
public MatrixKernel<T>* Result; // 8
public int ElementSize = sizeof(T);
public int ReservedPtr0; // 4 (extension/reserved)
#endregion
@@ -133,4 +207,4 @@ namespace StgSharp.Mathematics
#endregion
}
}
}
StgSharp.Common/Mathematics/Linear/MatrixParallel.TaskFactory.cs
+25 -43
View File
@@ -1,6 +1,6 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="MatrixParallel.TaskWrapFactory.cs"
// file="MatrixParallel.TaskFactory.cs"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
@@ -33,6 +33,7 @@ using StgSharp.HighPerformance.Memory;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
@@ -57,13 +58,13 @@ namespace StgSharp.Mathematics
private static SlabAllocator<ScalarPacket> _scalarAllocator ;
private static SlabAllocator<MatrixParallelTaskPackage> _wrapAllocator ;
private static SlabAllocator<MatrixParallelTaskPackageNonGeneric> _wrapAllocator ;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static MatrixParallelTaskPackage* CreateBaseTask()
public static MatrixParallelTaskPackage<T>* CreateBaseTask<T>() where T: unmanaged, INumber<T>
{
MatrixParallelTaskPackage* p = (MatrixParallelTaskPackage*)_wrapAllocator.Allocate();
Span<byte> s = new Span<byte>((byte*)p, sizeof(MatrixParallelTaskPackage));
MatrixParallelTaskPackage<T>* p = (MatrixParallelTaskPackage<T>*)_wrapAllocator.Allocate();
Span<byte> s = new Span<byte>((byte*)p, sizeof(MatrixParallelTaskPackage<T>));
s.Fill(0);
return p;
}
@@ -75,10 +76,10 @@ namespace StgSharp.Mathematics
return p;
}
<<<<<<< HEAD:StgSharp.Common/Mathematics/Linear/MatrixParallel.TaskWrapFactory.cs
public static MatrixParallelTaskPackage* FromTaskWrap(MatrixParallelTaskPackage* source, int offset)
public static MatrixParallelTaskPackage<T>* FromTaskWrap<T>(MatrixParallelTaskPackage<T>* source, int offset)
where T: unmanaged, INumber<T>
{
MatrixParallelTaskPackage* p = (MatrixParallelTaskPackage*)_wrapAllocator.Allocate();
MatrixParallelTaskPackage<T>* p = (MatrixParallelTaskPackage<T>*)_wrapAllocator.Allocate();
/*
*p = *source;
p->Left += offset * p->LeftStride;
@@ -88,16 +89,24 @@ namespace StgSharp.Mathematics
return p;
}
=======
[MethodImpl(MethodImplOptions.AggressiveInlining)]
>>>>>>> 8007eee8461498a85a9515e8fd076f03cb552b64:StgSharp.Common/Mathematics/Linear/MatrixParallel.TaskFactory.cs
public static void Release(ScalarPacket* source)
{
_scalarAllocator.Free((nuint)source);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void Release(MatrixParallelTaskPackage* source)
public static void Release(MatrixParallelTaskPackageNonGeneric* source)
{
if (source->Scalar != null) {
_scalarAllocator.Free((nuint)source->Scalar);
}
_wrapAllocator.Free((nuint)source);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void Release<T>(MatrixParallelTaskPackage<T>* source) where T: unmanaged, INumber<T>
{
if (source->Scalar != null) {
_scalarAllocator.Free((nuint)source->Scalar);
@@ -108,40 +117,13 @@ namespace StgSharp.Mathematics
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void Init()
{
<<<<<<< HEAD:StgSharp.Common/Mathematics/Linear/MatrixParallel.TaskWrapFactory.cs
int count = group.Length;
group[0] = (nint)source;
int l = source->LeftPrimStride, r = source->RightPrimStride, res = source->ResultPrimStride, c = source->PrimCount / count;
source->LeftPrimStride *= count;
source->RightPrimStride *= count;
source->ResultPrimStride *= count;
source->PrimCount = c;
int remain = source->PrimCount - (c * count);
for (int i = 1; i < count; i++)
if (_intermediateResult is null)
{
nint handle = (nint)_wrapAllocator.Allocate();
MatrixParallelTaskPackage* p = (MatrixParallelTaskPackage*)handle;
*p = *source;
p->Left += l * i;
p->Right += r * i;
p->Result += res * i;
p->PrimCount = c;
group[i] = handle;
_intermediateResult = new hlsfAllocator(64 * 16 * 16);
_scalarAllocator = SlabAllocator<ScalarPacket>.Create(64 * 1024, SlabBufferLayout.Chunked);
_wrapAllocator = SlabAllocator<MatrixParallelTaskPackageNonGeneric>.
Create(128 * 1024, SlabBufferLayout.Chunked);
}
// Distribute remaining work to the last few tasks
for (int i = 0; i < remain; i++)
{
int targetIndex = count - 1 - i;
if (targetIndex >= 0) {
((MatrixParallelTaskPackage*)group[targetIndex])->PrimCount++;
}
}
=======
_scalarAllocator = SlabAllocator<ScalarPacket>.Create(64, SlabBufferLayout.Chunked, true);
_wrapAllocator = SlabAllocator<MatrixParallelTaskPackage>.Create(64, SlabBufferLayout.Chunked, true);
_intermediateResult = new hlsfAllocator((nuint)(sizeof(MatrixKernel) * 64));
>>>>>>> 8007eee8461498a85a9515e8fd076f03cb552b64:StgSharp.Common/Mathematics/Linear/MatrixParallel.TaskFactory.cs
}
}
StgSharp.Common/Mathematics/Linear/MatrixParallel.TaskPublic.cs
+79
View File
@@ -0,0 +1,79 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="MatrixParallel.TaskPublic.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.Numerics;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Mathematics
{
public static partial class MatrixParallel
{
public static unsafe void PublicTask<T>(
MatrixSegmentEnumeration<T> left,
MatrixSegmentEnumeration<T> right,
MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation)
where T: unmanaged, INumber<T>
{
int columnCount = left.PrimSize;
int rowCount = right.PrimSize;
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.cs
+16 -14
View File
@@ -64,7 +64,7 @@ namespace StgSharp.Mathematics
* we allow each wrap to contain either 3 or 4 threads, providing flexibility while maintaining efficiency.
*/
internal static partial class MatrixParallel
public static partial class MatrixParallel
{
private static Thread[] _threads;
@@ -167,7 +167,7 @@ namespace StgSharp.Mathematics
{
ResetThreadCount();
foreach (MatrixParallelWrap item in _wraps) {
_ = item.SchedulerReset.Set();
item.SchedulerReset.Set();
}
}
@@ -176,17 +176,17 @@ namespace StgSharp.Mathematics
private readonly Queue<IntPtr>[] _cache;
private readonly Thread[] _threads;
private readonly AutoResetEvent[] _workerReset;
private readonly ManualResetEventSlim[] _workerReset;
public MatrixParallelWrap(int id, int wrapSize, bool isFirst)
{
ID = id;
int begin = isFirst ? 1 : 0, end = wrapSize - 1;
_cache = new Queue<IntPtr>[wrapSize];
_workerReset = new AutoResetEvent[end];
_workerReset = new ManualResetEventSlim[end];
_threads = new Thread[wrapSize];
for (int i = 0; i < end; i++) {
_workerReset[i] = new AutoResetEvent(false);
_workerReset[i] = new ManualResetEventSlim(false);
}
for (int i = 0; i < _cache.Length; i++) {
_cache[i] = new Queue<IntPtr>(8);
@@ -212,7 +212,7 @@ namespace StgSharp.Mathematics
public int ID { get; init; }
internal AutoResetEvent SchedulerReset { get; } = new(false);
internal ManualResetEventSlim SchedulerReset { get; } = new(false);
public Span<IntPtr> EnqueuePackage(Span<IntPtr> packageSpan)
{
@@ -224,7 +224,7 @@ namespace StgSharp.Mathematics
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public AutoResetEvent GetWorkerResetEvent(int id)
public ManualResetEventSlim GetWorkerResetEvent(int id)
{
return _workerReset[id];
}
@@ -238,8 +238,8 @@ namespace StgSharp.Mathematics
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void SetAllWorker()
{
foreach (AutoResetEvent item in _workerReset) {
_ = item.Set();
foreach (ManualResetEventSlim item in _workerReset) {
item.Set();
}
}
@@ -253,10 +253,11 @@ namespace StgSharp.Mathematics
MatrixParallelWrap wrap = handle.Wrap;
int inWrapIndex = handle.InWrapIndex;
Thread self = Thread.CurrentThread;
AutoResetEvent reset = wrap.GetWorkerResetEvent(inWrapIndex);
ManualResetEventSlim reset = wrap.GetWorkerResetEvent(inWrapIndex);
do
{
_ = reset.WaitOne();
reset.Wait();
reset.Reset();
self.Priority = ThreadPriority.Highest;
ExecuteTaskPackage(wrap.GetWorkerTaskQueue(inWrapIndex));
_ = Interlocked.Decrement(ref RemainThreadCount);
@@ -270,11 +271,12 @@ namespace StgSharp.Mathematics
MatrixParallelWrap wrap = handle.Wrap;
int inWrapIndex = handle.InWrapIndex;
Queue<IntPtr> taskQueue = wrap.GetWorkerTaskQueue(inWrapIndex);
AutoResetEvent resetEvent = wrap.SchedulerReset;
ManualResetEventSlim resetEvent = wrap.SchedulerReset;
Thread self = Thread.CurrentThread;
do
{
_ = resetEvent.WaitOne();
resetEvent.Wait();
resetEvent.Reset();
self.Priority = ThreadPriority.Highest;
// TODO task publication to worker in wrap
@@ -290,7 +292,7 @@ namespace StgSharp.Mathematics
{
while (taskQueue.TryDequeue(out nint handle))
{
MatrixParallelTaskPackage* p = (MatrixParallelTaskPackage*)handle;
MatrixParallelTaskPackageNonGeneric* p = (MatrixParallelTaskPackageNonGeneric*)handle;
switch (p->ComputeMode)
{
case 1: