C++ NUMA 架构优化：跨内存节点访问的性能考量

好的，各位，欢迎来到今天的“C++ NUMA架构优化：跨内存节点访问的性能考量”特别节目！我是你们的老朋友，今天咱们不讲段子，只谈代码和性能。

开场白：NUMA，你好大的头！

话说现在CPU核心数是越来越多了，动不动就几十个核，像不要钱似的往服务器里塞。但问题也来了，这么多核心，怎么喂饱它们？光靠一个大内存条可不行，这就像几十个孩子抢一个奶瓶，肯定不够分。于是，NUMA（Non-Uniform Memory Access，非一致性内存访问）架构就应运而生了。

NUMA架构的核心思想是：把内存分成多个节点（Node），每个节点都有自己的CPU核心和本地内存。这样，CPU访问本地内存的速度就非常快，就像孩子喝自己手边的奶瓶一样方便。但是，如果CPU要访问其他节点的内存，那就需要跨节点访问，速度就会慢很多，就像去抢别人的奶瓶一样费劲。

所以，NUMA架构既带来了性能提升的潜力，也带来了性能陷阱的风险。如果你不了解NUMA，写出来的程序可能跑得比单核CPU还慢，那就尴尬了！

第一幕：NUMA架构的爱恨情仇

首先，我们来深入了解一下NUMA架构。

1. NUMA节点是什么？

想象一下，你的服务器被分成了几个小岛，每个岛上都有自己的居民（CPU核心）和食物（本地内存）。这些小岛就是NUMA节点。

// 获取NUMA节点数量 (Linux)
#include <sched.h>
#include <iostream>
#include <numa.h> // 需要安装libnuma库

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

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

    return 0;
}

2. 本地内存 vs 远程内存

• 本地内存： CPU直接访问自己所在节点的内存，速度快如闪电。

• 远程内存： CPU需要通过互连总线访问其他节点的内存，速度慢如蜗牛。

  访问类型	速度	优点	缺点
  本地内存	快	响应快，延迟低	容量受限于单个节点
  远程内存	慢	可以访问所有节点的内存	延迟高，性能下降明显

3. 如何查看NUMA信息？

在Linux系统中，你可以使用lscpu命令查看CPU和NUMA节点的信息。

lscpu | grep NUMA

或者使用numactl --hardware 命令来查看更详细的NUMA配置。

第二幕：跨节点访问的性能噩梦

现在，我们来看看跨节点访问到底有多可怕。

1. 性能测试：本地 vs 远程

我们写一个简单的程序，分别测试本地内存访问和远程内存访问的性能。

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

const size_t ARRAY_SIZE = 1024 * 1024 * 100; // 100MB
const int NUM_ITERATIONS = 100;

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

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

    // 分配本地内存
    std::vector<int> local_data(ARRAY_SIZE);
    numa_run_on_node(0); // 将当前线程绑定到节点0
    for (size_t i = 0; i < ARRAY_SIZE; ++i) {
        local_data[i] = i;
    }

    // 分配远程内存
    std::vector<int> remote_data(ARRAY_SIZE);
    numa_run_on_node(1 % num_nodes); // 将当前线程绑定到节点1(如果只有一个节点，则绑定到节点0，避免错误)
     for (size_t i = 0; i < ARRAY_SIZE; ++i) {
        remote_data[i] = i;
    }
   numa_run_on_node(0); // 切换回节点0

    // 测试本地内存访问
    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < NUM_ITERATIONS; ++i) {
        for (size_t j = 0; j < ARRAY_SIZE; ++j) {
            local_data[j]++;
        }
    }
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    std::cout << "Local memory access time: " << duration.count() << " ms" << std::endl;

    // 测试远程内存访问
    start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < NUM_ITERATIONS; ++i) {
        for (size_t j = 0; j < ARRAY_SIZE; ++j) {
            remote_data[j]++;
        }
    }
    end = std::chrono::high_resolution_clock::now();
    duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    std::cout << "Remote memory access time: " << duration.count() << " ms" << std::endl;

    return 0;
}

