Que fait #pragma dérouler exactement? Cela affecte-t-il le nombre de threads?

Je suis nouveau sur CUDA, et je ne peut pas comprendre le déroulement de la boucle. J'ai écrit un bout de code pour comprendre la technique

__global__ void kernel(float *b, int size)
{
    int tid = blockDim.x * blockIdx.x + threadIdx.x;
 #pragma unroll
    for(int i=0;i<size;i++)
        b[i]=i;
}

Ci-dessus est ma fonction noyau. Dans main je l'appelle comme ci-dessous

int main()
{
    float * a; //host array
    float * b; //device array
    int size=100;

    a=(float*)malloc(size*sizeof(float));
    cudaMalloc((float**)&b,size);
    cudaMemcpy(b, a, size, cudaMemcpyHostToDevice);

    kernel<<<1,size>>>(b,size); //size=100

    cudaMemcpy(a, b, size, cudaMemcpyDeviceToHost);

    for(int i=0;i<size;i++)
        cout<<a[i]<<"\t";

    _getch();

    return 0;
}

Signifie-t-il, j'ai size*size=10000 threads en cours d'exécution pour exécuter le programme? Sont 100 d'entre eux créés lorsque la boucle est déroulé?

source d'informationauteur Magzhan Abdibayev

  1. 24

    Pas. Cela signifie que vous avez appelé un CUDA noyau avec un bloc et que l'on bloquer a 100 threads actifs. Vous êtes de passage taille que le deuxième paramètre de la fonction de votre noyau. Dans le noyau de chacune de ces threads 100 exécute la boucle de 100 fois.

    #pragma unroll est une optimisation du compilateur qui peut, par exemple, remplacer un morceau de code comme 

    for ( int i = 0; i < 5; i++ )
    b[i] = i;

    avec

    b[0] = 0;
b[1] = 1;
b[2] = 2;
b[3] = 3;
b[4] = 4;

    en mettant #pragma unroll directive juste avant la boucle. La bonne chose à propos de l'déroulé version est qu'il s'agit moins de la charge de traitement du processeur. En cas de for boucle version, le traitement, en plus d'affecter chaque i à b[i]implique i l'initialisation, l'évaluation de i<5 6 fois, et en incrémentant i pour 5 fois. Alors que dans le second cas, il s'agit uniquement de dépôt jusqu' b tableau de contenu (peut-être plus int i=5; si i est utilisé plus tard). Un autre avantage de déroulement de la boucle de l'amélioration de l'Enseignement au Niveau de Parallélisme (ILP). Dans le déroulé de la version, il y aurait peut-être plus d'opérations pour le processeur de pousser dans le pipeline de traitement sans être inquiet au sujet de la for condition de boucle à chaque itération.

    Messages comme cette expliquer que l'exécution déroulement de la boucle ne peut pas se produire pour CUDA. Dans votre cas, le compilateur CUDA n'ont pas d'indices qui size va être 100 donc au moment de la compilation déroulement de la boucle ne se produira pas, et donc si vous avez la force de dérouler, vous pouvez finir par affecter les performances.

    Si vous êtes sûr que le size est de 100 pour toutes les exécutions, vous pouvez dérouler la boucle comme ci-dessous:

    #pragma unroll
for(int i=0;i<SIZE;i++)  //or simply for(int i=0;i<100;i++)
    b[i]=i;

    dans lequel SIZE est connu au moment de la compilation avec #define SIZE 100.

    Je vous conseille aussi d'avoir une bonne CUDA vérification d'erreur dans votre code (expliqué ici).