[EM] Check whether memory policy is set.

Author: trivialfis

src/common/error_msg.cc

@@ -1,12 +1,14 @@
 /**
- * Copyright 2023 by XGBoost contributors
+ * Copyright 2023-2025, XGBoost contributors
  */
 #include "error_msg.h"
 
-#include <mutex>    // for call_once, once_flag
-#include <sstream>  // for stringstream
+#include <mutex>         // for call_once, once_flag
+#include <sstream>       // for stringstream
+#include <system_error>  // for error_code, system_category
 
 #include "../collective/communicator-inl.h"  // for GetRank
+#include "xgboost/collective/socket.h"       // for LastError
 #include "xgboost/context.h"                 // for Context
 #include "xgboost/logging.h"
 
@@ -76,4 +78,10 @@ void CheckOldNccl(std::int32_t major, std::int32_t minor, std::int32_t patch) {
     LOG(WARNING) << msg();
   }
 }
+
+[[nodiscard]] std::error_code SystemError() {
+  std::int32_t errsv = system::LastError();
+  auto err = std::error_code{errsv, std::system_category()};
+  return err;
+}
 }  // namespace xgboost::error

src/common/error_msg.h

@@ -6,9 +6,10 @@
 #ifndef XGBOOST_COMMON_ERROR_MSG_H_
 #define XGBOOST_COMMON_ERROR_MSG_H_
 
-#include <cstdint>    // for uint64_t
-#include <limits>     // for numeric_limits
-#include <string>     // for string
+#include <cstdint>       // for uint64_t
+#include <limits>        // for numeric_limits
+#include <string>        // for string
+#include <system_error>  // for error_code
 
 #include "xgboost/base.h"     // for bst_feature_t
 #include "xgboost/context.h"  // for Context
@@ -140,5 +141,7 @@ constexpr StringView CacheHostRatioNotImpl() {
 constexpr StringView CacheHostRatioInvalid() {
   return "`cache_host_ratio` must be in range [0, 1].";
 }
+
+[[nodiscard]] std::error_code SystemError();
 }  // namespace xgboost::error
 #endif  // XGBOOST_COMMON_ERROR_MSG_H_

src/common/io.cc

@@ -1,6 +1,7 @@
 /**
  * Copyright 2019-2025, by XGBoost Contributors
  */
+#include "error_msg.h"
 #if defined(__unix__) || defined(__APPLE__)
 
 #include <fcntl.h>     // for open, O_RDONLY, posix_fadvise
@@ -29,12 +30,10 @@
 #include <iterator>      // for distance
 #include <memory>        // for unique_ptr, make_unique
 #include <string>        // for string
-#include <system_error>  // for error_code, system_category
 #include <utility>       // for move
 #include <vector>        // for vector
 
 #include "io.h"
-#include "xgboost/collective/socket.h"  // for LastError
 #include "xgboost/logging.h"            // for CHECK_LE
 #include "xgboost/string_view.h"        // for StringView
 
@@ -134,19 +133,13 @@ std::size_t GetMmapAlignment() {
   return getpagesize();
 #endif
 }
