ARPO

1. ARPO Architectures des processeurs superscalaires, VLIW et optimisations

2. L’interface logiciel / matériel langage logiciel compilateur jeu d’instructions (ISA) micro-architecture matériel transistor

3. Différents contextes • Processeurs à usage général • serveurs, ordinateurs de bureau, ordinateurs de poche ... • exécute tous types d’applications • Processeurs « enfouis » • téléphone, télévision, voiture ... • application spécifique • processeur spécialisé ou dérivé d’un processeur à usage général

4. Besoins en performances • Performance: • améliorer le temps de réponse => interactivité • applications scientifiques • bases de données • traitement du signal • multimédia • ...

5. Comment améliorer la performance ? écrire un meilleur algorithme langage optimisations du compilateur compilateur jeu d’instructions (ISA) améliorer l’ISA micro-architecture meilleure micro-architecture transistor nouvelle technologie

6. Où doit porter l’effort ? compilateur ISA micro-architecture processeur usage général + + + + + + processeur enfoui + + + + + + + • Processeur usage général • en général, on hérite d’un ISA existant (exemple: Intel x86) • compatibilité binaire: la nouvelle génération de processeur doit pouvoir exécuter les codes exécutables sur les anciennes générations • Processeur enfoui • attention au coût du processeur • compromis performance / consommation électrique

7. Plan du cours • Performances • Architecture des processeurs • jeu d’instructions (ISA: Instruction Set Architecture) • micro-architecture • Compilateur • optimisations de code

8. Améliorer la performance ? • Ca dépend du point de vue • Débit d’exécution: faire plus de travail utile pendant un temps donné • serveurs • environnement multiprogrammé • Temps d’exécution : faire un travail donné dans un temps plus court • point de vue de l’utilisateur • Rem: diminuer le temps d’exécution augmente le débit

9. temps d’exécution 1 accélération 2/1 = temps d’exécution 2 Accélération Exemple: Un programme compilé avec le compilateur A s’exécute en 10 ms Avec le compilateur B, s’exécute en 5 ms 10 accélération B/A = = 2 5 Le compilateur B est « 2 fois plus performant » que le compilateur A

10. Accélération locale / globale Exemple: supposons qu’un programme passe 50% du temps d’exécution dans du calcul en virgule flottante, et supposons qu’on multiplie par 2 les performances du calcul en virgule flottante. Quelle est l’accélération globale ?

11. Loi d’Amdahl

12. Exemple Exemple: supposons que 50% du temps d’exécution provienne du CPU, les 50% restant des entrées/sorties. On multiplie par 5 les performances du CPU. Quelle est l’accélération globale ? Il faut optimiser d’abord le cas le plus fréquent

13. temps CPU / temps réel temps CPU = temps utilisateur + système temps d’exécution temps « réel » (E/S, temps partagé …) Exemple: processeur fixé, on travaille sur le compilateur On peut utiliser le temps CPU utilisateur pour mesurer la performance

14. Fréquence / cycle / IPC Fréquence CPU f : fréquence de l’horloge interne du processeur dépend (entre autres) de l’échelle de gravure des transistors Cycle CPU: T = 1 / f Exemple: f= 500 MHz T= 2 ns Nombre moyen d’instructions exécutées par cycle

15. MIPS / megaflops MIPS= nombre moyen de millions d’instructions exécutées par seconde Exemple: ISA et compilateur fixés , on travaille sur la micro-architecture utiliser les MIPSpour mesurer la performance Si on travaille a fréquence CPU fixée, on peut utiliser l’IPC megaflops = nombre moyen de millions d’opérations virgule flottante par seconde Utilisé pour le calcul numérique intensif

16. Comparer des machines différentes Les MIPS n’ont aucune signification ici car les ISA sont différents Solution 1 : temps CPU Solution 2 : utiliser une machine de référence Exemple: VAX MIPS

17. Programmes de test • Programmes « standards » (benchmarks) • exemple 1 : SPEC CPU2000 • SPEC int : compression de données, compilateur, interpréteur, synthèse d’image, analyseur grammatical, jeu d’échec, conception de circuits ... • SPEC fp : physique, maths, chimie, météo ... • Exemple 2 : TPC (Transaction Processing Performance) • base de données multi-utilisateurs • sollicite les entrées-sorties • Programmes spécifiques Il faut choisir les programmes de test appropriés au cas étudié ...