编译时需要链接libnuma库: g++ numa_test.cpp -lnuma -o numa_test

运行结果会让你大吃一惊，远程内存访问的时间通常是本地内存访问的几倍甚至几十倍！

2. 为什么这么慢？

• 互连总线延迟： 数据需要在不同的NUMA节点之间传输，经过互连总线，延迟自然就高了。
• 缓存一致性： 如果多个CPU核心同时访问同一块内存，需要维护缓存一致性，这也会带来额外的开销。

第三幕：NUMA优化之葵花宝典

既然跨节点访问这么可怕，那我们该如何避免呢？这里给大家奉上NUMA优化之葵花宝典。

1. 数据本地化：把数据放在离CPU最近的地方

这是NUMA优化的核心思想。尽量让CPU访问自己所在节点的内存，避免跨节点访问。

• 线程绑定： 将线程绑定到特定的NUMA节点，让线程在固定的节点上运行。
• 内存分配策略： 在分配内存时，尽量将内存分配到线程所在的NUMA节点上。

// 线程绑定到NUMA节点 (Linux)
#include <pthread.h>
#include <sched.h>
#include <iostream>
#include <numa.h>

void* thread_func(void* arg) {
    int node_id = *(int*)arg;

    // 创建CPU集合
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);

    // 获取节点node_id上的所有CPU核心
    long ncpus = sysconf(_SC_NPROCESSORS_ONLN);
    for (long i = 0; i < ncpus; ++i) {
        if (numa_node_of_cpu(i) == node_id) {
            CPU_SET(i, &cpuset);
        }
    }
    // 将线程绑定到CPU集合
    int rc = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
    if (rc != 0) {
        std::cerr << "Error calling pthread_setaffinity_np: " << rc << std::endl;
    }

    std::cout << "Thread running on node " << node_id << std::endl;

    // 执行一些计算任务
    for (int i = 0; i < 100000000; ++i) {
        // Do something
    }

    pthread_exit(NULL);
    return NULL;
}

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

    int num_nodes = numa_num_configured_nodes();
    std::cout << "Number of NUMA nodes: " << num_nodes << std::endl;
    pthread_t threads[num_nodes];
    int node_ids[num_nodes];

    for (int i = 0; i < num_nodes; ++i) {
        node_ids[i] = i;
        int rc = pthread_create(&threads[i], NULL, thread_func, (void*)&node_ids[i]);
        if (rc) {
            std::cerr << "Error creating thread: " << rc << std::endl;
            return 1;
        }
    }

    for (int i = 0; i < num_nodes; ++i) {
        pthread_join(threads[i], NULL);
    }

    return 0;
}

// 在指定NUMA节点上分配内存 (Linux)
#include <iostream>
#include <vector>
#include <numa.h>

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

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

    size_t array_size = 1024 * 1024 * 100; // 100MB
    int node_id = 0; // 在节点0上分配内存

    // 分配内存
    void* mem = numa_alloc_onnode(array_size, node_id);
    if (mem == NULL) {
        std::cerr << "Error allocating memory on node " << node_id << std::endl;
        return 1;
    }

    // 将内存转换为int数组
    int* data = static_cast<int*>(mem);

    // 初始化数组
    for (size_t i = 0; i < array_size / sizeof(int); ++i) {
        data[i] = i;
    }

    // 释放内存
    numa_free(mem, array_size);

    std::cout << "Memory allocated and freed on node " << node_id << std::endl;

    return 0;
}

2. 减少跨节点通信：能不跨就不跨

如果必须进行跨节点通信，尽量减少通信的频率和数据量。

• 数据复制： 将需要共享的数据复制到每个节点的本地内存，避免频繁的跨节点访问。
• 消息传递： 使用消息传递机制进行节点间通信，减少共享内存的竞争。

3. 算法优化：选择适合NUMA架构的算法

有些算法在NUMA架构下性能会更好，有些则会更差。

• 并行算法： 尽量选择能够充分利用多核CPU的并行算法。
• 数据分割： 将数据分割成多个块，每个块由一个线程处理，并尽量让线程处理自己所在节点的本地数据。