-
-auto SystemErrorMsg() {
-  std::int32_t errsv = system::LastError();
-  auto err = std::error_code{errsv, std::system_category()};
-  return err.message();
-}
 }  // anonymous namespace
 
 std::vector<char> LoadSequentialFile(std::string uri) {
   auto OpenErr = [&uri]() {
     std::string msg;
     msg = "Opening " + uri + " failed: ";
-    msg += SystemErrorMsg();
+    msg += error::SystemError().message();
     LOG(FATAL) << msg;
   };
 
@@ -193,10 +186,11 @@ MMAPFile* detail::OpenMmap(std::string path, std::size_t offset, std::size_t len
 #if defined(xgboost_IS_WIN)
   HANDLE fd = CreateFile(path.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
                          FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, nullptr);
-  CHECK_NE(fd, INVALID_HANDLE_VALUE) << "Failed to open:" << path << ". " << SystemErrorMsg();
+  CHECK_NE(fd, INVALID_HANDLE_VALUE)
+      << "Failed to open:" << path << ". " << SystemError().message();
 #else
   auto fd = open(path.c_str(), O_RDONLY);
-  CHECK_GE(fd, 0) << "Failed to open:" << path << ". " << SystemErrorMsg();
+  CHECK_GE(fd, 0) << "Failed to open:" << path << ". " << error::SystemError().message();
 #endif
 
   std::byte* ptr{nullptr};
@@ -207,7 +201,7 @@ MMAPFile* detail::OpenMmap(std::string path, std::size_t offset, std::size_t len
 #if defined(__linux__) || defined(__GLIBC__)
   int prot{PROT_READ};
   ptr = reinterpret_cast<std::byte*>(mmap(nullptr, view_size, prot, MAP_PRIVATE, fd, view_start));
-  CHECK_NE(ptr, MAP_FAILED) << "Failed to map: " << path << ". " << SystemErrorMsg();
+  CHECK_NE(ptr, MAP_FAILED) << "Failed to map: " << path << ". " << error::SystemError().message();
   auto handle = new MMAPFile{fd, ptr, view_size, offset - view_start, std::move(path)};
 #elif defined(xgboost_IS_WIN)
   auto file_size = GetFileSize(fd, nullptr);
@@ -216,16 +210,16 @@ MMAPFile* detail::OpenMmap(std::string path, std::size_t offset, std::size_t len
   access = FILE_MAP_READ;
   std::uint32_t loff = static_cast<std::uint32_t>(view_start);
   std::uint32_t hoff = view_start >> 32;
-  CHECK(map_file) << "Failed to map: " << path << ". " << SystemErrorMsg();
+  CHECK(map_file) << "Failed to map: " << path << ". " << error::SystemError().message();
   ptr = reinterpret_cast<std::byte*>(MapViewOfFile(map_file, access, hoff, loff, view_size));
-  CHECK_NE(ptr, nullptr) << "Failed to map: " << path << ". " << SystemErrorMsg();
+  CHECK_NE(ptr, nullptr) << "Failed to map: " << path << ". " << error::SystemError().message();
   auto handle = new MMAPFile{fd, map_file, ptr, view_size, offset - view_start, std::move(path)};
 #else
   CHECK_LE(offset, std::numeric_limits<off_t>::max())
       << "File size has exceeded the limit on the current system.";
   int prot{PROT_READ};
   ptr = reinterpret_cast<std::byte*>(mmap(nullptr, view_size, prot, MAP_PRIVATE, fd, view_start));
-  CHECK_NE(ptr, MAP_FAILED) << "Failed to map: " << path << ". " << SystemErrorMsg();
+  CHECK_NE(ptr, MAP_FAILED) << "Failed to map: " << path << ". " << error::SystemError().message();
   auto handle = new MMAPFile{fd, ptr, view_size, offset - view_start, std::move(path)};
 #endif  // defined(__linux__) || defined(__GLIBC__)
 
@@ -238,22 +232,24 @@ void detail::CloseMmap(MMAPFile* handle) {
   }
 #if defined(xgboost_IS_WIN)
   if (handle->base_ptr) {
-    CHECK(UnmapViewOfFile(handle->base_ptr)) << "Failed to call munmap: " << SystemErrorMsg();
+    CHECK(UnmapViewOfFile(handle->base_ptr))
+        << "Failed to call munmap: " << error::SystemError().message();
   }
   if (handle->fd != INVALID_HANDLE_VALUE) {
-    CHECK(CloseHandle(handle->fd)) << "Failed to close handle: " << SystemErrorMsg();
+    CHECK(CloseHandle(handle->fd)) << "Failed to close handle: " << error::SystemError().message();
   }
   if (handle->file_map != INVALID_HANDLE_VALUE) {
-    CHECK(CloseHandle(handle->file_map)) << "Failed to close mapping object: " << SystemErrorMsg();
+    CHECK(CloseHandle(handle->file_map))
+        << "Failed to close mapping object: " << error::SystemError().message();
   }
 #else
   if (handle->base_ptr) {
     CHECK_NE(munmap(handle->base_ptr, handle->base_size), -1)
-        << "Failed to call munmap: `" << handle->path << "`. " << SystemErrorMsg();
+        << "Failed to call munmap: `" << handle->path << "`. " << error::SystemError().message();
   }
   if (handle->fd != 0) {
     CHECK_NE(close(handle->fd), -1)
-        << "Failed to close: `" << handle->path << "`. " << SystemErrorMsg();
+        << "Failed to close: `" << handle->path << "`. " << error::SystemError().message();
   }
 #endif
   delete handle;
@@ -293,7 +289,7 @@ std::shared_ptr<MallocResource> MemBufFileReadStream::ReadFileIntoBuffer(StringV
   std::unique_ptr<FILE, std::function<int(FILE*)>> fp{fopen(path.c_str(), "rb"), fclose};
 
   auto err = [&] {
-    auto e = SystemErrorMsg();
+    auto e = error::SystemError().message();
     LOG(FATAL) << "Failed to read file `" << path << "`. System error message: " << e;
   };
 #if defined(__linux__)
@@ -302,7 +298,7 @@ std::shared_ptr<MallocResource> MemBufFileReadStream::ReadFileIntoBuffer(StringV
     err();
   }
   if (posix_fadvise(fd, offset, length, POSIX_FADV_SEQUENTIAL) != 0) {
-    LOG(FATAL) << SystemErrorMsg();
+    LOG(FATAL) << error::SystemError().message();
   }
 #endif  // defined(__linux__)
 
@@ -358,12 +354,12 @@ AlignedMemWriteStream::~AlignedMemWriteStream() = default;
 [[nodiscard]] std::size_t TotalMemory() {
 #if defined(__linux__)
   struct sysinfo info;
-  CHECK_EQ(sysinfo(&info), 0) << SystemErrorMsg();
+  CHECK_EQ(sysinfo(&info), 0) << error::SystemError().message();
   return info.totalram * info.mem_unit;
 #elif defined(xgboost_IS_WIN)
   MEMORYSTATUSEX status;
   status.dwLength = sizeof(status);
-  CHECK(GlobalMemoryStatusEx(&status)) << SystemErrorMsg();
+  CHECK(GlobalMemoryStatusEx(&status)) << error::SystemError().message();
   return static_cast<std::size_t>(status.ullTotalPhys);
 #else
   LOG(FATAL) << "Not implemented";

src/common/numa_utils.cc

@@ -0,0 +1,167 @@
+/**
+ * Copyright 2025, XGBoost Contributors
+ */
+#include "numa_utils.h"
+
+#if defined(__linux__)
+
+#include <linux/mempolicy.h>  // for MPOL_BIND
+#include <sys/syscall.h>      // for SYS_get_mempolicy
+#include <unistd.h>           // for syscall
+
+#endif  // defined(__linux__)
+
+#include <cctype>      // for isalnum
+#include <cstddef>     // for size_t
+#include <cstdint>     // for int32_t
+#include <filesystem>  // for path
+#include <fstream>     // for ifstream
+#include <string>      // for string, stoi
+#include <vector>      // for vector
+
+#include "common.h"     // for TrimLast, TrimFirst
+#include "error_msg.h"  // for SystemError
+#include "xgboost/logging.h"
+
+namespace xgboost::common {
+
+namespace {
+namespace fs = std::filesystem;
+#if defined(__linux__)
+// Wrapper for the system call
+auto GetMemPolicy(int *mode, unsigned long *nodemask, unsigned long maxnode, void *addr,  // NOLINT
+                  unsigned long flags) {                                                  // NOLINT
+  return syscall(SYS_get_mempolicy, mode, nodemask, maxnode, addr, flags);
+}
+
+auto GetMemPolicy(int *policy, unsigned long *nmask, unsigned long maxnode) {  // NOLINT
+  return GetMemPolicy(policy, nmask, maxnode, nullptr, 0);
+}
+#endif  // defined(__linux__)
+}  // namespace
+
+void ReadCpuList(fs::path const &path, std::vector<std::int32_t> *p_cpus) {
+  auto &cpus = *p_cpus;
+  cpus.clear();
+
+  std::ifstream fin{path};
+  std::string buff;
+  fin >> buff;
+  CHECK(!buff.empty());
+  buff = common::TrimFirst(common::TrimLast(buff));
+
+  std::int32_t k = 0;
+  CHECK(std::isalnum(buff[k]));
+  while (static_cast<std::size_t>(k) < buff.size()) {
+    std::int32_t val0 = -1, val1 = -1;
+    std::size_t idx = 0;
+    CHECK(std::isalnum(buff[k])) << k << " " << buff;
+    val0 = std::stoi(buff.data() + k, &idx);
+    auto last = k + idx;
+    CHECK_LE(last, buff.size());
+    k = last + 1;  // new begin
+    if (last == buff.size() || buff[last] != '-') {
+      cpus.push_back(val0);
+      continue;
+    }
+    CHECK_EQ(buff[last], '-') << last;
+
+    idx = -1;
+    CHECK_LT(k, buff.size());
+    val1 = std::stoi(buff.data() + k, &idx);
+    CHECK_GE(idx, 1);
+    // Parse range
+    for (auto i = val0; i <= val1; ++i) {
+      cpus.push_back(i);
+    }
+    k += (idx + 1);
+  }
+}
+
+void GetNumaNodeCpus(std::int32_t node_id, std::vector<std::int32_t> *p_cpus) {
+  p_cpus->clear();
+#if defined(__linux__)
+  std::string nodename = "node" + std::to_string(node_id);
+  auto p_cpulist = fs::path{"/sys/devices/system/node"} / fs::path{nodename} / fs::path{"cpulist"};
+
+  if (!fs::exists(p_cpulist)) {
+    return;
+  }
+  ReadCpuList(p_cpulist, p_cpus);
+#endif  // defined(__linux__)
+}
+
+[[nodiscard]] std::int32_t GetNumaMaxNumNodes() {
+#if defined(__linux__)
+  auto p_possible = fs::path{"/sys/devices/system/node/possible"};
+  std::int32_t max_n_nodes = -1;
+  if (fs::exists(p_possible)) {
+    std::vector<std::int32_t> cpus;
+    ReadCpuList(p_possible, &cpus);
+    auto it = std::max_element(cpus.cbegin(), cpus.cend());
+    if (it != cpus.cend()) {
+      max_n_nodes = *it;
+    }
+  }
+
+  // Just in case if it keeps getting into error
+  constexpr decltype(max_n_nodes) kThresh = 16384;
+  // Estimate the size of the CPU set based on the error returned from get mempolicy.
+  // Strategy used by hwloc and libnuma.
+  while (true) {
+    std::vector<std::uint64_t> mask(max_n_nodes, 0);
+
+    std::int32_t mode = -1;
+    auto err = GetMemPolicy(&mode, mask.data(), max_n_nodes);
+    if (!err || errno != EINVAL) {
+      return max_n_nodes;
+    }
+    max_n_nodes *= 2;
+
+    if (max_n_nodes > kThresh) {
+      break;
+    }
+  }
+  return -1;
+#else
+  return -1;
+#endif  // defined(__linux__)
+}
+
+[[nodiscard]] bool GetNumaMemBind() {
+#if defined(__linux__)
+  std::int32_t mode = -1;
+  auto max_n_nodes = GetNumaMaxNumNodes();
+  if (max_n_nodes <= 0) {
+    return false;
+  }
+  std::vector<std::uint64_t> mask(max_n_nodes / 8);
+  CHECK_GE(GetMemPolicy(&mode, mask.data(), max_n_nodes), 0) << error::SystemError().message();
+  return mode == MPOL_BIND;
+#else
+  return false;
+#endif  // defined(__linux__)
+}
+
+[[nodiscard]] std::int32_t GetNumaNumNodes() {
+#if defined(__linux__)
+  fs::path p_node{"/sys/devices/system/node"};
+  if (!fs::exists(p_node)) {
+    return -1;
+  }
+  std::int32_t n_nodes{0};
+  for (auto const &entry : fs::directory_iterator{p_node}) {
+    auto name = entry.path().filename().string();
+    if (name.find("node") == 0) {  // starts with `node`
+      n_nodes += 1;
+    }
+  }
+  if (n_nodes == 0) {
+    return -1;
+  }
+  return n_nodes;
+#else
+  return -1;
+#endif  // defined(__linux__)
+}
+}  // namespace xgboost::common