18. Évaluer / analyser les performances • Mesures de temps  d’exécution • Instrumentation • exemple: quelle partie du code contribue le plus au temps d’exécution ? • code instrumenté = code original + code supplémentaire permettant de récupérer de l’information à l’exécution (exemple: adresses mémoire) • exemples d’outils: Prof, Pixie, Salto, EEL, Atom, … • Utilisation des compteurs matériels du processeur • compte certains évènements (exemple: nombre d’instructions exécutées) • quand un compteur atteint sa valeur maximum, génère une interruption • Simulation • on simule l’exécution au lieu d’exécuter réellement • l’ISA simulé peut ne pas être celui de la machine sur laquelle on simule • Exemples de simulateurs: Simplescalar, Shade, SimOS, Impact ...

19. Jeu d’instructions (ISA) • C’est l’interface matériel / logiciel • Exemples • Intel x86 (1979) • MIPS , SPARC (milieu années 80) • Alpha (début années 90) • Les ISA évoluent lentement, par ajouts successifs • il faut avoir de bonnes raisons pour lancer un nouveau jeu d’instructions • plus de raisons pour les processeurs enfouis : applications spécifiques, densité du code, consommation électrique, ...

20. Types d’ISA • CISC (Complex Instruction Set Computer) • ex. Intel x86, VAX, IBM 360, ... • taille d’instruction variable • plusieurs modes  d’adressage (absolu, basé, indexé, indirect) • instructions registres-mémoire • instructions itératives • RISC (Reduced Instruction Set Computer) • ex. Alpha, Sparc, MIPS, PowerPC ... • taille d’instruction constante (en général 32 bits) • architecture load / store • modes d’adressage simples (basé, indexé) • instructions simples registre-registre • VLIW (Very Long Instruction Word) • 1 instruction VLIW = plusieurs opérations indépendantes

21. CISC : exemple add r4, 10 (r5, r6) r4 = r4 + mem[r5+r6+10] 3 additions add r7, r5, r6 load r7, 10 (r7) add r4, r4, r7 r7 = r5 + r6 r7 = mem[r7+10] r4 = r4 + r7 Équivalent RISC:

22. RISC contre CISC • CISC • code plus dense, prend moins de place en mémoire • RISC • décodage plus rapide • processeur plus simple • le compilateur peut optimiser le code CISC décode Remarque: l’Intel P6 traduit à la volée les instructions x86 en micro-opérations RISC RISC cœur RISC

23. 6 26 op déplacement Jeu d’instructions RISC typique • instructions sur 32 bits • 32 registres entiers • 32 registres flottants • load / store (basé) • rt = rs op imm • branchement • saut registre 6 5 5 16 Format I op rs rt immédiat 6 5 5 5 11 • rd = rs fonc rt • load / store (indexé) Format R op rs rt rd fonc • saut Format J

24. RISC : remarques • Architecture 32 ou 64 bits ? • c’est la taille des adresses virtuelles (= adresses logiques) • Intel x86 : architecture 32 bits • Alpha, Sparc, MIPS : architectures 64 bits • en général, correspond à la taille des registres entiers • Virgule flottante • add, mul, div, sqrt, mult-add • banc de registres flottants séparé des registres entiers • registres 64 bits (double précision) • Accès mémoires • plusieurs grains d’accès: octet, demi-mot (2 octets), mot (4 octets), double-mot (8 octets) • accès alignés = quand on accède un groupe de N octets, les log2(N) bits de poids faible de l’adresse sont nuls

25. Étapes d’exécution (RISC) • Générer l’adresse de l’instruction • incrémenter le compteur de programme: PC = PC + 4 • Lire l’instruction en mémoire • Décoder l’instruction • type d’instruction (ALU, flottant, load, store, branchement, … ?) • préciser (add, mul, shift, and, or, adressage basé, indexé, … ?) • registres sources, registre destination • Lire les registres sources • Exécuter l’opération • Écrire le résultat dans le registre destination • rem: pour un saut ou un branchement pris, le registre destination implicite est le compteur de programme

