Réduction avec OpenMP

Je suis en train de calculer la moyenne d'une matrice 2d en utilisant openmp. Cette matrice 2d est en fait une image.

Je fais le fil-sage de la division des données. Par exemple, si j'ai les N threads que j'traiter les Lignes/N nombre de lignes avec thread0, et ainsi de suite.

Ma question est puis-je utiliser openmp clause de réduction avec "#pragma omp parallel"?
Quelque chose comme 

#pragma omp parallel reduction( + : sum )
{
    if( thread == 0 )
       bla bla code 
       sum = sum + val;

    else if( thread == 1 )
       bla bla code
       sum = sum + val;
}

OriginalL'auteur mkuse | 2012-11-08

  1. 18

    Oui, vous pouvez - la clause de réduction est applicable à l'ensemble de la région parallèle ainsi qu'à des for le partage du travail constructions. Cela permet par exemple de réduction sur les calculs effectués dans les différentes sections parallèles (la meilleure façon de restructurer le code):

    #pragma omp parallel sections private(val) reduction(+:sum)
{
   #pragma omp section
   {
      bla bla code
      sum += val;
   }
   #pragma omp section
   {
      bla bla code
      sum += val;
   }
}

    Vous pouvez également utiliser OpenMP for un partage des tâches construire pour distribuer automatiquement les itérations de boucle entre les threads dans l'équipe au lieu de réimplanter à l'aide de sections:

    #pragma omp parallel for private(val) reduction(+:sum)
for (row = 0; row < Rows; row++)
{
   bla bla code
   sum += val;
}

    Noter que la réduction des variables sont privés et leurs valeurs intermédiaires (c'est à dire la valeur qu'ils détiennent avant la réduction à la fin de la parallel région) ne sont que partielles et pas très utile. Par exemple la série suivantes boucle ne peut pas être (facilement?) transformé en parallèle avec la réduction de fonctionnement:

    for (row = 0; row < Rows; row++)
{
   bla bla code
   sum += val;
   if (sum > threshold)
      yada yada code
}

    Ici la yada yada code doit être exécutée à chaque itération une fois que la valeur cumulée des sum a passé la valeur de threshold. Lorsque la boucle est exécutée en parallèle, les valeurs privées de sum ne pourrait jamais atteindre threshold, même si leur somme ne.

    S'il appelle commandé avec ce genre o distribution il lâche la plupart du parallélisme.
    si elles sont appliquées correctement, ordonne l'exécution peut pas tuer la plupart du parallélisme - voir cette réponse.
    Exactement, nous ne devons pas utiliser la statique avec la valeur par défaut taille de bloc.
    Dans le second cas, si au lieu d'une réduction sur une somme, de l'e.g avec reduction(+:..., c'était de trouver le minimum ou le maximum, de l'e.g avec reduction(min:..., on pourrait le faire manuellement à l'aide d'un double contrôle de verrouillage et de travail, beau travail.
    l'édition de raison que vous avez spécifié n'est pas valide. Ni shared(Rows) ni private(row) est par le standard OpenMP. row est le compteur de la boucle et en tant que tel a prédéterminé le partage des données de la classe de private. Rows est déclarée en dehors de la région parallèle et en tant que telle a un certain partage de la classe de shared.

    OriginalL'auteur Hristo Iliev

  2. 0

    Dans votre cas, le sum = sum + val pourrait interpréter comme val[i] = val[i-1] + val[i] en 1-d tableau (ou val[rows][cols] = val[rows][cols-1] + val[rows][cols] en 2-d tableau) qui est un préfixe somme calcul.

    Réduction est l'une des solution pour le préfixe de la somme, vous pouvez utiliser la réduction pour toute commutative associatifs, opérateurs comme '+', '-', '*', '/'.

    Comment est - et / commutative-associatif?

    OriginalL'auteur Charles Chow