C++ NUMA (Non-Uniform Memory Access) 架构优化：跨内存节点访问

好的，各位观众老爷，今天咱们来聊聊C++里的NUMA架构优化，这玩意儿听起来高大上，其实就是怎么让你的程序在多核服务器上跑得飞起，不卡顿。别担心，我保证用最接地气的方式，把这背后的门道给你们讲明白。

啥是NUMA？别装不懂，就是内存分配的“贫富差距”！

想象一下，你家是个大家庭，住在一个大房子里，有好几个冰箱（CPU核心），每个冰箱旁边都有个储藏室（内存节点）。如果某个家庭成员（线程）老是跑到离自己最远的冰箱里拿东西，那效率肯定低。NUMA就是这么个概念：

Non-Uniform Memory Access: 非一致性内存访问。啥意思？就是说，CPU访问不同内存区域的速度是不一样的。
内存节点: 每个CPU核心组（socket）都有自己专属的内存区域。
本地访问: CPU访问自己所属内存节点的速度最快。
远程访问: CPU访问其他内存节点的速度较慢。

如果你的程序不考虑NUMA，那很可能出现“远水解不了近渴”的情况，线程们抢着访问同一个远程内存节点，导致性能瓶颈。

C++ NUMA编程：磨刀不误砍柴工

要玩转NUMA，我们需要一些“武器”：

libnuma: 这是一个C库，提供了NUMA相关的API。在Linux系统上通常预装，如果没有，用包管理器安装即可（例如 sudo apt-get install libnuma-dev）。
C++标准库: C++11及以后版本提供了线程（std::thread）和原子操作（std::atomic），这些是并发编程的基础。

代码示例：Hello NUMA World!

首先，我们来写一个简单的程序，检测系统NUMA配置：

#include <iostream>
#include <numa.h>

int main() {
  if (numa_available() == -1) {
    std::cerr << "NUMA is not available on this system." << std::endl;
    return 1;
  }

  int num_nodes = numa_max_node() + 1;
  std::cout << "Number of NUMA nodes: " << num_nodes << std::endl;

  // 获取每个节点上的 CPU 核心列表
  for (int node = 0; node < num_nodes; ++node) {
    nodemask_t mask;
    numa_node_to_cpus(node, &mask);
    std::cout << "Node " << node << " CPUs: ";
    for (int cpu = 0; cpu < numa_num_configured_cpus(); ++cpu) {
      if (numa_bitmask_isbitset(&mask, cpu)) {
        std::cout << cpu << " ";
      }
    }
    std::cout << std::endl;
  }

  return 0;
}

这段代码的作用是：

检查NUMA是否可用。
获取NUMA节点的数量。
打印每个节点上的CPU核心列表。

编译运行：

g++ -o numa_info numa_info.cpp -lnuma
./numa_info

内存分配：让数据离线程更近

接下来，我们来分配内存，并将其绑定到特定的NUMA节点：

#include <iostream>
#include <numa.h>
#include <vector>

int main() {
  if (numa_available() == -1) {
    std::cerr << "NUMA is not available on this system." << std::endl;
    return 1;
  }

  int num_nodes = numa_max_node() + 1;
  size_t data_size = 1024 * 1024 * 100; // 100MB
  int target_node = 0; // 分配到节点 0

  // 分配NUMA感知的内存
  void* data = numa_alloc_onnode(data_size, target_node);
  if (data == nullptr) {
    std::cerr << "Failed to allocate memory on node " << target_node << std::endl;
    return 1;
  }

  // 初始化数据 (避免被优化掉)
  memset(data, 0, data_size);

  std::cout << "Allocated " << data_size << " bytes on node " << target_node << std::endl;

  // 释放内存
  numa_free(data, data_size);

  return 0;
}

代码解释：

numa_alloc_onnode(size, node): 在指定的NUMA节点上分配内存。
numa_free(ptr, size): 释放NUMA分配的内存。
memset(data, 0, data_size): 避免编译器优化，确保内存真的被访问。

线程绑定：让线程在“家”工作

线程绑定是指将线程固定在特定的CPU核心上运行。这可以减少线程在不同核心之间迁移的开销，并提高缓存命中率。

#define _GNU_SOURCE // Required for CPU_SET and sched_setaffinity
#include <iostream>
#include <thread>
#include <sched.h>
#include <unistd.h> // For syscall

