समांतर कार्यक्रमों (पापी के साथ)

Question

मैंने अपने आप से पूछा कि समांतर कार्यक्रम के प्रदर्शन (फ्लॉप में) को मापने का सबसे अच्छा तरीका क्या होगा। मैंने papi_flops के बारे में पढ़ा। ऐसा लगता है कि एक धारावाहिक कार्यक्रम के लिए ठीक काम करता है। लेकिन मुझे नहीं पता कि मैं समानांतर कार्यक्रम के समग्र प्रदर्शन को कैसे माप सकता हूं।

मैं नीचे दिए गए उदाहरण में अपने उदाहरण में ब्लैस/लैपैक फ़ंक्शन के प्रदर्शन को मापना चाहता हूं। लेकिन मैं अन्य कार्यों को भी मापना चाहता हूं, विशेष रूप से कार्य जहां ऑपरेशन की संख्या ज्ञात नहीं है। (जीएमएम के मामले में ओप्स ज्ञात हैं (ओप (जीएमएम) = 2 * एन^3), इसलिए मैं संचालन की संख्या और निष्पादन समय के कार्य के रूप में प्रदर्शन की गणना कर सकता हूं।) लाइब्रेरी (मैं इंटेल का उपयोग कर रहा हूं एमकेएल) धागे स्वचालित रूप से spawn। तो मैं व्यक्तिगत रूप से प्रत्येक धागे के प्रदर्शन को माप नहीं सकता और फिर इसे कम कर सकता हूं।

#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

सबसे पहले, मैं सिर्फ उत्सुक हूं - आपको फ्लॉप की आवश्यकता क्यों है? क्या आपको बस परवाह नहीं है कि कितना समय लिया जाता है? या शायद अन्य बीएलएएस पुस्तकालयों की तुलना में लिया गया समय?

पीएपीआई धागा अपने आप पर बहुत मदद नहीं है।

मैं क्या करूँगा फ़ंक्शन कॉल के आसपास मापता है और देखें कि यह कितने थ्रेडों के साथ बदलता है। इसे भौतिक कोर की तुलना में अधिक धागे नहीं पैदा करना चाहिए (एचटी यहां अच्छा नहीं है)। फिर, यदि मैट्रिक्स काफी बड़ा है, और मशीन लोड नहीं होती है, तो समय को केवल धागे की संख्या से विभाजित करना चाहिए। उदा।, 4 कोर से 10 सेकंड 2.5 सेकंड बनना चाहिए।

इसके अलावा, 2 चीजें हैं जो आप वास्तव में इसे मापने के लिए कर सकते हैं:
1. जो भी आप अभी उपयोग करते हैं उसका उपयोग करें लेकिन बीएलएएस कोड के आस-पास अपना प्रारंभ/अंत माप कोड डालें। ऐसा करने का एक तरीका (लिनक्स में) एक lib को प्री-लोड करना है जो pthread_start को परिभाषित करता है और अपने स्वयं के फ़ंक्शंस का उपयोग करता है जो मूल को कॉल करते हैं लेकिन कुछ अतिरिक्त माप करते हैं। जब प्रक्रिया पहले से चल रही है (= trampoline) फ़ंक्शन पॉइंटर को ओवरराइड करने का एक और तरीका। लिनक्स में यह जीओटी/पीएलटी में है और खिड़कियों में यह अधिक जटिल है - लाइब्रेरी की तलाश करें।
2. आप जिस समय देखभाल करते हैं उसमें निष्पादित निर्देशों की संख्या की रिपोर्ट करने के लिए oprofile, या कुछ अन्य प्रोफाइलर का उपयोग करें। या फिर बेहतर, निष्पादित फ्लोटिंग पॉइंट निर्देशों की संख्या की रिपोर्ट करने के लिए। इसके साथ एक छोटी सी समस्या यह है कि एसएसई निर्देश एक समय में 2 या अधिक युगल गुणा कर रहे हैं या जोड़ना चाहते हैं ताकि आपको इसके लिए जिम्मेदार होना पड़े। मुझे लगता है कि आप मान सकते हैं कि वे हमेशा अधिकतम संभव संचालन का उपयोग करते हैं।