Comment OpenMP poignée de boucles imbriquées?

Le code suivant juste paralléliser le premier (externe) des boucles, ou il paralléliser l'ensemble de boucles imbriquées?

    #pragma omp parallel for
    for (int i=0;i<N;i++)
    { 
      for (int j=0;j<M;j++)
      {
       //do task(i,j)//
      }
    }

Je veux juste m'assurer que si le code ci-dessus paralléliser l'ensemble imbriqué pour des boucles (donc un thread directement liées à la tâche(i,j)), ou il ne parallelizes l'extérieur pour la boucle (donc il s'assure que, pour chaque thread parallèle avec l'indice de boucle i, sa boucle intérieure va être fait de manière séquentielle dans un seul thread, ce qui est très important).

InformationsquelleAutor user0002128 | 2012-11-13
  1. 41

    Les lignes que vous avez écrit, paralléliser seulement la boucle externe. Pour paralléliser les deux, vous devez ajouter un collapse clause:

    #pragma omp parallel for collapse(2)
    for (int i=0;i<N;i++)
    { 
      for (int j=0;j<M;j++)
      {
       //do task(i,j)//
      }
    }

    Vous voudrez peut-être vérifier OpenMP 3.1 spécifications de la sec (2.5.1) pour plus de détails.

    • Merci, c'est génial, je veux juste mettre en parallèle l'extérieur des boucles tout en garantir l'intérieur des boucles de faire son travail de manière séquentielle.
    InformationsquelleAutor Massimiliano
  2. 5

    Vous serez en mesure de mieux comprendre ce avec l'exemple suivant.
    Nous allons faire cela avec deux threads.

    #pragma omp parallel for num_threads(2)
for(int i=0; i< 3; i++) {
    for (int j=0; j< 3; j++) {
        printf("i = %d, j= %d, threadId = %d \n", i, j, omp_get_thread_num());
    }
}

    alors le résultat sera,

    i = 0, j= 0, threadId = 0 
i = 0, j= 1, threadId = 0 
i = 0, j= 2, threadId = 0 
i = 1, j= 0, threadId = 0 
i = 1, j= 1, threadId = 0 
i = 1, j= 2, threadId = 0 
i = 2, j= 0, threadId = 1 
i = 2, j= 1, threadId = 1 
i = 2, j= 2, threadId = 1

    Cela signifie que, lorsque vous ajoutez #pragma omp parallel pour la première boucle for, l'indice de la boucle for est divisé entre les threads. Comme vous pouvez le voir, lorsque l'indice de je en est de même de l'id de thread est aussi le même.

    Au lieu de cela, nous pouvons en parallèle les combinaisons que nous avons imbriqués pour la boucle. Dans cet exemple, on peut avoir la suite des combinaisons de i et j.

    i = 0, j= 0
i = 0, j= 1
i = 0, j= 2
i = 1, j= 0
i = 1, j= 1
i = 1, j= 2
i = 2, j= 0
i = 2, j= 1
i = 2, j= 2

    Afin de paralléliser le code de sage, nous pouvons ajouter l'effondrement mot-clé comme suit.

    #pragma omp parallel for num_threads(2) collapse(2)
for(int i=0; i< 3; i++) {
    for (int j=0; j< 3; j++) {
        printf("i = %d, j= %d, threadId = %d \n", i, j, omp_get_thread_num());
    }
}

    alors le résultat sera comme suit.

    i = 0, j= 0, threadId = 0 
i = 0, j= 1, threadId = 0 
i = 1, j= 2, threadId = 1 
i = 2, j= 0, threadId = 1 
i = 2, j= 1, threadId = 1 
i = 2, j= 2, threadId = 1 
i = 0, j= 2, threadId = 0 
i = 1, j= 0, threadId = 0 
i = 1, j= 1, threadId = 0

    Ensuite, vous pouvez voir que, contrairement à avant, pour le même indice i, il peut être de différents id de thread ( si i=1 et j=2 threadId=1) (i=1 et j=0 threadId=0)). Cela signifie que dans ce scénario, les combinaisons de i et j sont répartis entre les threads.

    • Avec les boucles correctement imbriquées, boucle externe de parallélisation est souvent le meilleur. Si l'extérieur de la boucle de comptage n'est pas grande par rapport au nombre de threads, l'effondrement mentionné ci-dessus est une bonne méthode si les boucles imbriquées peuvent être éligible, et si elle n'interfère pas avec boucle interne des optimisations telles que simd la vectorisation.
    • pas toutes les boucles sont rétractables en raison de la dépendance de données, donc la réponse en général, n'est pas, pour imbriquée parallélisme n'est pas va travailler pour chaque boucle, c'est pourquoi les gens de plus vers le GPU est là où il y a trois niveaux de parallélisme
    InformationsquelleAutor Erangad
  3. 4

    OpenMP seulement parallelizes la boucle à côté de la pragma. Vous pouvez paralléliser l'intérieur de la boucle aussi, si vous le souhaitez, mais cela ne se fera pas automatiquement.

    InformationsquelleAutor hcarver