[feat] Support numa node bind.

Author: meilirensheng2020

src/cache/dingo_cache.cc

@@ -31,6 +31,7 @@
 #include "common/options/cache.h"
 #include "common/options/common.h"
 #include "utils/daemonize.h"
+#include "utils/numa_manager.h"
 
 namespace dingofs {
 namespace cache {
@@ -134,6 +135,13 @@ int DingoCache::Run(int argc, char** argv) {
     }
   }
 
+  // numa bind to node to avoid performance degradation caused by
+  // cross-node memory access
+  auto& numa_manager = dingofs::utils::NumaManager::GetInstance();
+  if (dingofs::FLAGS_numa_bind_enable && numa_manager.Available()) {
+    numa_manager.BindNode(dingofs::FLAGS_numa_bind_node);
+  }
+
   return StartServer();
 }
 

src/client/main.cc

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include <gflags/gflags.h>
 #include <glog/logging.h>
 
 #include <csignal>
@@ -32,8 +33,8 @@
 #include "common/options/common.h"
 #include "common/types.h"
 #include "fmt/format.h"
-#include "gflags/gflags.h"
 #include "utils/daemonize.h"
+#include "utils/numa_manager.h"
 #include "utils/scoped_cleanup.h"
 
 using FuseServer = dingofs::client::fuse::FuseServer;
@@ -181,6 +182,13 @@ int main(int argc, char* argv[]) {
     return EXIT_FAILURE;
   }
 
+  // numa bind to node to avoid performance degradation caused by
+  // cross-node memory access
+  auto& numa_manager = dingofs::utils::NumaManager::GetInstance();
+  if (dingofs::FLAGS_numa_bind_enable && numa_manager.Available()) {
+    numa_manager.BindNode(dingofs::FLAGS_numa_bind_node);
+  }
+
   struct MountOption mount_option{
       .mount_point = mountpoint,
       .fs_name = fs_name,

src/common/options/client.h

@@ -133,6 +133,10 @@ DECLARE_bool(vfs_use_fake_block_store);
 DECLARE_bool(vfs_block_store_access_log_enable);
 DECLARE_int64(vfs_block_store_access_log_threshold_us);
 
+// numa
+DECLARE_bool(numa_bind_enable);
+DECLARE_int32(numa_bind_node);
+
 }  // namespace client
 }  // namespace dingofs
 

src/common/options/common.cc

@@ -37,4 +37,8 @@ DEFINE_validator(log_clean_filter_pattern,
                    return !value.empty();
                  });
 
+// numa
+DEFINE_bool(numa_bind_enable, false, "enable numa bind");
+DEFINE_int32(numa_bind_node, 0, "numa bind node");
+
 }  // namespace dingofs

src/common/options/common.h

@@ -33,6 +33,10 @@ DECLARE_bool(log_clean_enable);
 DECLARE_int32(log_retention_seconds);
 DECLARE_string(log_clean_filter_pattern);
 
+// numa
+DECLARE_bool(numa_bind_enable);
+DECLARE_int32(numa_bind_node);
+
 }  // namespace dingofs
 
 #endif  // DINGOFS_COMMON_OPTIONS_COMMON_OPTION_H_

src/mds/main.cc

@@ -29,6 +29,7 @@
 #include "mds/common/helper.h"
 #include "mds/server.h"
 #include "utils/daemonize.h"
+#include "utils/numa_manager.h"
 
 DEFINE_string(storage_url, "file://./conf/coor_list", "storage url, e.g. file://<path> or list://<addr1>");
 
@@ -298,6 +299,13 @@ int main(int argc, char* argv[]) {
     return 1;
   }
 
+  // numa bind to node to avoid performance degradation caused by
+  // cross-node memory access
+  auto& numa_manager = dingofs::utils::NumaManager::GetInstance();
+  if (dingofs::FLAGS_numa_bind_enable && numa_manager.Available()) {
+    numa_manager.BindNode(dingofs::FLAGS_numa_bind_node);
+  }
+
   // print config info
   dingofs::Helper::PrintConfigInfo(GenConfigs());
 

src/utils/CMakeLists.txt

