介绍
Intel Nehalem架构处理器内建了内存控制器，处理器之间通过QPI互联，是典型的NUMA系统。NUMA系统的特点是每一个节点都有自己的内存控制器，尽管每个节点都能访问所有节点上的内存，但是代价不一样，访问本地内存的速度比访问远程节点的速度要快。使用Intel Nehalem架构的处理器时，如果一个节点需要访问另一个节点的内存，那么数据需要通过CPU的QPI通道访问，因此会有一些延时。下面通过实验来测试内存带宽、QPI带宽以及访问远程节点和本地节点内存的性能差异。
实验平台
硬件：双Intel® Xeon® Processor E5606(8M Cache, 2.13 GHz, 4.80 GT/s Intel® QPI)处理器，每一个处理器有4个物理内核，并且带有3个内存通道。分别在两个处理器的一个通道上插一根4GB DDR3 1066内存，内存总计8GB。
软件：最简64bit gentoo系统，kernel 3.0.6，开启numa支持，系统中除了系统守护进程之外只运行了nfsd和sshd。
实验方案
要测带宽就要跑满内存，但是真正要把内存带宽跑满还是需要一点技巧的。为了单纯地将读方向的带宽跑满，可以写一个循环读数组。这样有几个问题：
- 如果不开启编译器优化，那么编译器会生成很多垃圾代码，不能充分利用内存带宽。
- 不能将一个数组写入另一个数组，因为如果读写发生在同一个内存通道上，那么这个通道上会发生争用，无法占满带宽。因此为了纯粹地测试“读出数据”产生的带宽，应该将数组读入一个变量。
- 如果开启-O优化，编译器会生成优化的代码，而这个优化的代码会把读内存优化掉，因为光读不写。
- 如果将读入的变量声明为volatile，由于mov不能从内存位置复制到另一个内存位置，所以生成的代码会先将内存中的数据读入一个寄存器，然后再从寄存器写入变量的位置。
- 这一款处理器的cache line为64字节。也就是说读入数组中的第一个字节的时候实际上后面的63个字节也加载到cache中了，所以后面数据的读取实际上走的是cache，没有跑内存。
为了解决上面的问题以及问题引发的问题，这个实验采取的方法是开辟一个很大的缓冲区（256MB），然后通过循环将缓冲区的内容读入一个寄存器。循环步进为64字节，但是每一次只执行一次mov指令。实际上只复制了256M/64=4M次数据。这样可以保证每一次循环都从内存加载了数据，但是不能遍历整个缓冲区，不过也没有必要遍历缓冲区的所有字节，因为实验目的是把内存带宽跑满，而不是为了最快复制数据或正确复制数据。
另外，为了测试跨节点内存访问，测试程序启两个线程，一个线程（1）生成缓冲区，然后创建另一个线程（2），将缓冲区地址传给线程2。线程2读数据。线程1和线程2分别绑定在两个CPU内核上。绑定之后，Linux的NUMA特性可以确保线程1分配的缓冲区在线程1绑定的节点所属的内存上，而线程2的读取数据的寄存器一定在线程2运行的CPU内核上。如果线程1和线程2在同一个节点（也就是同一个CPU）上，那么可以直接访问内存，而不用通过QPI。如果线程1和线程2不在同一个节点上，那么读取内存就需要通过QPI，必然会有性能损失。
实验中通过intel提供的性能调优工具PTU查看当前QPI使用量和内存流量。
实验过程
实验代码如下所示：
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <sched.h>
#include <pthread.h>
#include <sys/time.h>
#include <sys/times.h>
#define SIZE_IN_MB 256
#define NUM_BYTE (SIZE_IN_MB*1024*1024)
#define NUM_LONG (NUM_BYTE/sizeof(long))
#define CACHELINE_SIZE 64
/* wall time */
struct timeval start_time, stop_time, elapse_time;
/* process time */
struct tms start_process, stop_process, elapse_process;
typedef struct
{
cpu_set_t binding;
size_t times;
long* datap;
} reader_args_t;
typedef struct
{
cpu_set_t binding;
cpu_set_t reader_binding;
size_t reader_times;
} gen_args_t;
void* read_data(void *arg)
{
reader_args_t *my_args = (reader_args_t *)arg;
/* do binding */
sched_setaffinity(0, sizeof(cpu_set_t), &(my_args->binding));
/* int *buf = (int *)malloc( (my_args->datasz) * sizeof(int));*/
gettimeofday(&start_time, NULL);
times(&start_process);
long *datap;
for (size_t times = 0; times < my_args->times; ++times)
{
datap = my_args->datap;
__asm__ ("movq %0, %%rax\n\t"
:
:"m"(datap)
);
for (size_t i = 0; i < NUM_BYTE / CACHELINE_SIZE; ++i)
{
__asm__ ("movq (%%rax), %%rcx\n\t"
"addq $64, %%rax\n\t"
:
: "a"(datap)
: "%rcx");
}
}
return ((void *)0);
}
void* gen_data(void *arg)
{
pthread_t reader_tid;
void *tret;
gen_args_t *my_args = (gen_args_t *)arg;
/* do binding */
sched_setaffinity(0, sizeof(cpu_set_t), &(my_args->binding));
unsigned long* data = (long*)malloc(NUM_LONG * sizeof(long));
printf("The address of source data is %p\n", data);
for (size_t i = 0; i < NUM_LONG; ++i)
data[i] = 0x5a5a5a5a5a5a5a5a;
reader_args_t *reader_args = (reader_args_t *)malloc(sizeof(reader_args_t));
reader_args->binding = my_args->reader_binding;
reader_args->times = my_args->reader_times;
reader_args->datap = data;
pthread_create(&reader_tid, NULL, read_data, (void*)reader_args);
pthread_join(reader_tid, &tret);
free(data);
return ((void *)0);
}
int main(int argc, char *argv[])
{
if (argc < 4)
{
fprintf(stderr, "Usage: %s <times> <from> <to>\n", argv[0]);
exit(EXIT_FAILURE);
}
pthread_t gen_tid;
void *tret;
gen_args_t *gen_args = (gen_args_t *)malloc(sizeof(gen_args_t));
gen_args->reader_times = (size_t)atoi(argv[1]);
cpu_set_t from_binding, to_binding;
CPU_ZERO(&from_binding);
CPU_ZERO(&to_binding);
CPU_SET(atoi(argv[2]), &from_binding);
CPU_SET(atoi(argv[3]), &to_binding);
gen_args->binding = from_binding;
gen_args->reader_binding = to_binding;
pthread_create(&gen_tid, NULL, gen_data, (void *)gen_args);
pthread_join(gen_tid, &tret);
gettimeofday(&stop_time, NULL);
times(&stop_process);
timersub(&stop_time, &start_time, &elapse_time);
printf("time cost %ld.%06ld secs.\n",
elapse_time.tv_sec,
elapse_time.tv_usec);
return 0;
}
read_data()是读取数据的线程调用的线程函数。这个函数里面通过内嵌汇编确保真的将数据读入了rcx寄存器。将数据读入寄存器可以尽可能地避免写数据的干扰。
这个程序可以在参数中选择要复制的次数，以及两个线程分别绑在哪个CPU内核上。在这个实验平台中，第一个CPU的4个内核对应的id是0，1，2，3；第二个CPU的4个内核对应的id是4，5，6，7。
因此，运行
zsy-gentoo thread_read # ./thread_read 500 0 0 The address of source data is 0x7f1aeda5a010 time cost 16.759935 secs.
表示程序运行500次，两个线程都在CPU内核0上，因此这是节点内读取。这一次的读取时间是16.8秒。
运行这条命令的时候，PTU显示如下图所示：
可以看出，内存通道2上读数据的流量为8140MB/s。这是1066的通道，所以理论带宽为1066*8 = 8528，因此实测带宽为理论带宽的95%以上。
下面运行
zsy-gentoo thread_read # ./thread_read 500 3 4 The address of source data is 0x7f29a8bd7010 time cost 19.825897 secs.
这一次，缓冲区在第一个节点上，而数据读取在第二个节点上，所以会产生跨节点通信。PTU显示如下图所示：
这一次，虽然读取数据发生在第二个节点，但是实际的数据在第一个节点上，所以内存流量全部都发生在第一个节点上，QPI负责从第一个节点上访问数据。由于跨节点访问，所以读取数据的时间从16.8秒降为19.8秒。这一次很明显节点1的内存带宽受制于QPI所以没有跑满。
那么这是不是说明QPI的带宽就是6.8GB/s呢？根据Intel的qpi白皮书文档，4.80 GT/s的QPI相当于19.2GB/s的理论带宽，单向带宽就是19.2/2 = 9.6GB/s。
下面做另一个实验。把第二块CPU的内存取出，放在第一块CPU的一个空闲通道上，这样第一块CPU就有2个通道，理论内存带宽倍增，第二块CPU没有内存，因此第二块CPU上的任何数据访问都要通过QPI。
首先运行以下命令：
zsy-gentoo thread_read # ./thread_read 500 4 4 The address of source data is 0x7f5228a02010 time cost 20.358352 secs.
在第二块CPU上通过QPI访问数据，这是PTU显示如下：
可以看出QPI使用率达到了前一个实验中的使用率。在第一块CPU上的两个内存通道都有流量，而且因为操作系统的调度，这两个内存通道流量均衡，共同承担了数据访问，但是这两个内存通道的使用率明显偏低。
下面在第二块CPU上再启一个访问数据的程序，看一看QPI使用率是否会增加。
zsy-gentoo thread_read # ./thread_read 500 4 4 & zsy-gentoo thread_read # ./thread_read 500 6 6 &
这时PTU显示如下：
这时可以看到QPI使用率提升到了8.3GB/s，说明并发访问能够提升QPI的使用率。可是此时内存通道的使用率仍然不高，两个内存通道都达到一半左右。因此，再增加第二块CPU上的内存访问负载，运行第三个访问内存程序。
zsy-gentoo thread_read # ./thread_read 500 4 4 & zsy-gentoo thread_read # ./thread_read 500 6 6 & zsy-gentoo thread_read # ./thread_read 500 5 5 &
这时PTU显示如下图所示：
可以看出，QPI使用率并没有明显增加。因此可以看出在这个实验平台上QPI的单向带宽大约为8.3GB/s，是理论带宽的86%。