Introduction

Module : Système d’exploitation II
Responsable : NINI B.
Chapitre IV : Introduction aux architectures parallèles
Page 1
Introduction aux architectures parallèles
Aujourd'hui, la plupart des serveurs sont des machines parallèles (des multiprocesseurs). C'est
ainsi qu'un ordinateur peut exécuter des instructions aussi rapidement que la vitesse de la lumière. En
réalité, il s'agit d'une structure dite de "pipe-line" qui consiste à décomposer l'exécution d'une
instruction en étapes élémentaires traitées en parallèle par plusieurs processeurs. De la sorte, le temps
moyen d'exécution d'une instruction est considérablement accéléré.
1 Parallélisme et Architectures Parallèles
Il existe plusieurs domaines d'applications pour lesquels l'exploitation du parallélisme est
fondamentale : le traitement numérique, les bases de données, le traitement d'images, etc. Pour traiter
ces applications, les architectures parallèles peuvent être généralistes (c'est-à-dire capables de
répondre aux besoins d'une grande diversité d'applications) ou spécialisées. Les architectures
spécialisées sont destinées à exploiter les caractéristiques spécifiques d'une catégorie d'applications ou
même d'une seule application.
1.1 Motivations pour le parallélisme
1.1.1 Besoins des applications
Le parallélisme peut être exploité pour répondre à la puissance de traitement qui recouvre
deux grandes notions : la latence et le débit de traitement. La latence représente le temps nécessaire
pour l'exécution d'un traitement. Le débit représente le nombre de traitements exécutables par unité de
temps.
Réduire la latence est plus difficile qu'augmenter le débit. Dans le premier cas, il s'agit de
lutter contre le temps qui, en dernier ressort, est fixé par les possibilités technologiques. Alors que,
dans le deuxième cas, si plusieurs traitements sont indépendants, l'augmentation du nombre de
ressources suffit pour exécuter plus de traitements en même temps.
La puissance de traitement dépend aussi de la capacité et de l'organisation de la mémoire d'un
ordinateur. Certaines applications requièrent des ensembles de données dont la taille est supérieure à
la capacité d'adressage d'un ordinateur séquentiel. Certaines organisations d'architectures parallèles
permettent d’adresser plus de mémoire que des architectures séquentielles.
La résistance aux pannes suppose que l'arrêt d'une partie de l'ordinateur (pour panne,
maintenance, etc.) n’entraîne pas son arrêt complet. Si l'élément arrêté est le processeur, il est évident
1
Module : Système d’exploitation II
Responsable : NINI B.
Chapitre IV : Introduction aux architectures parallèles
Page 2
que seul un autre permet de résister à un manque. La redondance repose donc sur la mise en parallèle
d'éléments assurant les mêmes fonctionnalités.
1.1.2 Limites des architectures séquentielles
Les limites de l'exécution séquentielle découlent des limites des microprocesseurs actuels. Les
microprocesseurs possèdent des formats de leurs données et de leurs opérations inadéquates aux
caractéristiques de certaines applications. Il peut être préférable, en termes de performance et de coût,
de concevoir un ordinateur dont les opérateurs de traitement, l'organisation mémoire, etc. sont adaptés
aux calculs à réaliser. L'utilisation simultanée de plusieurs ressources entraîne la nécessité de gérer la
coordination de ces ressources et complexifie la programmation.
1.2 Niveaux de parallélisme
Le traitement de plus d'une tâche à la fois sur un ordinateur (parallélisme) peut se faire par une
exécution concurrente des tâches (simultanéité apparente) ou par une exécution simultanée. La
simultanéité réelle ne peut être obtenue que par la multiplication des unités fonctionnelles. Elle
implique la duplication de certains éléments de la machine. L'exécution concurrente peut être réalisée
soit par la machine elle-même, soit par le logiciel.
Le fait que le parallélisme soit réel ou apparent dépend du niveau de la fonction à exécuter
dans le système. Il existe plusieurs niveaux auxquels le parallélisme des opérations est possible.
1.2.1 Cheminement des données
A ce niveau, le parallélisme est défini par la "largeur" des voies de transfert des données d'une
unité fonctionnelle à l'autre à l'intérieur de la machine ; c'est le nombre de bits qu'il est possible de
transférer simultanément entre ces unités.
1.2.2 Entre les étapes du traitement des instructions
A ce niveau, le parallélisme repose sur l'existence d'au moins deux étapes dans l'exécution
d'instructions. Ces deux étapes sont habituellement constituées par une phase "instruction" où
l'instruction est amenée de la mémoire à l'unité de traitement, puis décodée, suivie d'une phase
d'"exécution" pendant laquelle l'instruction se déroule. Si les circuits logiques participant aux deux
phases ne comportent pas la partie commune, partagée, alors la machine est capable d'exécuter une
instruction pendant qu'elle prépare la suivante. Il en résulte un certain degré de superposition dans le
traitement des instructions. Cette caractéristique est connue sous le nom de "look-ahead".
2
Module : Système d’exploitation II
Responsable : NINI B.
Chapitre IV : Introduction aux architectures parallèles
Page 3
Potentiellement, cette caractéristique permet de doubler le taux de traitement de la machine.
Mais en fait, ce doublement est rarement atteint à cause de goulets d'étranglements apparaissant dans
le système : interférence d'accès à la mémoire retardant l'arrivée de l'information requise par l'une des
phases, retards dus au traitement des instructions de branchement conditionnel qui empêchent
l'arrivée de l'instruction suivante jusqu'au moment où la direction de branchement est connue, ou
retards dus à la durée variable d'exécution de certaines instructions en fonction des opérandes
(division, par exemple), ce qui immobilise l'unité d'exécution pendant une période plus ou moins
longue et retarde donc le démarrage de l'instruction suivante.
1.2.3 Entre les instructions
Le parallélisme entre instructions repose sur la multiplication de certaines unités
fonctionnelles. Le parallélisme est d'ailleurs souvent limité à la phase d'exécution. Ceci repose sur la
technique du "pipe-line" qui est une extension de la technique "look-ahead". La phase d'exécution des
instructions est fragmentée en plusieurs étapes intermédiaires. A un instant donné, il y a plusieurs
instructions en train d'être exécutées, chacune à une étape différente de son exécution. A un instant
donné, on peut avoir par exemple une multiplication virgule flottante, un transfert à mémoire, une
addition d'entier s'exécutant simultanément.
1.2.4 Entre régions d'un programme
On appellera région une zone de code telle que son exécution peut avoir lieu indépendamment
d'autres zones. Par exemple, deux zones constituent des régions si elles ne se passent pas de
paramètre et si leur exécution peut être lancée de façon indépendante. Le parallélisme entre régions
d'un même programme est obtenu par diverses combinaisons entre machine et logiciel. Pour qu'il y ait
simultanéité réelle dans l'exécution des différentes régions, la machine doit être dotée de possibilités
de parallélisme au niveau de la phase de décodage/préparation d'instructions multiples. Par contre, la
simultanéité apparente entre régions d'un programme peut être obtenue avec un logiciel de
multiprogrammation. Les techniques machine/logiciel nécessaires pour une simultanéité réelle ou
apparente entre deux régions impliquent l'existence d'un moyen de :

