TD : Rôle des performances
TD : Rôle des performances .... Soient tUCA et tUCN les temps d'exécution, tcA et
tcN les temps de cycle, nA et nN les nombres d'instructions, et CPIA et CPIN ...
part of the document
quêtes en attente. Dans ce cas, augmenter le débit de sortie pourrait aussi améliorer le temps de réponse. Ainsi, pour de nombreux systèmes informatiques réels, changer un paramètre, soit le temps d'exécution soit le débit de sortie, affecte souvent l'autre.
La performance
Dans notre discussion nous nous intéressons aux temps de réponse. Maximiser les performances équivaut à minimiser le temps d'exécution.
Exercice
Si la machine A exécute un programme en 10 secondes et la machine B exécute le même programme en 15 secondes, de combien A est-elle plus rapide que B ?
Réponse:
Nous savons que A est n fois plus rapide que B si
Performances-A / Performances-B = n ou
Temps d'exécution-B / temps d'exécution-A = n
Le rapport est donc de 15/10.
Relier les métriques entre elles.
Temps d'exécution UC pour un programme = Nombre de cycles UC pour un programme/fréquence d'horloge. Tous les ordinateurs sont construits avec une horloge de fréquence constante qui détermine à quels moments les événements se produisent dans la machine.
Exercice
Notre programme s'exécute en 10 secondes sur A, qui dispose d'une horloge à 100Mhz. Nous tentons d'aider un concepteur à construire une machine B, qui exécutera ce programme en 6 secondes. Le concepteur établi qu'une augmentation substantielle de la fréquence d'horloge est possible, mais que cette augmentation affectera le reste de la conception de l'UC, imposant à la machine B d'utiliser 1,2 fois plus de cycles d'horloge que la machine A pour ce programme. Quel objectif de la fréquence d'horloge devrons-nous donner au concepteur ?
Déterminons tout d'abord le nombre de cycles d'horloge nécessaires au programme sur A :
Tps UC-A = NB de cycles UC-A / Fréquence d'H-A
10 = NB cycles UC-A / 100*106Cycles/secondes
Nb cycles UC-A = 10*100*106 = 1000*106 cycles
Le temps UC pour B peut être obtenu en utilisant l'équation suivante :
Tps UC-B = 1,2*1000*106cycles / Fréquence d'H-B
Fréquence d'H-B = 1,2*1000*106 cycles / 6 secondes = 200Mhz
Rappel : NB de cycles UC = NI * CPI. Avec CPI, le nombre de cycles d'horloge par instruction, correspond au nombre moyen de cycles d'horloge qu'il faut à chaque instruction pour s'exécuter.
Exercice
Supposons que nous ayons deux mises en oeuvres différentes de la même architecture de jeu d'instructions. Pour un programme donné, la machine-A a un temps de cycle d'horloge de 10 ns et un CPI de 2, et la machine B un temps de cycle d'H de 20 ns et un CPI de 1,2 pour le même programme. Quelle machine est la plus rapide pour ce programme et de combien ?
Réponse
Nous savons que chaque machine exécute le même nombre d'instructions pour ce programme, soit I ce nombre. Tout d'abord, déterminons le nombre de cycles d'H pour chaque machine :
Nombre de cycles UC-A = I*2
Nombre de cycles UC-B = I*1,2
Nous pouvons calculer le temps UC pour chaque machine :
Temps UC-A = Nb. de cycles UC-A * Tps de cycle-A
= I*2*10ns=20*Ins
De même pour B :
Temps UC-B=I*1,2*20ns=24*Ins
De manière évidente, la machine A est plus rapide. Le rapport des temps d'exécution nous indique de combien A est plus rapide :
Performance UC-A/Performances UC-B = Tps d'exécution-B / Tps d'exécution-A = 24*I ns/20*I ns=1,2
A est 1,2 plus rapide que B pour ce programme.
Autre formule à donner au étudiants
Le CPI varie avec l'application, ainsi qu'avec les mises en oeuvre d'un même jeu d'instructions. Les concepteurs obtiennent souvent le CPI par une simulation détaillée de la mise en oeuvre. Il est parfois possible de calculer le nombre de cycles d'horloge UC en regardant les différents types d'instructions utilisés et en se servant de leurs nombres de cycles d'horloge.
Nb de cycles d'horloge UC = EMBED Equation.3
Où Ci est le nombre des instructions de classe i exécutées, CPI, est le nombre moyen de cycles par instruction pour cette classe, et n le nombre de classes d'instructions.
Exercice
Un concepteur de compilateur essaie de choisir entre deux séquences de code pour une machine donnée. Les concepteurs du matériel ont fourni les informations suivantes :
Classe d'instructionCPI pour cette classeA1B2C3
Pour une expression particulière d'un langage de haut niveau, le concepteur du compilateur envisage deux séquences de code qui nécessitent les nombres d'instructions suivantes :
Nombre d'instructions pour la classe d'instructionSéquence de codeABC12122411
Quelle séquence de code exécute le plus d'instructions ? Laquelle sera la plus rapide ? Quel est le CPI de chaque séquence ?
La séquence 1 exécute 2+1+2 = 5 instructions. La séquence 2 en exécute 4+1+1 = 6. La séquence 1 exécute donc moins d'instructions.
Nous pouvons utiliser l'équation du nombre de cycles d'horloge UC fondée sur le nombre d'instructions et le CPI pour obtenir le nombre total de cycles d'horloge pour chaque séquence :
il vient d'après la formule :
Nb de cycles UC-1 = 2*1+1*2+2*3 = 10cycles
Nb. de cycles UC2 = 4*1+1*2+1*3 = 9 cycles
La séquence 2 est donc plus rapide, même si elle exécute en fait plus d'instructions. Puisque la séquence 2 utilise globalement moins de cycles d'horloge mais a plus d'instructions, elle doit avoir un CPI inférieur. Les valeurs du CPI peuvent être calculées par
CPI = Nb. de cycle UC / Nb. d'instructions
CPI-1 = 10/5 = 2
CPI-2 = 9/6 = 1,5
Cet exercice montre le danger encouru lorsque l'on utilise un seul paramètre (le nombre d'instructions) pour établir les performances. Par exemple le MIPS ne prend pas en compte tous les termes.
Exercice
Pour les instructions de branchement conditionnel, on envisage deux possibilités :
UC A. Un code condition est positionné par une instruction de comparaison et suivi par un branchement qui teste le code condition.
UC B. Une comparaison est comprise dans le branchement.
Sur les deux UC, linstruction de branchement conditionnel prend 2 cycles, et toutes les instructions prennent 1 cycle. (Evidemment, en décidant que le CPI est 1 pour tout excepté les branchements, on ne prend pas en compte dans cet exemple simple les pertes dues au système mémoire). Sur lUC A, 20% de toutes les instructions exécutées sont des branchements conditionnels ; puisque chaque branchement nécessité une comparaison, il y a aussi 20% des instructions qui sont des comparaisons. Parce que lUC A na pas de comparaison dans le branchement, son temps de cycle est de 25% inférieur à celui de lUC B. Quelle UC est le plus rapide ?
Puisque les aspects système sont négligés, on peut utiliser la formule de performance de lUC :
CPIA = ((0,2*2)+(0,8*1)) soit 1,2 puisque 20% des instructions sont des branchements (2 cycles) et que les autres prennent 1 cycle.
Soit tUCA et tUCB les temps dexécution, tcA et tcB les temps de cycle et nA et nB les nombres dinstructions respectifs des deux machines A et B. tcB = 1,25*tcA, puisque A est 25% plus rapide. La performance de lUC A est alors
TUCA = nA*1,2*tcA = 1,2*nA*tcA
Il ny a pas de comparaisons dans lUC B, de telle sorte que 20%/80%, soit 25% des instructions, sont des branchements (2 cycles), et les 75% restant prennent 1 cycle, CPIb est alors ((0,25*2)+(0,75*1) soit 1,25. Puisque lUC B nexécute pas de comparaisons, nb=0,8*nA. La performance de lUC B est
TUCB = (0,8*nA)*1,25*(1,25*tcA) = 1,25*nA*tcA
Sous, ces hypothèses, lUC A, avec le plus petit cycle dhorloge, est plus rapide que lUC B, qui exécute moins dinstructions.
Au vue de cette analyse, un concepteur sest aperçu que, en retravaillant la structure, la différence de temps de cycle peut être facilement réduite à 10%. Quelle UC est maintenant la plus rapide.
Le seul changement par rapport à la réponse ci-dessus est que tcB= 1,10*tcA, puisque A est simplement 10% plus rapide. La performance de lucA est encore tcA=1,2*nA*tcA. La performance de lucB est maintenant tucB=(0,8*nA)*1,25*(1,1*tcA)=1,1*nA*tcA.
Avec cette amélioration, lUCB, qui exécute moins dinstructions, est maintenant plus rapide.
Considérons une autre modification du jeu dinstructions. La machine initiale a seulement des chargements et rangements mémoire, et donc toutes les opérations travaillent sur les registres. De telles machines sont appelées machine chargement/rangement. Les mesures sur la machine chargement/rangement présentant la fréquence des instructions et le nombre de cycles par instruction sont données ci dessous.
OpérationfréquenceNb cyclesOpérations UAL431Chargement212Rangement122Branchement242Supposons que 25% des opérations de lUAL demandent un opérande qui ne sera pas réutilisé après sa lecture depuis la mémoire.
On se propose dajouter des instructions UAL qui ont un opérande source en mémoire. Ces nouvelles instructions registre-mémoire durent 2 cycles. De plus, on suppose que lextension du jeu dinstructions augmente de 1 le nombre le nombre de cycles de branchements, mais naffecte pas le temps de cycle. Cette modification améliore-t-elle la performance de lUC ?
La question est de savoir si la nouvelle machine est plus rapide que lancienne. On utilise la formule de performance de lUC puisque, là encore, les aspects système sont négligés. Soient tUCA et tUCN les temps dexécution, tcA et tcN les temps de cycle, nA et nN les nombres dinstructions, et CPIA et CPIN les nombres de cycles par instruction, respectivement pour les versons ancienne et nouvelle.
Le CPI original est calculé en multipliant entre elles les deux colonnes de la figure ci dessus. :
CPIA=(0,43*1+0,21*2+0,12*2+0,24*2)=1,57
La performance de lancienne version est alors
TUCA=na*1,57*tCA=1,57*nA*tCA
Donnons la formule pour le nouveau CPI, puis expliquons ses composantes :
EMBED Equation.3
25% des instructions UAL (qui représentent 43% des instructions exécutées) deviennent des instructions registre-mémoire, changeant les trois premières composantes du numérateur. Il y a (0,25*0,43) fois moins dopérations UAL , (0,25*0,43) fois moins dopérations chargement et (0,25*0,43) nouvelles instructions UAL registre-mémoire. Le reste du numémrateur ne change pas, sauf que les branchements prennent 3 cycles au lieu de 2. Nous divisons par le nouveau nombre dinstructions, qui est 0,25*0,43 plus petit que lancien. En effectuant le calcul :
CPIN=1,703/0,893=1,908
Puisque le temps de cycle est inchangé, la performance de la nouvelle UC est
TUCN=(0,893*nA)*1,908*tCA=1,703*nA*TcA
Avec les hypothèses ci-dessus, la réponse à la question est non : cest une mauvaise idée dajouter des instructions registre-mémoire, parce quelles ne compensent pas laugmentation du temps dexécution des branchements.
Le MIPS
Utiliser les MIPS comme mesure pose trois problèmes. Le nombre de MIPS indique la fréquence d'exécution des instructions mais ne dépendent pas du jeu d'instructions. Nous ne pouvons donc pas comparer des ordinateurs à jeu d'instructions différents. Le nombre de MIPS varient d'un programme à l'autre sur un ordinateur donné ; donc une machine ne peut avoir une mesure du débit MIPS unique. Le débit MIPS peut varier en sens inverse des performances.
Exercice
Considérons la machine à trois classes d'instructions et les mesures de CPI de lexercice REF _Ref82237902 \r \h 4.1. Maintenant supposons que nous mesurions le code généré à partir d'un même programme par deux compilateurs différents et que nous obtenions les résultats suivants :
Nombres d'instructions (millions) pour chaque classe d'instructionsCode issu duABCCompilateur 1511Compilateur21011
Supposons que la fréquence d'horloge de la machine est de 100 Mhz. Quelle séquence de code s'exécutera la plus rapidement en termes de MIPS ? En termes de temps d'exécution ?
Nous pouvons utiliser l'équation suivante pour déterminer le nombre de MIPS :
MIPS = Fréquence d'horloge / CPI *106
Pour déterminer le CPI global pour chaque compilateur, nous partons de :
CPI = Nb. de cycles UC / Nb. d'instructions
Nous pouvons utiliser une formule précédente pour les cycles d'horloge UC :
NB. de cycles UC = Somme(CPIi*Ci)
Après avoir substitué dans la première formule, on obtient :
CPI = Somme(CPIi*Ci) / NI
Nous utilisons cette dernière formule pour calculer les valeurs du CPI pour les deux séquences de code.
CPI-1=(5*1+1*2+1*3)*106 / (5+1+1)*106 = 1,43
MIPS-1 = 100 Mhz / 1,43*106
CPI-2 = (10*1+1*2+1*3)106 / (10+1+1)*106 =1,25
MIPS-2 = 100Mhz / 1,25*106 = 80
Par conséquent, le code produit par le compilateur 2 a un débit MIPS plus élevé. Calculons maintenant le temps d'exécution en utilisant la formule :
Tps UC = NI * CPI / Fréquence d'horloge
Tps UC-1 = (5+1+1)*106*1,43 / 100*106 = 0,1 secondes
Tps UC2 = (10+1+1)*106*1,25 / 100*106 = 0,15 secondes
Donc, le compilateur 1 est de manières évidente plus rapide - contrairement à ce que nous pouvions conclure à partir des MIPS.
Nous pouvions calculer également le rapport de performances à partir des mesures des MIPS et des nombres d'instructions, en utilisant la formule :
Tps d'exécution = NI / MIPS*106
Soit
Tps UC-1 = 7*106 / 69,9*106 = 0,1 secondes
Tps UC-2 = 12*106 / 80*106 = 0,15 secondes.
exercice
Soit un compilateur optimisant pour la machine chargement/rangement décrite sur le tableau suivant.
OpérationfréquenceNb cyclesOpérations UAL431Chargement212Rangement122Branchement242
Le compilateur écarte 50% des instructions UAL , bien quil ne puisse réduire les chargements, rangement ou branchements. En négligeant les aspects système et en supposant un temps de cycle de 2ns, quel est le débit MIPS pour le code optimisé par rapport au code non optimisé ? Le classement selon de nombre de MIPS correspond-il au classement en fonction des temps dexécution ?
Le CPIno (non optimisé) vaut 1,57 et EMBED Equation.3
La performance du code non optimisé est :
TUCno=nno*1,57*(2*10-9)=3,14*10-9*nno
Pour le code optimisé :
EMBED Equation.3
puisque la moitié des instructions UAL ont été supprimées (0 ,43/2) et que le nombre dinstructions est réduit par les instructions UAL manquantes. Ainsi,
MIPSo=50MHZ/(1,73*106)=28,9
La performance du code optimisé est
TUCo=(0,785*Nno)*1,73*(2*10-9)=2,72*10-9*nno
Le code optimisé est de 13% plus rapide, mais son débit MIPS est plus faible.
La loi dAmdahl
Exercice
Montrer que laccélération globale peut sécrire :
EMBED Equation.3
exercice
Considérons un dispositif damélioration dix fois plus rapide que la machine originelle mais que lon ne peut utiliser que 40% du temps. Quelle est laccélération totale obtenue en intégrant ce dispositif ?
Fraction améliorée = 0,4
Accélération améliorée = 10
Accélération globale = EMBED Equation.3
Exercice
La loi peut servir de guide pour calculer limpact dun dispositif sur les performances et la façon de répartir les ressources de façon à améliorer le rapport coût/performances.
Supposons que nous voulions améliorer la vitesse de lunité centrale de notre machine dun facteur 5 (sans toucher aux performances des entrées/sorties) pour cinq fois son prix. Supposons aussi que lUC est utilisée pendant 50% du temps et que, pour le reste, elle est en attente dE/S. Si le coût de lUC est le tiers du coût total de lordinateur, le fait daugmenter la vitesse de lUC dun facteur de cinq constituera-t-il un bon investissement du point de vue coût/performance ?
Laccélération obtenue est :
EMBED Equation.3
La nouvelle machine coûtera : 2/3*1+1/3*5 = 2,33 fois la machine originelle.
Performances caches
Exercice
Supposons que nous ayons un ordinateur avec une petite mémoire rapide qui contient 2000 instructions. 10% de celles-ci provoquent 90% des accès aux instructions et laccès à ces 10% est uniforme. (Ce qui signifie que chaque instruction parmi ces 10% est exécutée un nombre égal de fois. Si on a un programme de 50000 instructions et si on sait où se trouvent les 10% des instructions les plus utilisées, quelle proportion des accès pourra être effectuée dans la mémoire rapide.
10% des 50000 est égal à 5000. Ainsi, on peut avoir 2/5 des 90%, soit 36% des instructions accélérées.
Exercice
Supposons quun cache soit 5 fois plus rapide que la mémoire centrale, et que ce cache puisse être utilisé durant 90% du temps. Quel est le gain de vitesse lié à lutilisation du cache ?
Il sagit de la simple utilisation de la loi dAmdahl : EMBED Equation.3
EMBED Equation.3
EMBED MSWordArt.2 \s PAGE 8