26. Quelques données technologiques • Le temps de traversée d’une porte logique n’est pas nul • Positionner une tension sur une connexion, ca prend du temps • Temps de cycle des processeurs rapides (2000): ~1 ns • Durée d’une addition entière 64 bits: ~1 cycle • Durée d’une addition / multiplication flottante: ~3-4 cycles • Lecture / écriture registres: ~1 cycle (dépend du nombre de registres et du nombre de ports) • Accès mémoire: de < 1 cycle à plusieurs centaines de cycles suivant le type et la taille de la mémoire Il faut plusieurs cycles pour exécuter complètement une instruction

27. La technique du pipeline • Découper le traitement d’une instruction en plusieurs étages • mise à jour PC, chargement instruction, décodage et lecture registres, exécution, écriture registre • A un instant donné, chaque étage travaille sur une instruction différente • en début de cycle, chaque étage envoie « son » instruction à l’étage suivant cycle N cycle N+1 cycle N+2 PC = PC+4 Inst 5 Inst 6 Inst 7 chargement Inst 4 Inst 5 Inst 6 décodage / lecture registres Inst 3 Inst 4 Inst 5 exécution Inst 2 Inst 3 Inst 4 écriture registre Inst 1 Inst 2 Inst 3

28. Pipeline: remarques • Le pipeline ne réduit pas le temps d’exécution d ’une instruction • en fait, ça l’allonge même un peu à cause des verrous qu’on rajoute entre les étages • Permet un débit d’une instruction par cycle • en théorie, pas en pratique (cf. transparents suivants) • Banc de registres à 3 ports : 2 ports de lecture et 1 port d’écriture • Rem: si l’ISA autorise l’adressage indexé (Sparc, PowerPC), il faut un troisième port de lecture pour les stores

29. Aléas structurels • supposons qu’au cycle N, une instruction load se trouve à l’étage d’exécution et essaie d’accéder à la mémoire • au même instant, une autre instruction se trouve à l ’étage de chargement  d’instructions: on doit également accéder à la mémoire • problème: s’il n’y a qu’un seul port d’accès à la mémoire, conflit de ressource • 1ère solution: donner la priorité au load, et différer d’un cycle l’instruction à l’étage de chargement: c’est un aléa structurel • 2ème solution: 2 ports  d’accès à la mémoire

30. Dépendances de données • Soit 2 instructions I1 et I2 (I2 après I1) • 3 types de dépendances de données • dépendance RAW (Read After Write) • le résultat de I1 est utilisé par I2 • aussi appelée dépendance vraie • dépendance WAR (Write After Read) • I2 écrit dans un registre lu par I1 • aussi appelée anti-dépendance • dépendance WAW (Write After Write) • I2 écrit dans le même registre que I1 • aussi appelé dépendance de sortie I1: r1 = r1+1 I2: load r2, 0(r1) I1: load r2, 0(r1) I2: r1 = r1+1 I1: load r2, 0(r1) jump I3 if r5=0 I2: load r2, 0(r3)

31. Aléas de données • Pour respecter les dépendances RAW, WAR et WAW, on peut être amené à introduire des « bulles » dans le pipeline • bulle: la partie amont du pipeline est « gelée », seule la partie aval du pipeline progresse • Aléas de données • RAW • WAW: pas de problème si les instructions passent par l’étage d’écriture dans l’ordre du programme • WAR : pas de problème si on lit les registres dans l’ordre du programme et toujours au même étage du pipeline • Les aléas de données, comme les aléas structurels, diminuent les performances

32. Aléa RAW Cycle N Cycle N+1 Cycle N+2 Cycle N+3 PC = PC+4 chargement décodage / lecture registres I2: r1=r1+1 I2 I2 I1: r1=r2+r3 bulle bulle I2 exécution écriture registre I1 bulle bulle Dépendance RAW entre I1 et I2: au moment ou I2 essaie de lire r1, I1 n’a pas encore écrit dedans I2 doit attendre ... On attend 2 cycles avant de lancer I2 2 cycles perdus

33. ALU Mécanisme de « bypass » Banc de registres Enlève l’aléa RAW entre I1 et I2 PC = PC+4 MUX MUX chargement décodage / lecture registres exécution écriture registre

