Vrai parallélisme vs pseudo (Pool)

Bonjour,

Si ma machine dispose de 5 fils d'exécution possible en vrai parallélisme (je ne sais pas si j'utilise les bons termes), et que j'utilise un Pool de thread en faisant en sorte d'être borné par ce nombre de fil, et que mon programme ai 10 taches a effectuer.

Borner le nombre d'exécution en parallèle est ce vraiment plus efficace que du temps partagé ? Au final, 5 taches devront attendre la place pour pouvoir être exécutées, exécuter les 10 avec du parallélisme et du temps partagé, c'est vraiment moins rapide ?

En vérité, ici, je me questionne sur l'utilité d'un Pool de thread si on a beaucoup de taches et peu de cœurs

je crois qu'on gagne bien en temps d'exécution puisque dans le premier cas (pool de thread) on ne crée que 5 threads pour exécuter les 10 tâches, par contre dans le 2e cas, on en crée 10 alors qu'on en exécute que 5 en même temps.(création de thread=opération coûteuse)
donc au final est-ce que le nombre de thread dans un pool doit être égal au nombre de tâches max qu'on peut exécuter en même temps ?

Bonjour,
Tout dépend de l'objectif, de la charge visée (pour 10 000 tâches, le pool est indispensable…) et surtout des tâches.
Un pool sert surtout à :
1) limiter le nombre total de threads, pour ne pas surcharger le système inutilement ;
2) économiser les temps de création/destruction des threads.
Après, c'est effectivement un compromis à trouver avec les contraintes de l'application.

Pour cet exemple, s'il s'agit de tâches non-bloquantes (idéalement du calcul pur…) et idéalement équilibrées, le pool est globalement optimal : 5 tâches seront en attente au début, mais le temps d'exécution pour l'ensemble est meilleur : on économise sur le temps de création des threads et on les exploite à fond (et concrètement tous les cœurs sont exploités au maximum). Et plus il y a de tâches (par rapport au nombre de cœurs), plus c'est efficace (le nombre «amortit» les déséquilibres entre les tâches). Si au contraire les tâches peuvent se bloquer, elles «occupent» alors un thread inutilement et ralentissent l'ensemble. Tant qu'il reste suffisamment de tâches non bloquées pour occuper tous les cœurs, ce n'est pas un problème.

D'autres paramètres peuvent entrer en jeu : par exemple s'il y a des contraintes de latence (chaque tâche à des moments d'inactivité mais doit communiquer régulièrement dés son lancement), le pool n'est pas une solution acceptable. Ou, dans ce cas, on divisera chaque tâche en plusieurs sous-tâches pour permettre l'entrelacement des opérations.

Un lien pour se faire une petite idée sur un problème similaire : https://fr.wikipedia.org/wiki/C10k_problem