小编Sha*_*man的帖子

我正在编写一些 C 代码，它实现了一个三重嵌套 for 循环来计算矩阵乘法，同时使用 OpenMP 对其进行并行化。我试图准确地测量从 for 循环开始到结束所花费的时间。到目前为止，我一直在使用 gettimeofday()，但我注意到有时感觉它没有准确记录执行 for 循环所花费的时间。似乎是在说它比实际花费的时间更长。

这是原始代码：

struct timeval start end;
double elapsed;

gettimeofday(&start, NULL);
#pragma omp parallel for num_threads(threads) private(i, j, k)
for(...)
{
 ...
 for(...)
 {
  ...
  for(...)
  {
   ...
  }
 }
}

gettimeofday(&end, NULL);
elapsed = (end.tv_sec+1E-6*end.tv_usec) - (start.tv_sec+1E-6*start.tv_usec)

这是使用clock_gettime()的相同代码：

 struct timespec start1, finish1;
 double elapsed1;

clock_gettime(CLOCK_MONOTONIC, &start1);

  #pragma omp parallel for num_threads(threads) private(i, j, k)
    for(...)
    {
     ...
     for(...)
     {
      ...
      for(...)
      {
       ...
      }
     }
    }

clock_gettime(CLOCK_MONOTONIC, &finish1);
elapsed1 …

我目前正在尝试在 Maestro 处理器上使用 OpenMP 加速简单的矩阵减法基准测试，该处理器具有 NUMA 架构并基于 Tilera Tile64 处理器。Maestro 主板有 49 个处理器，以 7x7 配置排列成二维阵列。每个核心都有自己的 L1 和 L2 缓存。可以在此处查看电路板的布局：https ://i.stack.imgur.com/RG0fC.png

我对编写“NUMA 感知”应用程序的想法很陌生，但我读到的主要共识是数据局部性是最大化性能的重要组成部分。在核心之间并行化代码时，我应该尽可能将数据保留在执行处理的线程本地使用。

对于这个矩阵减法基准（C[i] = A[i] - B[i]），我认为最好为每个线程分配自己的私有 A、B 和 C 数组，其大小为总大小工作大小除以线程数。例如，如果数组的总大小为 6000*6000，并且我尝试在 20 个线程上并行化它，我将分配大小为 (6000*6000)/20 的私有数组。每个线程都会对其自己的私有数组执行此减法，然后我会将结果收集回总大小为 6000*6000 的最终数组中。例如（无需将每个线程的结果收集到最终数组中）：

int threads = 20;
int size = 6000;
uint8_t *C_final = malloc(sizeof(uint8_t)*(size*size));
#pragma omp parallel num_threads(threads) private(j)
{
     uint8_t *A_priv = malloc(sizeof(uint8_t)*((size*size)/threads));
     uint8_t *B_priv = malloc(sizeof(uint8_t)*((size*size)/threads));
     uint8_t *C_priv = malloc(sizeof(uint8_t)*((size*size)/threads));

     for(j=0; j<((size*size)/threads); j++)
       {
            A_priv[j]=100;
            B_priv[j]=omp_get_thread_num();
            C_priv[j]=0;
       }

     for(j=0; j<((size*size)/threads); j++) …