void worker_thread(int cpu_id) {
  // 设置线程 affinity
  cpu_set_t cpuset;
  CPU_ZERO(&cpuset);
  CPU_SET(cpu_id, &cpuset);

  int result = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
  if (result != 0) {
    std::cerr << "Error setting thread affinity: " << result << std::endl;
    return;
  }

  // 验证线程 affinity (可选)
  cpu_set_t check_cpuset;
  CPU_ZERO(&check_cpuset);
  pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &check_cpuset);
  if (!CPU_ISSET(cpu_id, &check_cpuset)) {
    std::cerr << "Failed to verify thread affinity!" << std::endl;
  }

  std::cout << "Thread running on CPU " << cpu_id << std::endl;

  // 执行一些计算密集型任务
  for (int i = 0; i < 1000000000; ++i) {
    // 简单的自增操作
    int temp = i * i;
  }
}

int main() {
  // 获取系统 CPU 核心数量
  int num_cpus = sysconf(_SC_NPROCESSORS_ONLN);
  std::cout << "Number of CPUs: " << num_cpus << std::endl;

  // 创建并绑定线程到不同的 CPU 核心
  std::vector<std::thread> threads;
  for (int i = 0; i < num_cpus; ++i) {
    threads.emplace_back(worker_thread, i);
  }

  // 等待所有线程完成
  for (auto& thread : threads) {
    thread.join();
  }

  return 0;
}

代码解释：

cpu_set_t: 一个位集合，用于表示CPU核心的集合。
CPU_ZERO(&cpuset): 清空CPU集合。
CPU_SET(cpu_id, &cpuset): 将指定的CPU核心添加到集合中。
pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset): 将当前线程绑定到指定的CPU核心集合。
pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &check_cpuset): 获取当前线程的CPU核心绑定情况。
sysconf(_SC_NPROCESSORS_ONLN): 获取系统在线的CPU核心数量

综合应用：NUMA感知的并行计算

现在，我们将内存分配和线程绑定结合起来，实现一个简单的NUMA感知的并行计算：

#define _GNU_SOURCE
#include <iostream>
#include <thread>
#include <vector>
#include <numa.h>
#include <sched.h>
#include <unistd.h>
#include <numeric> // std::iota

// 每个线程处理的数据块大小
const size_t CHUNK_SIZE = 1024 * 1024; // 1MB

// 线程函数
void process_chunk(int node_id, int cpu_id, std::vector<int>& data, size_t start, size_t end) {
    // 绑定线程到指定的 CPU 核心
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(cpu_id, &cpuset);
    if (pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset) != 0) {
        std::cerr << "Error setting thread affinity for CPU " << cpu_id << std::endl;
        return;
    }

    std::cout << "Thread " << std::this_thread::get_id() << " (CPU " << cpu_id << ", Node " << node_id << ") processing data from " << start << " to " << end << std::endl;

    // 模拟计算密集型任务 (对数据进行平方)
    for (size_t i = start; i < end; ++i) {
        data[i] = data[i] * data[i];
    }
}

