From b32c1cb4eb8dce91a6b66478b09f5dcc3020e471 Mon Sep 17 00:00:00 2001 From: Youmu Liu <105042599+Nitload-NSI@users.noreply.github.com> Date: Thu, 18 Dec 2025 18:04:55 +0800 Subject: [PATCH] redesign matrix design --- .../{MatrixEnum.cs => Matrix.Create.cs} | 24 +- StgSharp.Common/Mathematics/Linear/Matrix.cs | 97 ++++---- .../Mathematics/Linear/MatrixMetadata.cs | 114 +++++++++ .../Mathematics/Linear/MatrixStorage.cs | 65 ++++++ .../Mathematics/Linear/Matrix_T.GC.cs | 124 ---------- .../Mathematics/Linear/Matrix_T.HLSF.cs | 137 ----------- .../Mathematics/Linear/Matrix_T.cs | 218 ------------------ .../Numeric/MatrixCompute.Factorize.cs | 2 +- StgSharp.Native/sn-src/k_pivot.c | 17 +- 9 files changed, 256 insertions(+), 542 deletions(-) rename StgSharp.Common/Mathematics/Linear/{MatrixEnum.cs => Matrix.Create.cs} (63%) create mode 100644 StgSharp.Common/Mathematics/Linear/MatrixMetadata.cs create mode 100644 StgSharp.Common/Mathematics/Linear/MatrixStorage.cs delete mode 100644 StgSharp.Common/Mathematics/Linear/Matrix_T.GC.cs delete mode 100644 StgSharp.Common/Mathematics/Linear/Matrix_T.HLSF.cs delete mode 100644 StgSharp.Common/Mathematics/Linear/Matrix_T.cs diff --git a/StgSharp.Common/Mathematics/Linear/MatrixEnum.cs b/StgSharp.Common/Mathematics/Linear/Matrix.Create.cs similarity index 63% rename from StgSharp.Common/Mathematics/Linear/MatrixEnum.cs rename to StgSharp.Common/Mathematics/Linear/Matrix.Create.cs index 4c0aee51..cde390e0 100644 --- a/StgSharp.Common/Mathematics/Linear/MatrixEnum.cs +++ b/StgSharp.Common/Mathematics/Linear/Matrix.Create.cs @@ -1,6 +1,6 @@ -//----------------------------------------------------------------------- +//----------------------------------------------------------------------- // ----------------------------------------------------------------------- -// file="MatrixEnum" +// file="Matrix.Create" // Project: StgSharp // AuthorGroup: Nitload // Copyright (c) Nitload. All rights reserved. @@ -25,6 +25,7 @@ // // ----------------------------------------------------------------------- // ----------------------------------------------------------------------- +using StgSharp.HighPerformance.Memory; using System; using System.Collections.Generic; using System.Linq; @@ -33,11 +34,24 @@ using System.Threading.Tasks; namespace StgSharp.Mathematics.Numeric { - public enum MatrixAllocation + public unsafe partial class Matrix { - HLSF, - GC, + public static Matrix Create( + int columnLength, + int rowLength, + HybridLayerSegregatedFitAllocator allocator) + { + Matrix matrix = new Matrix(); + int tSize = sizeof(T); + int totalSize = columnLength * rowLength * tSize; + HybridLayerSegregatedFitAllocationHandle handle = allocator.Alloc((uint)totalSize); + MatrixStorageHLSF storage = new MatrixStorageHLSF(handle); + storage._handle = handle; + matrix._buffer = storage; + matrix._enumeration = new MatrixMetadata(columnLength, rowLength); + return matrix; + } } } diff --git a/StgSharp.Common/Mathematics/Linear/Matrix.cs b/StgSharp.Common/Mathematics/Linear/Matrix.cs index 5738ecca..8ecf1326 100644 --- a/StgSharp.Common/Mathematics/Linear/Matrix.cs +++ b/StgSharp.Common/Mathematics/Linear/Matrix.cs @@ -25,59 +25,74 @@ // // ----------------------------------------------------------------------- // ----------------------------------------------------------------------- +using StgSharp.HighPerformance; +using StgSharp.Mathematics.Numeric; using System; -using System.Collections.Generic; -using System.Linq; using System.Numerics; using System.Runtime.CompilerServices; -using System.Text; -using System.Threading.Tasks; +using System.Runtime.InteropServices; -using hlsfAllocator = global::StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocator; +// using hlsfHandle = global::StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocationHandle; namespace StgSharp.Mathematics.Numeric { - public static class Matrix + public unsafe partial class Matrix where T : unmanaged, INumber { - public static hlsfAllocator? DefaultAllocator + private protected static readonly int t_count = 16 / sizeof(T); + + private protected static readonly int t_size = sizeof(T); + private MatrixMetadata _enumeration; + + private MatrixStorage _buffer; + + private protected Matrix() { } + + public ref T this[int column, int row] { - get - { - ArgumentNullException.ThrowIfNull(field, nameof(DefaultAllocator)); - return null; + get => throw new NotImplementedException(); + } + + public unsafe Matrix this[ + ReadOnlySpan column, + ReadOnlySpan row] + { + get { throw new NotImplementedException(); } + set { throw new NotImplementedException(); } + } + + /// + /// Length of the matrix in columns. + /// + public int ColumnLength { get; init; } + + /// + /// Length of the matrix in rows. + /// + public int RowLength { get; init; } + + public MatrixLayout Layout { get; init; } + + internal MatrixKernel* Buffer { get; } + + protected internal int KernelColumnLength { get; init; } + + protected internal int KernelRowLength { get; init; } + + public ref MatrixKernel GetMatrixKernel(int column, int row) + { + if (_enumeration.GetCurrentKernelIndex) { } else { } + } + + private protected void AssertIndex(int column, int row) + { + if (column < 0 || column >= ColumnLength) { + throw new ArgumentOutOfRangeException(nameof(column)); } - set; - } = null; - public static MatrixAllocation DefaultAllocation { get; set; } = MatrixAllocation.GC; - - public static Matrix FromDefault(int columnLength, int rowLength) - where T : unmanaged, INumber - { - return DefaultAllocation switch - { - MatrixAllocation.GC => FromGC(columnLength, rowLength), - MatrixAllocation.HLSF => FromHlsf(columnLength, rowLength, DefaultAllocator!), - _ => throw new NotSupportedException("This allocation is not supported."), - }; - } - - public static Matrix FromGC(int columnLength, int rowLength) - where T : unmanaged, INumber - { - return new GCMatrix(columnLength, rowLength); - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static Matrix FromHlsf( - int columnLength, - int rowLength, - hlsfAllocator allocator) - where T : unmanaged, INumber - { - ArgumentNullException.ThrowIfNull(allocator, nameof(allocator)); - return new HlsfMatrix(columnLength, rowLength, allocator); + if (row < 0 || row >= RowLength) { + throw new ArgumentOutOfRangeException(nameof(row)); + } } } diff --git a/StgSharp.Common/Mathematics/Linear/MatrixMetadata.cs b/StgSharp.Common/Mathematics/Linear/MatrixMetadata.cs new file mode 100644 index 00000000..754ea926 --- /dev/null +++ b/StgSharp.Common/Mathematics/Linear/MatrixMetadata.cs @@ -0,0 +1,114 @@ +//----------------------------------------------------------------------- +// ----------------------------------------------------------------------- +// file="MatrixMetadata" +// Project: StgSharp +// AuthorGroup: Nitload +// Copyright (c) Nitload. All rights reserved. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +// +// ----------------------------------------------------------------------- +// ----------------------------------------------------------------------- +using StgSharp.HighPerformance; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; + +namespace StgSharp.Mathematics.Numeric +{ + public enum MatrixLayout + { + + DenseSquare, + UpperTriangle, + LowerTriangle, + + } + + [StructLayout(LayoutKind.Sequential)] + public unsafe struct MatrixKernelEnumeration + { + + public readonly delegate* unmanaged[Cdecl] + GetIndexOffset; + + public readonly delegate* unmanaged[Cdecl] IsInBuffer; + + [Obsolete("Do not use constructor, use static method instead", true)] + public MatrixKernelEnumeration() { } + + public MatrixKernelEnumeration( + delegate* unmanaged[Cdecl] + getOffset, + delegate* unmanaged[Cdecl] inBuffer) + { + GetIndexOffset = getOffset; + IsInBuffer = inBuffer; + } + + private static delegate* unmanaged[Cdecl] IsInBufferDenseSquarePtr { get; } = (delegate* unmanaged[Cdecl])&IsInBufferDenseSquare; + + public static MatrixKernelEnumeration Create(MatrixLayout layout) + { + return layout switch + { + MatrixLayout.DenseSquare => new MatrixKernelEnumeration(null, IsInBufferDenseSquarePtr), + + MatrixLayout.UpperTriangle => throw new NotImplementedException(), + }; + } + + private static bool IsInBufferDenseSquare( + int col, + int row, + MatrixKernelEnumerator* enumerator) + { + return true; + } + + } + + [StructLayout(LayoutKind.Explicit)] + public struct MatrixSize + { + + [FieldOffset(0)] public readonly int ElementColumnLength; + [FieldOffset(4)] public readonly int ElementRowLength; + + [FieldOffset(8)] public readonly int KernelColumnLength; + [FieldOffset(12)] public readonly int KernelRowLength; + + } + + [StructLayout(LayoutKind.Explicit)] + public struct MatrixKernelEnumerator + { + + [FieldOffset(0)] public int CurrentColumn; + [FieldOffset(4)] public int CurrentRow; + + [FieldOffset(8)] public readonly int KernelColumnLength; + [FieldOffset(12)] public readonly int KernelRowLength; + + } +} diff --git a/StgSharp.Common/Mathematics/Linear/MatrixStorage.cs b/StgSharp.Common/Mathematics/Linear/MatrixStorage.cs new file mode 100644 index 00000000..696ba01a --- /dev/null +++ b/StgSharp.Common/Mathematics/Linear/MatrixStorage.cs @@ -0,0 +1,65 @@ +//----------------------------------------------------------------------- +// ----------------------------------------------------------------------- +// file="MatrixStorage" +// Project: StgSharp +// AuthorGroup: Nitload +// Copyright (c) Nitload. All rights reserved. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +// +// ----------------------------------------------------------------------- +// ----------------------------------------------------------------------- +using StgSharp.HighPerformance.Memory; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Numerics; +using System.Text; +using System.Threading.Tasks; + +using HLSFAllocator = global::StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocator; +using HLSFHandle = global::StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocationHandle; + +namespace StgSharp.Mathematics.Numeric +{ + public abstract class MatrixStorage : IDisposable where T : unmanaged, INumber + { + + protected internal abstract unsafe T* BufferPointer { get; } + + public abstract void Dispose(); + + } + + internal class MatrixStorageHLSF(HLSFAllocator allocator, HLSFHandle handle) : MatrixStorage + where T : unmanaged, INumber + { + + internal HLSFAllocator _allocator = allocator; + internal HLSFHandle _handle = handle; + + protected internal override unsafe T* BufferPointer => (T*)_handle.Pointer; + + public override void Dispose() + { + allocator.Free(_handle); + } + + } +} diff --git a/StgSharp.Common/Mathematics/Linear/Matrix_T.GC.cs b/StgSharp.Common/Mathematics/Linear/Matrix_T.GC.cs deleted file mode 100644 index 5d971427..00000000 --- a/StgSharp.Common/Mathematics/Linear/Matrix_T.GC.cs +++ /dev/null @@ -1,124 +0,0 @@ -//----------------------------------------------------------------------- -// ----------------------------------------------------------------------- -// file="Matrix_T.GC" -// Project: StgSharp -// AuthorGroup: Nitload -// Copyright (c) Nitload. All rights reserved. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -// SOFTWARE. -// -// ----------------------------------------------------------------------- -// ----------------------------------------------------------------------- -using StgSharp.HighPerformance; -using StgSharp.Mathematics; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Numerics; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using System.Text; -using System.Threading.Tasks; - -namespace StgSharp.Mathematics.Numeric -{ - internal unsafe partial class GCMatrix : Matrix where T : unmanaged, INumber - { - - private readonly MatrixKernel* _buffer; - - public GCMatrix(int column, int row) - { - KernelColumnLength = (column + 3) / 4; - KernelRowLength = (row + 3) / t_count; - ColumnLength = column; - RowLength = row; - _buffer = (MatrixKernel*)NativeMemory.AlignedAlloc((nuint)(column * row * sizeof(T)), (nuint)World.DefaultSIMDAlignment); - } - - public override ref T this[int column, int row] - { - get - { - 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[c, r]; - } - } - - public override Matrix this[ReadOnlySpan column, ReadOnlySpan row] - { - get => throw new NotImplementedException(); - set => throw new NotImplementedException(); - } - - internal override unsafe MatrixKernel* Buffer - { - [MethodImpl(MethodImplOptions.AggressiveInlining)] - get => _buffer; - } - - public override unsafe ref MatrixKernel GetMatrixKernel(int column, int row) - { - AssertIndex(column, row); - int kernelColumn = column / 4; - int kernelRow = row / t_count; - return ref _buffer[kernelColumn + (KernelColumnLength * kernelRow)]; - } - - public override ref T UnsafeIndex(int column, int 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[c, r]; - } - - ~GCMatrix() - { - NativeMemory.AlignedFree(_buffer); - } - - #region enumeration - - public override unsafe MatrixSegmentEnumeration ColumnEnumeration - { - [MethodImpl(MethodImplOptions.AggressiveInlining)] - get => new MatrixSegmentEnumeration(_buffer, KernelColumnLength, KernelColumnLength * KernelRowLength, 1, - KernelColumnLength); - } - - public override unsafe MatrixSegmentEnumeration GetRowEnumeration() - { - return new MatrixSegmentEnumeration(_buffer, 1, KernelColumnLength, KernelColumnLength, KernelRowLength); - } - - public override unsafe MatrixSegmentEnumeration SequentialEnumeration - { - [MethodImpl(MethodImplOptions.AggressiveInlining)] - get => new MatrixSegmentEnumeration(_buffer, KernelRowLength * KernelColumnLength, - KernelColumnLength * KernelRowLength, 1, - KernelRowLength * KernelColumnLength); - } - - #endregion - } -} diff --git a/StgSharp.Common/Mathematics/Linear/Matrix_T.HLSF.cs b/StgSharp.Common/Mathematics/Linear/Matrix_T.HLSF.cs deleted file mode 100644 index c0b28d22..00000000 --- a/StgSharp.Common/Mathematics/Linear/Matrix_T.HLSF.cs +++ /dev/null @@ -1,137 +0,0 @@ -//----------------------------------------------------------------------- -// ----------------------------------------------------------------------- -// file="Matrix_T.HLSF" -// Project: StgSharp -// AuthorGroup: Nitload -// Copyright (c) Nitload. All rights reserved. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -// SOFTWARE. -// -// ----------------------------------------------------------------------- -// ----------------------------------------------------------------------- -using StgSharp.HighPerformance; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Numerics; -using System.Runtime.CompilerServices; -using System.Text; -using System.Threading.Tasks; - -using hlsfAllocator = global::StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocator; -using hlsfHandle = global::StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocationHandle; - -namespace StgSharp.Mathematics.Numeric -{ - internal unsafe partial class HlsfMatrix : Matrix where T : unmanaged, INumber - { - - private readonly MatrixKernel* k_buffer; - private readonly hlsfAllocator allocator; - private readonly hlsfHandle handle; - - internal HlsfMatrix(int column, int row, hlsfAllocator allocator) - { - KernelColumnLength = (column + 3) / 4; - KernelRowLength = (row + 3) / t_count; - ColumnLength = column; - RowLength = row; - long size = (long)KernelColumnLength * (long)KernelRowLength * (long)sizeof(MatrixKernel); - this.handle = allocator.Alloc((uint)(size)); - if (handle.AllocSize < size) { - throw new InsufficientMemoryException(); - } - k_buffer = (MatrixKernel*)handle.Pointer; - } - - public override ref T this[int column, int row] - { - get - { - 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[c, r]; - } - } - - public override Matrix this[ - ReadOnlySpan column, - ReadOnlySpan row] - { - get => throw new NotImplementedException(); - set => throw new NotImplementedException(); - } - - internal override unsafe MatrixKernel* Buffer - { - [MethodImpl(MethodImplOptions.AggressiveInlining)] - get => k_buffer; - } - - public override unsafe ref MatrixKernel GetMatrixKernel(int column, int row) - { - AssertIndex(column, row); - int kernelColumn = column / 4, c = column % 4; - int kernelRow = row / t_count, r = row % t_count; - return ref k_buffer[(kernelColumn * kernelColumn) + kernelRow]; - } - - public override ref T UnsafeIndex(int column, int 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[c, r]; - } - - ~HlsfMatrix() - { - allocator.Free(handle); - } - - #region enumeration - - public override unsafe MatrixSegmentEnumeration ColumnEnumeration - { - [MethodImpl(MethodImplOptions.AggressiveInlining)] - get => new MatrixSegmentEnumeration(k_buffer, KernelColumnLength, - KernelColumnLength * KernelRowLength, 1, - KernelColumnLength); - } - - public override unsafe MatrixSegmentEnumeration GetRowEnumeration() - { - return new MatrixSegmentEnumeration(k_buffer, 1, KernelColumnLength, - KernelColumnLength, KernelRowLength); - } - - public override unsafe MatrixSegmentEnumeration SequentialEnumeration - { - [MethodImpl(MethodImplOptions.AggressiveInlining)] - - get => new MatrixSegmentEnumeration(k_buffer, KernelRowLength * KernelColumnLength, - KernelColumnLength * KernelRowLength, 1, - KernelRowLength * KernelColumnLength); - } - - #endregion - } -} diff --git a/StgSharp.Common/Mathematics/Linear/Matrix_T.cs b/StgSharp.Common/Mathematics/Linear/Matrix_T.cs deleted file mode 100644 index 3d1e3cff..00000000 --- a/StgSharp.Common/Mathematics/Linear/Matrix_T.cs +++ /dev/null @@ -1,218 +0,0 @@ -//----------------------------------------------------------------------- -// ----------------------------------------------------------------------- -// file="Matrix_T" -// Project: StgSharp -// AuthorGroup: Nitload -// Copyright (c) Nitload. All rights reserved. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -// SOFTWARE. -// -// ----------------------------------------------------------------------- -// ----------------------------------------------------------------------- -using StgSharp.HighPerformance; -using System; -using System.Numerics; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; - -// using hlsfHandle = global::StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocationHandle; - -namespace StgSharp.Mathematics.Numeric -{ - public abstract unsafe partial class Matrix where T : unmanaged, INumber - { - - private protected readonly int t_count = 16 / sizeof(T); - - private protected readonly int t_size = sizeof(T); - - private protected Matrix() { } - - public abstract ref T this[int column, int row] - { - get; - } - - public abstract unsafe Matrix this[ReadOnlySpan column, ReadOnlySpan row] - { - get; - set; - } - - /// - /// Length of the matrix in columns. - /// - public int ColumnLength { get; init; } - - /// - /// Length of the matrix in rows. - /// - public int RowLength { get; init; } - - public abstract MatrixSegmentEnumeration ColumnEnumeration { get; } - - public abstract MatrixSegmentEnumeration SequentialEnumeration { get; } - - internal abstract MatrixKernel* Buffer { get; } - - protected internal int KernelColumnLength { get; init; } - - protected internal int KernelRowLength { get; init; } - - public abstract ref MatrixKernel GetMatrixKernel(int column, int row); - - public abstract MatrixSegmentEnumeration GetRowEnumeration(); - - [Obsolete("This method does not contain boarder check, so be careful on size or use indexer instead.", false)] - public abstract ref T UnsafeIndex(int column, int row); - - private protected void AssertIndex(int column, int row) - { - if (column < 0 || column >= ColumnLength) { - throw new ArgumentOutOfRangeException(nameof(column)); - } - - if (row < 0 || row >= RowLength) { - throw new ArgumentOutOfRangeException(nameof(row)); - } - } - - } - - public readonly unsafe ref struct MatrixSegmentEnumeration( - MatrixKernel* source, - int primStride, - int primSize, - int secondaryStride, - int secondarySize, - int primOffset = 0, - int secondaryOffset = 0) - where T : unmanaged, INumber - { - - private readonly MatrixKernel* _source = source; - internal readonly int PrimOffset = primOffset; - - internal readonly int PrimSize = primSize; - internal readonly int PrimStride = primStride; - internal readonly int SecondaryOffset = secondaryOffset; - internal readonly int SecondarySize = secondarySize; - internal readonly int SecondaryStride = secondaryStride; - - internal readonly MatrixKernel* Source - { - [MethodImpl(MethodImplOptions.AggressiveInlining)] - get => _source; - } - - public Enumerator GetEnumerator() - { - return new Enumerator(in this); - } - - public ref struct Enumerator(in MatrixSegmentEnumeration enumeration) - { - - private readonly MatrixKernel* _source = enumeration._source; - private int _indexCount = -1; - 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 _enumeration; - - public readonly MatrixSegment Current - { - [MethodImpl(MethodImplOptions.AggressiveInlining)] - get => new(_source + _index, _enumeration.SecondarySize, _enumeration.SecondaryStride, - _enumeration.PrimOffset); - } - - public bool MoveNext() - { - _indexCount++; - _index += _stride; - if (_index >= _bound) { - _index = 0; - } - return _indexCount >= _enumeration.PrimSize; - } - - } - - } - - public readonly unsafe ref struct MatrixSegment(MatrixKernel* source, int size, int stride, int offset) - where T : unmanaged, INumber - { - - private readonly MatrixKernel* _source = source; - private readonly int _offset = offset; - private readonly int _secondarySize = size; - private readonly int _size = size; - private readonly int _stride = stride; - - public ref MatrixKernel this[int index] - { - get - { - if (index < 0 || index >= _size) { - throw new ArgumentOutOfRangeException(nameof(index)); - } - return ref _source[index * _stride]; - } - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public Enumerator GetEnumerator() - { - return new Enumerator(in this); - } - - public ref struct Enumerator(in MatrixSegment segment) - { - - private readonly int _end = segment._size; - - private int _indexCount = -1; - private readonly long _bound = (long)segment._size * segment._stride; - private long _index = (long)segment._offset * segment._stride; - private readonly MatrixSegment _segment = segment; - - public readonly MatrixKernel* Current - { - [MethodImpl(MethodImplOptions.AggressiveInlining)] - get => _segment._source + _index; - } - - public bool MoveNext() - { - _index += _segment._stride; - _indexCount++; - if (_index >= _bound) { - _index = 0; - } - - return _indexCount < _end; - } - - } - - } -} diff --git a/StgSharp.Mathematics/Numeric/MatrixCompute.Factorize.cs b/StgSharp.Mathematics/Numeric/MatrixCompute.Factorize.cs index ebc58bdd..c2b8d787 100644 --- a/StgSharp.Mathematics/Numeric/MatrixCompute.Factorize.cs +++ b/StgSharp.Mathematics/Numeric/MatrixCompute.Factorize.cs @@ -38,7 +38,7 @@ namespace StgSharp.Mathematics.Numeric public static void FactorizePLU( Matrix matrix, - Matrix p, + Span p, Matrix lower, Matrix upper) { diff --git a/StgSharp.Native/sn-src/k_pivot.c b/StgSharp.Native/sn-src/k_pivot.c index 6617c14b..c2b51c7b 100644 --- a/StgSharp.Native/sn-src/k_pivot.c +++ b/StgSharp.Native/sn-src/k_pivot.c @@ -2,7 +2,7 @@ // Hybrid implementation: SIMD for Abs, Scalar for Max // Assumes Column-Major layout for both MAT_KERNEL content and Kernel sequence -static void povit_float_simd_abs(MAT_KERNEL(float) const *source, size_t col_begin, +static void povit_float(MAT_KERNEL(float) const *source, size_t col_begin, size_t col_length, size_t *restrict ans) { float max_v[4] = { -1.0f, -1.0f, -1.0f, -1.0f }; @@ -62,18 +62,3 @@ static void povit_float_simd_abs(MAT_KERNEL(float) const *source, size_t col_beg } } } - -DECLARE_MAT_POVIT_PROC(float, sse) -{ - povit_float_simd_abs(source, col_begin, col_length, ans); -} - -DECLARE_MAT_POVIT_PROC(float, avx) -{ - povit_float_simd_abs(source, col_begin, col_length, ans); -} - -DECLARE_MAT_POVIT_PROC(float, 512) -{ - povit_float_simd_abs(source, col_begin, col_length, ans); -}