34. Plus d’aléas de données ? presque ... • Plus d’aléas RAW entre instructions registre-registre • A priori, il n’y a pas d’aléas WAR ou WAW • Mais … • certaines instructions nécessitent plusieurs cycles d ’exécution • load / store • division et multiplication entière • opérations virgule flottante

35. Cas des load / store • On supposera pour l’instant que l’accès à la mémoire se fait en 1 cycle • Pour exécuter un load / store • 1 cycle pour calculer l’adresse d’accès (addition) • 1 cycle pour accéder à la mémoire • total = 2 cycles à l ’étage d’exécution • Solution: diviser en 2 étages • étage d’exécution: utiliser l’ALU pour calculer l’adresse • étage d’accès mémoire

36. Nombre d’étages variable ? Pour les load / store, pipeline à 6 étages Pour les autres instructions, pipeline à 5 étages PC = PC+4 chargement décodage / lecture registres exécution I2: r3=r4+r5 accès mémoire I1: load r1,0(r2) Aléa structurel: au cycle suivant, I1 et I2 vont essayer d’écrire en même temps dans le banc de registre, or il n’y a qu’un seul port d’écriture. écriture registre

37. Nombre d’étages fixe Pipeline à 6 étages pour toutes les instructions Si l’instruction n’est pas un load / store, l’étage accès mémoire ne fait rien PC = PC+4 chargement décodage / lecture registres exécution I2: r3=r4+r5 accès mémoire I1: load r1,0(r2) écriture registre I1 et I2 écriront dans les registres à des cycles différents: plus d’aléa structurel Grâce au bypass, pas de problème

38. Il reste des aléas RAW: load-use Cycle N Cycle N+1 Cycle N+2 PC = PC+4 chargement décodage / lecture registres I2: r1=r1+1 I2 exécution I1: load r1,0(r2) bulle I2 accès mémoire bulle I1 écriture registre I1 Un cycle de pénalité load-use: Le compilateur doit essayer d’ordonner les instructions de manière à insérer une instruction entre I1 et I2 qui n’utilise pas le résultat de I1

39. Exercice load r2, 0(r1) ;a add r2, r2, 1 store r2, 0(r1) load r2, 4(r1) ;b add r2, r2, 1 store r2, 4(r1) a=a+1 ; b=b+1 ; PC = PC+4 chargement décodage / lecture registres exécution accès mémoire • Combien de bulles sont générées sur cette séquence ? • Transformer le code de manière à éliminer ces bulles écriture registre

40. Exercice • Hypothèse : • 1 instruction sur 5 est un load PC = PC+4 chargement • 1) Quel est l’IPC moyen si la probabilité qu’une instruction dépende de l’instruction précédente vaut 1/2 ? • 2) On suppose qu’en ordonnant les instructions, le compilateur est capable de placer une instruction indépendante derrière 75% des load. Quel est l’IPC moyen ? décodage / lecture registres exécution accès mémoire écriture registre

41. Exercice On modifie le pipeline: on insère un étage calcul d’adresse spécifique avant l’étage d’exécution. Les accès mémoire se font à l’étage d’exécution. (l’étage calcul d’adresse ne fait rien pour les instructions qui ne sont pas des load / store) PC = PC+4 chargement décodage / lecture registres • Combien de bulles sur une dépendance load-use ? • Cette structure de pipeline a-t’elle le même coût matériel que la structure précédente ? • Que doit faire le compilateur pour tirer partie de cette structure de pipeline ? calcul adresse exécution / mem écriture registre

42. Instructions longues • Instructions longues sur l’Alpha 21264 (1998) • multiplication entière: 7 cycles, complètement pipelinée • division flottante: 12 cycles SP, 15 cycles DP, non pipelinée • racine carrée: 18 cycles SP, 33 cycles DP, non pipelinée • Les opérations non pipelinées génèrent des aléas structurels • Attention aux aléas WAW • Problème des interruptions précises • si une interruption se produit entre I1 et I2, il faut maintenir un état cohérent des registres • il ne faut pas que I2 écrivent dans les registres avant d’être sûr que I1 ne génèrera pas d’exception

