Linux安全网 - Linux操作系统_Linux 命令_Linux教程_Linux黑客

绿色网站无广告
会员投稿 投稿指南 本期推荐:
搜索:
您的位置: Linux安全网 > Linux培训 > » 正文

测试服务器最大内存带宽的实验

来源: zhengsyao 分享至:
本文原创作者:zhengsyao  Blog地址:zhengsyao.iteye.com  非常感谢作者的付出和分享精神。

介绍

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使用量和内存流量。

实验过程

实验代码如下所示:

 

  1. #define _GNU_SOURCE
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <sched.h>
  5. #include <pthread.h>
  6. #include <sys/time.h>
  7. #include <sys/times.h>
  8.  
  9. #define SIZE_IN_MB 256
  10. #define NUM_BYTE (SIZE_IN_MB*1024*1024)
  11. #define NUM_LONG (NUM_BYTE/sizeof(long))
  12. #define CACHELINE_SIZE 64
  13.  
  14. /* wall time */
  15. struct timeval start_time, stop_time, elapse_time;
  16. /* process time */
  17. struct tms start_process, stop_process, elapse_process;
  18.  
  19. typedef struct
  20. {
  21. cpu_set_t binding;
  22. size_t times;
  23. long* datap;
  24. } reader_args_t;
  25.  
  26. typedef struct
  27. {
  28. cpu_set_t binding;
  29. cpu_set_t reader_binding;
  30. size_t reader_times;
  31. } gen_args_t;
  32.  
  33. void* read_data(void *arg)
  34. {
  35. reader_args_t *my_args = (reader_args_t *)arg;
  36.  
  37. /* do binding */
  38. sched_setaffinity(0, sizeof(cpu_set_t), &(my_args->binding));
  39.  
  40. /* int *buf = (int *)malloc( (my_args->datasz) * sizeof(int));*/
  41. gettimeofday(&start_time, NULL);
  42. times(&start_process);
  43. long *datap;
  44. for (size_t times = 0; times < my_args->times; ++times)
  45. {
  46. datap = my_args->datap;
  47. __asm__ ("movq %0, %%rax\n\t"
  48. :
  49. :"m"(datap)
  50. );
  51. for (size_t i = 0; i < NUM_BYTE / CACHELINE_SIZE; ++i)
  52. {
  53. __asm__ ("movq (%%rax), %%rcx\n\t"
  54. "addq $64, %%rax\n\t"
  55. :
  56. : "a"(datap)
  57. : "%rcx");
  58. }
  59. }
  60. return ((void *)0);
  61. }
  62.  
  63. void* gen_data(void *arg)
  64. {
  65. pthread_t reader_tid;
  66. void *tret;
  67. gen_args_t *my_args = (gen_args_t *)arg;
  68.  
  69. /* do binding */
  70. sched_setaffinity(0, sizeof(cpu_set_t), &(my_args->binding));
  71.  
  72. unsigned long* data = (long*)malloc(NUM_LONG * sizeof(long));
  73. printf("The address of source data is %p\n", data);
  74. for (size_t i = 0; i < NUM_LONG; ++i)
  75. data[i] = 0x5a5a5a5a5a5a5a5a;
  76.  
  77. reader_args_t *reader_args = (reader_args_t *)malloc(sizeof(reader_args_t));
  78. reader_args->binding = my_args->reader_binding;
  79. reader_args->times = my_args->reader_times;
  80. reader_args->datap = data;
  81. pthread_create(&reader_tid, NULL, read_data, (void*)reader_args);
  82. pthread_join(reader_tid, &tret);
  83.  
  84. free(data);
  85.  
  86. return ((void *)0);
  87. }
  88.  
  89. int main(int argc, char *argv[])
  90. {
  91. if (argc < 4)
  92. {
  93. fprintf(stderr, "Usage: %s <times> <from> <to>\n", argv[0]);
  94. exit(EXIT_FAILURE);
  95. }
  96. pthread_t gen_tid;
  97. void *tret;
  98. gen_args_t *gen_args = (gen_args_t *)malloc(sizeof(gen_args_t));
  99. gen_args->reader_times = (size_t)atoi(argv[1]);
  100. cpu_set_t from_binding, to_binding;
  101. CPU_ZERO(&from_binding);
  102. CPU_ZERO(&to_binding);
  103. CPU_SET(atoi(argv[2]), &from_binding);
  104. CPU_SET(atoi(argv[3]), &to_binding);
  105. gen_args->binding = from_binding;
  106. gen_args->reader_binding = to_binding;
  107. pthread_create(&gen_tid, NULL, gen_data, (void *)gen_args);
  108. pthread_join(gen_tid, &tret);
  109. gettimeofday(&stop_time, NULL);
  110. times(&stop_process);
  111. timersub(&stop_time, &start_time, &elapse_time);
  112. printf("time cost %ld.%06ld secs.\n",
  113. elapse_time.tv_sec,
  114. elapse_time.tv_usec);
  115.  
  116. return 0;
  117. }  

 

 

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%。

 

  • 大小: 115 KB
  • 大小: 116.3 KB
  • 大小: 115.4 KB
  • 大小: 116.4 KB
  • 大小: 115 KB
  • 查看图片附件

Tags:
分享至:
最新图文资讯
1 2 3 4 5 6
验证码:点击我更换图片 理智评论文明上网,拒绝恶意谩骂 用户名:
关于我们 - 联系我们 - 广告服务 - 友情链接 - 网站地图 - 版权声明 - 发展历史