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的lib并使用您自己的函数来调用原件但执行一些额外的测量。在进程已经运行时（= trampoline）覆盖函数指针的另一种方法。在Linux中，它在GOT / PLT和Windows中更复杂 - 寻找一个库。
2.使用oprofile或其他一些分析器报告您在关注时间内执行的指令数。或者更好的是，报告执行的浮点指令的数量。这方面的一个小问题是，SSE指令一次增加或增加2个或更多个双打，因此您必须考虑到这一点。我猜你可以假设他们总是使用最大可能的操作数。

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

1 个答案: