Le parallélisme de tâches : la loi d'Amdhal

La loi d'Amdhal donne l’amélioration maximale que l'on peut obtenir d'un programme parallèle, quand il s’exécute sur plusieurs processeurs. Pour la calculer, on suppose que ce code parallèle peut tout aussi bien exploiter la puissance d'un seul processeur, que de 2, 20, voir 10 000 000 processeurs. Bref, le code est quasiment parfait et on s'interdit les situations du style : on observe un gain énorme avec 2 ou 4 processeurs, mais pas au-delà. De plus, ce programme est exécuté sur la même quantité de données : on ne rajoute pas de données en même temps qu'on ajoute des processeurs, et ces données ont toujours la même taille, histoire de comparer ce qui est comparable.

La limite du parallélisme de tâches tient dans le fait que tous les programmes ne peuvent pas utiliser plusieurs processeurs à la perfection. Tout programme conserve une certaine portion de code qui ne profite pas du parallélisme. Appelons cette portion de code le code série, tandis que la portion de code qui profite du parallélisme sera appelée le code parallèle. Le ou les processeurs passeront un certain temps à exécuter le code série, et un autre temps dans le code parallèle. Notons ces deux temps ${\displaystyle T_{s}}$ et ${\displaystyle T_{p}}$. On sait que le temps ${\displaystyle T}$ mis par un programme à s'exécuter vaut donc :

${\displaystyle T=T_{s}+T_{p}}$

Seconde hypothèse : le code parallèle profite au mieux de la présence de plusieurs processeurs. Dit autrement, si on possède ${\displaystyle N}$ processeurs, tous auront une part égale du code parallèle, en temps d'exécution. Dans ces conditions, le temps d'exécution ${\displaystyle T}$ du programme devient celui-ci :

${\displaystyle T_{parallele}=T_{s}+{\frac {T_{p}}{N}}}$

Ces deux formules nous permettent de calculer le rapport entre le temps sans parallélisme et celui avec. On a alors :

${\displaystyle {\frac {T_{parallele}}{T}}=\left(T_{s}+{\frac {T_{p}}{N}}\right){\frac {1}{T}}={\frac {T_{s}}{T}}+{\frac {T_{p}}{T}}{\frac {1}{N}}}$

Maintenant, notons ${\displaystyle S}$ et ${\displaystyle P}$ le pourcentage de temps d’exécution passé respectivement dans le code série et dans le code parallèle. Par définition, ces deux pourcentages valent ${\displaystyle {\frac {T_{s}}{T}}}$ et ${\displaystyle {\frac {T_{p}}{T}}}$. Dans l'équation précédente, on peut identifier ces deux pourcentages (leur inverse, précisément). On a alors, en faisant le remplacement :

${\displaystyle {\frac {T_{parallele}}{T}}=S+{\frac {P}{N}}}$

Cette formule nous permet de calculer le gain obtenu grâce au parallélisme. Ce gain se calcule en divisant le temps avant parallélisation et le temps obtenu après. C'est intuitif : si un programme va deux fois plus vite, c'est que son temps d’exécution a été divisé par deux entre avant et après. Dit autrement, il s'agit de l'inverse du rapport calculé précédemment. L'équation obtenue ainsi, qui donne le gain en performance que l'on peut attendre en fonction du nombre de processeur et du pourcentage de code parallèle, est appelée la loi d'Amdhal.

${\displaystyle G={\frac {1}{S+{\frac {P}{N}}}}={\frac {1}{1-P+{\frac {P}{N}}}}}$

Cette formule, la loi d'Amdhal proprement dit, nous donne donc une estimation du gain en temps d’exécution d'une application exécutée sur plusieurs processeurs. Mais que peut-on en déduire d'utile ? Peut-on trouver des moyens de gagner en performance efficacement grâce à cette loi ? Oui, et c'est ce qu'on va voir.

L'influence du nombre de CPU

La loi d'Amdhal nous dit qu'augmenter le ombre de processeur permet de diminuer le terme ${\displaystyle {\frac {P}{N}}}$ et d'augmenter le gain. Mais cette solution a une efficacité assez limitée : il faut que la part de code parallélisable soit suffisante pour que cela ait un impact suffisant. Imaginons un exemple simple : 20% du temps d’exécution de notre programme (quand il est exécuté sur un seul processeur) est passé à exécuter du code parallèle. Si on calcule le gain en fonction du nombre de processeurs, on obtient alors la tableau suivant.

Nombre de processeurs	Gain maximal
2	11.11%
3	15.38%
4	17.64%
5	19.04%
6	20%
7	20.6%
8	21.21%
...	...
16	23%
...	...
${\displaystyle \infty }$	25%

Gain de performances et nombre de processeurs.

Les chiffres précédents nous disent qu'aller au-delà de 5 ou 6 processeurs ne sert pas vraiment à grand-chose. Doubler leur nombre revient souvent à augmenter les performances d'un misérable pourcent. Pour prendre un autre exemple, au-delà de 8 processeurs, un code passant 50% de son temps à exécuter du code parallèle ne sera pas vraiment exécuté plus vite. Pour résumer, le rendement du parallélisme diminue rapidement avec le nombre de processeurs. Passer de 2 à 4 processeurs permet d'obtenir des gains substantiels, alors que passer de 16 à 32 processeurs ne donne de gains sensibles que si P est extrêmement élevé.

Loi d'Amdhal.

Le parallélisme de données : la loi de Gustafson

Le parallélisme de données est très utilisé pour des applications où les données sont indépendantes, et peuvent se traiter en parallèle. Un bon exemple est le calcul des graphismes d'un jeu vidéo. Chaque pixel étant colorié indépendamment des autres, on peut rendre chaque pixel en parallèle. C'est pour cela que les cartes vidéo contiennent un grand nombre de processeurs et sont des architectures SIMD capables d’exécuter un grand nombre de calculs en parallèle.

Le parallélisme de données n'a pas les limitations intrinsèques au parallélisme de tâches. En effet, celui-ci est avant tout limité certes par le code série, mais aussi par la quantité de données à traiter. Prenons le cas d'une carte graphique, par exemple : ajouter des processeurs ne permet pas de diminuer le temps de calcul, mais permet de traiter plus de données en même temps. Augmenter la résolution permet ainsi d'utiliser des processeurs qui auraient été en trop auparavant. Reste à quantifier de tels gains, si possible avec une loi similaire à celle d'Amdhal. Pour cela, nous allons partir du cas où on dispose d'un processeur qui doit traiter N données. Celui-ci met un temps ${\displaystyle T_{s}}$ à éxecuter le code série et un temps ${\displaystyle T_{p}}$ pour traiter une donnée. On a donc :

${\displaystyle T=T_{s}+T_{p}\times N}$

Avec N processeurs, le traitement des N données s'effectuera en un temps ${\displaystyle T_{p}}$, vu qu'il y a une donnée est prise en charge par un processeur, sans temps d'attente.

${\displaystyle T_{parallele}=T_{s}+T_{p}\times N}$

Le gain est donc :

${\displaystyle {\frac {T_{parallele}}{T}}={\frac {T_{s}+T_{p}\times N}{T}}={\frac {T_{s}}{T}}+{\frac {T_{p}}{T}}\times N}$

On peut utiliser les définitions ${\displaystyle S={\frac {T_{s}}{T}}}$ et ${\displaystyle P={\frac {T_{p}}{T}}}$ pour reformuler l'équation précédente :

${\displaystyle G=S+P\times N=1-P+P\times N}$

On voit que le gain est proportionnel au nombre de données à traiter. Plus on a de données à traiter, plus on gagnera à utiliser un grand nombre de processeurs. Il n'y a pas de limites similaires à celles obtenues à la loi d'Amdhal, du moins, tant qu'on dispose de suffisamment de données à traiter en parallèle.

Loi de Gustafson.