4. 使用NUMA-aware的库：事半功倍

有些库已经针对NUMA架构进行了优化，可以直接使用这些库来提高性能。

• Intel MKL： Intel Math Kernel Library，包含大量的数学函数，针对Intel CPU进行了优化，包括NUMA优化。
• OpenMP： Open Multi-Processing，一个并行编程框架，可以方便地将程序并行化，并支持NUMA优化。

5. 工具辅助：性能分析，精准定位

使用性能分析工具可以帮助你找到程序中的NUMA瓶颈。

• perf： Linux自带的性能分析工具，可以分析CPU、内存等方面的性能。
• VTune Amplifier： Intel的性能分析工具，可以提供更详细的性能分析报告。

第四幕：实战演练：NUMA优化的例子

我们来看一个简单的例子，演示如何使用NUMA优化来提高性能。

假设我们有一个数组，需要对数组中的每个元素进行计算。

1. 原始代码（没有NUMA优化）

#include <iostream>
#include <vector>
#include <chrono>

const size_t ARRAY_SIZE = 1024 * 1024 * 100; // 100MB
const int NUM_ITERATIONS = 100;

int main() {
    std::vector<int> data(ARRAY_SIZE);

    // 初始化数组
    for (size_t i = 0; i < ARRAY_SIZE; ++i) {
        data[i] = i;
    }

    // 进行计算
    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < NUM_ITERATIONS; ++i) {
        for (size_t j = 0; j < ARRAY_SIZE; ++j) {
            data[j] = data[j] * 2 + 1;
        }
    }
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    std::cout << "Time: " << duration.count() << " ms" << std::endl;

    return 0;
}

2. NUMA优化后的代码（使用OpenMP）

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

const size_t ARRAY_SIZE = 1024 * 1024 * 100; // 100MB
const int NUM_ITERATIONS = 100;

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

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

    std::vector<int> data(ARRAY_SIZE);

    // 初始化数组 (每个线程初始化自己的部分)
    #pragma omp parallel num_threads(num_nodes)
    {
        int thread_id = omp_get_thread_num();
        numa_run_on_node(thread_id % num_nodes); // 绑定线程到对应节点

        size_t chunk_size = ARRAY_SIZE / num_nodes;
        size_t start = thread_id * chunk_size;
        size_t end = (thread_id == num_nodes - 1) ? ARRAY_SIZE : start + chunk_size;

        for (size_t i = start; i < end; ++i) {
            data[i] = i;
        }
    }

    // 进行计算
    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < NUM_ITERATIONS; ++i) {
        #pragma omp parallel for num_threads(num_nodes) schedule(static)
        for (size_t j = 0; j < ARRAY_SIZE; ++j) {
            data[j] = data[j] * 2 + 1;
        }
    }
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    std::cout << "Time: " << duration.count() << " ms" << std::endl;

    return 0;
}

编译时，需要加上-fopenmp选项：g++ numa_omp_test.cpp -fopenmp -lnuma -o numa_omp_test

在这个例子中，我们使用了OpenMP将计算任务并行化，并将每个线程绑定到不同的NUMA节点。这样，每个线程就可以访问自己所在节点的本地内存，从而提高性能。

第五幕：总结与展望

今天，我们一起学习了NUMA架构的原理和优化方法。希望大家能够掌握以下几点：

• 了解NUMA架构的特点，包括NUMA节点、本地内存和远程内存。
• 认识到跨节点访问的性能影响。
• 掌握NUMA优化的基本原则，包括数据本地化、减少跨节点通信和选择适合NUMA架构的算法。
• 学会使用NUMA相关的工具和库。

NUMA优化是一个复杂而有趣的话题，需要不断学习和实践。随着CPU核心数的不断增加，NUMA架构将会越来越重要。希望大家能够继续深入研究，写出更加高效的程序！

结尾：NUMA优化，永无止境！

好了，今天的讲座就到这里。感谢大家的收听，我们下次再见！