small changed

.gitignore

@@ -14,3 +14,4 @@
 obj
 /cmake_build
 */.cache
+.cache

StgSharp.Common/HighPerformance/ProcessorAbstraction/LogicalCore.cs

@@ -44,5 +44,21 @@ namespace StgSharp.Common.HighPerformance.ProcessorAbstraction
         /// </summary>
         public readonly uint NumaNodeId;
 
+        internal LogicalCore(
+                 uint globalCpuId,
+                 uint numaGroupId,
+                 uint numaNodeId
+        )
+        {
+            GlobalCpuId = globalCpuId;
+            NumaGroupId = numaGroupId;
+            NumaNodeId = numaNodeId;
+        }
+
+        [Obsolete(
+                "Do not manually create instances of LogicalCore. Use NumaNode to obtain LogicalCore instances.",
+                true)]
+        public LogicalCore() { }
+
     }
 }

StgSharp.Common/HighPerformance/ProcessorAbstraction/Numa.cs

@@ -47,9 +47,9 @@ namespace StgSharp.Common.HighPerformance.ProcessorAbstraction
         [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
         [DefaultDllImportSearchPaths(DllImportSearchPath.AssemblyDirectory)]
         public static partial int GetNumaEach(
-                                  int numaId,
+                                  uint numaId,
-                                  Span<ulong> coreCountInNuma,
+                                  Span<ulong> CpuIndexInNuma,
-                                  Span<ulong> globalCpuIdInNuma
+                                  Span<uint> globalCpuIdInNuma
         );
 
         [LibraryImport(Native.LibName, EntryPoint = "sn_get_numa_overall")]
@@ -68,12 +68,22 @@ namespace StgSharp.Common.HighPerformance.ProcessorAbstraction
                 throw new InvalidOperationException("Failed to get NUMA overall information.");
             }
             _numaNodes = new NumaNode[numaNodeCount];
-            for (int i = 0; i < numaNodeCount; i++)
+            for (uint i = 0; i < numaNodeCount; i++) {
-            {
+                _numaNodes[i] = InitNumaNode(i, coreCountInNuma[(int)i]);
-                NumaNode node = new(coreCountInNuma[i]);
-                GetNumaEach(i, coreCountInNuma, node.GlobalCpuIds);
             }
         }
 
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static NumaNode InitNumaNode(
+                                uint numaId,
+                                int count
+        )
+        {
+            Span<uint> globalIndex = stackalloc uint[count];
+            Span<ulong> groupIndex = stackalloc ulong[count];
+            _ = GetNumaEach(numaId, groupIndex, globalIndex);
+            return new(numaId, count, globalIndex);
+        }
+
     }
 }

StgSharp.Common/HighPerformance/ProcessorAbstraction/NumaNode.cs

@@ -39,11 +39,17 @@ namespace StgSharp.Common.HighPerformance.ProcessorAbstraction
 
         private LogicalCore[] _logicalCores;
 
