diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 00000000..a1611d2c --- /dev/null +++ b/.editorconfig @@ -0,0 +1,5 @@ +root = true + +[*.cs] +dotnet_diagnostic.IDE0032.severity = none +dotnet_diagnostic.IDE0055.severity = none \ No newline at end of file diff --git a/src/Nitload.Common/HighPerformance/Memory/L4.Design.md b/src/Nitload.Common/HighPerformance/Memory/L4.Design.md index 03e71bde..26cbc4a4 100644 --- a/src/Nitload.Common/HighPerformance/Memory/L4.Design.md +++ b/src/Nitload.Common/HighPerformance/Memory/L4.Design.md @@ -83,17 +83,20 @@ published buffer 地址以 `ulong` 保存： ## 6. 预测器注册、任务状态与在途缓冲 -这三者职责不同，不应合并成一个队列： +预测器调度和预测任务执行是两条相关但不同的生命周期，不能把“预测器已预测完”当成“它产生的工作已完成”。 -- **预测器管理数组**：`PredictorMonitor` 的固定槽位数组，保存注册顺序、稳定 ID 和生命周期状态。容量上限（曾讨论 256）是预测器数量，与缓存行计数无关。预测器按依赖顺序依次执行，一个 L4 同一时刻只有一个 predictor worker 处于 prefetch 阶段，因此不需要多 lane 或 thread-local lane 归属。 -- **Swiss 预测任务状态**：保存/查找待映射的 `AddressSource` 条目；这是预测任务/映射状态，不是预测器注册表。 -- **在途预测器缓冲**：预测器已经产出预测，但对应实际工作尚未完成时，保留该预测器及其 mission/写回上下文。它与注册槽位不同：注册槽位描述“有哪些预测器”，在途缓冲描述“哪些预测工作还未完成”。具体容量、完成标记和回收时机尚待设计。 +- **待调度预测器（多个）**：保存在 PredictorMonitor 的有序管理数组/队列中，等待轮到自己。固定槽位容量（曾讨论 256）表示预测器注册上限，与缓存行计数无关。 +- **活动预测器（最多一个）**：当前 L4 正在执行其同步 `PredictMission`。预测器之间按依赖顺序切换，不需要多 lane 或 thread-local lane 归属。 +- **在途预测批次（可以多个）**：某预测器已经产出候选，但候选对应的实际任务尚未全部执行。此时要保留稳定的 predictor ID/代次、mission 或写回上下文；该记录属于任务 bag，不等同于预测器注册槽位。`PredictMission` 按预测器依赖顺序串行调用；前一批次的实际任务可以仍在途，是否与后续批次重叠由任务依赖决定。 +- **已完成批次**：对应实际工作全部完成，且所需软件写回或显式丢弃已完成。此时释放在途记录及其引用资源，不再由 L4 保存该批次。预测器本身是否注销是另一项生命周期操作。 + +Swiss 负责预测任务/映射条目的查找状态；Monitor 负责预测器注册和调度；在途预测器缓冲负责尚未完成的预测工作及其归属。三者不可混为同一个队列或数组。 `PredictMission(in Span)` 是同步接口，L4 可传入 stackalloc span。若返回后仍需跨线程或跨 NUMA 处理其内容，必须将内容复制到拥有明确生命周期的缓冲区；不得让 stack span 逃逸。由于预测器顺序有依赖，待处理预测必须按既定顺序交接。若采用异步 worker，队列应有界且不阻塞 Map 快路径。 ## 7. 驱逐与写回策略 -L4 不得推断或解码预测器的 packed 格式。若丢弃一个尚未写回、且对应实际工作仍在途的预测条目会丢失必要状态，就不能静默驱逐它。按缓存行的保护/引用字段或 sidecar 正在讨论中，引用/owner metadata 布局尚未定稿。 +L4 不得推断或解码预测器的 packed 格式。若丢弃一个尚未写回、且对应实际工作仍在途的预测条目会丢失必要状态，就不能静默驱逐它；必须由缓存行保护/引用状态阻止替换，或由 Monitor/预测器先完成写回、撤销或显式释放。相关状态可放在 KVP metadata 或 sidecar，布局尚未定稿。 owner ID 可用于路由显式写回；但若多个预测器能独立声明同一条目，单一 owner 字段不够。引用计数可保护共享条目，而写回路径仍需获得预测器 identity/source spec。 diff --git a/src/Nitload.Common/HighPerformance/Memory/L4.Map.cs b/src/Nitload.Common/HighPerformance/Memory/L4.Map.cs index 6e9c4a4e..0226abc5 100644 --- a/src/Nitload.Common/HighPerformance/Memory/L4.Map.cs +++ b/src/Nitload.Common/HighPerformance/Memory/L4.Map.cs @@ -18,9 +18,9 @@ namespace Nitload.Common.HighPerformance.Memory { private const int _low_predict = 512; - private readonly int _predict_slow_path_count; private int _predict_count; + private readonly int _predict_slow_path_count; private int _swiss_reader_counter; private int _swiss_swap_lock; private int _swiss_writer_lock; @@ -45,6 +45,7 @@ namespace Nitload.Common.HighPerformance.Memory _addressMap.SwapBuffers(); Volatile.Write(ref _predict_count, effectivePredictionCount); + _addressMap.TryRehash(); } if (_addressMap.TryGet(source, out handle)) { @@ -61,8 +62,9 @@ namespace Nitload.Common.HighPerformance.Memory } } else if (predictCount < _low_predict + _predict_slow_path_count) { - if (!TryGetAddress(source, out handle)) + if (!TryGetAddress(source, out handle)) { throw new InvalidOperationException($"Unexpected map request: [address source: 0x{source.Address:x16}; layout profile: {source.Description:x16}]."); + } } else if (!_addressMap.TryGet(source, out handle)) { throw new InvalidOperationException($"Unexpected map request: [address source: 0x{source.Address:x16}; layout profile: {source.Description:x16}]."); } diff --git a/src/Nitload.Common/HighPerformance/Memory/L4.Predict.cs b/src/Nitload.Common/HighPerformance/Memory/L4.Predict.cs index 01ef1212..594ea332 100644 --- a/src/Nitload.Common/HighPerformance/Memory/L4.Predict.cs +++ b/src/Nitload.Common/HighPerformance/Memory/L4.Predict.cs @@ -16,7 +16,10 @@ namespace Nitload.Common.HighPerformance.Memory public unsafe partial class L4 { - internal partial int Predict() => 0; + internal partial int Predict() + { + throw new NotImplementedException(); + } } } diff --git a/src/Nitload.Common/HighPerformance/Memory/L4.SwissTable.cs b/src/Nitload.Common/HighPerformance/Memory/L4.SwissTable.cs index 42c6decf..5929d155 100644 --- a/src/Nitload.Common/HighPerformance/Memory/L4.SwissTable.cs +++ b/src/Nitload.Common/HighPerformance/Memory/L4.SwissTable.cs @@ -6,8 +6,10 @@ // ----------------------------------------------------------------------------- using System.Buffers; +using System.Numerics; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; using System.Runtime.Intrinsics.X86; namespace Nitload.Common.HighPerformance.Memory @@ -93,11 +95,65 @@ namespace Nitload.Common.HighPerformance.Memory } + internal unsafe struct SwissEnumerator( + byte* buffer + ) + { + + private readonly SwissBucket* _buckets = (SwissBucket*)(buffer + IdealCount); + private readonly Vector128* _control_bytes = (Vector128*)buffer; + private int _current_group; + private int _current_mask; + private int _current_offset; + private bool _group_loaded; + + public (AddressSource key, ulong value) Current + { + get + { + SwissBucket* bucket = &_buckets[_current_group]; + AddressSource key = bucket->Keys[_current_offset]; + ulong value = bucket->Values[_current_offset]; + return (key, value); + } + } + + public bool MoveNext() + { + while (_current_group < GroupCount) + { + if (!_group_loaded) + { + if (Sse42.IsSupported) + { + _current_mask = SwissReaderX86.CompareOccupiedMask(*(_control_bytes + _current_group)); + } else + { + throw new PlatformNotSupportedException(); + } + _group_loaded = true; + } + + if (_current_mask != 0) + { + _current_offset = BitOperations.TrailingZeroCount(_current_mask); + _current_mask &= _current_mask - 1; + return true; + } + + _current_group++; + _group_loaded = false; + } + return false; + } + + } + internal unsafe struct SwissTable : IDisposable { private byte* _buffer_write; - + private int _delete_count; private ulong _published_buffer; private SwissTable( @@ -133,13 +189,13 @@ namespace Nitload.Common.HighPerformance.Memory /// /// Writes to the inactive buffer. The caller must serialize all writes. /// - public readonly bool TryAddOrSet( + public bool TryAddOrSet( AddressSource key, ulong value ) { if (Sse42.IsSupported) { - return SwissWriterX86.TryAddOrSet(_buffer_write, key, value); + return SwissWriterX86.TryAddOrSet(_buffer_write, key, value, ref _delete_count); } throw new NotImplementedException("The Swiss backend is not implemented for this ISA."); @@ -161,6 +217,40 @@ namespace Nitload.Common.HighPerformance.Memory throw new NotImplementedException("The Swiss backend is not implemented for this ISA."); } + public void TryRehash() + { + if (_delete_count < 2048) + { + NativeMemory.Copy(_buffer_write, (byte*)_published_buffer, (nuint)TableBufferSize); + return; + } + try + { + SwissEnumerator e = new((byte*)_published_buffer); + InitializeBuffer(_buffer_write); + if (Sse42.IsSupported) + { + while (e.MoveNext()) + { + (AddressSource key, ulong value) = e.Current; + if (!SwissWriterX86.TryAddOrSet(_buffer_write, key, value, ref _delete_count)) + { + throw new InvalidOperationException("The Swiss table could not fit all active entries during rehash."); + } + } + _delete_count = 0; + } else + { + throw new PlatformNotSupportedException(); + } + } + catch (Exception) + { + NativeMemory.Copy(_buffer_write, (byte*)_published_buffer, (nuint)TableBufferSize); + throw; + } + } + /// /// Removes from the inactive buffer. The caller must serialize all writes. /// @@ -169,11 +259,13 @@ namespace Nitload.Common.HighPerformance.Memory out ulong value ) { - if (Sse42.IsSupported) { - return SwissWriterX86.TryRemove(_buffer_write, key, out value); + if (Sse42.IsSupported) + { + return SwissWriterX86.TryRemove(_buffer_write, key, out value, ref _delete_count); + } else + { + throw new NotImplementedException("The Swiss backend is not implemented for this ISA."); } - - throw new NotImplementedException("The Swiss backend is not implemented for this ISA."); } internal static SwissTable Create( diff --git a/src/Nitload.Common/HighPerformance/Memory/L4.Swiss_X86.cs b/src/Nitload.Common/HighPerformance/Memory/L4.Swiss_X86.cs index f2edc6b2..7b9d93e8 100644 --- a/src/Nitload.Common/HighPerformance/Memory/L4.Swiss_X86.cs +++ b/src/Nitload.Common/HighPerformance/Memory/L4.Swiss_X86.cs @@ -39,7 +39,8 @@ namespace Nitload.Common.HighPerformance.Memory public static bool TryAddOrSet( byte* buffer, AddressSource key, - ulong value + ulong value, + ref int delete_count ) { Vector128* control_bytes = (Vector128*)buffer; @@ -101,6 +102,7 @@ namespace Nitload.Common.HighPerformance.Memory bucket->Keys[first_tomb_idx] = key; bucket->Values[first_tomb_idx] = value; ((byte*)(control_bytes + first_tomb_group))[first_tomb_idx] = target_hash; + delete_count--; } return true; } @@ -113,6 +115,7 @@ namespace Nitload.Common.HighPerformance.Memory bucket->Keys[first_tomb_idx] = key; bucket->Values[first_tomb_idx] = value; ((byte*)(control_bytes + first_tomb_group))[first_tomb_idx] = target_hash; + delete_count--; return true; } value = 0; @@ -122,7 +125,8 @@ namespace Nitload.Common.HighPerformance.Memory public static bool TryRemove( byte* buffer, AddressSource key, - out ulong value + out ulong value, + ref int delete_count ) { Vector128* control_bytes = (Vector128*)buffer; @@ -148,6 +152,7 @@ namespace Nitload.Common.HighPerformance.Memory { ((byte*)(control_bytes + begin))[index] = (byte)SwissControl.Deleted; value = bucket->Values[index]; + delete_count++; return true; } mask &= ~(1 << index); @@ -171,6 +176,20 @@ namespace Nitload.Common.HighPerformance.Memory internal readonly unsafe struct SwissReaderX86 { + private static readonly Vector128 _empty_mask = Vector128.Create((byte)SwissControl.Empty); + private static readonly Vector128 _tomb_mask = Vector128.Create((byte)SwissControl.Deleted); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int CompareOccupiedMask( + Vector128 control_bytes_v128 + ) + { + Vector128 cmp_eql = Sse2.CompareEqual(control_bytes_v128, _empty_mask); + Vector128 cmp_del = Sse2.CompareEqual(control_bytes_v128, _tomb_mask); + int specialMask = Sse2.MoveMask(Sse2.Or(cmp_eql, cmp_del)); + return (ushort)~(ushort)specialMask; + } + public static bool TryGet( byte* buffer, AddressSource key, diff --git a/src/Nitload.Native/CMakeLists.txt b/src/Nitload.Native/CMakeLists.txt index 7fa06e56..7c79913e 100644 --- a/src/Nitload.Native/CMakeLists.txt +++ b/src/Nitload.Native/CMakeLists.txt @@ -17,39 +17,16 @@ nfn_resolve_target_identifiers( NFN_RESOLVED_ARCH_NAME NFN_RESOLVED_ARCH_DEFINE) -set(NFN_NATIVE_SOURCES - ${CMAKE_CURRENT_LIST_DIR}/nfn-src/dllmain.c - ${CMAKE_CURRENT_LIST_DIR}/nfn-src/load_glfw.c - ${CMAKE_CURRENT_LIST_DIR}/nfn-src/load_intrinsic.x86.c - ${CMAKE_CURRENT_LIST_DIR}/nfn-src/m.bufop.x86.c - ${CMAKE_CURRENT_LIST_DIR}/nfn-src/m.solve.x86.c - ${CMAKE_CURRENT_LIST_DIR}/nfn-src/m.transpose.x86.c - ${CMAKE_CURRENT_LIST_DIR}/nfn-src/mk.fma.pack.c - ${CMAKE_CURRENT_LIST_DIR}/nfn-src/mk.fma.x86.c - ${CMAKE_CURRENT_LIST_DIR}/nfn-src/mk.p_scan.x86.c - ${CMAKE_CURRENT_LIST_DIR}/nfn-src/s.factorial.x86.c - ${CMAKE_CURRENT_LIST_DIR}/nfn-src/s.hash.x86.c - ${CMAKE_CURRENT_LIST_DIR}/nfn-src/simdid_compare.x86.c - ${CMAKE_CURRENT_LIST_DIR}/nfn-src/simdid.x86.c - ${CMAKE_CURRENT_LIST_DIR}/nfn-src/sk.fma.x86.c - ${CMAKE_CURRENT_LIST_DIR}/nfn-src/thread.linux.c - ${CMAKE_CURRENT_LIST_DIR}/nfn-src/thread.windows.c - ${CMAKE_CURRENT_LIST_DIR}/nfn-src/vector.c - ${CMAKE_CURRENT_LIST_DIR}/nfn-src/vector_dot.c) +# CONFIGURE_DEPENDS makes CMake reconfigure when files are added or removed, +# so native sources, headers, and templates need no per-file CMake edits. +file(GLOB_RECURSE NFN_NATIVE_SOURCES CONFIGURE_DEPENDS + ${CMAKE_CURRENT_LIST_DIR}/nfn-src/*.c) -set(NFN_NATIVE_HEADERS - ${CMAKE_CURRENT_LIST_DIR}/nfn-head/glfw_function.h - ${CMAKE_CURRENT_LIST_DIR}/nfn-head/nfn_internal.h - ${CMAKE_CURRENT_LIST_DIR}/nfn-head/nfn_intrinsic.context.base.h - ${CMAKE_CURRENT_LIST_DIR}/nfn-head/nfn_intrinsic.context.x86.h - ${CMAKE_CURRENT_LIST_DIR}/nfn-head/nfn_intrinsic.h - ${CMAKE_CURRENT_LIST_DIR}/nfn-head/nfn_intrinsic.matkernel.h - ${CMAKE_CURRENT_LIST_DIR}/nfn-head/nfn_intrinsic.std.h - ${CMAKE_CURRENT_LIST_DIR}/nfn-head/nfn_target.h - ${CMAKE_CURRENT_LIST_DIR}/nfn-head/NitloadFrameWork.h) +file(GLOB_RECURSE NFN_NATIVE_HEADERS CONFIGURE_DEPENDS + ${CMAKE_CURRENT_LIST_DIR}/nfn-head/*.h) -set(NFN_NATIVE_TEMPLATES - ${CMAKE_CURRENT_LIST_DIR}/nfn-template/nfn_template.fma.x86.h) +file(GLOB_RECURSE NFN_NATIVE_TEMPLATES CONFIGURE_DEPENDS + ${CMAKE_CURRENT_LIST_DIR}/nfn-template/*.h) # Nitload.Native now lives under /src/Nitload.Native, so walk up two # levels (project dir -> src -> solution root) to reach the solution root. diff --git a/src/Nitload.Native/nfn-head/NitloadFrameWork.h b/src/Nitload.Native/nfn-head/NitloadFrameWork.h index ed9f9663..cc627f53 100644 --- a/src/Nitload.Native/nfn-head/NitloadFrameWork.h +++ b/src/Nitload.Native/nfn-head/NitloadFrameWork.h @@ -19,17 +19,19 @@ #ifndef NFN_ #endif -NFN_API void NFN_DECL nfn_load_glfw_functions(GLFWFunctionTable *table); -NFN_API void NFN_DECL nfn_load_intrinsic_function(void *intrinsic_context, uint64_t id); +NFN_API void NFN_DECL nfn_load_glfw_functions(GLFWFunctionTable *table); +NFN_API void NFN_DECL nfn_load_intrinsic_function(void *intrinsic_context, uint64_t id); NFN_API SIMDID NFN_DECL nfn_get_simd_level_global(); /* Per-core variant: always re-executes CPUID, never caches. * Must be called on the target core (after affinity is set). */ NFN_API SIMDID NFN_DECL nfn_get_simd_level_local(); NFN_API SIMDID NFN_DECL nfn_get_unite_simd(SIMDID left, SIMDID right); -NFN_API int NFN_DECL nfn_compare_simd(SIMDID left, SIMDID right); -NFN_API void NFN_DECL nfn_set_thread_affinity(int core_id, int numa_id); -NFN_API void* NFN_DECL nfn_numa_alloc(size_t size, int numa_id); -NFN_API void NFN_DECL nfn_numa_free(void *ptr, size_t size, int numa_id); -NFN_API int NFN_DECL nfn_get_numa_each(int numa_id, uint64_t *internal, uint32_t *global); -NFN_API int NFN_DECL nfn_get_numa_overall(int *out_numa_count, int *count_of_each_numa); +NFN_API int NFN_DECL nfn_compare_simd(SIMDID left, SIMDID right); +NFN_API void NFN_DECL nfn_set_thread_affinity(int cpu_index, int processor_group_id); +NFN_API void *NFN_DECL nfn_numa_alloc(size_t size, int numa_id); +NFN_API void NFN_DECL nfn_numa_free(void *ptr, size_t size, int numa_id); +NFN_API int NFN_DECL nfn_get_numa_each(int numa_id, uint32_t *processor_group_ids, + uint32_t *socket_ids, uint32_t *cpu_indices, + uint32_t *numa_node_ids); +NFN_API int NFN_DECL nfn_get_numa_overall(int *out_numa_count, int *count_of_each_numa); #endif diff --git a/src/Nitload.Native/nfn-src/thread.linux.c b/src/Nitload.Native/nfn-src/thread.linux.c index 8adbdd3c..46922899 100644 --- a/src/Nitload.Native/nfn-src/thread.linux.c +++ b/src/Nitload.Native/nfn-src/thread.linux.c @@ -26,18 +26,12 @@ typedef struct nfn_linux_max_context { int max_value; } nfn_linux_max_context; -<<<<<<< HEAD:src/Nitload.Native/nfn-src/thread.linux.c typedef struct nfn_linux_fill_cpu_context { - uint64_t *internal; - uint32_t *global; -======= -typedef struct nif_linux_fill_cpu_context { uint32_t *processor_group_ids; uint32_t *socket_ids; uint32_t *cpu_indices; uint32_t *numa_node_ids; int numa_id; ->>>>>>> 3a2b1234782f893f5b71655289b372ffed8dfd93:src/Nitload.Native/nif-src/thread.linux.c int index; } nfn_linux_fill_cpu_context; @@ -127,12 +121,7 @@ static int nfn_linux_track_max_id(int value, void *context) return 1; } -<<<<<<< HEAD:src/Nitload.Native/nfn-src/thread.linux.c -static int nfn_linux_fill_cpu_id(int value, void *context) -{ - nfn_linux_fill_cpu_context *fill_context = (nfn_linux_fill_cpu_context *)context; -======= -static int nif_linux_read_socket_id(int cpu_id, uint32_t *socket_id) +static int nfn_linux_read_socket_id(int cpu_id, uint32_t *socket_id) { char path[160]; char buffer[64]; @@ -140,25 +129,24 @@ static int nif_linux_read_socket_id(int cpu_id, uint32_t *socket_id) long parsed_value; snprintf(path, sizeof(path), "/sys/devices/system/cpu/cpu%d/topology/physical_package_id", cpu_id); - if (!nif_linux_read_first_line(path, buffer, sizeof(buffer))) + if (!nfn_linux_read_first_line(path, buffer, sizeof(buffer))) return 0; errno = 0; parsed_value = strtol(buffer, &end, 10); - if (end == buffer || errno == ERANGE || parsed_value < 0 || parsed_value > UINT32_MAX) + if (end == buffer || errno == ERANGE || parsed_value < 0 || (uintmax_t)parsed_value > UINT32_MAX) return 0; *socket_id = (uint32_t)parsed_value; return 1; } -static int nif_linux_fill_cpu_id(int value, void *context) +static int nfn_linux_fill_cpu_id(int value, void *context) { - nif_linux_fill_cpu_context *fill_context = (nif_linux_fill_cpu_context *)context; + nfn_linux_fill_cpu_context *fill_context = (nfn_linux_fill_cpu_context *)context; uint32_t socket_id = 0; - if (!nif_linux_read_socket_id(value, &socket_id)) + if (!nfn_linux_read_socket_id(value, &socket_id)) return 0; ->>>>>>> 3a2b1234782f893f5b71655289b372ffed8dfd93:src/Nitload.Native/nif-src/thread.linux.c fill_context->processor_group_ids[fill_context->index] = 0u; fill_context->socket_ids[fill_context->index] = socket_id; @@ -249,15 +237,8 @@ static int nfn_linux_populate_writable_mapping(void *address, size_t size) #endif } -<<<<<<< HEAD:src/Nitload.Native/nfn-src/thread.linux.c -/* Pin the calling thread to a single logical processor. - * core_id >= 0 : bind to that logical processor (global index, across groups). - * core_id < 0 : clear affinity constraint within the current group. */ -NFN_API void NFN_DECL nfn_set_thread_affinity(int core_id, int numa_id) -======= /* Linux has no Windows-style processor groups; processor_group_id is ignored. */ -NIF_API void NIF_DECL nif_set_thread_affinity(int cpu_index, int processor_group_id) ->>>>>>> 3a2b1234782f893f5b71655289b372ffed8dfd93:src/Nitload.Native/nif-src/thread.linux.c +NFN_API void NFN_DECL nfn_set_thread_affinity(int cpu_index, int processor_group_id) { (void)processor_group_id; @@ -311,15 +292,11 @@ NFN_API int NFN_DECL nfn_get_numa_overall(int *out_numa_count, int *count_of_eac return 1; } -<<<<<<< HEAD:src/Nitload.Native/nfn-src/thread.linux.c -NFN_API int NFN_DECL nfn_get_numa_each(int numa_id, uint64_t *internal, uint32_t *global) -======= -NIF_API int NIF_DECL nif_get_numa_each(int numa_id, - uint32_t *processor_group_ids, - uint32_t *socket_ids, - uint32_t *cpu_indices, - uint32_t *numa_node_ids) ->>>>>>> 3a2b1234782f893f5b71655289b372ffed8dfd93:src/Nitload.Native/nif-src/thread.linux.c +NFN_API int NFN_DECL nfn_get_numa_each(int numa_id, + uint32_t *processor_group_ids, + uint32_t *socket_ids, + uint32_t *cpu_indices, + uint32_t *numa_node_ids) { if (numa_id < 0 || processor_group_ids == NULL || socket_ids == NULL || cpu_indices == NULL || numa_node_ids == NULL) @@ -331,11 +308,7 @@ NIF_API int NIF_DECL nif_get_numa_each(int numa_id, if (!nfn_linux_read_first_line(path, buffer, sizeof(buffer))) return 0; -<<<<<<< HEAD:src/Nitload.Native/nfn-src/thread.linux.c - nfn_linux_fill_cpu_context fill_context = { internal, global, 0 }; - return nfn_linux_visit_id_list(buffer, nfn_linux_fill_cpu_id, &fill_context); -======= - nif_linux_fill_cpu_context fill_context = { + nfn_linux_fill_cpu_context fill_context = { processor_group_ids, socket_ids, cpu_indices, @@ -343,8 +316,7 @@ NIF_API int NIF_DECL nif_get_numa_each(int numa_id, numa_id, 0 }; - return nif_linux_visit_id_list(buffer, nif_linux_fill_cpu_id, &fill_context); ->>>>>>> 3a2b1234782f893f5b71655289b372ffed8dfd93:src/Nitload.Native/nif-src/thread.linux.c + return nfn_linux_visit_id_list(buffer, nfn_linux_fill_cpu_id, &fill_context); } NFN_API void *NFN_DECL nfn_numa_alloc(size_t size, int numa_id) diff --git a/src/Nitload.Native/nfn-src/thread.windows.c b/src/Nitload.Native/nfn-src/thread.windows.c index d5001882..3012a79c 100644 --- a/src/Nitload.Native/nfn-src/thread.windows.c +++ b/src/Nitload.Native/nfn-src/thread.windows.c @@ -2,15 +2,12 @@ #include "NitloadFrameWork.h" #if NFN_IS_OS(NFN_OS_WINDOWS) +#include +#include +#include +#include -<<<<<<< HEAD:src/Nitload.Native/nfn-src/thread.windows.c -/* Pin the calling thread to a single logical processor. - * core_id >= 0 : bind to that logical processor (global index, across groups). - * core_id < 0 : clear affinity constraint within the current group. */ -NFN_API void NFN_DECL nfn_set_thread_affinity(int core_id, int numa_id) -======= -static int nif_windows_get_socket_map(uint32_t **out_socket_map, DWORD *out_group_count) ->>>>>>> 3a2b1234782f893f5b71655289b372ffed8dfd93:src/Nitload.Native/nif-src/thread.windows.c +static int nfn_windows_get_socket_map(uint32_t **out_socket_map, DWORD *out_group_count) { DWORD group_count = GetActiveProcessorGroupCount(); DWORD buffer_size = 0; @@ -71,7 +68,7 @@ static int nif_windows_get_socket_map(uint32_t **out_socket_map, DWORD *out_grou return 1; } -static int nif_windows_get_processor_node(WORD group, BYTE cpu, USHORT *node_id) +static int nfn_windows_get_processor_node(WORD group, BYTE cpu, USHORT *node_id) { PROCESSOR_NUMBER processor; memset(&processor, 0, sizeof(processor)); @@ -81,7 +78,7 @@ static int nif_windows_get_processor_node(WORD group, BYTE cpu, USHORT *node_id) } /* Pin the calling thread using its processor group and group-local CPU index. */ -NIF_API void NIF_DECL nif_set_thread_affinity(int cpu_index, int processor_group_id) +NFN_API void NFN_DECL nfn_set_thread_affinity(int cpu_index, int processor_group_id) { if (cpu_index < 0 || processor_group_id < 0) { GROUP_AFFINITY current; @@ -98,7 +95,7 @@ NIF_API void NIF_DECL nif_set_thread_affinity(int cpu_index, int processor_group if ((DWORD)processor_group_id >= GetActiveProcessorGroupCount() || cpu_index >= 64) return; USHORT node_id = 0; - if (!nif_windows_get_processor_node((WORD)processor_group_id, (BYTE)cpu_index, &node_id)) + if (!nfn_windows_get_processor_node((WORD)processor_group_id, (BYTE)cpu_index, &node_id)) return; GROUP_AFFINITY affinity; @@ -124,7 +121,7 @@ NFN_API int NFN_DECL nfn_get_numa_overall(int *out_numa_count, int *count_of_eac for (DWORD group = 0; group < group_count; group++) { for (DWORD cpu = 0; cpu < 64; cpu++) { USHORT node_id = 0; - if (nif_windows_get_processor_node((WORD)group, (BYTE)cpu, &node_id) && + if (nfn_windows_get_processor_node((WORD)group, (BYTE)cpu, &node_id) && count_of_each_numa != NULL && node_id <= highest) count_of_each_numa[node_id]++; } @@ -132,15 +129,11 @@ NFN_API int NFN_DECL nfn_get_numa_overall(int *out_numa_count, int *count_of_eac return 1; } -<<<<<<< HEAD:src/Nitload.Native/nfn-src/thread.windows.c -NFN_API int NFN_DECL nfn_get_numa_each(int numa_id, uint64_t *internal, uint32_t *global) -======= -NIF_API int NIF_DECL nif_get_numa_each(int numa_id, - uint32_t *processor_group_ids, - uint32_t *socket_ids, - uint32_t *cpu_indices, - uint32_t *numa_node_ids) ->>>>>>> 3a2b1234782f893f5b71655289b372ffed8dfd93:src/Nitload.Native/nif-src/thread.windows.c +NFN_API int NFN_DECL nfn_get_numa_each(int numa_id, + uint32_t *processor_group_ids, + uint32_t *socket_ids, + uint32_t *cpu_indices, + uint32_t *numa_node_ids) { if (numa_id < 0 || processor_group_ids == NULL || socket_ids == NULL || cpu_indices == NULL || numa_node_ids == NULL) @@ -148,14 +141,14 @@ NIF_API int NIF_DECL nif_get_numa_each(int numa_id, uint32_t *socket_map = NULL; DWORD group_count = 0; - if (!nif_windows_get_socket_map(&socket_map, &group_count)) + if (!nfn_windows_get_socket_map(&socket_map, &group_count)) return 0; int index = 0; for (DWORD group = 0; group < group_count; group++) { for (DWORD cpu = 0; cpu < 64; cpu++) { USHORT node_id = 0; - if (!nif_windows_get_processor_node((WORD)group, (BYTE)cpu, &node_id) || + if (!nfn_windows_get_processor_node((WORD)group, (BYTE)cpu, &node_id) || node_id != (USHORT)numa_id) continue;