如何衡量并行程序的整体性能（使用 papi）

Question

我问自己什么是衡量并行程序性能（以失败计）的最佳方法。我读到了 papi_flops。这似乎适用于串行程序。但我不知道如何衡量并行程序的整体性能。

我想测量一个 blas/lapack 函数的性能，在我下面的 gemm 示例中。但我也想测量其他功能，特别是操作次数未知的功能。 （在 gemm 的情况下，ops 是已知的（ops(gemm) = 2*n^3），所以我可以将性能计算为操作数和执行时间的函数。）库（我使用的是 Intel MKL) 自动生成线程。所以不能单独衡量每个线程的性能，然后再降低。

这是我的例子：

#include <stdlib.h>                                                              
#include <stdio.h>                                                               
#include <string.h>                                                             
#include "mkl.h"
#include "omp.h"
#include "papi.h"       

int main(int argc, char *argv[] )                                                
{                                                                                
  int i, j, l, k, n, m, idx, iter;
  int mat, mat_min, mat_max;
  int threads;
  double *A, *B, *C;
  double alpha =1.0, beta=0.0;

  float rtime1, rtime2, ptime1, ptime2, mflops;
  long long flpops;

  #pragma omp parallel
  {
    #pragma omp master
    threads = omp_get_num_threads();
  }

  if(argc < 4){                                                                  
    printf("pass me 3 arguments!\n");                                            
    return( -1 );                                                                
  }                                                                              
  else                                                                           
  {                                                                            
    mat_min = atoi(argv[1]);
    mat_max = atoi(argv[2]);
    iter = atoi(argv[3]);                                                         
  }                    

  m = mat_max;  n = mat_max;  k = mat_max;

  printf (" Initializing data for matrix multiplication C=A*B for matrix \n"
            " A(%ix%i) and matrix B(%ix%i)\n\n", m, k, k, n);

  A = (double *) malloc( m*k * sizeof(double) );
  B = (double *) malloc( k*n * sizeof(double) );
  C = (double *) malloc( m*n * sizeof(double) );

  printf (" Intializing matrix data \n\n");
  for (i = 0; i < (m*k); i++)
    A[i] = (double)(i+1);
  for (i = 0; i < (k*n); i++)
    B[i] = (double)(-i-1);
  memset(C,0,m*n*sizeof(double));

  // actual meassurment
  for(mat=mat_min;mat<=mat_max;mat+=5)
  {
    m = mat;  n = mat; k = mat;

    for( idx=-1; idx<iter; idx++ ){
      PAPI_flops( &rtime1, &ptime1, &flpops, &mflops );
      cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, 
                    m, n, k, alpha, A, k, B, n, beta, C, n);
      PAPI_flops( &rtime2, &ptime2, &flpops, &mflops );
    }

    printf("%d threads: %d in %f sec, %f MFLOPS\n",threads,mat,rtime2-rtime1,mflops);fflush(stdout);
  }

  printf("Done\n");fflush(stdout);

  free(A);
  free(B);
  free(C);

  return 0;
}

这是一个输出（矩阵大小为 200）：

1 threads: 200 in 0.001459 sec, 5570.258789 MFLOPS
2 threads: 200 in 0.000785 sec, 5254.993652 MFLOPS
4 threads: 200 in 0.000423 sec, 4919.640137 MFLOPS
8 threads: 200 in 0.000264 sec, 3894.036865 MFLOPS

我们可以看到函数 gemm 的执行时间是可伸缩的。但我测量的失败只是线程 0 的性能。

我的问题是：如何衡量整体表现？我很感激任何意见。

Answer 1

首先，我很好奇 - 为什么需要 FLOPS？你不关心花了多少时间吗？或者与其他 BLAS 库相比所花费的时间？

PAPI 是基于线程的，在这里没有太多帮助。

我要做的是围绕函数调用进行测量，看看时间如何随着它产生的线程数而变化。它不应产生比物理内核更多的线程（HT 在这里不好）。然后，如果矩阵足够大，并且机器没有加载，则时间应该简单地除以线程数。例如，4 核上的 10 秒应变为 2.5 秒。

除此之外，您可以做两件事来真正衡量它：
1. 使用你现在使用的任何东西，但在 BLAS 代码周围注入你的开始/结束测量代码。一种方法（在 linux 中）是通过预加载一个定义 pthread_start 的库并使用您自己的函数来调用原始函数但进行一些额外的测量。当进程已经运行（=蹦床）时覆盖函数指针的另一种方法。在 linux 中它位于 GOT/PLT 中，而在 Windows 中则更复杂 - 寻找一个库。
2. 使用 oprofile 或其他一些分析器来报告在您关心的时间内执行的指令数。或者更好的是，报告执行的浮点指令的数量。一个小问题是 SSE 指令一次乘以或添加 2 个或更多双精度数，因此您必须考虑到这一点。我猜你可以假设他们总是使用尽可能多的操作数。