reconnaître leur indépendance,

démarrer leur exécution "en parallèle",

établir les conditions d'une fusion ultérieure des deux chemins parallèles.
1.2.5 Entre tâches formalisées
Le parallélisme entre tâches formalisées d'un programme structuré est obtenu par
l'intermédiaire du programme de contrôle du système répondant à des directives données par le
3
Module : Système d’exploitation II
Responsable : NINI B.
Chapitre IV : Introduction aux architectures parallèles
Page 4
programmeur. La différence fondamentale entre parallélisme régional et parallélisme de tâches réside
dans la dimension de l'unité à traiter et dans l'utilisation du programme de contrôle dans le deuxième
cas.
1.2.6 Entre programmes indépendants
Le degré le plus général de parallélisme est obtenu avec la possibilité d'exécuter
simultanément des flux de programmes entièrement indépendants. Il est réalisé par couplage de
systèmes indépendants en une association formant un système multiprocesseur. Le couplage peut être
un partage d'unités de contrôle et/ou d'unités E/S, ou des flux d'E/S des jobs.
En dehors des contraintes normales de sérialisation dans l'utilisation des ressources partagées,
ces deux arrangements ne requièrent que peu ou pas de coordination entre les différents flux de jobs.
1.3 Définition du parallélisme
1.3.1 Approche intuitive du parallélisme
C'est le parallélisme présent dans une application qui permet d'exécuter simultanément, par
des ressources matérielles différentes, plusieurs parties de cette application. Le corps de la boucle
suivante ne comporte qu'une seule opération.
Pour i de 1 à n faire
A[ i ]  B[ i ] + C [ i ]
FinPour
A[ 1 ]  B[ 1 ] + C [ 1 ] (a)
A[ 2 ]  B[ 2 ] + C [ 2 ] (b)
A[ 3 ]  B[ 3 ] + C [ 3 ] (c)
Quelque soit l'ordre d'exécution ex : a, b, c ou c, b, a, ou encore b, c, a, etc. les résultats en
mémoire sont identiques. La sémantique du programme ne dépend pas de l'ordre d'exécution des
itérations de cette boucle. Ces itérations peuvent donc être exécutées en parallèle.
1.3.2 Définition
Bernstein a introduit en 1966 un ensemble de conditions permettant d'établir la possibilité
d'exécuter plusieurs programmes (processus) en parallèle. Supposons deux programmes : P1 et P2 où
chacun utilise des variables en entrée (respectivement E1 et E2) et produit des résultats en sortie
(respectivement S1 et S2). Selon Bernstein, les programmes P1 et P2 sont exécutables en parallèle
(notation : P1 II P2) si les conditions suivantes sont respectées :
{E1  S2 = , E2  S1 = , S2  S1 = }
4
Module : Système d’exploitation II
Responsable : NINI B.
Chapitre IV : Introduction aux architectures parallèles
Page 5
Plus généralement, un ensemble de programmes P1, P2, ... Pk peuvent être exécutés en
parallèle ssi les conditions de Bernstein sont satisfaites c'est à dire si Pi II Pj pour tout couple (i; j)
avec i  j.
L'exemple intuitif et les conditions de Bernstein introduisent la notion de dépendances entre
deux ou plusieurs programmes (ou opérations). Pour que deux programmes ou deux opérations
puissent être exécutées en parallèle, il faut :
1) qu'ils (elles) soient indépendants (elles),
2) que l'on puisse détecter cette indépendance et
3) qu'il existe suffisamment de ressources pour les exécuter simultanément.
1.4 Les sources du parallélisme
1.4.1 Le parallélisme de données
Le parallélisme de données est un type de parallélisme pour lequel la même opération est
réalisée simultanément par de nombreux processeurs sur des données différentes. Un exemple simple
est celui du calcul matriciel.
Pour i de 1 à n
Pour j de 1 à n
A[i][ j]  B[i][j ] +C [i ][j]
FinPour
FinPour
Les itérations de cette boucle sont indépendantes. Il y a n2 itérations avec une opération par
itération. Le potentiel de parallélisme exploitable dans cette boucle est donc de n2 opérations
simultanées. Son ampleur exploitable dépend directement de la taille des structures de données
manipulées. Les données sont de loin la source de parallélisme qui offre le plus de potentiel.
Généralement le nombre de processeurs est beaucoup plus petit que le parallélisme potentiel et
chaque processeur devra donc traiter plusieurs données.
1.4.2 Le parallélisme de contrôle
Le parallélisme de contrôle est un type de parallélisme pour lequel des opérations différentes
sont réalisées simultanément. C’est l'absence de dépendances entre différentes parties du programme
qui est la source du parallélisme de contrôle. Ceci est un exemple très simple de programme pour un
serveur et ci-dessous le programme correspondant pour le traitement client :
faire toujours
détecter demande-client
si demande client vrai
lancer traitement-client
5
Module : Système d’exploitation II
Responsable : NINI B.
Chapitre IV : Introduction aux architectures parallèles
Page 6
finsi
finfaire
début
ouvrir fichier-client
faire traitement-demande
fermer fichier-client
fin
Supposons que la fonction « lancer » retourne immédiatement après avoir lancé le programme
traitement-client ; c'est-à-dire sans attendre que celui-ci se termine. Dans ce cas, le programme du
serveur continue à s'exécuter alors que le programme traitement-client est en cours d'exécution. S’il y
a suffisamment de ressources, ces deux programmes seront exécutés simultanément.
Il existe une autre forme d'exploitation du parallélisme de contrôle. Elle est appropriée au cas
où il existe une dépendance entre les parties du programme qui peuvent être exécutées en parallèle.
Imaginons une application vidéo pour laquelle une scène est filmée (opération F) en permanence par
une caméra numérique qui fournit un flux d'images numérisées (i0, i1, ...,). On applique à chaque
image un filtrage numérique (opération N) qui, à son tour, fournit une image numérisée (j0, j1,...,).
Cette image est ensuite compressée (opération C qui fournit l'image k) puis elle est stockée (opération
S). L'algorithme de cette application est le suivant :
x=0
tant que la scène est filmée faire
ix = F()
jx = N(ix)
kx = C(jx)
S(kx)
x=x+1
fin faire
Les opérations, F, N, C et S, sont toutes limitées par des dépendances de flot. Pourtant ces
opérations sont exécutables en parallèle. Il est impossible d'exécuter ces opérations simultanément
pour la même image. L'exécution simultanée de ces opérations réside dans le traitement par chacune
d'elle d'une image différente. Autrement dit, lorsque F fournit l'image in+3, N traite l'image in+2, C
traite l'image jn+1 et S stocke l'image kn. Lorsque ces opérations sont terminées, toutes propagent
leur résultat à l'opération suivante et traitent une nouvelle image. Une chaîne est constituée et
fonctionne tant que la scène est filmée.
Cette forme d'exploitation du parallélisme de contrôle s'appelle le pipeline. Elle repose sur
l'organisation des données à traiter sous la forme d'un flux d'informations et sur l'application de
plusieurs traitements consécutifs sur chaque élément de ce flux.
6
Module : Système d’exploitation II
Responsable : NINI B.
Chapitre IV : Introduction aux architectures parallèles
Page 7
1.5 Organisation des architectures parallèles
Une architecture parallèle est le résultat d'un équilibre entre plusieurs paramètres : la nature
des ressources, les performances relatives de ces ressources, l'agencement des ressources et leur mode
de contrôle.
1.5.1 Ressources et organisation schématique des architectures parallèles
Les architectures parallèles sont généralement construites à partir des ressources qui
composent les architectures séquentielles : unité de traitement, unité de contrôle, mémoire, entrées
sorties (disque, réseau, etc.). Durant l'exécution d'un traitement parallèle, toutes les unités échangent
des informations. Ces transferts d'informations sont réalisés par une ressource supplémentaire : le
réseau de communication interne. Ainsi, les performances des architectures parallèles dépendent des
performances de leurs ressources et de leurs agencements.
Les microprocesseurs actuels ont des latences pour des opérations entières ou flottantes de 1 à
3 cycles. Avec une fréquence de fonctionnement de 2ns pour les meilleurs, la latence d'exécution de
traitement pour une donnée est d'environ 2 à 6ns. Certains processeurs peuvent réaliser deux
opérations flottantes et deux opérations entières (sans compter les branchements et les accès
mémoire) en un cycle. Avec des données 64 bits, le débit de données peut atteindre 8 opérandes et 4
résultats 64 bits par cycle d'horloge soit : 48 Go/s avec une horloge à 500Mhz.
La mémoire statique possède un temps d'accès de quelques ns (typiquement inférieur à 10ns)
et un débit égal à l'inverse de cette valeur multiplié par la largeur des mots accédés. Avec des mots de
64 bits et une mémoire à 5ns à 2 ports (i.e à deux accès simultanés), le débit peut atteindre
théoriquement 3,2 Go/s. Les meilleurs réseaux actuels ont une latence d'environ 10 s (s : 10-6
seconde) et un débit de 125 Mo/s. Enfin les disques ont des temps d'accès d'environ 10 ms (ms : 10 -3
seconde) et un débit de 10 Mo/s.
Les performances des ressources sont donc très différentes. Les modèles d'architectures
parallèles sont des équilibres établis à partir des performances relatives de ces ressources.
1.5.2 Classification des architectures parallèles
La diversité des ressources et leur nombre important conduit à une grande variété
d'agencements possibles de ces ressources dans une architecture parallèle. Pour distinguer des
familles d'architectures, on utilise des classifications.
7
Module : Système d’exploitation II
Responsable : NINI B.
Chapitre IV : Introduction aux architectures parallèles
Page 8
La classification la plus utilisée est connue historiquement sous le nom de classification de
‘Flynn’. Elle classe les architectures suivant les relations entre les unités de traitement et les unités de
contrôle. Les unités de traitement calculent chacune un flux de données ou « Data stream ». Les
unités de contrôle déroulent chacune un programme (un flux d'instructions ou « Instruction stream »).
1 flux de données
Plus de 1 flux de données
1 flux d'instructions
SISD
SIMD
Plus de 1 flux d'instructions
MISD (Pipeline)
MIMD
On distingue quatre types principaux de parallélisme : SISD, SIMD, MISD et MIMD. De nos
jours cette classification peut paraître un peu artificielle car le moindre micro-processeur courant
inclut lui-même plusieurs formes de micro-parallélisme. Elle permet néanmoins d'expliquer les bases
de l'architectures des ordinateurs, séquentiels et parallèles. Cette classification est basée sur les
notions de flot de contrôle (deux premières lettres, I voulant dire ‘Instruction’) et flot de données
(deux dernières lettres, D voulant dire ‘Data’).
1.5.2.1 Machine SISD
Une machine SISD (Single Instruction Single Data) est ce que l'on appelle d'habitude une
machine de Von Neuman. Une seule instruction est exécutée et une seule donnée (simple, nonstructurée) est traitée à tout instant.
Le code suivant,
int A[100];
...
for (i=1;100>i;i++)
A[i]=A[i]+A[i+1];
s'exécute sur une machine séquentielle en faisant
+A[3],
les additions
A[1]+A[2],
A[2]
etc., A[99]+A[100] à la suite les unes des autres.
1.5.2.2 Machine SIMD
Une machine SIMD (Single Instruction Multiple Data) peut être de plusieurs types, parallèle
ou systolique. En général l'exécution en parallèle de la même instruction se fait en même temps sur
des processeurs différents.
Examinons par exemple le code suivant écrit en CM-Fortran sur une machine avec 32
processeurs :
INTEGER I,A(32,1000)
8
Module : Système d’exploitation II
Responsable : NINI B.
Chapitre IV : Introduction aux architectures parallèles
Page 9
CMF$ LAYOUT A(:NEWS,:SERIAL)
...
FORALL (I=1:32,J=1:1000)
$
A(I:I,J:J)=A(I:I,J:J)+A(I:I,(J+1):(J+1))
Chaque processeur i, 1  i  32 a en sa mémoire locale une tranche du tableau A: A(i,1), A(i,2),
..., A(i,1000).
Il n'y a pas d'interférence dans le calcul de la boucle entre les différentes tranches : tous
les processeurs exécutent la même boucle sur leur propre tranche en même temps.
1.5.2.3 Machine MISD
Une machine MISD (Multiple Instruction Single Data) peut exécuter plusieurs instructions en
même temps sur la même donnée. Cela peut paraître paradoxal mais cela recouvre un type très
ordinaire de micro-parallélisme dans les micro-processeurs modernes : les processeurs vectoriels et
les architectures pipelines.
1.5.2.4 Machine MIMD
Le cas des machines MIMD (Multiple Instruction Multiple Data) est le plus intuitif. On a deux
types d'architecture possibles :
(1) Mémoire partagée
(2) Mémoire locale avec réseau de communication (Transputer ou
par réseau
d'interconnexion), ou système réparti
Mémoire Partagée:
Une machine MIMD à mémoire partagée est principalement constituée de processeurs avec
des horloges indépendantes, donc évoluant de façon asynchrone et communiquant en écrivant et lisant
des valeurs dans une seule et même mémoire (la mémoire partagée). Le cache de données de chaque
9
Module : Système d’exploitation II
Responsable : NINI B.
Chapitre IV : Introduction aux architectures parallèles
Page 10
processeur induit une difficulté où ce dernier doit avoir les informations cohérentes aux moments
cruciaux.
Architecture simplifiée d'une machine à mémoire partagée
La synchronisation des exécutions des processus est nécessaire dans certains cas. Si elle n'est
pas faite, il y aurait un risque d'incohérence des données.
Machine distribuée
En général, l'emploi d'autres mécanismes de communication que la mémoire partagée pour
une machine MIMD est due au fait que les processeurs sont physiquement éloignés et qu'un partage
de petites informations soit raisonnable. Par exemple, le réseau Internet permet de considérer en un
certain sens, tous les ordinateurs reliés comme étant un seul et même ordinateur distribué, où les
processeurs travaillent de façon asynchrone et où les informations transitent par passage de message.
De façon générale, la synchronisation et l'échange d'information peuvent se faire par :

Appel de procédure distribuée (RPC) avec réponse synchrone ou asynchrone.

Envoi/Réception de message asynchrone (tampon de taille limitée ou non).

Envoi/Réception de message synchrone : rendez-vous.

Mixtion des deux derniers cas.
1.6 Contrôle d'une machine parallèle
Il y a deux méthodes principales :
(1) On dispose d'un langage séquentiel : le compilateur parallélise le code objet généré,
(2) On a une extension d'un langage séquentiel ou un langage dédié avec des constructions
parallèles explicites (Parallel C, Occam...)
Pour le deuxième cas, il faut disposer de primitives (ou instructions) pour :

10
La création de parallélisme,
Module : Système d’exploitation II
Responsable : NINI B.
o Itération simultanée sur

Chapitre IV : Introduction aux architectures parallèles
Page 11
tous les processeurs (FORALL de Fortran parallèle),
o
Définition d'un ensemble de processus (COBEGIN),
o
Création de processus (FORK de Unix)
Contrôler les tâches parallèles,
o
Synchronisation (Rendez-vous d'Ada),
o
Passage de messages (synchrones/asynchrones,...),
o
Section critiques (gestion de la mémoire partagée),
o
Arrêt d'une exécution parallèle (COEND, WAIT d'Unix)
2 Lois, modèles et métriques des performances des architectures
parallèles
2.1 Performance
La performance la plus simple à calculer mais aussi la moins utile est la performance crête.
Elle est simplement obtenue par la multiplication de la performance crête individuelle de toutes les
unités de traitement par leur nombre dans l'architecture.
P = Nb opérations / temps du traitement
Par exemple, le nombre d'opérations flottantes pour le produit de matrices carrées est 2n3 si n
est la taille du côté de la matrice. Avec un coté de 1000 éléments, il y a donc 2 x 109 calculs à réaliser.
Si le temps de traitement est de 1 seconde, le débit de calcul est de 2 x 109 opérations flottantes par
seconde ; soit 2 GigaFlops.
Le temps d'exécution sert de base à la comparaison d'architectures pour le traitement d'une
même application. Avec la formule A = t1/t2, on calcule l'accélération que permet l'architecture 2 (qui
à pris le temps t2 pour calculer l'application) par rapport à l'architecture 1 (temps t1).
Une des caractéristiques recherchées dans les architectures parallèles est leur extensibilité
(possibilité d'augmenter le nombre de processeurs dans l'architecture). Etendre une architecture a un
intérêt seulement si cela se traduit par de meilleures performances. Deux paramètres mesurent le gain
de performance obtenu par l'augmentation du matériel (plus de processeurs) : l'accélération (speedup)
et l'augmentation du débit (scaleup)
L'accélération indique le rapport de performance entre deux architectures identiques traitant le
même problème mais avec un nombre de processeurs différents. L'accélération est calculée avec la
formule précédente. t2 représente alors le temps de l'architecture avec x processeurs et t1 le temps
11
Module : Système d’exploitation II
Responsable : NINI B.
Chapitre IV : Introduction aux architectures parallèles
Page 12
avec y processeurs. On suppose x >y. L'accélération devrait augmenter linéairement avec le nombre
de processeurs. En pratique, c'est rarement le cas.
L'augmentation du débit mesure le rapport de la quantité d'information traitée dans le même
temps par deux architectures similaires, l'une ayant plus de ressources que la seconde. La formule
suivante mesure le scaleup : S = Q2 / Q1. Q2 est la quantité de données traitée par l'architecture 2 et
Q1 est la quantité de données traitée par l'architecture 1 dans le même temps. S >1 peut être obtenu en
augmentant la performance individuelle des processeurs ou en augmentant le nombre des processeurs.
Dans ce cas aussi, l'augmentation du nombre de processeurs devrait accroître proportionnellement le
scaleup. En pratique, même si cela est mois difficile que pour le cas du speedup, la présence de
communication entre les processeurs et leur coordination réduit le scaleup.
2.2 Lois d'Amdahl et de Gustafson
Comme d'autres disciplines, l'architecture des ordinateurs est gouvernée par des lois.
Cependant, dans ce domaine de nombreuses lois restent à découvrir pour parvenir à une ingénierie
purement calculatoire. Les lois connues découlent directement des propriétés des programmes.
La première loi découverte fut la loi D'Amdhal. Cette loi indique la limite de l'accélération
atteignable par une architecture parallèle (quelque soit son type) pour un programme particulier.
Supposons un programme X. Ce programme est composé d'une partie P exécutable en parallèle et
d'une partie S ne pouvant pas être exécutée en parallèle. Soit p le temps d'exécution séquentiel de la
partie P et s le temps d'exécution de la partie S. Soit n le nombre de processeurs utilisés pour
l'exécution parallèle de P. Alors dans le meilleur des cas l'accélération est égale à : A 
s p
.
p
s
n
Selon cette formule, on remarque que quelque soit le nombre de processeurs, l'accélération est
toujours bornée inférieurement par s. Si s représente seulement 10% du temps d'exécution totale
(s+p), l'accélération sera bornée par (s + p)/s, soit 10. Cela signifie que même avec une infinité de
processeurs, l'accélération ne pourra pas dépasser 10. On déduit deux règles de cette loi.
Premièrement, lors de l'écriture d'un programme parallèle, il faut limiter autant que possible la partie
séquentielle. Deuxièmement, un ordinateur parallèle doit être un excellent ordinateur séquentiel pour
traiter le plus rapidement possible la partie séquentielle.
12
Module : Système d’exploitation II
Responsable : NINI B.
Chapitre IV : Introduction aux architectures parallèles
Page 13
La loi d'Amdahl indique que la performance ne dépend pas seulement du nombre de
ressources mises en parallèle et de surcroît elle désigne la partie séquentielle comme le facteur
limitant. La limite est aussi très sévère car il est très difficile de paralléliser 90 % d'un programme.
La loi de Gustavson modère les conclusions de la loi d'Amdahl. Gustavson fait remarquer que
la partie parallèle est composée de boucles qui traitent les données. Si la quantité de données à traiter
progresse alors la contribution de la partie parallèle dans le temps d'exécution va augmenter (ceci
pour un même nombre de processeurs). Par conséquent, la contribution de la partie séquentielle va
diminuer. Comme généralement, l'utilisateur du parallélisme utilise plus de processeurs parce qu'il
veut traiter plus de données, l'approche de Gustavson est cohérente avec l'utilisation du parallélisme.
Plus rigoureusement, soit un programme X avec une partie séquentielle S et une partie
parallèle P. Avec n processeurs, le temps de calcul selon la loi d'Amdahl est t = s + P/n. En supposant
que la partie parallèle augmente linéairement avec le nombre de processeurs P = a * n, le temps
d'exécution avec n processeurs devient : t = s + a.
D'où l'accélération : A = (s + an)/(s + a) Et A  n ; lorsque a  1.
Notons que a représente la taille de la partie parallèle attribuée à chaque processeur. Plus cette
taille est importante, plus l'accélération tend vers le nombre de processeurs. Cette taille dépend
directement de la quantité d'informations à traiter. Comme les structures de données comportent
généralement beaucoup plus d'éléments qu'il n'y a de processeurs dans une machine parallèle
(plusieurs millions d'éléments contre moins de mille processeurs), chaque processeur à une quantité
importante de données à traiter. L'augmentation de cette quantité provoque généralement une
augmentation proportionnelle du temps de traitement pour chaque processeur.
La loi de Gustavson correspond donc bien à une réalité. La conclusion de cette loi est que le
parallélisme peut dépasser la limite établie par la loi d'Amdahl à condition d'augmenter la quantité
d'informations à traiter.
13