OpenMP: obtenez le nombre total de threads en cours d'exécution

J'ai besoin de savoir le nombre total de threads que ma demande a engendré par OpenMP. Malheureusement, la omp_get_num_threads() fonction ne pas travailler ici, car il ne donne le nombre de threads dans l'équipe actuelle.

Cependant, mon code s'exécute de manière récursive (diviser pour régner, en gros) et je tiens à frayer de nouveaux threads tant qu'il y a encore ralenti processeurs, mais pas plus.

Est-il un moyen de contourner les limitations de omp_get_num_threads et obtenir le total nombre de threads en cours d'exécution?

Si plus de détails, voici un pseudo-code que les modèles de mon flux de travail de très près:

function divide_and_conquer(Job job, int total_num_threads):
  if job.is_leaf(): # Recurrence base case.
    job.process()
    return

  left, right = job.divide()

  current_num_threads = omp_get_num_threads()
  if current_num_threads < total_num_threads: # (1)
    #pragma omp parallel num_threads(2)
      #pragma omp section
        divide_and_conquer(left, total_num_threads)
      #pragma omp section
        divide_and_conquer(right, total_num_threads)

  else:
    divide_and_conquer(left, total_num_threads)
    divide_and_conquer(right, total_num_threads)

  job = merge(left, right)

Si j'appelle ce code avec un total_num_threads valeur de 4, le conditionnel annoté avec (1) sera toujours évaluer à true (car chaque thread équipe contiendra au plus deux fils) et donc le code sera toujours apparaître deux nouveaux threads, peu importe combien de fils sont déjà en cours d'exécution à un niveau supérieur.

Je suis à la recherche d'un indépendant de la plate- moyen de déterminer le nombre total de threads en cours d'exécution dans ma demande.

source d'informationauteur Konrad Rudolph

  1. 0

    Avoir à l'esprit que vous connaissez le montant exact de threads en cours de création, la solution la plus simple me vient est de garder votre propre compteur de thread.

    Être conscient que je suis complètement dans le noir sur OpenMP que je n'ai jamais vraiment utilisé.

  2. 4

    Je pense qu'il n'y a pas de routine dans au moins OpenMP 3; et s'il y avait, je ne suis pas sûr que ça pourrait l'aider, comme il y a évidemment une énorme course de condition entre le comptage du nombre de threads et la fourche. Vous pourriez vous retrouver dépassement votre cible nombre de threads par près d'un facteur 2 si tout le monde voit qu'il y a de la place pour un filetage à gauche et puis tout le monde donne naissance à un fil.

    Si c'est vraiment la structure de votre programme, cependant, et vous voulez juste de limiter le nombre total de threads, il y a des options (tous ces éléments sont OpenMP 3.0):

    1. Utiliser le OMP_THREAD_LIMIT variable d'environnement afin de limiter le nombre total de threads OpenMP
    2. Utilisation OMP_MAX_ACTIVE_LEVELSou omp_set_max_active_levels()ou test contre omp_get_level()pour limiter la façon dont profondément imbriqués votre fils; si vous voulez seulement 16 threads, de limiter à 4 niveaux d'imbrication
    3. Si vous voulez plus de contrôle que les puissances de deux, vous pouvez utiliser omp_get_level() pour trouver votre niveau, et de faire appel omp_get_ancestor_thread_num(int level) à différents niveaux, à savoir le thread qui est votre parent, grand-parent, etc et de ce que (à l'aide de cette simple gauche-droite de la bifurcation) déterminer un mondial de l'ID de thread. (Je pense que dans ce cas ce serait quelque chose comme ∑l=0..L-1 al 2L-l où l est le nombre de niveaux en commençant à 0 et a est l'ancêtre le nombre de thread à ce niveau). Cela permettra de vous (dire) de permettre les discussions 0-3 à la fourchette mais pas 4-7, de sorte que vous finirais avec 12, plutôt que de 16 threads. Je pense que cela ne fonctionne que dans une telle situation régulière; si chaque parent fil fourchue un nombre différent de threads, je ne pense pas que vous pourriez déterminer globale et unique ID de thread parce qu'il semble que vous ne pouvez interroger vos ancêtres directs.
  3. 2

    Le code que vous avez montré a un problème en ce qu'une "omp section" doit être dans la portée lexicale d'un "omp sections". Je suppose que vous voulez dire "omp parallel" être "omp sections parallèles". L'autre manière de faire ceci est d'utiliser des "omp tâche", et puis vous n'avez pas à tenir compte du nombre de threads. Vous suffit d'attribuer les filets de la région parallèle et permettent à la OpenMP la mise en œuvre d'attribuer les tâches aux threads.