Programmation basée sur les tâches: #pragma omp tâche versus #pragma omp parallèle pour

Considérant :

    void saxpy_worksharing(float* x, float* y, float a, int N) {
      #pragma omp parallel for
      for (int i = 0; i < N; i++) {
         y[i] = y[i]+a*x[i];
      }
    }

Et

    void saxpy_tasks(float* x, float* y, float a, int N) {
      #pragma omp parallel
      {
         for (int i = 0; i < N; i++) {
         #pragma omp task
         {
           y[i] = y[i]+a*x[i];
         }
      }
   }

Quelle est la différence à l'aide de tâches et l'omp parallel directive ? Pourquoi peut-on écrire des algorithmes récursifs tels que la fusion de tri avec des tâches, mais pas avec un partage des tâches ?

source d'informationauteur user1511956

  1. 21

    Je dirais que vous avez un oeil à la OpenMP tutoriel du Lawrence Livermore National Laboratory, disponible ici.

    Votre exemple particulier est celui qui devrait pas être mis en œuvre en utilisant OpenMP tâches. Le deuxième code crée N fois le nombre de threads tâches (parce que ya une erreur dans le code à côté de l'manquant }; je reviendrai plus tard), et chaque tâche est seulement de l'exécution d'une très simple de calcul. La surcharge de tâches gigantesques, comme vous pouvez le voir dans ma réponse à cette question. D'ailleurs le deuxième code est conceptuellement mal. Depuis il n'y a pas de partage du travail directive, tous les threads à l'exécution de toutes les itérations de la boucle, et au lieu de N tâches, N fois le nombre de threads tâches créées. Il doit être réécrit dans l'une des façons suivantes:

    Seule tâche producteur - modèle commun, NUMA hostile:

    void saxpy_tasks(float* x, float* y, float a, int N) {
   #pragma omp parallel
   {
      #pragma omp single
      {
         for (int i = 0; i < N; i++)
            #pragma omp task
            {
               y[i] = y[i]+a*x[i];
            }
      }
   }
}

    La single directive faire la boucle exécuter à l'intérieur d'un seul fil. Tous les autres fils de sauter et frapper la barrière implicite à la fin de la single construire. Comme des obstacles contenir implicite de la planification des tâches points, les threads en attente de commencer les tâches de traitement dès qu'elles deviennent disponibles.

    Parallèle du producteur - plus NUMA de l'environnement:

    void saxpy_tasks(float* x, float* y, float a, int N) {
   #pragma omp parallel
   {
      #pragma omp for
      for (int i = 0; i < N; i++)
         #pragma omp task
         {
            y[i] = y[i]+a*x[i];
         }
   }
}

    Dans ce cas, la tâche de la création de la boucle serait partagé entre les threads.

    Si vous ne savez pas ce que NUMA est, ignorer les commentaires à propos de NUMA amitié.