Come misurare le prestazioni generali dei programmi paralleli (con papi)

Question

Mi sono chiesto quale sarebbe stato il modo migliore per misurare le prestazioni (in flop) di un programma parallelo. Ho letto di papi_flops. Questo sembra funzionare bene per un programma seriale. Ma non so come posso misurare le prestazioni generali di un programma parallelo.

Vorrei misurare le prestazioni di una funzione blas/lapack, nel mio esempio sotto gemm. Ma voglio anche misurare altre funzioni, specialmente funzioni in cui il numero di operazioni non è noto. (Nel caso di gemm gli op sono conosciuti (ops (gemm) = 2 * n^3), quindi potrei calcolare le prestazioni in funzione del numero di operazioni e del tempo di esecuzione.) La libreria (sto usando Intel MKL) genera automaticamente i fili. Quindi non posso misurare le prestazioni di ogni thread singolarmente e quindi ridurlo.

Questo è il mio esempio:

#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; 
} 

Questa è un'uscita (per dimensione della matrice 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 

Si osserva per il tempo di esecuzione, che le scale funzione GEMM. Ma il flop che sto misurando è solo la prestazione del thread 0.

La mia domanda è: come posso misurare le prestazioni complessive? Sono grato per qualsiasi input.

Answer 1

In primo luogo, sono solo curioso: perché hai bisogno di FLOPS? non ti importa solo quanto tempo è preso? o forse il tempo impiegato in confronto ad altre librerie BLAS?

PAPI è un thread basato non molto di aiuto qui.

Quello che vorrei fare è misurare la chiamata di funzione e vedere come il tempo cambia con il numero di thread che genera. Non dovrebbe generare più thread dei core fisici (HT non va bene qui). Quindi, se la matrice è abbastanza grande e la macchina non è caricata, il tempo dovrebbe semplicemente dividere per il numero di thread. Ad esempio, 10 secondi su 4 core dovrebbero diventare 2,5 secondi.

Oltre a questo, ci sono 2 cose che potete fare per misurare davvero:
1. Utilizzare qualunque cosa si usa adesso, ma inietta il proprio codice di misura di inizio/fine intorno al codice BLAS. Un modo per farlo (in linux) è precaricando una lib che definisce pthread_start e usando le proprie funzioni che chiamano gli originali ma eseguono alcune misurazioni aggiuntive. Un altro modo per sovrascrivere il puntatore della funzione quando il processo è già in esecuzione (= trampolino). In Linux è in GOT/PLT e in Windows è più complicato: cerca una libreria.
2. Utilizzare oprofile, o qualche altro profiler, per riportare il numero di istruzioni eseguite nel tempo che si desidera. O meglio ancora, per segnalare il numero di istruzioni in virgola mobile eseguite. Un piccolo problema è che le istruzioni SSE si stanno moltiplicando o aggiungendo 2 o più doppi alla volta, quindi dovresti tenerne conto. Immagino che tu possa presumere che usino sempre il massimo degli operandi possibili.