pourquoi utiliser plus de 2 threads consomment plus de temps?

Question

Je souhaite optimiser mon code séquentiel pour créer un dégradé.

Le dégradé de calcul principal pour la bordure de l'image et les autres threads calculent chacun le dégradé pour un fragment de l'image, en utilisant 2 threads et le thread principal donne un résultat meilleur que le code séquentiel mais en utilisant plus de 2 threads, mais il consomme de plus et semble pire que le séquentiel.

J'ai essayé ce code pour accélérer le processus gradient:

for (int n = 0; n<iter_outer; n++) 
     { 
      int chunk = 1 + ((row - 1)/num_threads); //ceiling 
      int start=0; 
      int end=0; 
      //Launch a group of threads 
      for (int tid = 0; tid < num_threads; ++tid) 
      { 
       start = tid * chunk; 
       end = start + chunk; 
       t[tid] = thread(gradient, tid, g, vx, vy, row, col, 1, start, end); 

      } 
      //Launched from the main; 
      gradient(1, g, vx, vy, row, col,0, start, end); 
      //Join the threads with the main thread 
      for (int i = 0; i < num_threads; ++i) 
      { 
       t[i].join(); 

      } 

     } 

Answer 1

Il semble que votre processeur est dual-core. Donc, en réalité, seulement 2 tâches peuvent être effectuées en parallèle

Answer 2

L'exécution parallèle est un énorme avantage pour les tâches qui sont facilement divisibles et les threads ne dépendront pas d'eux-mêmes, mais la création de threads a un prix. Imaginons qu'un ordinateur ne fasse rien d'autre que d'exécuter votre programme (il n'y a pas d'OS et pas d'autres processus). Le processeur a 2 cœurs, ils sont des processeurs à leur propre compte et peuvent exécuter simultanément n'importe quel code. Dans le cas d'un seul thread, le second noyau est assis et ne fait absolument rien, d'où un potentiel d'accélération. Si vous lancez le second thread (et lui donnez 50% de la tâche), le deuxième noyau fonctionne également et théoriquement l'accélération est de 2 (en ignorant les parties séquentielles et les aspects pratiques). Maintenant, faisons 4 threads. Attendez ... nous avons deux processeurs et 4 threads? Oui, maintenant chaque CPU fait plus d'une chose et avant de changer la tâche sur laquelle elle travaille, le CPU doit changer de contexte (changer les valeurs des registres pour conserver les valeurs de variables appropriées, aller à une section de code différente etc.). Si vous créez trop de threads, cela prendra plus de temps que de faire le travail. Cela peut avoir un impact énorme sur n'importe quelle application threadée et doit être noté avant de décider du nombre de threads à exécuter. Notez que ce poste est aussi simple que de nombreux processeurs modernes peuvent fonctionner efficacement plus d'un thread par cœur (c'est-à-dire HyperThreading).

Answer 3

Pour toute exécution parallèle, vous devez prendre en compte Amdahl's law. Il précise que le temps nécessaire pour faire une tâche en parallèle n'échelle pas linéaire avec le nombre de processeurs:

t = ((1-p) + p/n) * T 

où

T is the time needed for the task when it is done sequentially 
p fraction of time that can be parallelized 
n is the number of processors 

Notez que j'ai utilisé une formulation légèrement différente, mais la déclaration est le même: L'accélération totale que vous obtenez est limitée par 1/(1-p) (par exemple si p=50% votre version parallèle fonctionnera au maximum deux fois plus vite).

En plus de cela, vous devez considérer que l'ajout de parallélisme dans la réalité ajoute également plus de frais généraux (pour la synchronisation, la mise en place des fils, etc), donc une estimation plus réaliste est:

t = ((1-p) + p/n) * T + o*p 
          ^^ overhead 

Ce t comme une fonction du nombre de processeurs p a un minimum pour un certain nombre de processeurs. Ajouter plus de processeurs au problème n'entraînera pas une accélération, mais plutôt un ralentissement, car le temps minimum nécessaire pour faire cette partie est zéro, mais le temps supplémentaire que vous ajoutez en ajoutant plus de processeurs augmente sans limite.Cela n'explique pas pourquoi vous n'obtenez pas d'accélération dans votre cas, mais en général ce n'est pas une grande surprise que d'ajouter simplement plus de processeurs à une tâche n'entraîne pas toujours une accélération.