diff --git a/StgSharp.Common/Mathematics/Linear/KernelParallel.cs b/StgSharp.Common/Mathematics/Linear/KernelParallel.cs new file mode 100644 index 00000000..598f3dcb --- /dev/null +++ b/StgSharp.Common/Mathematics/Linear/KernelParallel.cs @@ -0,0 +1,40 @@ +//----------------------------------------------------------------------- +// ----------------------------------------------------------------------- +// file="KernelParallel.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 System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StgSharp.Mathematics +{ + internal class KernelParallel { } +} diff --git a/StgSharp.Common/Mathematics/Linear/Matrix.Basic.cs b/StgSharp.Common/Mathematics/Linear/Matrix.Basic.cs new file mode 100644 index 00000000..88486b88 --- /dev/null +++ b/StgSharp.Common/Mathematics/Linear/Matrix.Basic.cs @@ -0,0 +1,52 @@ +//----------------------------------------------------------------------- +// ----------------------------------------------------------------------- +// file="Matrix.Basic.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 System; +using System.Collections.Generic; +using System.Linq; +using System.Security.AccessControl; +using System.Text; +using System.Threading.Tasks; + +namespace StgSharp.Mathematics +{ + public static class Matrix + { + + public static Matrix Add(Matrix left, Matrix right) + { + if (left.ColumnLength != right.ColumnLength || left.RowLength != right.RowLength) { + throw new IndexOutOfRangeException("Matrix dimensions must agree."); + } + Matrix result = GCMatrix.FromDefault(left.ColumnLength, left.RowLength); + } + + } +} diff --git a/StgSharp.Common/Mathematics/Linear/Matrix.GC.cs b/StgSharp.Common/Mathematics/Linear/Matrix.GC.cs new file mode 100644 index 00000000..1a23bf2b --- /dev/null +++ b/StgSharp.Common/Mathematics/Linear/Matrix.GC.cs @@ -0,0 +1,111 @@ +//----------------------------------------------------------------------- +// ----------------------------------------------------------------------- +// file="Matrix.GC.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 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 +{ + 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; + _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.UnsafeIndex(c, r); + } + } + + public override Matrix this[ReadOnlySpan column, ReadOnlySpan row] + { + get => throw new NotImplementedException(); + set => throw new NotImplementedException(); + } + + 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.UnsafeIndex(c, r); + } + + #region enumeration + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override unsafe MatrixSegmentEnumeration GetColumnEnumeration() + { + return new MatrixSegmentEnumeration(_buffer, KernelColumnLength, KernelColumnLength * KernelRowLength, 1, KernelColumnLength); + } + + public override unsafe MatrixSegmentEnumeration GetRowEnumeration() + { + return new MatrixSegmentEnumeration(_buffer, 1, KernelColumnLength, KernelColumnLength, KernelRowLength); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override unsafe MatrixSegmentEnumeration GetSequentialEnumeration() + { + return new MatrixSegmentEnumeration(_buffer, KernelRowLength * KernelColumnLength, KernelColumnLength * KernelRowLength, 1, KernelRowLength * KernelColumnLength); + } + + #endregion + } +} diff --git a/StgSharp.Common/Mathematics/Linear/Matrix.HLSF.cs b/StgSharp.Common/Mathematics/Linear/Matrix.HLSF.cs new file mode 100644 index 00000000..c1053dd3 --- /dev/null +++ b/StgSharp.Common/Mathematics/Linear/Matrix.HLSF.cs @@ -0,0 +1,120 @@ +//----------------------------------------------------------------------- +// ----------------------------------------------------------------------- +// file="Matrix.HLSF.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.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 +{ + 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; + this.handle = allocator.Alloc((uint)(KernelColumnLength * KernelRowLength * sizeof(MatrixKernel))); + 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.UnsafeIndex(c, r); + } + } + + public override Matrix this[ReadOnlySpan column, ReadOnlySpan row] + { + get => throw new NotImplementedException(); + set => throw new NotImplementedException(); + } + + 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.UnsafeIndex(c, r); + } + + ~HlsfMatrix() + { + allocator.Free(handle); + } + + #region enumeration + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override unsafe MatrixSegmentEnumeration GetColumnEnumeration() + { + return new MatrixSegmentEnumeration(k_buffer, KernelColumnLength, KernelColumnLength * KernelRowLength, 1, KernelColumnLength); + } + + public override unsafe MatrixSegmentEnumeration GetRowEnumeration() + { + return new MatrixSegmentEnumeration(k_buffer, 1, KernelColumnLength, KernelColumnLength, KernelRowLength); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override unsafe MatrixSegmentEnumeration GetSequentialEnumeration() + { + return new MatrixSegmentEnumeration(k_buffer, KernelRowLength * KernelColumnLength, KernelColumnLength * KernelRowLength, 1, KernelRowLength * KernelColumnLength); + } + + #endregion + } +} diff --git a/StgSharp.Common/Mathematics/Linear/MatrixEnum.cs b/StgSharp.Common/Mathematics/Linear/MatrixEnum.cs new file mode 100644 index 00000000..5f6521c0 --- /dev/null +++ b/StgSharp.Common/Mathematics/Linear/MatrixEnum.cs @@ -0,0 +1,46 @@ +//----------------------------------------------------------------------- +// ----------------------------------------------------------------------- +// file="MatrixEnum.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 System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StgSharp.Mathematics +{ + public enum MatrixAllocation + { + + HLSF, + GC, + + } +} diff --git a/StgSharp.Common/Mathematics/Linear/MatrixIndex.cs b/StgSharp.Common/Mathematics/Linear/MatrixIndex.cs new file mode 100644 index 00000000..0012e3e0 --- /dev/null +++ b/StgSharp.Common/Mathematics/Linear/MatrixIndex.cs @@ -0,0 +1,77 @@ +//----------------------------------------------------------------------- +// ----------------------------------------------------------------------- +// file="MatrixIndex.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 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 +{ + [StructLayout(LayoutKind.Sequential)] + public readonly struct MatrixIndex + { + + public readonly int Begin; + public readonly int End; + + private MatrixIndex(int begin, int end, bool safe = false) + { + Begin = begin; + End = end; + } + + internal MatrixIndex(int begin, int end) + { + if (begin > end) { + throw new ArgumentException("Begin index cannot be greater than end index."); + } + + Begin = begin; + End = end; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator MatrixIndex((int, int) range) + { + return new(range.Item1, range.Item2, false); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator MatrixIndex(int index) + { + return new(index, -1, false); + } + + } +} diff --git a/StgSharp.Common/Mathematics/Linear/MatrixMarshal.cs b/StgSharp.Common/Mathematics/Linear/MatrixMarshal.cs new file mode 100644 index 00000000..967a3a1f --- /dev/null +++ b/StgSharp.Common/Mathematics/Linear/MatrixMarshal.cs @@ -0,0 +1,40 @@ +//----------------------------------------------------------------------- +// ----------------------------------------------------------------------- +// file="MatrixMarshal.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 System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StgSharp.Mathematics +{ + public readonly ref struct MatrixMarshal { } +} diff --git a/StgSharp.Common/Mathematics/Linear/MatrixParallelTask.cs b/StgSharp.Common/Mathematics/Linear/MatrixParallelTask.cs new file mode 100644 index 00000000..c1992c9b --- /dev/null +++ b/StgSharp.Common/Mathematics/Linear/MatrixParallelTask.cs @@ -0,0 +1,72 @@ +//----------------------------------------------------------------------- +// ----------------------------------------------------------------------- +// file="MatrixParallelTask.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.Drawing; +using System.IO.Pipes; +using System.Linq; +using System.Numerics; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace StgSharp.Mathematics +{ + [StructLayout(LayoutKind.Explicit)] + internal unsafe struct MatrixParallelTask + { + + [FieldOffset(0)] public MatrixKernel* left; + [FieldOffset(8)] public MatrixKernel* result; + [FieldOffset(16)]public MatrixKernel* right; + [FieldOffset(24)]public int constCount; + [FieldOffset(32)]public IntPtr executionHandle; + + } + + [StructLayout(LayoutKind.Explicit)] + internal unsafe struct MatrixParallelTask where T: unmanaged, INumber + { + + [FieldOffset(0)] public MatrixKernel* left; + [FieldOffset(8)] public MatrixKernel* result; + [FieldOffset(16)]public MatrixKernel* right; + [FieldOffset(24)]public int constCount; + [FieldOffset(32)] public IntPtr executionHandle; + [FieldOffset(0)] public MatrixParallelTask task; + [FieldOffset(sizeof(MatrixParallelTask))]public T Constant; + + public void Execute() { } + + } +} diff --git a/StgSharp.Native/.clang-format b/StgSharp.Native/.clang-format new file mode 100644 index 00000000..89332e75 --- /dev/null +++ b/StgSharp.Native/.clang-format @@ -0,0 +1,747 @@ +# Format Style Options - Created with Clang Power Tools +--- +AccessModifierOffset: -4 +AlignAfterOpenBracket: Align +AlignConsecutiveAssignments: false +AlignConsecutiveDeclarations: false +AlignEscapedNewlines: Left +AlignOperands: true +AlignTrailingComments: false +AllowAllParametersOfDeclarationOnNextLine: false +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: None +AllowShortIfStatementsOnASingleLine: false +AllowShortLoopsOnASingleLine: false +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: false +AlwaysBreakTemplateDeclarations: false +BinPackArguments: true +BinPackParameters: true +BraceWrapping: + AfterCaseLabel: false + AfterClass: false + AfterControlStatement: false + AfterEnum: false + AfterFunction: true + AfterNamespace: true + AfterObjCDeclaration: false + AfterStruct: false + AfterUnion: false + AfterExternBlock: false + BeforeCatch: false + BeforeElse: false + IndentBraces: false + SplitEmptyFunction: true + SplitEmptyRecord: true + SplitEmptyNamespace: true + BeforeLambdaBody: false + BeforeWhile: false +BreakBeforeBinaryOperators: None +BreakBeforeBraces: Custom +BreakBeforeInheritanceComma: false +BreakBeforeTernaryOperators: false +BreakConstructorInitializers: BeforeComma +BreakAfterJavaFieldAnnotations: false +BreakStringLiterals: false +ColumnLimit: 100 +CommentPragmas: '^ IWYU pragma:' +CompactNamespaces: false +ConstructorInitializerAllOnOneLineOrOnePerLine: false +ConstructorInitializerIndentWidth : 8 +ContinuationIndentWidth: 8 +Cpp11BracedListStyle: false +DerivePointerAlignment: false +ExperimentalAutoDetectBinPacking: false +FixNamespaceComments: false +ForEachMacros: + - '__ata_qc_for_each' + - '__bio_for_each_bvec' + - '__bio_for_each_segment' + - '__evlist__for_each_entry' + - '__evlist__for_each_entry_continue' + - '__evlist__for_each_entry_from' + - '__evlist__for_each_entry_reverse' + - '__evlist__for_each_entry_safe' + - '__for_each_mem_range' + - '__for_each_mem_range_rev' + - '__for_each_thread' + - '__hlist_for_each_rcu' + - '__map__for_each_symbol_by_name' + - '__pci_bus_for_each_res0' + - '__pci_bus_for_each_res1' + - '__pci_dev_for_each_res0' + - '__pci_dev_for_each_res1' + - '__perf_evlist__for_each_entry' + - '__perf_evlist__for_each_entry_reverse' + - '__perf_evlist__for_each_entry_safe' + - '__rq_for_each_bio' + - '__shost_for_each_device' + - '__sym_for_each' + - 'apei_estatus_for_each_section' + - 'ata_for_each_dev' + - 'ata_for_each_link' + - 'ata_qc_for_each' + - 'ata_qc_for_each_raw' + - 'ata_qc_for_each_with_internal' + - 'ax25_for_each' + - 'ax25_uid_for_each' + - 'bio_for_each_bvec' + - 'bio_for_each_bvec_all' + - 'bio_for_each_folio_all' + - 'bio_for_each_integrity_vec' + - 'bio_for_each_segment' + - 'bio_for_each_segment_all' + - 'bio_list_for_each' + - 'bip_for_each_vec' + - 'bond_for_each_slave' + - 'bond_for_each_slave_rcu' + - 'bpf_for_each' + - 'bpf_for_each_reg_in_vstate' + - 'bpf_for_each_reg_in_vstate_mask' + - 'bpf_for_each_spilled_reg' + - 'bpf_object__for_each_map' + - 'bpf_object__for_each_program' + - 'btree_for_each_safe128' + - 'btree_for_each_safe32' + - 'btree_for_each_safe64' + - 'btree_for_each_safel' + - 'card_for_each_dev' + - 'cgroup_taskset_for_each' + - 'cgroup_taskset_for_each_leader' + - 'cpu_aggr_map__for_each_idx' + - 'cpufreq_for_each_efficient_entry_idx' + - 'cpufreq_for_each_entry' + - 'cpufreq_for_each_entry_idx' + - 'cpufreq_for_each_valid_entry' + - 'cpufreq_for_each_valid_entry_idx' + - 'css_for_each_child' + - 'css_for_each_descendant_post' + - 'css_for_each_descendant_pre' + - 'damon_for_each_region' + - 'damon_for_each_region_from' + - 'damon_for_each_region_safe' + - 'damon_for_each_scheme' + - 'damon_for_each_scheme_safe' + - 'damon_for_each_target' + - 'damon_for_each_target_safe' + - 'damos_for_each_filter' + - 'damos_for_each_filter_safe' + - 'damos_for_each_quota_goal' + - 'damos_for_each_quota_goal_safe' + - 'data__for_each_file' + - 'data__for_each_file_new' + - 'data__for_each_file_start' + - 'device_for_each_child_node' + - 'device_for_each_child_node_scoped' + - 'dma_fence_array_for_each' + - 'dma_fence_chain_for_each' + - 'dma_fence_unwrap_for_each' + - 'dma_resv_for_each_fence' + - 'dma_resv_for_each_fence_unlocked' + - 'do_for_each_ftrace_op' + - 'drm_atomic_crtc_for_each_plane' + - 'drm_atomic_crtc_state_for_each_plane' + - 'drm_atomic_crtc_state_for_each_plane_state' + - 'drm_atomic_for_each_plane_damage' + - 'drm_client_for_each_connector_iter' + - 'drm_client_for_each_modeset' + - 'drm_connector_for_each_possible_encoder' + - 'drm_exec_for_each_locked_object' + - 'drm_exec_for_each_locked_object_reverse' + - 'drm_for_each_bridge_in_chain' + - 'drm_for_each_connector_iter' + - 'drm_for_each_crtc' + - 'drm_for_each_crtc_reverse' + - 'drm_for_each_encoder' + - 'drm_for_each_encoder_mask' + - 'drm_for_each_fb' + - 'drm_for_each_legacy_plane' + - 'drm_for_each_plane' + - 'drm_for_each_plane_mask' + - 'drm_for_each_privobj' + - 'drm_gem_for_each_gpuvm_bo' + - 'drm_gem_for_each_gpuvm_bo_safe' + - 'drm_gpuva_for_each_op' + - 'drm_gpuva_for_each_op_from_reverse' + - 'drm_gpuva_for_each_op_reverse' + - 'drm_gpuva_for_each_op_safe' + - 'drm_gpuvm_bo_for_each_va' + - 'drm_gpuvm_bo_for_each_va_safe' + - 'drm_gpuvm_for_each_va' + - 'drm_gpuvm_for_each_va_range' + - 'drm_gpuvm_for_each_va_range_safe' + - 'drm_gpuvm_for_each_va_safe' + - 'drm_mm_for_each_hole' + - 'drm_mm_for_each_node' + - 'drm_mm_for_each_node_in_range' + - 'drm_mm_for_each_node_safe' + - 'dsa_switch_for_each_available_port' + - 'dsa_switch_for_each_cpu_port' + - 'dsa_switch_for_each_cpu_port_continue_reverse' + - 'dsa_switch_for_each_port' + - 'dsa_switch_for_each_port_continue_reverse' + - 'dsa_switch_for_each_port_safe' + - 'dsa_switch_for_each_user_port' + - 'dsa_switch_for_each_user_port_continue_reverse' + - 'dsa_tree_for_each_cpu_port' + - 'dsa_tree_for_each_user_port' + - 'dsa_tree_for_each_user_port_continue_reverse' + - 'dso__for_each_symbol' + - 'elf_hash_for_each_possible' + - 'elf_symtab__for_each_symbol' + - 'evlist__for_each_cpu' + - 'evlist__for_each_entry' + - 'evlist__for_each_entry_continue' + - 'evlist__for_each_entry_from' + - 'evlist__for_each_entry_reverse' + - 'evlist__for_each_entry_safe' + - 'flow_action_for_each' + - 'for_each_acpi_consumer_dev' + - 'for_each_acpi_dev_match' + - 'for_each_active_dev_scope' + - 'for_each_active_drhd_unit' + - 'for_each_active_iommu' + - 'for_each_active_route' + - 'for_each_aggr_pgid' + - 'for_each_and_bit' + - 'for_each_andnot_bit' + - 'for_each_available_child_of_node' + - 'for_each_available_child_of_node_scoped' + - 'for_each_bench' + - 'for_each_bio' + - 'for_each_board_func_rsrc' + - 'for_each_btf_ext_rec' + - 'for_each_btf_ext_sec' + - 'for_each_bvec' + - 'for_each_card_auxs' + - 'for_each_card_auxs_safe' + - 'for_each_card_components' + - 'for_each_card_dapms' + - 'for_each_card_pre_auxs' + - 'for_each_card_prelinks' + - 'for_each_card_rtds' + - 'for_each_card_rtds_safe' + - 'for_each_card_widgets' + - 'for_each_card_widgets_safe' + - 'for_each_cgroup_storage_type' + - 'for_each_child_of_node' + - 'for_each_child_of_node_scoped' + - 'for_each_clear_bit' + - 'for_each_clear_bit_from' + - 'for_each_clear_bitrange' + - 'for_each_clear_bitrange_from' + - 'for_each_cmd' + - 'for_each_cmsghdr' + - 'for_each_collection' + - 'for_each_comp_order' + - 'for_each_compatible_node' + - 'for_each_component_dais' + - 'for_each_component_dais_safe' + - 'for_each_conduit' + - 'for_each_console' + - 'for_each_console_srcu' + - 'for_each_cpu' + - 'for_each_cpu_and' + - 'for_each_cpu_andnot' + - 'for_each_cpu_from' + - 'for_each_cpu_or' + - 'for_each_cpu_wrap' + - 'for_each_dapm_widgets' + - 'for_each_dedup_cand' + - 'for_each_dev_addr' + - 'for_each_dev_scope' + - 'for_each_dma_cap_mask' + - 'for_each_dpcm_be' + - 'for_each_dpcm_be_rollback' + - 'for_each_dpcm_be_safe' + - 'for_each_dpcm_fe' + - 'for_each_drhd_unit' + - 'for_each_dss_dev' + - 'for_each_efi_memory_desc' + - 'for_each_efi_memory_desc_in_map' + - 'for_each_element' + - 'for_each_element_extid' + - 'for_each_element_id' + - 'for_each_enabled_cpu' + - 'for_each_endpoint_of_node' + - 'for_each_event' + - 'for_each_event_tps' + - 'for_each_evictable_lru' + - 'for_each_fib6_node_rt_rcu' + - 'for_each_fib6_walker_rt' + - 'for_each_file_lock' + - 'for_each_free_mem_pfn_range_in_zone_from' + - 'for_each_free_mem_range' + - 'for_each_free_mem_range_reverse' + - 'for_each_func_rsrc' + - 'for_each_gpiochip_node' + - 'for_each_group_evsel' + - 'for_each_group_evsel_head' + - 'for_each_group_member' + - 'for_each_group_member_head' + - 'for_each_hstate' + - 'for_each_hwgpio' + - 'for_each_if' + - 'for_each_inject_fn' + - 'for_each_insn' + - 'for_each_insn_op_loc' + - 'for_each_insn_prefix' + - 'for_each_intid' + - 'for_each_iommu' + - 'for_each_ip_tunnel_rcu' + - 'for_each_irq_nr' + - 'for_each_lang' + - 'for_each_link_ch_maps' + - 'for_each_link_codecs' + - 'for_each_link_cpus' + - 'for_each_link_platforms' + - 'for_each_lru' + - 'for_each_matching_node' + - 'for_each_matching_node_and_match' + - 'for_each_media_entity_data_link' + - 'for_each_mem_pfn_range' + - 'for_each_mem_range' + - 'for_each_mem_range_rev' + - 'for_each_mem_region' + - 'for_each_member' + - 'for_each_memory' + - 'for_each_migratetype_order' + - 'for_each_missing_reg' + - 'for_each_mle_subelement' + - 'for_each_mod_mem_type' + - 'for_each_net' + - 'for_each_net_continue_reverse' + - 'for_each_net_rcu' + - 'for_each_netdev' + - 'for_each_netdev_continue' + - 'for_each_netdev_continue_rcu' + - 'for_each_netdev_continue_reverse' + - 'for_each_netdev_dump' + - 'for_each_netdev_feature' + - 'for_each_netdev_in_bond_rcu' + - 'for_each_netdev_rcu' + - 'for_each_netdev_reverse' + - 'for_each_netdev_safe' + - 'for_each_new_connector_in_state' + - 'for_each_new_crtc_in_state' + - 'for_each_new_mst_mgr_in_state' + - 'for_each_new_plane_in_state' + - 'for_each_new_plane_in_state_reverse' + - 'for_each_new_private_obj_in_state' + - 'for_each_new_reg' + - 'for_each_nhlt_endpoint' + - 'for_each_nhlt_endpoint_fmtcfg' + - 'for_each_nhlt_fmtcfg' + - 'for_each_node' + - 'for_each_node_by_name' + - 'for_each_node_by_type' + - 'for_each_node_mask' + - 'for_each_node_state' + - 'for_each_node_with_cpus' + - 'for_each_node_with_property' + - 'for_each_nonreserved_multicast_dest_pgid' + - 'for_each_numa_hop_mask' + - 'for_each_of_allnodes' + - 'for_each_of_allnodes_from' + - 'for_each_of_cpu_node' + - 'for_each_of_pci_range' + - 'for_each_old_connector_in_state' + - 'for_each_old_crtc_in_state' + - 'for_each_old_mst_mgr_in_state' + - 'for_each_old_plane_in_state' + - 'for_each_old_private_obj_in_state' + - 'for_each_oldnew_connector_in_state' + - 'for_each_oldnew_crtc_in_state' + - 'for_each_oldnew_mst_mgr_in_state' + - 'for_each_oldnew_plane_in_state' + - 'for_each_oldnew_plane_in_state_reverse' + - 'for_each_oldnew_private_obj_in_state' + - 'for_each_online_cpu' + - 'for_each_online_node' + - 'for_each_online_pgdat' + - 'for_each_or_bit' + - 'for_each_path' + - 'for_each_pci_bridge' + - 'for_each_pci_dev' + - 'for_each_pcm_streams' + - 'for_each_physmem_range' + - 'for_each_populated_zone' + - 'for_each_possible_cpu' + - 'for_each_present_blessed_reg' + - 'for_each_present_cpu' + - 'for_each_prime_number' + - 'for_each_prime_number_from' + - 'for_each_probe_cache_entry' + - 'for_each_process' + - 'for_each_process_thread' + - 'for_each_prop_codec_conf' + - 'for_each_prop_dai_codec' + - 'for_each_prop_dai_cpu' + - 'for_each_prop_dlc_codecs' + - 'for_each_prop_dlc_cpus' + - 'for_each_prop_dlc_platforms' + - 'for_each_property_of_node' + - 'for_each_reg' + - 'for_each_reg_filtered' + - 'for_each_reloc' + - 'for_each_reloc_from' + - 'for_each_requested_gpio' + - 'for_each_requested_gpio_in_range' + - 'for_each_reserved_child_of_node' + - 'for_each_reserved_mem_range' + - 'for_each_reserved_mem_region' + - 'for_each_rtd_ch_maps' + - 'for_each_rtd_codec_dais' + - 'for_each_rtd_components' + - 'for_each_rtd_cpu_dais' + - 'for_each_rtd_dais' + - 'for_each_rtd_dais_reverse' + - 'for_each_sband_iftype_data' + - 'for_each_script' + - 'for_each_sec' + - 'for_each_set_bit' + - 'for_each_set_bit_from' + - 'for_each_set_bit_wrap' + - 'for_each_set_bitrange' + - 'for_each_set_bitrange_from' + - 'for_each_set_clump8' + - 'for_each_sg' + - 'for_each_sg_dma_page' + - 'for_each_sg_page' + - 'for_each_sgtable_dma_page' + - 'for_each_sgtable_dma_sg' + - 'for_each_sgtable_page' + - 'for_each_sgtable_sg' + - 'for_each_sibling_event' + - 'for_each_sta_active_link' + - 'for_each_subelement' + - 'for_each_subelement_extid' + - 'for_each_subelement_id' + - 'for_each_sublist' + - 'for_each_subsystem' + - 'for_each_supported_activate_fn' + - 'for_each_supported_inject_fn' + - 'for_each_sym' + - 'for_each_test' + - 'for_each_thread' + - 'for_each_token' + - 'for_each_unicast_dest_pgid' + - 'for_each_valid_link' + - 'for_each_vif_active_link' + - 'for_each_vma' + - 'for_each_vma_range' + - 'for_each_vsi' + - 'for_each_wakeup_source' + - 'for_each_zone' + - 'for_each_zone_zonelist' + - 'for_each_zone_zonelist_nodemask' + - 'func_for_each_insn' + - 'fwnode_for_each_available_child_node' + - 'fwnode_for_each_child_node' + - 'fwnode_for_each_parent_node' + - 'fwnode_graph_for_each_endpoint' + - 'gadget_for_each_ep' + - 'genradix_for_each' + - 'genradix_for_each_from' + - 'genradix_for_each_reverse' + - 'hash_for_each' + - 'hash_for_each_possible' + - 'hash_for_each_possible_rcu' + - 'hash_for_each_possible_rcu_notrace' + - 'hash_for_each_possible_safe' + - 'hash_for_each_rcu' + - 'hash_for_each_safe' + - 'hashmap__for_each_entry' + - 'hashmap__for_each_entry_safe' + - 'hashmap__for_each_key_entry' + - 'hashmap__for_each_key_entry_safe' + - 'hctx_for_each_ctx' + - 'hists__for_each_format' + - 'hists__for_each_sort_list' + - 'hlist_bl_for_each_entry' + - 'hlist_bl_for_each_entry_rcu' + - 'hlist_bl_for_each_entry_safe' + - 'hlist_for_each' + - 'hlist_for_each_entry' + - 'hlist_for_each_entry_continue' + - 'hlist_for_each_entry_continue_rcu' + - 'hlist_for_each_entry_continue_rcu_bh' + - 'hlist_for_each_entry_from' + - 'hlist_for_each_entry_from_rcu' + - 'hlist_for_each_entry_rcu' + - 'hlist_for_each_entry_rcu_bh' + - 'hlist_for_each_entry_rcu_notrace' + - 'hlist_for_each_entry_safe' + - 'hlist_for_each_entry_srcu' + - 'hlist_for_each_safe' + - 'hlist_nulls_for_each_entry' + - 'hlist_nulls_for_each_entry_from' + - 'hlist_nulls_for_each_entry_rcu' + - 'hlist_nulls_for_each_entry_safe' + - 'i3c_bus_for_each_i2cdev' + - 'i3c_bus_for_each_i3cdev' + - 'idr_for_each_entry' + - 'idr_for_each_entry_continue' + - 'idr_for_each_entry_continue_ul' + - 'idr_for_each_entry_ul' + - 'in_dev_for_each_ifa_rcu' + - 'in_dev_for_each_ifa_rtnl' + - 'inet_bind_bucket_for_each' + - 'interval_tree_for_each_span' + - 'intlist__for_each_entry' + - 'intlist__for_each_entry_safe' + - 'kcore_copy__for_each_phdr' + - 'key_for_each' + - 'key_for_each_safe' + - 'klp_for_each_func' + - 'klp_for_each_func_safe' + - 'klp_for_each_func_static' + - 'klp_for_each_object' + - 'klp_for_each_object_safe' + - 'klp_for_each_object_static' + - 'kunit_suite_for_each_test_case' + - 'kvm_for_each_memslot' + - 'kvm_for_each_memslot_in_gfn_range' + - 'kvm_for_each_vcpu' + - 'libbpf_nla_for_each_attr' + - 'list_for_each' + - 'list_for_each_codec' + - 'list_for_each_codec_safe' + - 'list_for_each_continue' + - 'list_for_each_entry' + - 'list_for_each_entry_continue' + - 'list_for_each_entry_continue_rcu' + - 'list_for_each_entry_continue_reverse' + - 'list_for_each_entry_from' + - 'list_for_each_entry_from_rcu' + - 'list_for_each_entry_from_reverse' + - 'list_for_each_entry_lockless' + - 'list_for_each_entry_rcu' + - 'list_for_each_entry_reverse' + - 'list_for_each_entry_safe' + - 'list_for_each_entry_safe_continue' + - 'list_for_each_entry_safe_from' + - 'list_for_each_entry_safe_reverse' + - 'list_for_each_entry_srcu' + - 'list_for_each_from' + - 'list_for_each_prev' + - 'list_for_each_prev_safe' + - 'list_for_each_rcu' + - 'list_for_each_reverse' + - 'list_for_each_safe' + - 'llist_for_each' + - 'llist_for_each_entry' + - 'llist_for_each_entry_safe' + - 'llist_for_each_safe' + - 'lwq_for_each_safe' + - 'map__for_each_symbol' + - 'map__for_each_symbol_by_name' + - 'mas_for_each' + - 'mci_for_each_dimm' + - 'media_device_for_each_entity' + - 'media_device_for_each_intf' + - 'media_device_for_each_link' + - 'media_device_for_each_pad' + - 'media_entity_for_each_pad' + - 'media_pipeline_for_each_entity' + - 'media_pipeline_for_each_pad' + - 'mlx5_lag_for_each_peer_mdev' + - 'msi_domain_for_each_desc' + - 'msi_for_each_desc' + - 'mt_for_each' + - 'nanddev_io_for_each_page' + - 'netdev_for_each_lower_dev' + - 'netdev_for_each_lower_private' + - 'netdev_for_each_lower_private_rcu' + - 'netdev_for_each_mc_addr' + - 'netdev_for_each_synced_mc_addr' + - 'netdev_for_each_synced_uc_addr' + - 'netdev_for_each_uc_addr' + - 'netdev_for_each_upper_dev_rcu' + - 'netdev_hw_addr_list_for_each' + - 'nft_rule_for_each_expr' + - 'nla_for_each_attr' + - 'nla_for_each_attr_type' + - 'nla_for_each_nested' + - 'nla_for_each_nested_type' + - 'nlmsg_for_each_attr' + - 'nlmsg_for_each_msg' + - 'nr_neigh_for_each' + - 'nr_neigh_for_each_safe' + - 'nr_node_for_each' + - 'nr_node_for_each_safe' + - 'of_for_each_phandle' + - 'of_property_for_each_string' + - 'of_property_for_each_u32' + - 'pci_bus_for_each_resource' + - 'pci_dev_for_each_resource' + - 'pcl_for_each_chunk' + - 'pcl_for_each_segment' + - 'pcm_for_each_format' + - 'perf_config_items__for_each_entry' + - 'perf_config_sections__for_each_entry' + - 'perf_config_set__for_each_entry' + - 'perf_cpu_map__for_each_cpu' + - 'perf_cpu_map__for_each_cpu_skip_any' + - 'perf_cpu_map__for_each_idx' + - 'perf_evlist__for_each_entry' + - 'perf_evlist__for_each_entry_reverse' + - 'perf_evlist__for_each_entry_safe' + - 'perf_evlist__for_each_evsel' + - 'perf_evlist__for_each_mmap' + - 'perf_hpp_list__for_each_format' + - 'perf_hpp_list__for_each_format_safe' + - 'perf_hpp_list__for_each_sort_list' + - 'perf_hpp_list__for_each_sort_list_safe' + - 'perf_tool_event__for_each_event' + - 'plist_for_each' + - 'plist_for_each_continue' + - 'plist_for_each_entry' + - 'plist_for_each_entry_continue' + - 'plist_for_each_entry_safe' + - 'plist_for_each_safe' + - 'pnp_for_each_card' + - 'pnp_for_each_dev' + - 'protocol_for_each_card' + - 'protocol_for_each_dev' + - 'queue_for_each_hw_ctx' + - 'radix_tree_for_each_slot' + - 'radix_tree_for_each_tagged' + - 'rb_for_each' + - 'rbtree_postorder_for_each_entry_safe' + - 'rdma_for_each_block' + - 'rdma_for_each_port' + - 'rdma_umem_for_each_dma_block' + - 'resort_rb__for_each_entry' + - 'resource_list_for_each_entry' + - 'resource_list_for_each_entry_safe' + - 'rhl_for_each_entry_rcu' + - 'rhl_for_each_rcu' + - 'rht_for_each' + - 'rht_for_each_entry' + - 'rht_for_each_entry_from' + - 'rht_for_each_entry_rcu' + - 'rht_for_each_entry_rcu_from' + - 'rht_for_each_entry_safe' + - 'rht_for_each_from' + - 'rht_for_each_rcu' + - 'rht_for_each_rcu_from' + - 'rq_for_each_bvec' + - 'rq_for_each_segment' + - 'rq_list_for_each' + - 'rq_list_for_each_safe' + - 'sample_read_group__for_each' + - 'scsi_for_each_prot_sg' + - 'scsi_for_each_sg' + - 'sctp_for_each_hentry' + - 'sctp_skb_for_each' + - 'sec_for_each_insn' + - 'sec_for_each_insn_continue' + - 'sec_for_each_insn_from' + - 'sec_for_each_sym' + - 'shdma_for_each_chan' + - 'shost_for_each_device' + - 'sk_for_each' + - 'sk_for_each_bound' + - 'sk_for_each_entry_offset_rcu' + - 'sk_for_each_from' + - 'sk_for_each_rcu' + - 'sk_for_each_safe' + - 'sk_nulls_for_each' + - 'sk_nulls_for_each_from' + - 'sk_nulls_for_each_rcu' + - 'snd_array_for_each' + - 'snd_pcm_group_for_each_entry' + - 'snd_soc_dapm_widget_for_each_path' + - 'snd_soc_dapm_widget_for_each_path_safe' + - 'snd_soc_dapm_widget_for_each_sink_path' + - 'snd_soc_dapm_widget_for_each_source_path' + - 'sparsebit_for_each_set_range' + - 'strlist__for_each_entry' + - 'strlist__for_each_entry_safe' + - 'sym_for_each_insn' + - 'sym_for_each_insn_continue_reverse' + - 'symbols__for_each_entry' + - 'tb_property_for_each' + - 'tcf_act_for_each_action' + - 'tcf_exts_for_each_action' + - 'ttm_resource_manager_for_each_res' + - 'udp_portaddr_for_each_entry' + - 'udp_portaddr_for_each_entry_rcu' + - 'usb_hub_for_each_child' + - 'v4l2_device_for_each_subdev' + - 'v4l2_m2m_for_each_dst_buf' + - 'v4l2_m2m_for_each_dst_buf_safe' + - 'v4l2_m2m_for_each_src_buf' + - 'v4l2_m2m_for_each_src_buf_safe' + - 'virtio_device_for_each_vq' + - 'while_for_each_ftrace_op' + - 'xa_for_each' + - 'xa_for_each_marked' + - 'xa_for_each_range' + - 'xa_for_each_start' + - 'xas_for_each' + - 'xas_for_each_conflict' + - 'xas_for_each_marked' + - 'xbc_array_for_each_value' + - 'xbc_for_each_key_value' + - 'xbc_node_for_each_array_value' + - 'xbc_node_for_each_child' + - 'xbc_node_for_each_key_value' + - 'xbc_node_for_each_subkey' + - 'ynl_attr_for_each' + - 'ynl_attr_for_each_nested' + - 'ynl_attr_for_each_payload' + - 'zorro_for_each_dev' +IncludeBlocks: Preserve +IncludeCategories: + - Regex: '.*' + Priority: 1 +IncludeIsMainRegex: (Test)?$ +IndentCaseLabels: false +IndentGotoLabels: false +IndentPPDirectives: None +IndentWidth: 8 +IndentWrappedFunctionNames: false +JavaScriptQuotes: Leave +JavaScriptWrapImports: true +KeepEmptyLinesAtTheStartOfBlocks: false +MacroBlockBegin: '' +MacroBlockEnd: '' +MaxEmptyLinesToKeep: 1 +NamespaceIndentation: None +ObjCBinPackProtocolList: Auto +ObjCBlockIndentWidth: 8 +ObjCSpaceAfterProperty: true +ObjCSpaceBeforeProtocolList: true +PenaltyBreakAssignment: 10 +PenaltyBreakBeforeFirstCallParameter: 30 +PenaltyBreakComment: 10 +PenaltyBreakFirstLessLess: 0 +PenaltyBreakString: 10 +PenaltyExcessCharacter: 100 +PenaltyReturnTypeOnItsOwnLine: 60 +PointerAlignment: Right +ReflowComments: false +SortIncludes: false +SortUsingDeclarations: false +SpaceAfterCStyleCast: false +SpaceAfterTemplateKeyword: true +SpaceBeforeAssignmentOperators: true +SpaceBeforeCtorInitializerColon: true +SpaceBeforeInheritanceColon: true +SpaceBeforeParens: ControlStatementsExceptForEachMacros +SpaceBeforeRangeBasedForLoopColon: true +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 1 +SpacesInAngles: false +SpacesInContainerLiterals: false +SpacesInCStyleCastParentheses: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +Standard: Cpp03 +TabWidth: 8 +UseTab: Never +... diff --git a/StgSharp.Native/StgSharp.Native.vcxproj.filters b/StgSharp.Native/StgSharp.Native.vcxproj.filters new file mode 100644 index 00000000..30e54e47 --- /dev/null +++ b/StgSharp.Native/StgSharp.Native.vcxproj.filters @@ -0,0 +1,92 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + {bfdaad49-d6af-4b2e-aba9-2dcaa7f7d693} + + + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + + + 资源文件 + + + \ No newline at end of file diff --git a/StgSharp.Native/StgSharp.Native.vcxproj.user b/StgSharp.Native/StgSharp.Native.vcxproj.user new file mode 100644 index 00000000..6e73c83d --- /dev/null +++ b/StgSharp.Native/StgSharp.Native.vcxproj.user @@ -0,0 +1,7 @@ + + + + $(SolutionDir)Output\x64\Debug\net6.0\StgSharpDebug.exe + WindowsLocalDebugger + + \ No newline at end of file diff --git a/StgSharp.Native/glfw/glfw3.lib b/StgSharp.Native/glfw/glfw3.lib new file mode 100644 index 00000000..24e3068b Binary files /dev/null and b/StgSharp.Native/glfw/glfw3.lib differ diff --git a/StgSharp.Native/naming.md b/StgSharp.Native/naming.md new file mode 100644 index 00000000..30bd11e2 --- /dev/null +++ b/StgSharp.Native/naming.md @@ -0,0 +1,9 @@ +# StgSharp c file naming regulation + +| Name Header | Description | +|:-------:|:--------| +|sn-|Stgsharp Native lib self operation| +|k-|Matrix kernel operation| +|str-|SIMD boosted stream operation| +|load-|Context loading operation| +|##OTHER##-|File from another open source lib with name ##OTHER##| \ No newline at end of file diff --git a/StgSharp.Native/sn-src/k_basicop.c b/StgSharp.Native/sn-src/k_basicop.c new file mode 100644 index 00000000..c2bef309 --- /dev/null +++ b/StgSharp.Native/sn-src/k_basicop.c @@ -0,0 +1,134 @@ +#include "sn_intrinsic.h" + +INTERNAL void SN_DECL kernel_add_sse(mat_kernel *left, mat_kernel *right, mat_kernel *ans) +{ + register __m128 c0 = _mm_add_ps(left->xmm[0], right->xmm[0]); + register __m128 c1 = _mm_add_ps(left->xmm[1], right->xmm[1]); + register __m128 c2 = _mm_add_ps(left->xmm[2], right->xmm[2]); + register __m128 c3 = _mm_add_ps(left->xmm[3], right->xmm[3]); + + ans->xmm[0] = c0; + ans->xmm[1] = c1; + ans->xmm[2] = c2; + ans->xmm[3] = c3; +} + +INTERNAL void SN_DECL kernel_add_avx(mat_kernel *left, mat_kernel *right, mat_kernel *ans) +{ + register __m256 c0 = _mm256_add_ps(left->ymm[0], right->ymm[0]); + register __m256 c1 = _mm256_add_ps(left->ymm[1], right->ymm[1]); + ans->ymm[0] = c0; + ans->ymm[1] = c1; +} + +INTERNAL void SN_DECL kernel_add_512(mat_kernel *left, mat_kernel *right, mat_kernel *ans) +{ + register __m512 c0 = _mm512_add_ps(left->zmm[0], right->zmm[0]); + ans->zmm[0] = c0; +} + +INTERNAL void SN_DECL kernel_sub_sse(mat_kernel *left, mat_kernel *right, mat_kernel *ans) +{ + register __m128 c0 = _mm_sub_ps(left->xmm[0], right->xmm[0]); + register __m128 c1 = _mm_sub_ps(left->xmm[1], right->xmm[1]); + register __m128 c2 = _mm_sub_ps(left->xmm[2], right->xmm[2]); + register __m128 c3 = _mm_sub_ps(left->xmm[3], right->xmm[3]); + + ans->xmm[0] = c0; + ans->xmm[1] = c1; + ans->xmm[2] = c2; + ans->xmm[3] = c3; +} + +INTERNAL void SN_DECL kernel_sub_avx(mat_kernel *left, mat_kernel *right, mat_kernel *ans) +{ + register __m256 c0 = _mm256_sub_ps(left->ymm[0], right->ymm[0]); + register __m256 c1 = _mm256_sub_ps(left->ymm[1], right->ymm[1]); + ans->ymm[0] = c0; + ans->ymm[1] = c1; +} + +INTERNAL void SN_DECL kernel_sub_512(mat_kernel *left, mat_kernel *right, mat_kernel *ans) +{ + register __m512 c0 = _mm512_sub_ps(left->zmm[0], right->zmm[0]); + ans->zmm[0] = c0; +} + +// Matrix transpose implementations +INTERNAL void SN_DECL kernel_transpose_sse(mat_kernel *source, mat_kernel *target) +{ + register __m128 col0 = source->xmm[0]; + register __m128 col1 = source->xmm[1]; + register __m128 col2 = source->xmm[2]; + register __m128 col3 = source->xmm[3]; + register __m128 tmp0 = _mm_unpacklo_ps(col0, col1); + register __m128 tmp1 = _mm_unpackhi_ps(col0, col1); + register __m128 tmp2 = _mm_unpacklo_ps(col2, col3); + register __m128 tmp3 = _mm_unpackhi_ps(col2, col3); + + target->xmm[0] = _mm_movelh_ps(tmp0, tmp2); + target->xmm[1] = _mm_movehl_ps(tmp2, tmp0); + target->xmm[2] = _mm_movelh_ps(tmp1, tmp3); + target->xmm[3] = _mm_movehl_ps(tmp3, tmp1); +} + +INTERNAL void SN_DECL kernel_transpose_avx(mat_kernel *source, mat_kernel *target) +{ + register __m256 col_low = source->ymm[0]; + register __m256 col_high = source->ymm[1]; + + register __m256 unpack_low = _mm256_unpacklo_ps(col_low, col_high); + register __m256 unpack_high = _mm256_unpackhi_ps(col_low, col_high); + + col_low = _mm256_permute2f128_ps(unpack_low, unpack_high, 0x20); + col_high = _mm256_permute2f128_ps(unpack_low, unpack_high, 0x31); + + target->ymm[0] = _mm256_shuffle_ps(col_high, col_low, _MM_SHUFFLE(2, 0, 2, 0)); + target->ymm[1] = _mm256_shuffle_ps(col_high, col_low, _MM_SHUFFLE(3, 1, 3, 1)); +} + +INTERNAL void SN_DECL kernel_transpose_512(mat_kernel *source, mat_kernel *target) +{ + register __m512 matrix = source->zmm[0]; + + const __m512i transpose_indices = + _mm512_setr_epi32(0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15); + + target->zmm[0] = _mm512_permutexvar_ps(transpose_indices, matrix); +} + +INTERNAL void SN_DECL kernel_scalar_mul_sse(mat_kernel *matrix, float scalar, mat_kernel *ans) +{ + register __m128 temp = _mm_load_ss(&scalar); + register __m128 scalar_vec = _mm_shuffle_ps(temp, temp, _MM_SHUFFLE(0, 0, 0, 0)); + + register __m128 c0 = _mm_mul_ps(matrix->xmm[0], scalar_vec); + register __m128 c1 = _mm_mul_ps(matrix->xmm[1], scalar_vec); + register __m128 c2 = _mm_mul_ps(matrix->xmm[2], scalar_vec); + register __m128 c3 = _mm_mul_ps(matrix->xmm[3], scalar_vec); + + ans->xmm[0] = c0; + ans->xmm[1] = c1; + ans->xmm[2] = c2; + ans->xmm[3] = c3; +} + +INTERNAL void SN_DECL kernel_scalar_mul_avx(mat_kernel *matrix, float scalar, mat_kernel *ans) +{ + register __m256 scalar_vec = _mm256_broadcast_ss(&scalar); + + register __m256 c0 = _mm256_mul_ps(matrix->ymm[0], scalar_vec); + register __m256 c1 = _mm256_mul_ps(matrix->ymm[1], scalar_vec); + + ans->ymm[0] = c0; + ans->ymm[1] = c1; +} + +INTERNAL void SN_DECL kernel_scalar_mul_512(mat_kernel *matrix, float scalar, mat_kernel *ans) +{ + __m512 scalar_vec = _mm512_broadcastss_ps(_mm_load_ss(&scalar)); + + register __m512 c0 = _mm512_mul_ps(matrix->zmm[0], scalar_vec); + + ans->zmm[0] = c0; +} diff --git a/StgSharp.Native/sn-src/k_fma.c b/StgSharp.Native/sn-src/k_fma.c new file mode 100644 index 00000000..46d333fc --- /dev/null +++ b/StgSharp.Native/sn-src/k_fma.c @@ -0,0 +1,35 @@ +#include "sn_intrinsic.h" + +void kernel_fma_sse(mat_kernel *const left, mat_kernel *const right, mat_kernel *ans) +{ + register __m128 source0 = _mm_load_ps(&left->xmm[0]); + register __m128 source1 = _mm_load_ps(&left->xmm[1]); + register __m128 source2 = _mm_load_ps(&left->xmm[2]); + register __m128 source3 = _mm_load_ps(&left->xmm[3]); + + register __m128 broadcast; + + register __m128 ans0 = _mm_setzero_ps(); + register __m128 ans1 = _mm_setzero_ps(); + register __m128 ans2 = _mm_setzero_ps(); + register __m128 ans3 = _mm_setzero_ps(); + for (size_t i = 0; i < 3; i++) { + broadcast = _mm_load_ps(&right->xmm[i]); + _mm_add_ps(ans0, _mm_mul_ps(source0, broadcast)); + _mm_add_ps(ans1, _mm_mul_ps(source1, broadcast)); + _mm_add_ps(ans2, _mm_mul_ps(source2, broadcast)); + _mm_add_ps(ans3, _mm_mul_ps(source3, broadcast)); + for (size_t t = 0; t < 2; t++) { + broadcast = _mm_shuffle_ps(broadcast, broadcast, _MM_SHUFFLE(2, 1, 0, 3)); + + _mm_add_ps(ans0, _mm_mul_ps(source0, broadcast)); + _mm_add_ps(ans1, _mm_mul_ps(source1, broadcast)); + _mm_add_ps(ans2, _mm_mul_ps(source2, broadcast)); + _mm_add_ps(ans3, _mm_mul_ps(source3, broadcast)); + } + } + _mm_store_ps(&ans->xmm[0], ans0); + _mm_store_ps(&ans->xmm[1], ans1); + _mm_store_ps(&ans->xmm[2], ans2); + _mm_store_ps(&ans->xmm[3], ans3); +} diff --git a/StgSharp.Native/sn-src/load_intrinsic.c b/StgSharp.Native/sn-src/load_intrinsic.c new file mode 100644 index 00000000..8b89f0e7 --- /dev/null +++ b/StgSharp.Native/sn-src/load_intrinsic.c @@ -0,0 +1,101 @@ +#include "StgSharpNative.h" +#include "sn_intrinsic.h" + + +#if defined(_MSC_VER) && !defined(__clang__) +#include +#include +#else +#include +#endif // _MSC_VER + +PRIVATE void load_intrinsic_sse(sn_intrinsic *context); +PRIVATE void load_intrinsic_avx(sn_intrinsic *context); +PRIVATE void load_intrinsic_512(sn_intrinsic *context); + +PRIVATE int check_isa(most_advanced_instruction instruction_family) +{ + if (instruction_family != NEON) { +#if defined(_MSC_VER) && !defined(__clang__) + return __check_isa_support(instruction_family, 0); +#else + switch (instruction_family) { + case SSE: + return __builtin_cpu_supports("sse4.2"); + case AVX256: + return __builtin_cpu_supports("avx2"); + case AVX512: + return __builtin_cpu_supports("avx512f"); + default: + return 0; + } +#endif // _MSC_VER + } + +#if defined(__ARM_NEON) || defined(__ARM_NEON__) + return 1; +#else + return 0; +#endif +} + +SN_API int load_intrinsic_function(void *intrinsic_context) +{ + sn_null_assert(intrinsic_context); + + sn_intrinsic *context = (sn_intrinsic *)intrinsic_context; + + if (check_isa(AVX512)) { + load_intrinsic_512(context); + return 3; + } else if (check_isa(AVX256)) { + load_intrinsic_avx(context); + return 2; + } else if (check_isa(SSE)) { + load_intrinsic_sse(context); + return 1; + } else if (check_isa(NEON)) { + return -1; + } + + return 0; +} + +void load_intrinsic_sse(sn_intrinsic *context) +{ + context->city_hash_simplify = city_hash_simplify_sse; + context->factorial_simd = factorial_simd_sse; + context->index_pair = index_pair_sse; + context->kernel_add = (MATARITHMETIC)kernel_add_sse; + context->kernel_fma = (void(*)(void*, void*, void*))kernel_fma_sse; + context->kernel_scalar_mul = kernel_scalar_mul_sse; + context->kernel_sub = (MATARITHMETIC)kernel_sub_sse; + context->kernel_transpose = (MATTRANSPOSEPROC)kernel_transpose_sse; + context->normalize_3 = normalize; +} + +void load_intrinsic_avx(sn_intrinsic *context) +{ + context->city_hash_simplify = city_hash_simplify_sse; + context->factorial_simd = factorial_simd_sse; + context->index_pair = index_pair_sse; + context->kernel_add = (MATARITHMETIC)kernel_add_avx; + context->kernel_fma = (void(*)(void*, void*, void*))kernel_fma_sse; + context->kernel_scalar_mul = kernel_scalar_mul_avx; + context->kernel_sub = (MATARITHMETIC)kernel_sub_avx; + context->kernel_transpose = (MATTRANSPOSEPROC)kernel_transpose_avx; + context->normalize_3 = normalize; +} + +void load_intrinsic_512(sn_intrinsic *context) +{ + context->city_hash_simplify = city_hash_simplify_sse; + context->factorial_simd = factorial_simd_sse; + context->index_pair = index_pair_sse; + context->kernel_add = (MATARITHMETIC)kernel_add_512; + context->kernel_fma = (void(*)(void*, void*, void*))kernel_fma_sse; + context->kernel_scalar_mul = kernel_scalar_mul_512; + context->kernel_sub = (MATARITHMETIC)kernel_sub_512; + context->kernel_transpose = (MATTRANSPOSEPROC)kernel_transpose_512; + context->normalize_3 = normalize; +} diff --git a/StgSharp.Native/sn-src/sn_native.c b/StgSharp.Native/sn-src/sn_native.c new file mode 100644 index 00000000..987a86dc --- /dev/null +++ b/StgSharp.Native/sn-src/sn_native.c @@ -0,0 +1,75 @@ +#include "StgSharpNative.h" +#include "gl.h" +#include "../glfw/glfw3.h" +#include +#include + +extern GladGLContext *currentContext; +extern char infolog[512]; + +SN_API int SN_DECL glCheckShaderStat(GladGLContext *context, uint64_t shaderHandle, int key, + char **logRef) +{ + int stat = 0; + context->GetShaderiv(shaderHandle, key, &stat); + if (!stat) { + context->GetShaderInfoLog(shaderHandle, 512, NULL, infolog); + } + *logRef = infolog; + return stat; +} + +SN_API void SN_DECL initGL(int majorVersion, int minorVersion) +{ + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, majorVersion); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, minorVersion); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); + glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); +} + +SN_API GLFWglproc SN_DECL loadGlfuncDefault(char *procName) +{ + void *ret = glfwGetProcAddress(procName); + // printf("%llu\n", (uint64_t)ret); + if (ret == NULL) { + strcpy_s(infolog,30, "Failed to load OpenGL api:"); + for (size_t i = 0; i < sizeof(procName); i++) { + infolog[30 + i] = procName[i]; + } + //printf("%s\n", infolog); + } + return (GLFWglproc)ret; +} + +SN_API unsigned int linkShaderProgram(GladGLContext *context, GLuint shaderProgram) +{ + context->LinkProgram(shaderProgram); + + int success; + context->GetProgramiv(shaderProgram, GL_LINK_STATUS, &success); + if (!success) { + context->GetProgramInfoLog(shaderProgram, 512, NULL, infolog); + return 0; + } else { + return shaderProgram; + } +} + +SN_API void SN_DECL loadImageData(char *location, Image *out, imageLoader loader) +{ + if (loader == NULL) { + loader = stbi_load; + } + out->pixelPtr = loader(location, &(out->width), &(out->height), &(out->channel), 0); +} + +SN_API void SN_DECL unloadImageData(Image *out) +{ + free(out->pixelPtr); +} + +SN_API char *SN_DECL readLog() +{ + infolog[511] = '\0'; + return infolog; +} diff --git a/StgSharp.Native/sn-src/str_factorial.c b/StgSharp.Native/sn-src/str_factorial.c new file mode 100644 index 00000000..450bdbc5 --- /dev/null +++ b/StgSharp.Native/sn-src/str_factorial.c @@ -0,0 +1,23 @@ +#include "sn_internal.h" +#include "sn_intrinsic.h" + +INTERNAL __m128i facIncrement = { 4, 4, 4, 4 }; +INTERNAL __m128i facBase = { 1, 2, 3, 4 }; + +INTERNAL uint64_t SN_DECL factorial_simd_sse(int n) +{ + __m128i baseResult = facBase; + __m128i facBaseLocal = facBase; + const int cycle = (n - 3) >> 2; + const uint32_t rest = (cycle << 2) + 1; + for (size_t i = 0; i < cycle; i++) { + facBaseLocal = _mm_add_epi32(facBaseLocal, facIncrement); + baseResult = _mm_mullo_epi32(baseResult, facBaseLocal); + } + uint64_t result = (uint64_t)baseResult.m128i_i32[0] * (uint64_t)baseResult.m128i_i32[1] * + (uint64_t)baseResult.m128i_i32[2] * (uint64_t)baseResult.m128i_i32[3]; + for (uint64_t i = rest; i < n; i++) { + result *= i; + } + return result; +} diff --git a/StgSharp.Native/sn-src/str_hash.c b/StgSharp.Native/sn-src/str_hash.c new file mode 100644 index 00000000..89794198 --- /dev/null +++ b/StgSharp.Native/sn-src/str_hash.c @@ -0,0 +1,45 @@ +#include "sn_intrinsic.h" +#include "StgSharpNative.h" + +INTERNAL int SN_DECL city_hash_simplify_sse(byte const *str, int const length) +{ + uint32_t hash = length, size = length << 1; + byte *end = str + size, *ptr = str; + + if (size < 4) { + for (; ptr < end; ptr += 2) { + hash = _mm_crc32_u16(hash, *ptr); + } + } else if (size < 16) { + byte *last = end - 4; + for (; ptr < end; ptr += 4) { + hash = _mm_crc32_u32(hash, *(uint32_t *)ptr); + } + for (; ptr < end; ptr++) { + hash = _mm_crc32_u16(hash, *ptr); + } + } else { + byte *last_128 = end - 16; + byte *last_32 = end - 4; + uint64_t hash64 = size; + for (; ptr < last_128; ptr += 16) { + __m128i vec = _mm_loadu_si32((int *)ptr); + hash64 = _mm_crc32_u64(hash64, _mm_extract_epi64(vec, 0)); + hash64 = _mm_crc32_u64(hash64, _mm_extract_epi64(vec, 1)); + } + hash = _mm_crc32_u8(hash, hash64); + hash = _mm_crc32_u8(hash, hash64 >> 32); + for (; ptr < last_32; ptr += 4) { + hash = _mm_crc32_u32(hash,*(uint32_t *)ptr); + } + for (; ptr < end; ptr += 2) { + hash = _mm_crc32_u8(hash,*ptr); + } + } + hash ^= hash >> 16; + hash *= 0x85ebca6b; + hash ^= hash >> 13; + hash *= 0xc2b2ae35; + hash ^= hash >> 16; + return hash; +} diff --git a/StgSharp.Native/sn-src/str_string.c b/StgSharp.Native/sn-src/str_string.c new file mode 100644 index 00000000..21efc77e --- /dev/null +++ b/StgSharp.Native/sn-src/str_string.c @@ -0,0 +1,53 @@ +#include "sn_intrinsic.h" + +int index_pair_sse(short const *str, uint32_t target, int length) +{ + int index = 0, result = 0, size = length, end = size - 8; + __m128i s = { + target, + target, + target, + target, + }; + __m128i vec, com; + + while (index < end) { + vec = _mm_loadu_epi32(str + index); + com = _mm_cmpeq_epi16(vec, s); + result = _mm_movemask_epi8(com); + if (result) { + for (size_t i = 0; i < 7; i++) { + if (((result & 0xF) == 0xF)) { + return index + i; + } + if (result == 0) { + break; + } + result >>= 2; + } + } + index += 1; + vec = _mm_loadu_epi32(str + index); + com = _mm_cmpeq_epi16(vec, s); + result = _mm_movemask_epi8(com); + if (result) { + for (size_t i = 0; i < 7; i++) { + if (((result & 0xF) == 0xF)) { + return index + i; + } + if (result == 0) { + break; + } + result >>= 2; + } + } + index += 7; + } + for (; (index < size - 1) && (!result); index += 2) { + result = *(int *)(str + index) == target; + } + if (result) { + return index; + } + return -1; +} diff --git a/StgSharpDebug/hlsf-test.cs b/StgSharpDebug/hlsf-test.cs new file mode 100644 index 00000000..b3e5f7e5 --- /dev/null +++ b/StgSharpDebug/hlsf-test.cs @@ -0,0 +1,152 @@ +//----------------------------------------------------------------------- +// ----------------------------------------------------------------------- +// file="hlsf-test.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.Memory; +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StgSharp +{ + internal partial class Program + { + + public static void TestHlsf() + { + // HLSF test arena + Console.WriteLine( + "=== HLSF (Hybrid Layer Segregated Fit Allocator) Single-threaded Stress Test ===\n"); + + + // 使用适中的内存池大小 + HybridLayerSegregatedFitAllocator hlsfAllocator = new HybridLayerSegregatedFitAllocator(16 * 1024 * 1024); + + Console.WriteLine("开始单线程压力测试...\n"); + + + // 单线程压力测试：适度的分配和释放操作 + int totalCycles = 5; + int allocationsPerCycle = 1024 * 64; // 65536 次分配 + + for (int cycle = 0; cycle < totalCycles; cycle++) + { + Console.WriteLine($"\n=== 第 {cycle + 1} 轮压力测试 ==="); + + // 预生成随机数 + uint[] randomSizes = new uint[allocationsPerCycle]; + Random random = new Random(cycle); + for (int i = 0; i < allocationsPerCycle; i++) { + randomSizes[i] = (uint)(64 + random.Next(1024 - 64 + 1)); + } + + // 分配阶段 + List handles = new List(allocationsPerCycle); + Stopwatch stopwatch = Stopwatch.StartNew(); + + for (int i = 0; i < allocationsPerCycle; i++) { + handles.Add(hlsfAllocator.Alloc(randomSizes[i])); + } + + stopwatch.Stop(); + Console.WriteLine($"分配完成，总计分配 {handles.Count} 个块"); + Console.WriteLine($"分配耗时: {stopwatch.ElapsedMilliseconds} ms"); + if (stopwatch.ElapsedMilliseconds > 0) { + Console.WriteLine($"分配速度: {allocationsPerCycle * 1000 / stopwatch.ElapsedMilliseconds} allocs/sec"); + } + + + // 随机释放阶段 + stopwatch.Restart(); + + for (int i = handles.Count - 1; i >= 0; i--) { + hlsfAllocator.Free(handles[i]); + } + + stopwatch.Stop(); + Console.WriteLine($"释放完成，总计释放 {handles.Count} 个块"); + Console.WriteLine($"释放耗时: {stopwatch.ElapsedMilliseconds} ms"); + if (stopwatch.ElapsedMilliseconds > 0) { + Console.WriteLine($"释放速度: {handles.Count * 1000 / stopwatch.ElapsedMilliseconds} frees/sec"); + } + + handles.Clear(); + } + + Console.WriteLine("\n=== 边界测试 ==="); + + + // 测试最小分配 + Console.WriteLine("测试最小分配 (64字节)..."); + List minHandles = new List(); + for (int i = 0; i < 1000; i++) { + minHandles.Add(hlsfAllocator.Alloc(64)); + } + foreach (HybridLayerSegregatedFitAllocationHandle handle in minHandles) { + hlsfAllocator.Free(handle); + } + Console.WriteLine("最小分配测试完成"); + + // 测试最大分配 + Console.WriteLine("测试最大分配 (1024字节)..."); + List maxHandles = new List(); + for (int i = 0; i < 1000; i++) { + maxHandles.Add(hlsfAllocator.Alloc(1024)); + } + foreach (HybridLayerSegregatedFitAllocationHandle handle in maxHandles) { + hlsfAllocator.Free(handle); + } + Console.WriteLine("最大分配测试完成"); + + // 测试混合大小分配 + Console.WriteLine("测试混合大小分配..."); + List mixedHandles = new List(); + uint[] testSizes = { + 64, 128, 256, 512, 1024 + }; + for (int i = 0; i < 2000; i++) + { + uint size = testSizes[i % testSizes.Length]; + mixedHandles.Add(hlsfAllocator.Alloc(size)); + } + foreach (HybridLayerSegregatedFitAllocationHandle handle in mixedHandles) { + hlsfAllocator.Free(handle); + } + Console.WriteLine("混合大小分配测试完成"); + + Console.WriteLine("\n所有测试完成！HLSF分配器表现良好。"); + Console.WriteLine("按任意键退出..."); + Console.ReadKey(); + } + + } +}