Comment créer un pool de threads en C++ TBB?

Question

Je ne mesure peut-être pas correctement mais j'ai un code simple avec lequel je joue. Je ne pense pas que c'est un pool de threads parce que si je rends l'unité de travail très grande alors le processeur va à 190-199% (j'ai dual core) mais si je baisse, l'unité de travail est plus petite exécute le programme à 140-160%. Je pense que les threads ne sont pas regroupés mais sont détruits/créés en cas de besoin, ce qui ralentit le programme lorsque les charges de travail sont plus petites. J'utilise tbb::task_scheduler_init pour contrôler le nombre de threads mais je ne sais pas comment dire à tbb de garder le thread en vie.

est ici un code pour illustrer le problème:

#include <iostream> 
#include <list> 
#include <tbb/task.h> 
#include <tbb/task_group.h> 
//#include <stdlib.h> 
#include "tbb/task_scheduler_init.h" 
#include <boost/thread.hpp> 

using namespace tbb; 


long fib(long a) 
{ 
    if (a < 2) return 1; 

    return fib(a - 1) + fib(a - 2); 
} 

class PrintTask 
{ 
public: 
    void operator()() 
    { 
     //std::cout << "hi world!: " << boost::this_thread::get_id() << std::endl; 

     fib(10); 
    } 
}; 

int main() 
{ 
    tbb::task_scheduler_init init(4); //creates 4 threads 
    task_group group; 


    for (int i = 0; i < 2000000; ++i) 
    { 
     group.run(PrintTask()); 
     //std::cout << i << std::endl; 
    } 

    std::cout << "done" << std::endl; 
    group.wait(); 

    return(0); 
} 

si vous changez fib à 40-45, le travail pour chaque fil devient grande de sorte qu'il frappe pleine vitesse, mais si vous utilisez la configuration actuelle puis la les emplois sont très petits mais ils en font beaucoup.

note: Une chose que j'ai remarquée peut-être liée est que dans le cas ci-dessus, il utilise complètement ma mémoire (4 concerts gratuits). Le ralentissement pourrait-il être lié à cela? Aussi pourquoi ce programme prendrait-il toute la mémoire? Que stocke-t-il en mémoire, si je n'appelle que le thread, n'y a-t-il pas une file d'attente lui indiquant combien de fois il doit s'exécuter ou est-ce qu'il sauvegarde le thread entier en mémoire pour s'exécuter?

Désolé pour les questions étranges, j'ai lu le tutoriel, mais je suis encore confus à son comportement (même si j'obtiens le résultat escompté).

Merci.

Answer 1

Vous ne devriez pas trop vous inquiéter de l'utilisation de l'UC, mais plutôt du temps d'exécution et de l'accélération par rapport à l'utilisation séquentielle.

Il y a quelques choses que vous devez comprendre au sujet de TBB:

Vous pouvez penser à la surcharge de la planification d'une tâche comme étant essentiellement constante (il est pas tout à fait, mais il est assez proche). Plus la quantité de travail que vous planifiez est petite, plus elle s'approche de cette constante. Si vous vous rapprochez de cette constante, vous ne verrez pas d'accélération.

De même, les threads restent inactifs lorsqu'ils ne trouvent pas de travail. Je suppose que lorsque vous appelez 'fib (10)', le coût de l'appel lancé et les allocations de tâches nécessaires approchent le coût de l'exécution du travail. Plus précisément, si vous avez vraiment 2000000 éléments avec la même tâche, vous devriez probablement appeler parallel_for ou parallel_for_each.

-Rick

Answer 2

Juste pour souligner dernier point de Rick, le docs pour task_group Etat:

ATTENTION: Création d'un grand nombre de tâches pour un seul task_group est pas évolutive, parce que la création de tâches devient un goulot d'étranglement en série. Si crée plus d'un petit nombre de tâches simultanées, vous pouvez utiliser parallel_for (4.4) ou parallel_invoke (4.12) à la place, ou structurer le spawning en tant qu'arborescence récursive.

je fait ajouter parallel_do à cette liste probablement applicable à votre savoir-ne-nombre-de-tâches à l'avance des cas d'utilisation. Ses arguments incluent un "chargeur" ​​qui peut ajouter plus de tâches; mais encore une fois noter les commentaires dans les documents ne traitent pas des tâches une à la fois. Citation sélective:

Concevez votre algorithme de telle sorte que le corps ajoute souvent plus de pièce de travail. ... Pour atteindre l'accélération, la granulométrie de B :: operator() doit être de l'ordre d'au moins ~ 100 000 cycles d'horloge. Sinon, les frais généraux internes de parallel_do submergent le travail utile.

Si vous cherchez des exemples de TBB non trivial (au-delà parallel_for et tutorial etc), le TBB patterns manual est très bon.