int main() {
    if (numa_available() == -1) {
        std::cerr << "NUMA is not available on this system." << std::endl;
        return 1;
    }

    int num_nodes = numa_max_node() + 1;
    int num_cpus = sysconf(_SC_NPROCESSORS_ONLN);
    size_t data_size = 1024 * 1024 * 100; // 100MB
    size_t num_elements = data_size / sizeof(int);

    std::cout << "Number of NUMA nodes: " << num_nodes << std::endl;
    std::cout << "Number of CPUs: " << num_cpus << std::endl;
    std::cout << "Data size: " << data_size << " bytes (" << num_elements << " integers)" << std::endl;

    // 创建一个向量，用于存储数据
    std::vector<int> data(num_elements);

    // 初始化数据 (使用 iota 填充，以便后续验证结果)
    std::iota(data.begin(), data.end(), 0);

    // 创建线程
    std::vector<std::thread> threads;

    // 为每个 NUMA 节点创建一个线程
    for (int node_id = 0; node_id < num_nodes; ++node_id) {
        // 确定分配到这个节点的CPU
        nodemask_t mask;
        numa_node_to_cpus(node_id, &mask);
        int cpu_id = -1;
        for (int cpu = 0; cpu < numa_num_configured_cpus(); ++cpu) {
            if (numa_bitmask_isbitset(&mask, cpu)) {
                cpu_id = cpu;
                break;
            }
        }
        if (cpu_id == -1) {
            std::cerr << "No CPU found for node " << node_id << std::endl;
            return 1;
        }

        // 在指定的 NUMA 节点上分配内存
        void* node_data = numa_alloc_onnode(data_size, node_id);
        if (node_data == nullptr) {
            std::cerr << "Failed to allocate memory on node " << node_id << std::endl;
            return 1;
        }

        // 将数据复制到 NUMA 节点上的内存
        std::memcpy(node_data, data.data(), data_size);

        // 计算这个线程要处理的数据范围
        size_t start = (num_elements / num_nodes) * node_id;
        size_t end = (node_id == num_nodes - 1) ? num_elements : (num_elements / num_nodes) * (node_id + 1);

        // 创建线程并将其绑定到指定的 CPU 核心和 NUMA 节点
        threads.emplace_back(process_chunk, node_id, cpu_id, std::ref(*(std::vector<int>*)node_data), start, end);
    }

    // 等待所有线程完成
    for (auto& thread : threads) {
        thread.join();
    }

    // 验证结果 (可选)
    // ...

    // 释放内存
    for(int node_id = 0; node_id < num_nodes; ++node_id){
        nodemask_t mask;
        numa_node_to_cpus(node_id, &mask);
        int cpu_id = -1;
        for (int cpu = 0; cpu < numa_num_configured_cpus(); ++cpu) {
            if (numa_bitmask_isbitset(&mask, cpu)) {
                cpu_id = cpu;
                break;
            }
        }

        void* node_data = nullptr;
        // 查找指向node_data的指针
        for (auto& thread : threads) {
            std::thread::id id = thread.get_id();
        }
        // 找到数据，释放它
        size_t start = (num_elements / num_nodes) * node_id;
        size_t end = (node_id == num_nodes - 1) ? num_elements : (num_elements / num_nodes) * (node_id + 1);
        numa_free((void*)data.data(), data_size);  // 这里需要修改
    }

    std::cout << "Parallel processing completed." << std::endl;

    return 0;
}

代码解释：

为每个NUMA节点创建一个线程。
将每个线程绑定到对应NUMA节点上的CPU核心。
在每个NUMA节点上分配内存。
将数据复制到对应的NUMA节点上的内存。
每个线程处理分配给它的NUMA节点上的数据。

性能分析：知己知彼，百战不殆

光写代码还不够，我们需要知道我们的优化是否真的有效。可以使用以下工具进行性能分析：

perf: Linux下的性能分析工具，可以用来测量CPU周期、缓存命中率等指标。
likwid: 另一个性能分析工具，可以提供更详细的硬件性能数据。

NUMA优化策略：对症下药，药到病除

总结一下，NUMA优化的关键在于：

数据本地化: 将数据分配到离访问它的CPU核心最近的内存节点。
线程绑定: 将线程固定在特定的CPU核心上运行。
避免跨节点访问: 尽量减少线程访问其他NUMA节点上的数据的次数。
合理的数据划分: 将数据划分为多个块，每个块由一个线程处理，并将每个块分配到对应的NUMA节点上。

一些建议：别踩坑！

并非所有应用都需要NUMA优化: 如果你的程序是单线程的，或者数据量很小，那么NUMA优化可能反而会带来额外的开销。
NUMA优化需要对系统架构有深入的了解: 你需要知道你的服务器有多少个NUMA节点，每个节点上有多少个CPU核心，以及它们之间的连接关系。
NUMA优化是一个迭代的过程: 你需要不断地测试和调整你的代码，才能找到最佳的性能配置。

总结：NUMA，让你的程序飞起来！

NUMA架构优化是一个复杂但有趣的话题。通过理解NUMA的原理，并结合C++提供的工具，你可以让你的程序在多核服务器上发挥出最大的潜力。记住，数据本地化和线程绑定是NUMA优化的核心，合理的数据划分和避免跨节点访问是提高性能的关键。希望今天的讲解能帮助大家在NUMA优化的道路上少走弯路，写出更加高效的C++程序！

发表回复 取消回复

发表回复取消回复