-        public NumaNode(
+        internal NumaNode(
-               int count
+                 uint numaId,
+                 int count,
+                 Span<uint> logicalCoreIds
+
         )
         {
             _logicalCores = new LogicalCore[count];
+            for (int i = 0; i < count; i++) {
+                _logicalCores[i] = new LogicalCore(1, numaId, logicalCoreIds[i]);
+            }
         }
 
         public int LogicalCoreCount => _logicalCores.Length;

StgSharp.Native/StgSharp.Native.vcxproj

@@ -185,7 +185,8 @@
     <ClCompile Include="sn-src\simdid.x86.c" />
     <ClCompile Include="sn-src\simdid_compare.x86.c" />
     <ClCompile Include="sn-src\sn_native.c" />
-    <ClCompile Include="sn-src\t.affinity.c" />
+    <ClCompile Include="sn-src\thread.linux.c" />
+    <ClCompile Include="sn-src\thread.windows.c" />
     <ClCompile Include="sn-src\vector.c" />
     <ClCompile Include="sn-src\vector_dot.c" />
   </ItemGroup>

StgSharp.Native/StgSharp.Native.vcxproj.filters

@@ -60,10 +60,13 @@
     <ClCompile Include="sn-src\mk.fma.x86.c">
       <Filter>源文件</Filter>
     </ClCompile>
-    <ClCompile Include="sn-src\t.affinity.c">
+    <ClCompile Include="sn-src\simdid_compare.x86.c">
       <Filter>源文件</Filter>
     </ClCompile>
-    <ClCompile Include="sn-src\simdid_compare.x86.c">
+    <ClCompile Include="sn-src\thread.linux.c">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="sn-src\thread.windows.c">
       <Filter>源文件</Filter>
     </ClCompile>
   </ItemGroup>

StgSharp.Native/sn-head/StgSharpNative.h

@@ -56,4 +56,6 @@ SN_API SIMDID SN_DECL sn_get_unite_simd(SIMDID left, SIMDID right);
 SN_API int SN_DECL sn_compare_simd(SIMDID left, SIMDID right);
 SN_API void SN_DECL sn_set_thread_affinity(int core_id);
 
+SN_API int SN_DECL sn_get_numa_each(int numa_id, uint64_t *internal, uint32_t *global);
+SN_API int SN_DECL sn_get_numa_overall(int *out_numa_count, int *count_of_each_numa);
 #endif

StgSharp.Native/sn-src/mk.fma.x86.c

@@ -2,7 +2,8 @@
 /* clang-format off */
 #if SN_IS_ARCH(SN_ARCH_X86_64)
 
-#include "sn_intrinsic.h"
+// #include "sn_intrinsic.h"
+#include "sn_template.fma.x86.h"
 #include "sn_intrinsic.std.h"
 #include "sn_intrinsic.context.x86.h"
 
@@ -136,17 +137,6 @@ SN_MK_PROC_DECL_STD(float, avx, _fma, fma)
         _mm256_store_ps((float *)&ans_cur->f32_y[1], c23);
 }
 