@@ -19,6 +19,7 @@ add_library(dingofs_utils
     throttle.cc
     uuid.cc
     logclean_manager.cc
+    numa_manager.cc
 )
 
 target_link_libraries(dingofs_utils
@@ -27,4 +28,5 @@ target_link_libraries(dingofs_utils
     brpc::brpc
     glog::glog
     gflags::gflags
+    numa
 )

src/utils/numa_manager.cc

@@ -0,0 +1,184 @@
+// Copyright (c) 2025 dingodb.com, Inc. All Rights Reserved
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "utils/numa_manager.h"
+
+#include <numa.h>
+#include <numaif.h>
+#include <sched.h>
+#include <unistd.h>
+
+#include <sstream>
+#include <thread>
+
+#include "glog/logging.h"
+
+namespace dingofs {
+namespace utils {
+
+NumaManager& NumaManager::GetInstance() {
+  static NumaManager instance;
+  return instance;
+}
+
+NumaManager::NumaManager() {
+  available_ = numa_available() >= 0;
+
+  if (!available_) {
+    nodes_ = 1;
+    cpus_ = std::thread::hardware_concurrency();
+    return;
+  }
+
+  nodes_ = numa_max_node() + 1;
+  cpus_ = numa_num_configured_cpus();
+}
+
+void NumaManager::CheckNode(int node) const {
+  CHECK(node >= 0 && node < nodes_) << "invalid numa node: " << node;
+}
+
+std::vector<int> NumaManager::GetNodeCpus(const int node) const {
+  CheckNode(node);
+
+  std::vector<int> cpulist;
+
+  struct bitmask* mask = numa_allocate_cpumask();
+  numa_node_to_cpus(node, mask);
+
+  for (int i = 0; i < cpus_; ++i) {
+    if (numa_bitmask_isbitset(mask, i)) {
+      cpulist.push_back(i);
+    }
+  }
+
+  numa_free_cpumask(mask);
+  return cpulist;
+}
+
+void NumaManager::BindCpuNode(const int node) { BindCpuNodes({node}); }
+
+void NumaManager::BindCpuNodes(const std::vector<int>& nodes) {
+  CHECK(!nodes.empty());
+
+  struct bitmask* cpumask = numa_allocate_cpumask();
+  struct bitmask* tmpmask = numa_allocate_cpumask();
+
+  numa_bitmask_clearall(cpumask);
+
+  for (int node : nodes) {
+    CheckNode(node);
+
+    numa_bitmask_clearall(tmpmask);
+    numa_node_to_cpus(node, tmpmask);
+
+    for (int cpu = 0; cpu < cpus_; ++cpu) {
+      if (numa_bitmask_isbitset(tmpmask, cpu)) {
+        numa_bitmask_setbit(cpumask, cpu);
+      }
+    }
+  }
+
+  CHECK(numa_sched_setaffinity(0, cpumask) == 0)
+      << "numa_sched_setaffinity failed";
+
+  numa_free_cpumask(tmpmask);
+  numa_free_cpumask(cpumask);
+}
+
+void NumaManager::BindMemPreferredNode(int node) {
+  CheckNode(node);
+  numa_set_preferred(node);
+}
+
+void NumaManager::BindMemNode(const int node) { BindMemNodes({node}); }
+
+void NumaManager::BindMemNodes(const std::vector<int>& nodes) {
+  CHECK(!nodes.empty()) << "nodes cannot be empty";
+
+  struct bitmask* mask = numa_allocate_nodemask();
+  numa_bitmask_clearall(mask);
+
+  for (int node : nodes) {
+    CheckNode(node);
+    numa_bitmask_setbit(mask, node);
+  }
+
+  numa_set_membind(mask);
+
+  numa_free_nodemask(mask);
+}
+
+void NumaManager::BindNode(int node) {
+  BindCpuNode(node);
+  BindMemNode(node);
+}
+
+void NumaManager::BindNodes(const std::vector<int>& nodes) {
+  CHECK(!nodes.empty()) << "nodes cannot be empty";
+
+  BindCpuNodes(nodes);
+  BindMemNodes(nodes);
+}
+
+int NumaManager::CpuToNode(int cpu) const { return numa_node_of_cpu(cpu); }
+
+void NumaManager::InterleaveAll() const {
+  struct bitmask* mask = numa_allocate_nodemask();
+
+  for (int i = 0; i < nodes_; ++i) {
+    numa_bitmask_setbit(mask, i);
+  }
+
+  numa_set_interleave_mask(mask);
+  numa_free_nodemask(mask);
+}
+
+void NumaManager::BindThreadToCpu(const int id, const int cpu) const {
+  CHECK(cpu >= 0 && cpu < cpus_);
+
+  cpu_set_t cpuset;
+  CPU_ZERO(&cpuset);
+  CPU_SET(cpu, &cpuset);
+
+  CHECK(sched_setaffinity(id, sizeof(cpuset), &cpuset) == 0)
+      << "sched_setaffinity failed";
+}
+
+// 0 means current thread
+void NumaManager::BindCurrentThreadToCpu(const int cpu) const {
+  BindThreadToCpu(0, cpu);
+}
+
+void NumaManager::PrintTopology() const {
+  std::stringstream ss;
+
+  ss << "NUMA nodes: " << nodes_ << "\n";
+  ss << "CPU count : " << cpus_ << "\n";
+
+  for (int i = 0; i < nodes_; ++i) {
+    auto cpus = GetNodeCpus(i);
+
+    ss << "node " << i << " cpus: ";
+    for (auto c : cpus) {
+      ss << c << " ";
+    }
+    ss << "\n";
+  }
+
+  LOG(INFO) << ss.str();
+}
+
+}  // namespace utils
+}  // namespace dingofs

src/utils/numa_manager.h

@@ -0,0 +1,77 @@
+// Copyright (c) 2025 dingodb.com, Inc. All Rights Reserved
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_UTILS_NUMA_MANAGER_H_
+#define SRC_UTILS_NUMA_MANAGER_H_
+
+#include <vector>
+
+namespace dingofs {
+namespace utils {
+
+class NumaManager {
+ public:
+  static NumaManager& GetInstance();
+
+  bool Available() const { return available_; }
+
+  int NodeCount() const { return nodes_; }
+
+  int CpuCount() const { return cpus_; }
+
+  std::vector<int> GetNodeCpus(int node) const;
+
+  void BindCpuNode(int node);
+
+  void BindCpuNodes(const std::vector<int>& nodes);
+
+  void BindMemPreferredNode(int node);
+
+  void BindMemNode(int node);
+
+  void BindMemNodes(const std::vector<int>& nodes);
+
+  void BindNode(int node);
+
+  void BindNodes(const std::vector<int>& nodes);
+
+  int CpuToNode(int cpu) const;
+
+  void InterleaveAll() const;
+
+  void BindThreadToCpu(int id, int cpu) const;
+
+  void BindCurrentThreadToCpu(int cpu) const;
+
+  void PrintTopology() const;
+
+ public:
+  NumaManager(const NumaManager&) = delete;
+  NumaManager& operator=(const NumaManager&) = delete;
+
+ private:
+  NumaManager();
+
+  void CheckNode(int node) const;
+
+ private:
+  bool available_;
+  int nodes_;
+  int cpus_;
+};
+
+}  // namespace utils
+}  // namespace dingofs
+
+#endif  // SRC_UTILS_NUMA_MANAGER_H_