43. Dépendances WAW cycle de lancement cycle d’écriture Exemple de pipeline virgule flottante N N+5 N+1 N+4 I1: fmul f1,f1,f1 I2: fadd f1,f2,f3 PC charg. problème ... déc/lect. • Solutions possibles • retarder le lancement de I2 (bulles) • masquer l’écriture de I1 • rajouter 2 étages « vides » après l’additionneur flottant • ... fmul 5 cycles fadd 3 cycles écriture

44. Interruptions précises • Nécessaire lorsqu’on veut redémarrer un programme interrompu par une exception • par exemple, on peut « émuler » par logiciel certaines instructions • Faire les écritures registre dans  l’ordre du programme • Pipeline de même longueur pour (presque) toutes les instructions • Problème: augmente le nombre de niveaux de bypass • Solution: utiliser 2 copies du banc de registres • banc de travail: les écritures peuvent être faites dans le désordre • banc architectural : mis à jour dans l’ordre du programme au commit (dernier étage du pipeline) • en cas d’interruption, on recopie le contenu du banc architectural dans le banc de travail

45. Cas des sauts: aléas de contrôle PC = adresse de saut Cycle N Cycle N+1 Cycle N+2 PC I35 I36 chargement I3 I35 I36 décodage / lecture registres I2 bulle I35 exécution I1: jump @I35 bulle bulle accès mémoire bulle I1 écriture registre I1 Les instructions I2 et I3 sont annulées 2 cycles de pénalité de saut

46. Impact des aléas de contrôle • La pénalité de saut sera d’autant plus grande que les sauts et branchements seront exécutés tard dans le pipeline • En moyenne, 1 saut exécuté pour 7 instructions PC = PC+4 • Exercice: • on suppose pas d’aléas de donnée ou structurels • quel est l’impact des aléas de contrôle sur les performances ? chargement décodage / lecture registres exécution accès mémoire écriture registre

47. Quelles solutions ? • Branchement différé (MIPS, Sparc ) • le saut ne se fait pas tout de suite, mais avec un délai • exemple: le programme exécute I1, puis I2, puis I5 • permet d’enlever une bulle sur un saut • le compilateur doit trouver une instruction utile à mettre dans le délai du branchement (à défaut, mettre un NOP) • années 80, exécution des branchements au 3ème étage, aucune pénalité de saut grâce à cette technique • Prédiction de branchement • solution utilisée dans les processeurs d’usage général des années 90 • cf. plus loin dans le cours I1: jump @I5 I2: add r1,r1,1 I3: I4: I5:

48. Exemple: l’Ultrasparc-3 (2000) pred.PC charg. 1 charg. 2 decod. 1 decod. 2 dispatch Les loads 4/8 octets sont terminés à load 1, les loads 1/2 octets sont terminés à load 2. Pipeline « entier » lit int exec. load 1 load 2 commit écriture registre ou mémoire lit fp exec. 1 exec. 2 exec. 3 exec. 4 Pipeline « flottant »

49. Exercice • Sur l’Ultrasparc-3 • donner le nombre de bulles lorsque • une instruction de calcul entier dépend d’un load 4 ou 2 octets • 2 instructions de calcul flottant sont dépendantes • une instruction de calcul flottant dépend d’un load • l’étage vide en début du pipeline flottant vous paraît-il plutôt utile ou plutôt pénalisant ? • quel type de mécanisme peut-on imaginer pour résoudre le cas d’un load dépendant d’un store récent ?

50. Remarques • Optimiser le cas fréquent • les opérations très longues (ex. division) sont traitées « à coté » du pipeline, en dehors du chemin critique d’exécution • Certains processeurs découplent les pipelines entier et flottant • exemple: MIPS R8000 (1994) • les opérations de calcul flottant sont insérées dans une file d’attente et traitées séparément • avantage: les dépendances entres instructions de calcul flottant n’introduisent pas de bulles • inconvénient: pas d’interruption précise sur les instructions de calcul flottant • Les processeurs enfouis ont généralement un pipeline court (5-6 étages) alors que le pipeline d’un processeur à usage général peut faire entre 10 et 20 étages • pipeline long = haute fréquence et haute consommation électrique