-#define SN_MK_FMA_F32_512_PHASE(i)\
-        do {    \
-                ak = _mm512_broadcast_f32x4(left_##i ->f32_x[0]);\
-                c_0 = _mm512_fmadd_ps(ak, _mm512_permute_ps(b_##i, _FMA_SELECT(0)), c_##i);\
-                ak = _mm512_broadcast_f32x4(left_##i ->f32_x[0]);\
-                c_1 = _mm512_fmadd_ps(ak, _mm512_permute_ps(b_##i, _FMA_SELECT(0)), c_##i);\
-                ak = _mm512_broadcast_f32x4(left_##i ->f32_x[0]);\
-                c_2 = _mm512_fmadd_ps(ak, _mm512_permute_ps(b_##i, _FMA_SELECT(0)), c_##i);\
-                ak = _mm512_broadcast_f32x4(left_##i ->f32_x[0]);\
-                c_3 = _mm512_fmadd_ps(ak, _mm512_permute_ps(b_##i, _FMA_SELECT(0)), c_##i);\
-        }while(0)
 
 SN_MK_PROC_DECL_STD(float, 512, , fma)
 {
@@ -187,39 +177,6 @@ SN_MK_PROC_DECL_STD(float, 512, , fma)
         _mm512_store_ps((float *)ans_cur, c_0);
 }
 
-// double
-#define DOUBLE_KERNEL_FMA_CYCLE(i)                                            \
-        do {                                                                  \
-                /* k = 0 */                                                   \
-                register __m128d b_lo = _mm_load_pd(right_values + (2 * i + 0)); \
-                register __m128d b_hi = _mm_load_pd(right_values + (2 * i + 1)); \
-                register __m128d a_lo = _mm_load_pd(left_values + (0 * 2 + 0));  \
-                register __m128d a_hi = _mm_load_pd(left_values + (0 * 2 + 1));  \
-                register __m128d b = _mm_shuffle_pd(b_lo, b_lo, 0x0);         \
-                c##i##_lo = _mm_add_pd(c##i##_lo, _mm_mul_pd(a_lo, b));       \
-                c##i##_hi = _mm_add_pd(c##i##_hi, _mm_mul_pd(a_hi, b));       \
-                                                                              \
-                /* group = 1 */                                               \
-                a_lo = _mm_load_pd(left_values + (1 * 2 + 0));                 \
-                a_hi = _mm_load_pd(left_values + (1 * 2 + 1));                 \
-                b = _mm_shuffle_pd(b_lo, b_lo, 0x3);                          \
-                c##i##_lo = _mm_add_pd(c##i##_lo, _mm_mul_pd(a_lo, b));       \
-                c##i##_hi = _mm_add_pd(c##i##_hi, _mm_mul_pd(a_hi, b));       \
-                                                                              \
-                /* groupp = 2 */                                              \
-                a_lo = _mm_load_pd(left_values + (2 * 2 + 0));                 \
-                a_hi = _mm_load_pd(left_values + (2 * 2 + 1));                 \
-                b = _mm_shuffle_pd(b_hi, b_hi, 0x0);                          \
-                c##i##_lo = _mm_add_pd(c##i##_lo, _mm_mul_pd(a_lo, b));       \
-                c##i##_hi = _mm_add_pd(c##i##_hi, _mm_mul_pd(a_hi, b));       \
-                                                                              \
-                /* froup = 3 */                                               \
-                a_lo = _mm_load_pd(left_values + (3 * 2 + 0));                 \
-                a_hi = _mm_load_pd(left_values + (3 * 2 + 1));                 \
-                b = _mm_shuffle_pd(b_hi, b_hi, 0x3);                          \
-                c##i##_lo = _mm_add_pd(c##i##_lo, _mm_mul_pd(a_lo, b));       \
-                c##i##_hi = _mm_add_pd(c##i##_hi, _mm_mul_pd(a_hi, b));       \
-        } while (0)
 
 SN_MK_PROC_DECL_STD(double, sse, , fma)
 {
@@ -243,13 +200,13 @@ SN_MK_PROC_DECL_STD(double, sse, , fma)
                 const double *right_values = &right_cur->m[0][0];
                 const double *left_values = &left_cur->m[0][0];
 
-                DOUBLE_KERNEL_FMA_CYCLE(0);
+                SN_MK_FMA_F64_SSE_PHASE(0);
 
-                DOUBLE_KERNEL_FMA_CYCLE(1);
+                SN_MK_FMA_F64_SSE_PHASE(1);
 
-                DOUBLE_KERNEL_FMA_CYCLE(2);
+                SN_MK_FMA_F64_SSE_PHASE(2);
 
-                DOUBLE_KERNEL_FMA_CYCLE(3);
+                SN_MK_FMA_F64_SSE_PHASE(3);
         }
 
         ans_cur->f64_x[0] = c0_lo;

StgSharp.Native/sn-src/thread.windows.c

@@ -48,7 +48,7 @@ SN_API int SN_DECL sn_get_numa_overall(int *out_numa_count, int *count_of_each_n
         return 1;
 }
 
-SN_API int SN_DECL sn_get_numa_each(int numa_id, uint64_t *internal, uint64_t *global)
+SN_API int SN_DECL sn_get_numa_each(int numa_id, uint64_t *internal, uint32_t *global)
 {
         ULONGLONG mask = 0;
         if (!GetNumaNodeProcessorMask((UCHAR)numa_id, &mask))
@@ -56,9 +56,9 @@ SN_API int SN_DECL sn_get_numa_each(int numa_id, uint64_t *internal, uint64_t *g
 
         int intra = 0;
         while (mask) {
-                unsigned long idx;
+                uint32_t idx;
                 _BitScanForward64(&idx, mask);
-                internal[intra] = intra;
+                int _ = (internal == NULL) ? intra : (internal[intra] = intra);
                 global[intra] = (int)idx;
                 intra++;
                 mask &= mask - 1;

StgSharp.Native/sn-template/sn_template.fma.x86.h

@@ -0,0 +1,53 @@
+#include "sn_target.h"
+
+#if SN_IS_ARCH(SN_ARCH_X86_64)
+
+
+#define SN_MK_FMA_F32_512_PHASE(i)\
+        do {    \
+                ak = _mm512_broadcast_f32x4(left_##i ->f32_x[0]);\
+                c_0 = _mm512_fmadd_ps(ak, _mm512_permute_ps(b_##i, _FMA_SELECT(0)), c_##i);\
+                ak = _mm512_broadcast_f32x4(left_##i ->f32_x[0]);\
+                c_1 = _mm512_fmadd_ps(ak, _mm512_permute_ps(b_##i, _FMA_SELECT(0)), c_##i);\
+                ak = _mm512_broadcast_f32x4(left_##i ->f32_x[0]);\
+                c_2 = _mm512_fmadd_ps(ak, _mm512_permute_ps(b_##i, _FMA_SELECT(0)), c_##i);\
+                ak = _mm512_broadcast_f32x4(left_##i ->f32_x[0]);\
+                c_3 = _mm512_fmadd_ps(ak, _mm512_permute_ps(b_##i, _FMA_SELECT(0)), c_##i);\
+        }while(0)
+
+
+// double
+#define SN_MK_FMA_F64_SSE_PHASE(i)                                            \
+        do {                                                                  \
+                /* k = 0 */                                                   \
+                register __m128d b_lo = _mm_load_pd(right_values + (2 * i + 0)); \
+                register __m128d b_hi = _mm_load_pd(right_values + (2 * i + 1)); \
+                register __m128d a_lo = _mm_load_pd(left_values + (0 * 2 + 0));  \
+                register __m128d a_hi = _mm_load_pd(left_values + (0 * 2 + 1));  \
+                register __m128d b = _mm_shuffle_pd(b_lo, b_lo, 0x0);         \
+                c##i##_lo = _mm_add_pd(c##i##_lo, _mm_mul_pd(a_lo, b));       \
+                c##i##_hi = _mm_add_pd(c##i##_hi, _mm_mul_pd(a_hi, b));       \
+                                                                              \
+                /* group = 1 */                                               \
+                a_lo = _mm_load_pd(left_values + (1 * 2 + 0));                 \
+                a_hi = _mm_load_pd(left_values + (1 * 2 + 1));                 \
+                b = _mm_shuffle_pd(b_lo, b_lo, 0x3);                          \
+                c##i##_lo = _mm_add_pd(c##i##_lo, _mm_mul_pd(a_lo, b));       \
+                c##i##_hi = _mm_add_pd(c##i##_hi, _mm_mul_pd(a_hi, b));       \
+                                                                              \
+                /* group = 2 */                                               \
+                a_lo = _mm_load_pd(left_values + (2 * 2 + 0));                 \
+                a_hi = _mm_load_pd(left_values + (2 * 2 + 1));                 \
+                b = _mm_shuffle_pd(b_hi, b_hi, 0x0);                          \
+                c##i##_lo = _mm_add_pd(c##i##_lo, _mm_mul_pd(a_lo, b));       \
+                c##i##_hi = _mm_add_pd(c##i##_hi, _mm_mul_pd(a_hi, b));       \
+                                                                              \
+                /* group = 3 */                                               \
+                a_lo = _mm_load_pd(left_values + (3 * 2 + 0));                 \
+                a_hi = _mm_load_pd(left_values + (3 * 2 + 1));                 \
+                b = _mm_shuffle_pd(b_hi, b_hi, 0x3);                          \
+                c##i##_lo = _mm_add_pd(c##i##_lo, _mm_mul_pd(a_lo, b));       \
+                c##i##_hi = _mm_add_pd(c##i##_hi, _mm_mul_pd(a_hi, b));       \
+        } while (0)
+
+#endif