c - 如何衡量并行程序的整体性能(使用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 代码周围注入(inject)你的开始/结束测量代码。一种方法(在 Linux 中)是通过预加载定义 pthread_start 的库并使用您自己的函数来调用原件但进行一些额外的测量。另一种在进程已经运行时覆盖函数指针的方法(=蹦床)。在 linux 中它在 GOT/PLT 中，在 windows 中它更复杂 - 寻找一个库。
2. 使用 oprofile 或其他分析器报告在您关心的时间内执行的指令数。或者更好的是，报告执行的浮点指令数。一个小问题是 SSE 指令一次乘以或加 2 个或更多 double ，所以你必须考虑到这一点。我猜你可以假设他们总是使用最大可能的操作数。