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

working on dynamic wrapping, a good awaiting is on way

Browse Source
This commit is contained in:
Youmu Liu
2025-11-07 18:22:50 +08:00
parent ec1b8dbd51
commit f959339e18
16 changed files with 447 additions and 355 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.cr/personal/Editor/Right Margin Line/Right Margin Line.xml
+1 -1
View File
@@ -2,7 +2,7 @@
<Root Type="DevExpress.CodeRush.VisualizePlugins.RightMarginLine.Options.RightMarginLineOptions"> <Root Type="DevExpress.CodeRush.VisualizePlugins.RightMarginLine.Options.RightMarginLineOptions">
<Options Language="Neutral"> <Options Language="Neutral">
<Enabled>True</Enabled> <Enabled>True</Enabled>
<Style>DashDot</Style> <Style>Dot</Style>
<Width>2</Width> <Width>2</Width>
</Options> </Options>
</Root> </Root>
.cr/team/Editor/Formatting/Wrapping.CSharp.xml
+3 -1
View File
@@ -11,11 +11,13 @@
<Item Id="{10e904ea-f51d-4c32-9320-1b93fa557564}" Type="DevExpress.CodeRush.Formatting.UI.Options.Conversion.AssignmentExpressionFormattingOption" /> <Item Id="{10e904ea-f51d-4c32-9320-1b93fa557564}" Type="DevExpress.CodeRush.Formatting.UI.Options.Conversion.AssignmentExpressionFormattingOption" />
<Item Id="{25746bdc-0a43-4741-a740-20784691314b}" Type="DevExpress.CodeRush.Formatting.UI.Options.Conversion.InvocationArgumentListFormattingOption"> <Item Id="{25746bdc-0a43-4741-a740-20784691314b}" Type="DevExpress.CodeRush.Formatting.UI.Options.Conversion.InvocationArgumentListFormattingOption">
<WrapOpenParen> <WrapOpenParen>
<Option>WrapIfLong</Option> <Option>NoWrap</Option>
</WrapOpenParen> </WrapOpenParen>
<WrapArgSeparator> <WrapArgSeparator>
<Option>SimpleWrap</Option> <Option>SimpleWrap</Option>
<Kind>WrapAfter</Kind>
</WrapArgSeparator> </WrapArgSeparator>
<ArgCountTolerance>4</ArgCountTolerance>
</Item> </Item>
<Item Id="{D5EE2ECB-9FA6-47F7-A11F-007FC45E872D}" Type="DevExpress.CodeRush.Formatting.UI.Options.Conversion.AttributeArgumentsFormattingOption" /> <Item Id="{D5EE2ECB-9FA6-47F7-A11F-007FC45E872D}" Type="DevExpress.CodeRush.Formatting.UI.Options.Conversion.AttributeArgumentsFormattingOption" />
<Item Id="{5A186AB9-03A5-4BFE-83B1-B99B3B8408BC}" Type="DevExpress.CodeRush.Formatting.UI.Options.Conversion.DeclarationParameterListFormattingOption" /> <Item Id="{5A186AB9-03A5-4BFE-83B1-B99B3B8408BC}" Type="DevExpress.CodeRush.Formatting.UI.Options.Conversion.DeclarationParameterListFormattingOption" />
StgSharp.Common/Collections/CapacityFixedStack.cs
+3
View File
@@ -29,6 +29,7 @@ using System;
using System.Collections; using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
using System.Threading;
namespace StgSharp.Collections namespace StgSharp.Collections
{ {
@@ -45,6 +46,8 @@ namespace StgSharp.Collections
_index = -1; _index = -1;
} }
public T? First => Volatile.Read(ref _index) > 0 ? _values[0] : default;
public bool IsEmpty => _index == -1; public bool IsEmpty => _index == -1;
public int Count => _index + 1; public int Count => _index + 1;
StgSharp.Common/Internal/Intrinsic/MatInterface.cs
-35
View File
@@ -1,35 +0,0 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="MatInterface"
// 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 System;
using System.Collections.Generic;
using System.Text;
namespace StgSharp.Internal.Intrinsic
{
public interface IMat { }
}
StgSharp.Common/Mathematics/Graphic/Matrix44.cs
+58 -52
View File
@@ -27,14 +27,17 @@
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
using StgSharp.Mathematics.Numeric; using StgSharp.Mathematics.Numeric;
using System; using System;
using System.Collections;
using System.Collections.Generic;
using System.Numerics; using System.Numerics;
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
namespace StgSharp.Mathematics.Graphic namespace StgSharp.Mathematics.Graphic
{ {
[StructLayout(LayoutKind.Explicit, Size = 2 * 16 * sizeof(float) + sizeof(bool), Pack = 16)] [CollectionBuilder(builderType:typeof(Matrix44), methodName: nameof(Matrix44.FromSpan))]
public unsafe struct Matrix44 : IEquatable<Matrix44>, IMatrix<float> [StructLayout(LayoutKind.Explicit, Size = (2 * 16 * sizeof(float)) + sizeof(bool), Pack = 16)]
public unsafe struct Matrix44 : IEquatable<Matrix44>, IMatrix<float>, IEnumerable<Vec4>
{ {
[FieldOffset(2 * 64 * sizeof(float))] internal bool isTransposed; [FieldOffset(2 * 64 * sizeof(float))] internal bool isTransposed;
@@ -160,12 +163,6 @@ namespace StgSharp.Mathematics.Graphic
return MemoryMarshal.CreateReadOnlySpan(ref Unsafe.As<ColumnSet4, float>(ref mat), 16); return MemoryMarshal.CreateReadOnlySpan(ref Unsafe.As<ColumnSet4, float>(ref mat), 16);
} }
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public unsafe float Det()
{
return 0;
}
public override bool Equals(object? obj) public override bool Equals(object? obj)
{ {
return obj is Matrix44 x && Equals(x); return obj is Matrix44 x && Equals(x);
@@ -176,11 +173,24 @@ namespace StgSharp.Mathematics.Graphic
return mat.Equals(other.mat); return mat.Equals(other.mat);
} }
public static Matrix44 FromSpan(ReadOnlySpan<Vec4> rowSpan)
{
Matrix44 mat = new Matrix44();
mat.transpose.colum0 = rowSpan[0].vec;
mat.transpose.colum1 = rowSpan[1].vec;
mat.transpose.colum2 = rowSpan[2].vec;
mat.transpose.colum3 = rowSpan[3].vec;
NativeIntrinsic.Intrinsic.f32_transpose(&mat.transpose, &mat.mat);
mat.isTransposed = false;
return mat;
}
public override int GetHashCode() public override int GetHashCode()
{ {
return HashCode.Combine( return HashCode.Combine(mat.colum0.GetHashCode(), mat.colum1.GetHashCode(), mat.colum2.GetHashCode(),
mat.colum0.GetHashCode(), mat.colum1.GetHashCode(), mat.colum2.GetHashCode(), mat.colum3.GetHashCode());
mat.colum3.GetHashCode());
} }
public override string ToString() public override string ToString()
@@ -194,11 +204,8 @@ namespace StgSharp.Mathematics.Graphic
{ {
if (!isTransposed) if (!isTransposed)
{ {
fixed (ColumnSet4* source = &mat, target = &transpose) fixed (ColumnSet4* source = &mat, target = &transpose) {
{
NativeIntrinsic.Intrinsic.f32_transpose(source, target); NativeIntrinsic.Intrinsic.f32_transpose(source, target);
// InternalIO.Intrinsic.transpose44(source, target);
} }
isTransposed = true; isTransposed = true;
} }
@@ -207,13 +214,9 @@ namespace StgSharp.Mathematics.Graphic
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
public static unsafe Matrix44 operator -(Matrix44 left, Matrix44 right) public static unsafe Matrix44 operator -(Matrix44 left, Matrix44 right)
{ {
return new Matrix44 Matrix44 ret = new();
{ NativeIntrinsic.Intrinsic.f32_sub(&left, &right, &ret);
column0 = right.column0 - left.column0, return ret;
column1 = right.column1 - left.column1,
column2 = right.column2 - left.column2,
column3 = right.column3 - left.column3
};
} }
public static bool operator !=(Matrix44 left, Matrix44 right) public static bool operator !=(Matrix44 left, Matrix44 right)
@@ -224,47 +227,37 @@ namespace StgSharp.Mathematics.Graphic
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
public static unsafe Matrix44 operator *(Matrix44 mat, float value) public static unsafe Matrix44 operator *(Matrix44 mat, float value)
{ {
return new Matrix44( return new Matrix44(mat.mat.colum0 * value, mat.mat.colum1 * value, mat.mat.colum2 * value,
mat.mat.colum0 * value, mat.mat.colum1 * value, mat.mat.colum2 * value, mat.mat.colum3 * value);
mat.mat.colum3 * value);
} }
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Matrix44 operator *(Matrix44 left, Matrix44 right) public static Matrix44 operator *(Matrix44 left, Matrix44 right)
{ {
left.InternalTranspose(); left.InternalTranspose();
return new Matrix44( return new Matrix44(Vector4.Dot(left.transpose.colum0, right.mat.colum0),
Vector4.Dot(left.transpose.colum0, right.mat.colum0), Vector4.Dot(left.transpose.colum0, right.mat.colum1),
Vector4.Dot(left.transpose.colum0, right.mat.colum1), Vector4.Dot(left.transpose.colum0, right.mat.colum2),
Vector4.Dot(left.transpose.colum0, right.mat.colum2), Vector4.Dot(left.transpose.colum0, right.mat.colum3),
Vector4.Dot(left.transpose.colum0, right.mat.colum3), Vector4.Dot(left.transpose.colum1, right.mat.colum0),
Vector4.Dot(left.transpose.colum1, right.mat.colum1),
Vector4.Dot(left.transpose.colum1, right.mat.colum0), Vector4.Dot(left.transpose.colum1, right.mat.colum2),
Vector4.Dot(left.transpose.colum1, right.mat.colum1), Vector4.Dot(left.transpose.colum1, right.mat.colum3),
Vector4.Dot(left.transpose.colum1, right.mat.colum2), Vector4.Dot(left.transpose.colum2, right.mat.colum0),
Vector4.Dot(left.transpose.colum1, right.mat.colum3), Vector4.Dot(left.transpose.colum2, right.mat.colum1),
Vector4.Dot(left.transpose.colum2, right.mat.colum2),
Vector4.Dot(left.transpose.colum2, right.mat.colum0), Vector4.Dot(left.transpose.colum2, right.mat.colum3),
Vector4.Dot(left.transpose.colum2, right.mat.colum1), Vector4.Dot(left.transpose.colum3, right.mat.colum0),
Vector4.Dot(left.transpose.colum2, right.mat.colum2), Vector4.Dot(left.transpose.colum3, right.mat.colum1),
Vector4.Dot(left.transpose.colum2, right.mat.colum3), Vector4.Dot(left.transpose.colum3, right.mat.colum2),
Vector4.Dot(left.transpose.colum3, right.mat.colum3));
Vector4.Dot(left.transpose.colum3, right.mat.colum0),
Vector4.Dot(left.transpose.colum3, right.mat.colum1),
Vector4.Dot(left.transpose.colum3, right.mat.colum2),
Vector4.Dot(left.transpose.colum3, right.mat.colum3));
} }
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
public static unsafe Matrix44 operator +(Matrix44 left, Matrix44 right) public static unsafe Matrix44 operator +(Matrix44 left, Matrix44 right)
{ {
Matrix44 ret = new() Matrix44 ret = new();
{ NativeIntrinsic.Intrinsic.f32_add(&left, &right, &ret);
column0 = left.column0 + right.column0,
column1 = left.column1 + right.column1,
column2 = left.column2 + right.column2,
column3 = left.column3 + right.column3
};
return ret; return ret;
} }
@@ -273,5 +266,18 @@ namespace StgSharp.Mathematics.Graphic
return left.Equals(right); return left.Equals(right);
} }
IEnumerator IEnumerable.GetEnumerator()
{
throw new NotImplementedException();
}
IEnumerator<Vec4> IEnumerable<Vec4>.GetEnumerator()
{
ref Vec4 col0 = ref column0;
for (int i = 0; i < 4; i++) {
yield return Unsafe.Add(ref col0, i);
}
}
} }
} }
StgSharp.Common/Mathematics/Graphic/Vec4.cs
+26 -6
View File
@@ -36,8 +36,9 @@ using System.Runtime.InteropServices;
namespace StgSharp.Mathematics.Graphic namespace StgSharp.Mathematics.Graphic
{ {
[CollectionBuilder(builderType:typeof(Vec4), methodName: nameof(Vec4.FromSpan))]
[StructLayout(LayoutKind.Explicit, Size = 16, Pack = 16)] [StructLayout(LayoutKind.Explicit, Size = 16, Pack = 16)]
public struct Vec4 : IEquatable<Vec4>, IUnmanagedVector<Vec4> public unsafe struct Vec4 : IEquatable<Vec4>, IUnmanagedVector<Vec4, float>
{ {
[FieldOffset(0)] internal unsafe fixed float num[4]; [FieldOffset(0)] internal unsafe fixed float num[4];
@@ -127,11 +128,33 @@ namespace StgSharp.Mathematics.Graphic
return left + right; return left + right;
} }
public ReadOnlySpan<float> AsSpan()
{
return MemoryMarshal.CreateReadOnlySpan(ref reg.Member<float>(0), 4);
}
public override bool Equals(object obj) public override bool Equals(object obj)
{ {
return obj is Vec4 v && v == this; return obj is Vec4 v && v == this;
} }
public static Vec4 FromSpan(ReadOnlySpan<float> span)
{
return new Vec4
{
X = span[0],
Y = span[1],
Z = span[2],
W = span[3]
};
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public ReadOnlySpan<float>.Enumerator GetEnumerator()
{
return AsSpan().GetEnumerator();
}
public override int GetHashCode() public override int GetHashCode()
{ {
return vec.GetHashCode(); return vec.GetHashCode();
@@ -163,11 +186,8 @@ namespace StgSharp.Mathematics.Graphic
public static Vec4 operator *(Matrix44 mat, Vec4 vec) public static Vec4 operator *(Matrix44 mat, Vec4 vec)
{ {
mat.InternalTranspose(); mat.InternalTranspose();
return new Vec4( return new Vec4(Vector4.Dot(mat.transpose.colum0, vec.vec), Vector4.Dot(mat.transpose.colum1, vec.vec),
Vector4.Dot(mat.transpose.colum0, vec.vec), Vector4.Dot(mat.transpose.colum2, vec.vec), Vector4.Dot(mat.transpose.colum3, vec.vec));
Vector4.Dot(mat.transpose.colum1, vec.vec),
Vector4.Dot(mat.transpose.colum2, vec.vec),
Vector4.Dot(mat.transpose.colum3, vec.vec));
} }
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
StgSharp.Common/Mathematics/Linear/IMatrix.cs
+1
View File
@@ -30,6 +30,7 @@ using StgSharp.Graphics;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Numerics; using System.Numerics;
using System.Runtime.CompilerServices;
using System.Text; using System.Text;
namespace StgSharp.Mathematics.Numeric namespace StgSharp.Mathematics.Numeric
StgSharp.Mathematics/Numeric/MatrixCompute.Basic.cs
+12 -38
View File
@@ -47,6 +47,16 @@ namespace StgSharp.Mathematics.Numeric
} }
Matrix<float> ans = Matrix<float>.FromDefault(left.ColumnLength, left.RowLength); Matrix<float> ans = Matrix<float>.FromDefault(left.ColumnLength, left.RowLength);
long count = (long)left.KernelColumnLength * left.KernelRowLength; long count = (long)left.KernelColumnLength * left.KernelRowLength;
if (count <= 256)
{
MatrixKernel<float>* leftPtr = left.Buffer;
MatrixKernel<float>* rightPtr = right.Buffer;
MatrixKernel<float>* ansPtr = ans.Buffer;
for (int i = 0; i < count; i++) {
NativeIntrinsic.Intrinsic.f32_add(leftPtr + i, rightPtr + i, ansPtr + i);
}
return ans;
}
if (count <= 1024) if (count <= 1024)
{ {
ReadOnlySpan<MatrixParallelThread> pool = MatrixParallel.LeadParallel(1); ReadOnlySpan<MatrixParallelThread> pool = MatrixParallel.LeadParallel(1);
@@ -64,50 +74,14 @@ namespace StgSharp.Mathematics.Numeric
} }
return ans; return ans;
} }
Stack<MatrixParallelWrap> taskGroup = MatrixParallel.PublicTask(left.GetColumnEnumeration(), right.GetColumnEnumeration(), ans.GetColumnEnumeration(), MatrixParallelHandle taskGroup = MatrixParallel.PublicTask(left.GetColumnEnumeration(), right.GetColumnEnumeration(), ans.GetColumnEnumeration(),
(delegate*<MatrixKernel<float>*, MatrixKernel<float>*, MatrixKernel<float>*, void>)NativeIntrinsic.Intrinsic.f32_add); (delegate*<MatrixKernel<float>*, MatrixKernel<float>*, MatrixKernel<float>*, void>)NativeIntrinsic.Intrinsic.f32_add);
MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep); MatrixParallel.LaunchParallel(taskGroup, SleepMode.DeepSleep);
/* /*
* run parallel * run parallel
*/ */
return ans; taskGroup.Dispose();
}
public static unsafe Matrix<float> Sub(Matrix<float> left, Matrix<float> right)
{
if (left.ColumnLength != right.ColumnLength || left.RowLength != right.RowLength) {
throw new IndexOutOfRangeException("Matrix dimensions must agree.");
}
Matrix<float> ans = Matrix<float>.FromDefault(left.ColumnLength, left.RowLength);
long count = (long)left.KernelColumnLength * left.KernelRowLength;
if (count <= 1024)
{
// TODO: this is very awkward, blocking thread renting, need a better way to handle small tasks
ReadOnlySpan<MatrixParallelThread> pool = MatrixParallel.LeadParallel(1);
if (pool.Length == 0)
{
/*
* wait
*/
}
MatrixParallel.ReleaseParallelLeadership(ref pool);
MatrixKernel<float>* leftPtr = left.Buffer;
MatrixKernel<float>* rightPtr = right.Buffer;
MatrixKernel<float>* ansPtr = ans.Buffer;
for (int i = 0; i < count; i++) {
NativeIntrinsic.Intrinsic.f32_sub(leftPtr + i, rightPtr + i, ansPtr + i);
}
// thread.
return ans;
}
Stack<MatrixParallelWrap> taskGroup = MatrixParallel.PublicTask(left.GetColumnEnumeration(), right.GetColumnEnumeration(), ans.GetColumnEnumeration(),
(delegate*<MatrixKernel<float>*, MatrixKernel<float>*, MatrixKernel<float>*, void>)NativeIntrinsic.Intrinsic.f32_sub);
/*
* run parallel
*/
return ans; return ans;
} }
StgSharp.Mathematics/Numeric/MatrixParallel.Await.cs
+116
View File
@@ -0,0 +1,116 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="MatrixParallel.Await"
// 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 System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Mathematics.Numeric
{
public static partial class MatrixParallel
{
private static ConcurrentQueue<WaitHandle> _awaitingLeaderHandle;
private static volatile int _createGeneration = 0;
private static int _sortState;
public static MatrixParallelThread[] LeadParallel(int recommendCount)
{
int min = int.Min(recommendCount, _threads.Capacity);
min /= 2;
MatrixParallelThread[] ret;
if (_threads.Count < min)
{
WaitHandle handle = new WaitHandle
{
CreateGeneration = _createGeneration,
LeastCount = min,
BestCount = recommendCount
};
_awaitingLeaderHandle.Enqueue(handle);
int cycleGeneration = _createGeneration;
while (true)
{
// TODO 排队等待，对前八个按照优先级排序，优先级最高的独占进行等待，其他继续排队
if (_createGeneration != cycleGeneration)
{
if (Interlocked.Exchange(ref _sortState, 1) == 0)
{
// TODO 排序
_ = Interlocked.Exchange(ref _sortState, 0);
} else
{
cycleGeneration = _createGeneration;
continue;
}
}
if (_awaitingLeaderHandle.TryPeek(out WaitHandle? p) && p == handle)
{
// get the leader
ret = _threads.PopRange(recommendCount);
_awaitingLeaderHandle.TryDequeue(out _);
break;
}
Thread.Sleep(0);
}
} else
{
// directly get the leader
ret = _threads.PopRange(recommendCount);
}
_ = Interlocked.Increment(ref _createGeneration);
return ret;
}
public static void ReturnParallelResources(ref MatrixParallelThread[] pool)
{
_threads.PushRange(pool);
pool = null!;
}
private record class WaitHandle
{
public int CreateGeneration { get; set; }
public int LeastCount { get; set; }
public int BestCount { get; set; }
public int CurrentPriority(int currentGeneration)
{
return (currentGeneration - CreateGeneration) * (MatrixParallel._threads.Capacity - LeastCount);
}
}
}
}
StgSharp.Mathematics/Numeric/MatrixParallel.Publish.cs
+166 -163
View File
@@ -40,10 +40,10 @@ namespace StgSharp.Mathematics.Numeric
public static partial class MatrixParallel public static partial class MatrixParallel
{ {
public static unsafe Stack<MatrixParallelWrap> PublicTask<T>( public static unsafe MatrixParallelHandle PublicTask<T>(
MatrixSegmentEnumeration<T> source, MatrixSegmentEnumeration<T> source,
MatrixSegmentEnumeration<T> ans, MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation) delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
{ {
MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>(); MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
@@ -66,11 +66,11 @@ namespace StgSharp.Mathematics.Numeric
return PublicTaskPrivate<T>(package); return PublicTaskPrivate<T>(package);
} }
public static unsafe Stack<MatrixParallelWrap> PublicTask<T>( public static unsafe MatrixParallelHandle PublicTask<T>(
MatrixSegmentEnumeration<T> left, MatrixSegmentEnumeration<T> left,
MatrixSegmentEnumeration<T> right, MatrixSegmentEnumeration<T> right,
MatrixSegmentEnumeration<T> ans, MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation) delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
{ {
MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>(); MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
@@ -99,11 +99,11 @@ namespace StgSharp.Mathematics.Numeric
} }
// Unary with 1..8 scalars (each scalar is independent generic type) // Unary with 1..8 scalars (each scalar is independent generic type)
public static unsafe Stack<MatrixParallelWrap> PublicTask<T, TScalar0>( public static unsafe MatrixParallelHandle PublicTask<T, TScalar0>(
MatrixSegmentEnumeration<T> source, MatrixSegmentEnumeration<T> source,
MatrixSegmentEnumeration<T> ans, MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation, delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
TScalar0 s0) TScalar0 s0)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
where TScalar0: unmanaged, INumber<TScalar0> where TScalar0: unmanaged, INumber<TScalar0>
{ {
@@ -130,12 +130,12 @@ namespace StgSharp.Mathematics.Numeric
return PublicTaskPrivate<T>(package); return PublicTaskPrivate<T>(package);
} }
public static unsafe Stack<MatrixParallelWrap> PublicTask<T, TScalar0, TScalar1>( public static unsafe MatrixParallelHandle PublicTask<T, TScalar0, TScalar1>(
MatrixSegmentEnumeration<T> source, MatrixSegmentEnumeration<T> source,
MatrixSegmentEnumeration<T> ans, MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation, delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
TScalar0 s0, TScalar0 s0,
TScalar1 s1) TScalar1 s1)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
where TScalar0: unmanaged, INumber<TScalar0> where TScalar0: unmanaged, INumber<TScalar0>
where TScalar1: unmanaged, INumber<TScalar1> where TScalar1: unmanaged, INumber<TScalar1>
@@ -165,12 +165,12 @@ namespace StgSharp.Mathematics.Numeric
} }
// Binary with 1..8 scalars (each scalar is independent generic type) // Binary with 1..8 scalars (each scalar is independent generic type)
public static unsafe Stack<MatrixParallelWrap> PublicTask<T, TScalar0>( public static unsafe MatrixParallelHandle PublicTask<T, TScalar0>(
MatrixSegmentEnumeration<T> left, MatrixSegmentEnumeration<T> left,
MatrixSegmentEnumeration<T> right, MatrixSegmentEnumeration<T> right,
MatrixSegmentEnumeration<T> ans, MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation, delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
TScalar0 s0) TScalar0 s0)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
where TScalar0: unmanaged, INumber<TScalar0> where TScalar0: unmanaged, INumber<TScalar0>
{ {
@@ -202,13 +202,13 @@ namespace StgSharp.Mathematics.Numeric
return PublicTaskPrivate<T>(package); return PublicTaskPrivate<T>(package);
} }
public static unsafe Stack<MatrixParallelWrap> PublicTask<T, TScalar0, TScalar1, TScalar2>( public static unsafe MatrixParallelHandle PublicTask<T, TScalar0, TScalar1, TScalar2>(
MatrixSegmentEnumeration<T> source, MatrixSegmentEnumeration<T> source,
MatrixSegmentEnumeration<T> ans, MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation, delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
TScalar0 s0, TScalar0 s0,
TScalar1 s1, TScalar1 s1,
TScalar2 s2) TScalar2 s2)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
where TScalar0: unmanaged, INumber<TScalar0> where TScalar0: unmanaged, INumber<TScalar0>
where TScalar1: unmanaged, INumber<TScalar1> where TScalar1: unmanaged, INumber<TScalar1>
@@ -239,13 +239,13 @@ namespace StgSharp.Mathematics.Numeric
return PublicTaskPrivate<T>(package); return PublicTaskPrivate<T>(package);
} }
public static unsafe Stack<MatrixParallelWrap> PublicTask<T, TScalar0, TScalar1>( public static unsafe MatrixParallelHandle PublicTask<T, TScalar0, TScalar1>(
MatrixSegmentEnumeration<T> left, MatrixSegmentEnumeration<T> left,
MatrixSegmentEnumeration<T> right, MatrixSegmentEnumeration<T> right,
MatrixSegmentEnumeration<T> ans, MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation, delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
TScalar0 s0, TScalar0 s0,
TScalar1 s1) TScalar1 s1)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
where TScalar0: unmanaged, INumber<TScalar0> where TScalar0: unmanaged, INumber<TScalar0>
where TScalar1: unmanaged, INumber<TScalar1> where TScalar1: unmanaged, INumber<TScalar1>
@@ -279,14 +279,14 @@ namespace StgSharp.Mathematics.Numeric
return PublicTaskPrivate<T>(package); return PublicTaskPrivate<T>(package);
} }
public static unsafe Stack<MatrixParallelWrap> PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3>( public static unsafe MatrixParallelHandle PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3>(
MatrixSegmentEnumeration<T> source, MatrixSegmentEnumeration<T> source,
MatrixSegmentEnumeration<T> ans, MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation, delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
TScalar0 s0, TScalar0 s0,
TScalar1 s1, TScalar1 s1,
TScalar2 s2, TScalar2 s2,
TScalar3 s3) TScalar3 s3)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
where TScalar0: unmanaged, INumber<TScalar0> where TScalar0: unmanaged, INumber<TScalar0>
where TScalar1: unmanaged, INumber<TScalar1> where TScalar1: unmanaged, INumber<TScalar1>
@@ -319,14 +319,14 @@ namespace StgSharp.Mathematics.Numeric
return PublicTaskPrivate<T>(package); return PublicTaskPrivate<T>(package);
} }
public static unsafe Stack<MatrixParallelWrap> PublicTask<T, TScalar0, TScalar1, TScalar2>( public static unsafe MatrixParallelHandle PublicTask<T, TScalar0, TScalar1, TScalar2>(
MatrixSegmentEnumeration<T> left, MatrixSegmentEnumeration<T> left,
MatrixSegmentEnumeration<T> right, MatrixSegmentEnumeration<T> right,
MatrixSegmentEnumeration<T> ans, MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation, delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
TScalar0 s0, TScalar0 s0,
TScalar1 s1, TScalar1 s1,
TScalar2 s2) TScalar2 s2)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
where TScalar0: unmanaged, INumber<TScalar0> where TScalar0: unmanaged, INumber<TScalar0>
where TScalar1: unmanaged, INumber<TScalar1> where TScalar1: unmanaged, INumber<TScalar1>
@@ -362,15 +362,15 @@ namespace StgSharp.Mathematics.Numeric
return PublicTaskPrivate<T>(package); return PublicTaskPrivate<T>(package);
} }
public static unsafe Stack<MatrixParallelWrap> PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4>( public static unsafe MatrixParallelHandle PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4>(
MatrixSegmentEnumeration<T> source, MatrixSegmentEnumeration<T> source,
MatrixSegmentEnumeration<T> ans, MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation, delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
TScalar0 s0, TScalar0 s0,
TScalar1 s1, TScalar1 s1,
TScalar2 s2, TScalar2 s2,
TScalar3 s3, TScalar3 s3,
TScalar4 s4) TScalar4 s4)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
where TScalar0: unmanaged, INumber<TScalar0> where TScalar0: unmanaged, INumber<TScalar0>
where TScalar1: unmanaged, INumber<TScalar1> where TScalar1: unmanaged, INumber<TScalar1>
@@ -405,15 +405,15 @@ namespace StgSharp.Mathematics.Numeric
return PublicTaskPrivate<T>(package); return PublicTaskPrivate<T>(package);
} }
public static unsafe Stack<MatrixParallelWrap> PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3>( public static unsafe MatrixParallelHandle PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3>(
MatrixSegmentEnumeration<T> left, MatrixSegmentEnumeration<T> left,
MatrixSegmentEnumeration<T> right, MatrixSegmentEnumeration<T> right,
MatrixSegmentEnumeration<T> ans, MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation, delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
TScalar0 s0, TScalar0 s0,
TScalar1 s1, TScalar1 s1,
TScalar2 s2, TScalar2 s2,
TScalar3 s3) TScalar3 s3)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
where TScalar0: unmanaged, INumber<TScalar0> where TScalar0: unmanaged, INumber<TScalar0>
where TScalar1: unmanaged, INumber<TScalar1> where TScalar1: unmanaged, INumber<TScalar1>
@@ -451,16 +451,16 @@ namespace StgSharp.Mathematics.Numeric
return PublicTaskPrivate<T>(package); return PublicTaskPrivate<T>(package);
} }
public static unsafe Stack<MatrixParallelWrap> PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4, TScalar5>( public static unsafe MatrixParallelHandle PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4, TScalar5>(
MatrixSegmentEnumeration<T> source, MatrixSegmentEnumeration<T> source,
MatrixSegmentEnumeration<T> ans, MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation, delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
TScalar0 s0, TScalar0 s0,
TScalar1 s1, TScalar1 s1,
TScalar2 s2, TScalar2 s2,
TScalar3 s3, TScalar3 s3,
TScalar4 s4, TScalar4 s4,
TScalar5 s5) TScalar5 s5)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
where TScalar0: unmanaged, INumber<TScalar0> where TScalar0: unmanaged, INumber<TScalar0>
where TScalar1: unmanaged, INumber<TScalar1> where TScalar1: unmanaged, INumber<TScalar1>
@@ -497,16 +497,16 @@ namespace StgSharp.Mathematics.Numeric
return PublicTaskPrivate<T>(package); return PublicTaskPrivate<T>(package);
} }
public static unsafe Stack<MatrixParallelWrap> PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4>( public static unsafe MatrixParallelHandle PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4>(
MatrixSegmentEnumeration<T> left, MatrixSegmentEnumeration<T> left,
MatrixSegmentEnumeration<T> right, MatrixSegmentEnumeration<T> right,
MatrixSegmentEnumeration<T> ans, MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation, delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
TScalar0 s0, TScalar0 s0,
TScalar1 s1, TScalar1 s1,
TScalar2 s2, TScalar2 s2,
TScalar3 s3, TScalar3 s3,
TScalar4 s4) TScalar4 s4)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
where TScalar0: unmanaged, INumber<TScalar0> where TScalar0: unmanaged, INumber<TScalar0>
where TScalar1: unmanaged, INumber<TScalar1> where TScalar1: unmanaged, INumber<TScalar1>
@@ -546,17 +546,17 @@ namespace StgSharp.Mathematics.Numeric
return PublicTaskPrivate<T>(package); return PublicTaskPrivate<T>(package);
} }
public static unsafe Stack<MatrixParallelWrap> PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4, TScalar5, TScalar6>( public static unsafe MatrixParallelHandle PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4, TScalar5, TScalar6>(
MatrixSegmentEnumeration<T> source, MatrixSegmentEnumeration<T> source,
MatrixSegmentEnumeration<T> ans, MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation, delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
TScalar0 s0, TScalar0 s0,
TScalar1 s1, TScalar1 s1,
TScalar2 s2, TScalar2 s2,
TScalar3 s3, TScalar3 s3,
TScalar4 s4, TScalar4 s4,
TScalar5 s5, TScalar5 s5,
TScalar6 s6) TScalar6 s6)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
where TScalar0: unmanaged, INumber<TScalar0> where TScalar0: unmanaged, INumber<TScalar0>
where TScalar1: unmanaged, INumber<TScalar1> where TScalar1: unmanaged, INumber<TScalar1>
@@ -595,17 +595,17 @@ namespace StgSharp.Mathematics.Numeric
return PublicTaskPrivate<T>(package); return PublicTaskPrivate<T>(package);
} }
public static unsafe Stack<MatrixParallelWrap> PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4, TScalar5>( public static unsafe MatrixParallelHandle PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4, TScalar5>(
MatrixSegmentEnumeration<T> left, MatrixSegmentEnumeration<T> left,
MatrixSegmentEnumeration<T> right, MatrixSegmentEnumeration<T> right,
MatrixSegmentEnumeration<T> ans, MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation, delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
TScalar0 s0, TScalar0 s0,
TScalar1 s1, TScalar1 s1,
TScalar2 s2, TScalar2 s2,
TScalar3 s3, TScalar3 s3,
TScalar4 s4, TScalar4 s4,
TScalar5 s5) TScalar5 s5)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
where TScalar0: unmanaged, INumber<TScalar0> where TScalar0: unmanaged, INumber<TScalar0>
where TScalar1: unmanaged, INumber<TScalar1> where TScalar1: unmanaged, INumber<TScalar1>
@@ -647,18 +647,18 @@ namespace StgSharp.Mathematics.Numeric
return PublicTaskPrivate<T>(package); return PublicTaskPrivate<T>(package);
} }
public static unsafe Stack<MatrixParallelWrap> PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4, TScalar5, TScalar6, TScalar7>( public static unsafe MatrixParallelHandle PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4, TScalar5, TScalar6, TScalar7>(
MatrixSegmentEnumeration<T> source, MatrixSegmentEnumeration<T> source,
MatrixSegmentEnumeration<T> ans, MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation, delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
TScalar0 s0, TScalar0 s0,
TScalar1 s1, TScalar1 s1,
TScalar2 s2, TScalar2 s2,
TScalar3 s3, TScalar3 s3,
TScalar4 s4, TScalar4 s4,
TScalar5 s5, TScalar5 s5,
TScalar6 s6, TScalar6 s6,
TScalar7 s7) TScalar7 s7)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
where TScalar0: unmanaged, INumber<TScalar0> where TScalar0: unmanaged, INumber<TScalar0>
where TScalar1: unmanaged, INumber<TScalar1> where TScalar1: unmanaged, INumber<TScalar1>
@@ -699,18 +699,18 @@ namespace StgSharp.Mathematics.Numeric
return PublicTaskPrivate<T>(package); return PublicTaskPrivate<T>(package);
} }
public static unsafe Stack<MatrixParallelWrap> PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4, TScalar5, TScalar6>( public static unsafe MatrixParallelHandle PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4, TScalar5, TScalar6>(
MatrixSegmentEnumeration<T> left, MatrixSegmentEnumeration<T> left,
MatrixSegmentEnumeration<T> right, MatrixSegmentEnumeration<T> right,
MatrixSegmentEnumeration<T> ans, MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation, delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
TScalar0 s0, TScalar0 s0,
TScalar1 s1, TScalar1 s1,
TScalar2 s2, TScalar2 s2,
TScalar3 s3, TScalar3 s3,
TScalar4 s4, TScalar4 s4,
TScalar5 s5, TScalar5 s5,
TScalar6 s6) TScalar6 s6)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
where TScalar0: unmanaged, INumber<TScalar0> where TScalar0: unmanaged, INumber<TScalar0>
where TScalar1: unmanaged, INumber<TScalar1> where TScalar1: unmanaged, INumber<TScalar1>
@@ -754,19 +754,19 @@ namespace StgSharp.Mathematics.Numeric
return PublicTaskPrivate<T>(package); return PublicTaskPrivate<T>(package);
} }
public static unsafe Stack<MatrixParallelWrap> PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4, TScalar5, TScalar6, TScalar7>( public static unsafe MatrixParallelHandle PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4, TScalar5, TScalar6, TScalar7>(
MatrixSegmentEnumeration<T> left, MatrixSegmentEnumeration<T> left,
MatrixSegmentEnumeration<T> right, MatrixSegmentEnumeration<T> right,
MatrixSegmentEnumeration<T> ans, MatrixSegmentEnumeration<T> ans,
delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation, delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
TScalar0 s0, TScalar0 s0,
TScalar1 s1, TScalar1 s1,
TScalar2 s2, TScalar2 s2,
TScalar3 s3, TScalar3 s3,
TScalar4 s4, TScalar4 s4,
TScalar5 s5, TScalar5 s5,
TScalar6 s6, TScalar6 s6,
TScalar7 s7) TScalar7 s7)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
where TScalar0: unmanaged, INumber<TScalar0> where TScalar0: unmanaged, INumber<TScalar0>
where TScalar1: unmanaged, INumber<TScalar1> where TScalar1: unmanaged, INumber<TScalar1>
@@ -812,7 +812,7 @@ namespace StgSharp.Mathematics.Numeric
return PublicTaskPrivate<T>(package); return PublicTaskPrivate<T>(package);
} }
private static unsafe Stack<MatrixParallelWrap> PublicTaskPrivate<T>(MatrixParallelTaskPackage<T>* package) private static unsafe MatrixParallelHandle PublicTaskPrivate<T>(MatrixParallelTaskPackage<T>* package)
where T: unmanaged, INumber<T> where T: unmanaged, INumber<T>
{ {
int primCount = package->PrimCount; int primCount = package->PrimCount;
@@ -820,15 +820,21 @@ namespace StgSharp.Mathematics.Numeric
int tileWidth = (1024 / secCount) + 1; int tileWidth = (1024 / secCount) + 1;
int tileCount = (primCount + tileWidth - 1) / tileWidth; int tileCount = (primCount + tileWidth - 1) / tileWidth;
ReadOnlySpan<MatrixParallelThread> pool = LeadParallel(tileCount); MatrixParallelThread[] pool = LeadParallel(tileCount);
int threadCount = pool.Length;
if (pool.Length == 0) if (pool.Length == 0)
{ {
/* /*
* wait until has enough threads * wait until has enough threads
*/ */
} }
MatrixParallelHandle handle = new MatrixParallelHandle(pool);
if (handle.Wraps.Count() == 1)
{
handle.Wraps.First().WrapTask = (MatrixParallelTaskPackageNonGeneric*)package;
return handle;
}
int threadCount = pool.Length;
int tilePerThreadLess = tileCount / threadCount; // tiles per thread without extra slice int tilePerThreadLess = tileCount / threadCount; // tiles per thread without extra slice
int columnAfterBaseTile = tileCount % threadCount * tileWidth; // tile sliced into columns int columnAfterBaseTile = tileCount % threadCount * tileWidth; // tile sliced into columns
int extraColumnPerThread = columnAfterBaseTile / threadCount; int extraColumnPerThread = columnAfterBaseTile / threadCount;
@@ -837,13 +843,13 @@ namespace StgSharp.Mathematics.Numeric
int total = primCount; int total = primCount;
Stack<MatrixParallelWrap> taskBunch = new Stack<MatrixParallelWrap>(threadCount); Stack<MatrixParallelWrap> taskBunch = new Stack<MatrixParallelWrap>(threadCount);
MatrixParallelTaskPackage<T>* current = package; MatrixParallelTaskPackage<T>* current = package;
foreach (MatrixParallelThread thread in pool) foreach (MatrixParallelWrap wrap in handle.Wraps)
{ {
bool hasSlice = columnAfterBaseTile > 0; bool hasSlice = columnAfterBaseTile > 0;
bool isLargeSlice = extraColumnCount > 0; bool isLargeSlice = extraColumnCount > 0;
// count tiles for wrap // count tiles for wrap
int wrapWidth =/**/ 3/* wrap!.WrapTaskCapacity/**/; int wrapWidth = wrap!.WrapTaskCapacity/**/;
int columnFromSlicingCount = (hasSlice ? extraColumnPerThread : 0) * wrapWidth; int columnFromSlicingCount = (hasSlice ? extraColumnPerThread : 0) * wrapWidth;
int baseColumn = wrapWidth * tilePerThreadLess * tileWidth; int baseColumn = wrapWidth * tilePerThreadLess * tileWidth;
int columnInWrap = baseColumn + columnFromSlicingCount + (isLargeSlice ? 1 : 0); int columnInWrap = baseColumn + columnFromSlicingCount + (isLargeSlice ? 1 : 0);
@@ -869,10 +875,7 @@ namespace StgSharp.Mathematics.Numeric
total -= columnInWrap; total -= columnInWrap;
// set to wrap and push // set to wrap and push
// wrap.Tasks.Enqueue((IntPtr)current); wrap.WrapTask = (MatrixParallelTaskPackageNonGeneric*)current;
// taskBunch.Push(wrap);
if (total <= 0) if (total <= 0)
{ {
@@ -882,7 +885,7 @@ namespace StgSharp.Mathematics.Numeric
current->PrimTileOffset += columnInWrap; current->PrimTileOffset += columnInWrap;
} }
return taskBunch; return handle;
} }
} }
StgSharp.Mathematics/Numeric/MatrixParallel.cs
+4 -31
View File
@@ -27,6 +27,7 @@
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
using StgSharp.Collections; using StgSharp.Collections;
using System; using System;
using System.Collections.Concurrent;
using System.Collections.Generic; using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis; using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
@@ -74,46 +75,18 @@ namespace StgSharp.Mathematics.Numeric
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
_threads.Push(new()); _threads.Push(new());
} }
_awaitingLeaderHandle = new ConcurrentQueue<WaitHandle>();
IsInitialized = true; IsInitialized = true;
} }
public static void LaunchParallel(IEnumerable<MatrixParallelWrap> wraps, SleepMode afterWork) public static void LaunchParallel(MatrixParallelHandle handle, SleepMode afterWork)
{ {
RemainThreadCount = _threads.Count; RemainThreadCount = _threads.Count;
_AfterWork = (ThreadPriority)afterWork; _AfterWork = (ThreadPriority)afterWork;
ResetThreadCount(); foreach (MatrixParallelWrap w in handle.Wraps) {
foreach (MatrixParallelWrap w in wraps) {
w.SchedulerReset.Set(); w.SchedulerReset.Set();
} }
} }
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void ResetThreadCount()
{
RemainThreadCount = _threads.Count;
}
#region wrap field
public static MatrixParallelThread[] LeadParallel(int recommendCount)
{
#if NET9_0_OR_GREATER
#else
Monitor.Enter(_lock);
#endif
return _threads.PopRange(recommendCount);
}
public static void ReleaseParallelLeadership(ref MatrixParallelThread[] pool)
{
#if NET9_0_OR_GREATER
#else
Monitor.Exit(_lock);
#endif
pool = null!;
}
#endregion
} }
} }
StgSharp.Mathematics/Numeric/MatrixParallelTask.cs → StgSharp.Mathematics/Numeric/MatrixParallelHandle.cs
View File
StgSharp.Mathematics/Numeric/MatrixParallelPool.cs
+30 -2
View File
@@ -78,6 +78,17 @@ namespace StgSharp.Mathematics.Numeric
} }
} }
internal IEnumerable<MatrixParallelWrap> Wraps
{
get
{
if (_disposed) {
throw new ObjectDisposedException(typeof(MatrixParallelHandle).Name);
}
return _wraps;
}
}
internal ReadOnlySpan<MatrixParallelThread> ThreadsUnsafe internal ReadOnlySpan<MatrixParallelThread> ThreadsUnsafe
{ {
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -91,10 +102,16 @@ namespace StgSharp.Mathematics.Numeric
if (_disposed) { if (_disposed) {
return; return;
} }
MatrixParallel.ReleaseParallelLeadership(ref _threads); MatrixParallel.ReturnParallelResources(ref _threads);
_disposed = true; _disposed = true;
} }
public MatrixParallelThread GetLeader()
{
Threads[0].Role = 2;
return Threads[0];
}
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
private static (int count_3, int count_4) FastDecompose(int c) private static (int count_3, int count_4) FastDecompose(int c)
{ {
@@ -139,11 +156,22 @@ namespace StgSharp.Mathematics.Numeric
int count = _threads.Length; int count = _threads.Length;
if (count < 6) if (count < 6)
{ {
MatrixParallelWrap wrap = new MatrixParallelWrap(_threads); MatrixParallelWrap wrap = new MatrixParallelWrap(_threads, 0, count);
_wraps = [ wrap ]; _wraps = [ wrap ];
} }
(int c3,int c4) = FastDecompose(_threads.Length); (int c3,int c4) = FastDecompose(_threads.Length);
_wraps = new(c3 + c4); _wraps = new(c3 + c4);
int begin = 0;
for (int i = 0; i < c3; i++)
{
_wraps.Push(new MatrixParallelWrap(_threads, begin, 3));
begin += 3;
}
for (int i = 0; i < c4; i++)
{
_wraps.Push(new MatrixParallelWrap(_threads, begin, 4));
begin += 4;
}
} }
} }
StgSharp.Mathematics/Numeric/MatrixParallelThread.cs
+21 -24
View File
@@ -118,30 +118,27 @@ namespace StgSharp.Mathematics.Numeric
private unsafe void MatrixParallelWorker() private unsafe void MatrixParallelWorker()
{ {
// Thread self = Thread.CurrentThread; // Thread self = Thread.CurrentThread;
do _resetEvent.Wait();
_resetEvent.Reset();
_managedThread.Priority = ThreadPriority.Highest;
switch (Role)
{ {
_resetEvent.Wait(); case 0://worker
_resetEvent.Reset(); // _ = Interlocked.Decrement(ref RemainThreadCount);
_managedThread.Priority = ThreadPriority.Highest; ExecuteTaskPackage(Tasks);
switch (Role) break;
{ case 1://scheduler
case 0://worker BindedWrap.PublishTaskToWorkers(Tasks);
// _ = Interlocked.Decrement(ref RemainThreadCount); BindedWrap.SetAllWorker();
ExecuteTaskPackage(Tasks); ExecuteTaskPackage(Tasks);
break;
case 1://scheduler
BindedWrap.PublishTaskToWorkers(Tasks);
BindedWrap.SetAllWorker();
ExecuteTaskPackage(Tasks);
break; break;
case 2://leader, error because leader should be at outer thread but not here case 2://leader, error because leader should be at outer thread but not here
break; break;
default: default:
break; break;
} }
_managedThread.Priority = AfterWork; _managedThread.Priority = AfterWork;
} while (true);
} }
#region wrap belong #region wrap belong
@@ -150,10 +147,10 @@ namespace StgSharp.Mathematics.Numeric
internal Queue<IntPtr> Tasks { get; } = []; internal Queue<IntPtr> Tasks { get; } = [];
internal int Role public int Role
{ {
get; get;
set internal set
{ {
if ((Role & (~3u)) == 0) if ((Role & (~3u)) == 0)
{ {
StgSharp.Mathematics/Numeric/MatrixParallelWrap.cs
+4 -2
View File
@@ -42,10 +42,12 @@ namespace StgSharp.Mathematics.Numeric
private readonly MatrixParallelThread[] _threads; private readonly MatrixParallelThread[] _threads;
private int _begin; private int _begin;
internal MatrixParallelWrap(MatrixParallelThread[] threads) internal MatrixParallelWrap(MatrixParallelThread[] threads, int begin, int count)
{ {
_threads = threads; _threads = threads;
_begin = begin;
Count = threads.Length; Count = threads.Length;
_threads[_begin].Role = 1;
} }
public MatrixParallelWrap() public MatrixParallelWrap()
@@ -90,7 +92,7 @@ namespace StgSharp.Mathematics.Numeric
int primAverage = primCount / Count; int primAverage = primCount / Count;
int secAverage = secCount / Count; int secAverage = secCount / Count;
bool shouldSliceSec = secAverage > 512; bool shouldSliceSec = secAverage > 512;
for (int i = 0; i < Count; i++) for (int i = _begin; i < _begin + Count; i++)
{ {
Queue<IntPtr> tasks = _threads[i].Tasks; Queue<IntPtr> tasks = _threads[i].Tasks;
MatrixParallelTaskPackageNonGeneric* subTask = MatrixParallelFactory.FromExistPackage(taskPackage); MatrixParallelTaskPackageNonGeneric* subTask = MatrixParallelFactory.FromExistPackage(taskPackage);
StgSharpDebug/Program.cs
+2
View File
@@ -32,6 +32,7 @@ using StgSharp.Graphics;
using StgSharp.HighPerformance; using StgSharp.HighPerformance;
using StgSharp.HighPerformance.Memory; using StgSharp.HighPerformance.Memory;
using StgSharp.Mathematics; using StgSharp.Mathematics;
using StgSharp.Mathematics.Graphic;
using StgSharp.Mathematics.Numeric; using StgSharp.Mathematics.Numeric;
using StgSharp.Model.Step; using StgSharp.Model.Step;
using StgSharp.MVVM; using StgSharp.MVVM;
@@ -61,6 +62,7 @@ namespace StgSharp
{ {
World.Init(); World.Init();
// New test with synchronized start: // New test with synchronized start:
// - 8 producer threads, each pushing 1000 unique integers // - 8 producer threads, each pushing 1000 unique integers
// - 8 consumer threads, each attempting to pop 1000 times // - 8 consumer threads, each attempting to pop 1000 times