Architectures des processeurs superscalaires, VLIW et optimisations

Architectures des processeurs superscalaires, VLIW et optimisations
ARPO Architectures des processeurs superscalaires, VLIW et optimisations

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

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

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

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

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

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

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

Accélération temps d’exécution 1 temps d’exécution 2
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

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 ?

Loi d’Amdahl

Il faut optimiser d’abord le cas le plus fréquent
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

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

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

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 MIPS pour 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

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

Il faut choisir les programmes de test appropriés au cas étudié ...
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é ...

É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 ...

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, ...

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

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

RISC contre CISC CISC RISC CISC décode
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

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 op déplacement 6 26 saut Format J

RISC : remarques Architecture 32 ou 64 bits ? Virgule flottante
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

É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

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

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

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

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

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)

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

décodage / lecture registres
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

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

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

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

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

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

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

Exercice load r2, 0(r1) ;a add r2, r2, 1 store r2, 0(r1) load r2, 4(r1) ;b 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

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

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

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

Dépendances WAW Solutions possibles ...
cycle de lancement cycle d’écriture Exemple de pipeline virgule flottante I1: fmul f1,f1,f1 I2: fadd f1,f2,f3 N N+5 N N+4 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

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

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: 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

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

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: I2: add r1,r1,1 I3: I4: I5:

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 »

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 ?

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

La mémoire Plus une mémoire est grande, plus son temps d’accès est long 3 types de mémoire banc de registres peu d’entrées, temps d’accès court (< 1 cycle), plusieurs ports mémoire dynamique (DRAM) mémorisation d’une charge sur une capacité, 1 transistor par bit grande densité d’intégration (16-64 Mbits) temps d’accès long: ns utilisé comme mémoire principale mémoire statique (SRAM) mémorisation par bouclage de 2 portes: 1-4 Mbits cher temps d’accès court: 5-10 ns

Latence mémoire La latence mémoire n’est pas seulement constituée par le temps d’accès DRAM translation d’adresse traverser les broches du processeur et le bus externe multiplexage si plusieurs bancs mémoires Latence mémoire principale: ns à 1 GHz, ça fait 100 à 200 cycles CPU problème !!

Les caches utiliser de la SRAM pour maintenir des copies des instructions et des données utilisées souvent si possible, intégrer cette mémoire cache sur le processeur latence moindre les données et instructions stockées dans le cache sont étiquetées avec leur adresse afin de pouvoir les identifier sans ambiguïté quand on veut charger une instruction ou une donnée, on regarde si elle se trouve dans le cache ou pas si oui (hit), latence mémoire = latence cache = 1 à 10 cycles si non, c’est un défaut de cache (miss), on va chercher la donnée en mémoire principale, et on la recopie dans le cache le cache est transparent à l’utilisateur, tout est automatique actuellement, cache de données et cache d’instructions distincts permet de lire dans le même cycle une donnée et une instruction

Les caches: pourquoi ca marche
Localité temporelle des données ou des instructions déjà accédées dans le passé sont souvent réutilisées dans un futur proche Localité spatiale des données ou des instructions qui sont à des adresses proches ont tendance à être accédées dans des temps rapprochés sur un défaut de cache, on ne chargera pas une seule donnée ou une seule instruction, mais un bloc de plusieurs instructions ou données bloc = ligne de cache taille d’une ligne de cache: octets

Exercice On suppose que le chargement d’instructions se fait en 1 cycle (pas de défauts de cache d’instructions) , qu’il n’y a pas d’aléas de contrôle, structurels, WAW ou load-use On suppose que lorsque la donnée se trouve dans le cache de données, un load / store passe un seul cycle dans l’étage d’accès mémoire Sur un défaut de cache, le pipeline est gelé en amont de l’étage d’accès mémoire en attendant que la donnée arrive PC = PC+4 chargement décodage / lecture registres exécution accès mémoire Environ 40% des instructions sont des load/store Quel est le débit en IPC du pipeline si un défaut de cache prend 50 cycles à se résoudre et si cela se produit sur 10% des load/store ? Quelle est la latence moyenne d’un load/store ? écriture registre

Caches: remarques Même un faible pourcentage de défauts de cache est pénalisant Gros travail d’optimisation à faire sur les caches La hiérarchie mémoire est constituée de plusieurs niveaux de cache sur les processeurs actuels caches primaires (L1) cache d’instructions et cache de données 8 à 64 Ko temps d’accès: 1-2 cycles cache secondaire (L2) unifié (instructions et données) si externe, 512 ko à 4 Mo de plus en plus, intégré sur le processeur (256 Ko on-chip) latence: 5-10 cycles (cache tertiaire: externe)

Caches: remarques Sur un défaut de cache primaire, on va chercher la ligne manquante dans le cache secondaire Si défaut de cache secondaire, on va chercher la ligne manquante en mémoire principale (ou dans le cache tertiaire s’il y en a un) La plus grande partie du budget en transistors des processeurs actuels est utilisée dans les caches Exemple: le PA-8500 d’HP (1999) 130 millions de transistors, 1.5 Mo de cache on-chip

Cache: principe de mise en œuvre
étiquette (tag) = identificateur de ligne Espace mémoire lignes de cache Load &A Si l’adresse de la ligne contenant A se trouve dans la table des étiquettes, la donnée est dans le cache A

Différents types de cache
Compromis entre la complexité du cache et sa capacité à retenir un maximum de lignes Cache à correspondance directe (direct-mapped) une ligne n’a qu’un seul emplacement possible dans le cache conflits entre différentes lignes Cache complètement associatif (fully-associative) une ligne peut être à n’importe quel emplacement dans le cache l’espace du cache est mieux utilisé Associatif par ensembles de N lignes (N-way set-associative) intermédiaire entre direct-mapped et fully-associative

Cache direct-mapped Exemple: cache de 4 Ko, lignes de 16 octets, adresses 32 bits 20 bits 8 bits 4 bits adresse d’accès étiquette (tag) index cache offset ligne 8 256 tags de 20 bits 256 lignes de cache de 16 octets 4 20 20 ligne =? Si tags égaux, la donnée est dans le cache. Sinon, défaut de cache.

Exercice On considère une architecture 64 bits (adresses sur 64 bits).
Soit un cache direct-mapped pouvant contenir 64 Ko de données, la taille de ligne étant de 32 octets. Combien de lignes contient le cache ? Quelle est la taille d’une étiquette en nombre de bits ? Si on compte la table des étiquettes, quelle est la quantité de mémoire réellement occupée par le cache ? Montrer que, lorsque deux adresses sont séparées par une distance inférieure à 64 Ko, elles ne sont pas en conflit dans le cache. La réciproque est-elle vraie ?

Cache direct-mapped 4 Ko, ligne 16 octets
Exercice Cache direct-mapped 4 Ko, ligne 16 octets Programme A Programme B #define _8k char a[_8k]; register int i,x = 0; for (i=0;i<_8k;i++) a[i] = a[i]+1; for (i=_8k-1;i>=0;i--) x=x+a[i]; #define _8k int a[_8k]; register int i,x = 0; for (i=0;i<_8k;i++) a[i] = a[i]+1; for (i=_8k-1;i>=0;i--) x=x+a[i]; Combien de défauts de cache sont générés sur la deuxième boucle du programme A ? Même question sur le programme B

Exercice Soit un cache direct-mapped de N octets avec des lignes de L octets Quelle est la probabilité (fonction de N et L) pour que deux adresses aléatoires soient en conflit dans le cache ? Quelle conclusion en tirez-vous ? Soit deux tableaux de K octets chacun, commençant aux adresses respectives A et B (les données d’un tableau sont rangées à des adresses contiguës en mémoire). On suppose que les adresses A et B sont alignées sur des frontières de ligne et que chaque tableau fait un nombre entier de lignes. Quelle est la probabilité pour que ces deux tableaux soient en conflit dans le cache ?

Cache N-way set-associatif
Exemple: cache 2-way SA de 4 Ko, lignes de 16 octets, adresses 32 bits 21 bits 7 bits 4 bits étiquette (tag) index cache offset ligne banc 0 banc 1 banc 0 banc 1 128 tags 21 bits 128 tags 21 bits 128 lignes de 16 octets 128 lignes de 16 octets =? =? Sélectionner la bonne ligne La ligne est-elle présente ? ou

Cache N-way SA Chaque ensemble est composé de N lignes réparties sur N bancs et ayant le même index de cache Temps d’accès plus élevé qu’un cache direct-mapped pour accéder à la donnée, on doit avoir lu les tags et effectué la comparaison Si le nombre de bancs d’un cache SA est égal au nombre total de lignes dans le cache, on obtient un cache FA Politique de remplacement: en cas de défaut de cache, on a le choix entre N emplacements pour stocker la nouvelle ligne random remplacer une ligne au hasard parmi les N LRU (least recently used) remplacer la ligne la moins récemment utilisée meilleur que random

LRU: exemple Cache 4-way set-associatif
Supposons que les lignes A,B,C,D,E aient le même index cache Ligne accédée Cache avant Hit / miss ? Ligne évincée Cache après A DBCA hit ADBC B ADBC hit BADC C BADC hit CBAD D CBAD hit DCBA E DCBA miss A EDCB A EDCB miss B AEDC E AEDC hit EADC B EADC miss C BEAD

Mise en œuvre matérielle du LRU
Cache 2-way SA associer un bit B à chaque ensemble ce bit contient le numéro du dernier banc accédé (0 ou 1) dans l’ensemble considéré quand on doit évincer une ligne, choisir le banc NON(B) Cache N-way SA associer une matrice de bits A[i,j] à chaque ensemble du cache A[i,j]=1 signifie que le banc i a été accédé plus récemment que le banc j dans l’ensemble considéré comme A[i,j] = NON(A[j,i]), prendre la partie triangulaire sans la diagonale N(N-1)/2 bits lorsque le banc k est accédé, mettre la ligne k à 1 et la colonne k à 0 le banc le moins récemment accédé est celui dont la ligne ne contient que des 0 et la colonne que des 1 bonne approximation du LRU: utiliser une structure en arbre exemple 4-way : 3 bits (1 pour chaque paire de bancs + 1 global)

Distance de réutilisation: définition
D’un point de vue algorithmique, on peut maintenir l’ordre LRU par une liste chaînée chaque ligne accédée est placée en tête de liste la ligne en queue de liste est la moins récemment utilisée plusieurs listes chaînées les lignes qui ont le même index cache sont dans la même liste si cache FA, une seule liste globale Distance de réutilisation D d’une ligne = distance par rapport à la tête de liste D=0 pour la ligne en tête de liste D peut être globale (une seule liste) ou locale (plusieurs listes) Sur un cache N-way SA LRU, si D < N c’est un hit, sinon c’est un miss

Distance de réutilisation: utilité
La distance de réutilisation globale d’une ligne donne une idée de sa localité temporelle Sur un cache FA LRU comportant N lignes si D < N c’est un hit, sinon c’est un miss Sur un cache direct-mapped comportant N lignes soit une ligne A et soit D sa distance de réutilisation globale D lignes distinctes ont été accédées depuis la dernière utilisation si on néglige la localité spatiale, la probabilité que ces D lignes aient toutes un index différent de A vaut la probabilité d’avoir un miss sur A vaut La probabilité de miss augmente avec la distance de réutilisation

Exercice: multiplication de matrices
register int i, j, k ; for (i= 0; i < N; i++) for (j= 0; j < N; j++) for (k= 0; k < N; k++) C[i][j] + = A[i][k] * B[k][j] ; 1 for (jj= 0; jj < N; jj=jj+N/2) for (i= 0; i < N; i++) for (j= jj; j < jj+N/2; j++) for (k= 0; k < N; k++) C[i][j] + = A[i][k] * B[k][j] ; 3 Combien de fois utilise-t-on un même élément de A, B et C ? On suppose 1 ligne = 1 donnée. Quelle est la distance de réutilisation globale d’un élément de A, B et C sur chacun des 3 programmes ? Conclusion ? On suppose 1 ligne = plusieurs données. Entre les programmes 1 et 2, lequel des deux est à votre avis le plus performant ? on supposera &(X[i][j]) = &X + i N + j for (i= 0; i < N; i++) for (k= 0; k < N; k++) for (j= 0; j < N; j++) C[i][j] + = A[i][k] * B[k][j] ; 2

Direct-mapped / set-associatif
accès rapide on n’a pas besoin d’attendre la lecture des tags et la comparaison pour savoir ou se trouve la donnée Set-associatif en général, 2-way ou 4-way le temps d’accès augmente avec l’associativité moins de cache miss règle empirique: un cache 2-way SA de taille N a grosso-modo le même taux de miss qu’un cache DM de taille 2N

La bande passante Bande passante = débit maximum de transit des données sur le bus entre deux niveaux de cache ou vers la mémoire Bande passante limitée par la fréquence et la largeur du bus exemple: bus 128 bits 500 MHz, bande passante maximale = 8 Giga-octets par seconde Une bande passante trop petite augmente la latence apparente des accès mémoire La localité spatiale permet de bien utiliser la bande passante disponible

Exemple Soit un tableau de N entiers accédé pour la première fois. On suppose que les accès se font dans l’ordre 1,2,3,4,5, ... Les lignes font 64 octets et la bande passante du bus est de 8 octets par cycle. La latence mémoire est de 10 cycles. Fréquence des miss: 1 miss pour 16 accès Latence moyenne d’un load = (15*1 + 1*10)/16 = 1.56 cycles ? FAUX ! Un miss ne met pas 10 cycles à se résoudre, mais /8 = 17 cycles Latence moyenne d’un load = (15*1+1*17)/16 = 2 cycles Et si on prend des lignes plus petites, par ex. 16 octets ? Fréquence des miss: 1 miss pour 4 accès. Temps de résolution d’un miss = /8 = 11 cycles Latence moyenne d’un load = (3*1+1*11)/4 = 3.5 cycles

Quelle taille de ligne ? Petites lignes ? Grandes lignes ? Compromis
on ne charge sur le bus et dans le cache que des données utiles la place occupée par les tags augmente Grandes lignes ? bonne localité spatiale ? effet de préchargement bénéfique on peut avoir un bus plus large localité spatiale médiocre ? espace du cache mal utilisé (beaucoup de « trous » dans les lignes) risque de conflits entre lignes bande passante gaspillée Compromis taille de ligne typique: 64 octets

Les écritures dans le cache
Les écritures posent moins un problème de latence que de bande passante le problème de latence est résolu avec un tampon d’écritures en attente les écritures peuvent se faire lorsque la bande passante n’est pas utilisée par les lectures ou lorsque le tampon est plein Cache write-through lorsqu’une donnée est écrite dans le cache, elle est écrite en même temps dans le niveau de cache suivant ou en mémoire principale si le niveau de cache suivant est write-through, on propage l’écriture de la même façon en cas de miss sur écriture, on se contente généralement de ne faire l’écriture qu’en mémoire, on ne va pas chercher la ligne manquante facilite le maintient de la cohérence mémoire sur machine multi-processeur Cache write-back les écritures se font uniquement dans le cache. Lorsqu’une ligne est évincée du cache et qu’elle a été modifiée, elle est recopiée automatiquement en mémoire write-allocate: en cas de miss sur écriture, on va chercher la ligne manquante meilleur utilisation de la bande passante et débit d’écriture moindre

Mémoire virtuelle Les adresses logiques (ou virtuelles, c.a.d celles vues par le logiciel) ne sont pas forcément celles qui sont utilisées par le matériel pour adresser la DRAM (adresses physiques) avantage: permet de « voir » un espace d’adressage plus grand que celui offert par la quantité de DRAM disponible (et le nombre de broches) On utilise un mécanisme de translation d’adresse pour convertir les adresses logiques en adresses physiques en général, combinaison de techniques matérielles et logicielles l’unité de mémoire sur laquelle on travaille = page mémoire mécanisme de pagination les pages qu’on ne peut pas stocker en DRAM sont stockées sur disque on utilise une table des pages pour faire la translation page logique / physique pour accéder à une page qui se trouve sur disque, on la recopie en DRAM et on met à jour la table des pages

Pagination Taille de page typique: 4 Ko
Table des page indexée avec le numéro de page logique, fournit un numéro de page physique La table des pages est stockée en DRAM, dans une zone ne nécessitant pas de translation exemple: espace logique sur 32 bits, pages 4 Ko (12 bits d’offset), soit 220 pages logiques Si on devait consulter la table des pages pour chaque accès mémoire, le temps de translation serait beaucoup trop long On utilise un TLB (translation look-aside buffer) TLB = cache de translation d’adresse intégré sur le processeur contient un sous-ensemble de la table des pages typique: 64/128 entrées, full-associative

TLB Exemple: adresses logiques 32 bits, pages de 4 Ko, TLB 64 entrées
adresse logique numéro de page logique offset page 64 tags = numéros de page logique TLB 64 numéros de pages physiques + qq bits de statut 12 bits adresse physique numéro de page physique offset page

Défauts de TLB Sur un défaut de TLB, une exception est générée
le système consulte la table des pages en DRAM si la page est présente en DRAM, le système met le TLB à jour puis rend la main au programme latence: quelques dizaines à quelques centaines de cycles si la page n’est pas présente c’est un défaut de page latence: centaines de milliers de cycles (accès disque)

Mémoire virtuelle et caches
Stocke-t-on dans le cache des adresses logiques ou physiques ? Adresse logique problème des synonymes sur les pages accessibles en écriture des pages logiques distinctes projetées sur la même page physique plusieurs copies de la même données dans le cache Adresse physique il faut accéder au TLB avant d’accéder au cache, ça augmente le temps d’accès En général cache L1 données: index logique/tag physique cache L1 instructions: adresses logiques ou index logique/tag physique cache L2: adresses physiques

Index logique / tags physiques
Si la somme du nombre de bits d’index cache et du nombre de bits d’offset ligne ne dépasse pas le nombre de bits d’offset page, l’index de l’adresse physique est égal à l’index de l’adresse logique on peut commencer à indexer le cache avec l’adresse logique, sans attendre que l’accès TLB soit terminé l’accès TLB se fait en parallèle avec l’indexage du cache, il ne coûte rien la comparaison sur les tags s’effectue avec l’adresse physique Si les pages sont trop petites, on peut augmenter l’associativité du cache pour réduire le nombre de bits d’index imposer au système de ne pas altérer les bits « qui dépassent » lors de la translation d’adresse

En résumé ... Les caches permettent de masquer la latence d’accès à la mémoire principale lorsque la localité des références est bonne, la majorité des load et des store s’exécutent en 1 ou 2 cycles Un cache permet de filtrer les requêtes vers les niveaux de cache suivant: on économise de la bande passante si on a un bus mémoire avec une faible bande passante, on a intérêt à avoir un gros cache Technique complémentaire: le préchargement préchargement matériel exemple: sur un cache miss, charger la ligne manquante dans le cache et charger les lignes suivantes dans un tampon de préchargement d’accès rapide fonctionne bien pour les instructions et les accès aux tableaux préchargement logiciel: instructions fetch (plupart des ISA RISC) il faut de la bande passante !

Que peut faire le compilateur ?
Améliorer la localité temporelle réarranger les boucles exemple: multiplication de matrice Améliorer la localité spatiale: bien utiliser les lignes de cache lire les tableaux 2D dans le bon sens éviter de faire des accès par pas supérieur à 1 Utiliser les registres chaque fois que c’est possible Préchargement logiciel

Le problème des sauts IPC = inst / cycle
En moyenne, un saut se produit toutes les 7 instructions Pipeline de plus en plus long: actuellement > 10 étages (Intel P6, Ultrasparc 3, AMD Athlon …), bientôt ~20 étages (Intel Pentium 4) N= étage auquel les sauts sont exécutés IPC = inst / cycle

La prédiction de branchements
Années 80 Années 90 PC = PC+4 prédiction PC chargement chargement correction si mal prédit saut décodage décodage exécution exécution accès cache accès cache écriture registre écriture registre Branchements prédits non pris On essaie de prédire les sauts

Prédiction de branchement: principes
Il faut minimiser le nombre de mauvaises prédictions sur un branchement mal prédit, on retrouve le problème des aléas de contrôle (bulles) Utiliser le comportement passé des branchements la majorité du temps d’exécution est passé dans des boucles: lorsqu’on rencontre un branchement, on a de bonnes chances de l’avoir déjà rencontré dans le passé le comportement des branchements n’est pas aléatoire, il est biaisé: on peut prédire le comportement futur du branchement en regardant son comportement passé Stocker l’information sur le comportement passé de chaque branchement dans une table de prédictions table d’accès rapide indexé avec le PC du branchement premier étage du pipeline

Types de branchements Branchement inconditionnel
le saut est systématique saut relatif adresse de saut statique, connue à la compilation exemple: PC du branchement + offset immédiat saut indirect adresse de saut dynamique, lue dans un registre retours de fonction, appels de fonctions, switch case, pointeurs de fonctions … Branchement conditionnel dépend de l’évaluation d’une condition: le branchement peut être pris (on saute) ou non pris (on passe à l’instruction suivante) comparaison entre 2 registres ou comparaison d’un registre avec 0 en général, adresse de saut statique boucles, if…then…else, switch case, ...

Quelques statistiques ...
En moyenne 1 instruction sur 5 est un branchement (conditionnel ou inconditionnel) les blocs de base sont petits (certains font 1 ou 2 instructions) il est souhaitable de pouvoir prédire un branchement par cycle 75 % des branchements sont conditionnels il est important de bien prédire les branchements conditionnels 40 % des branchements conditionnels sont non pris prédire toujours non pris % de mauvaises prédictions 10 % des branchements sont des retours de fonction 0 à 10 % des branchements sont des appels de fonction indirects plus nombreux dans les codes orientés objet Restant = branchements inconditionnels relatifs

Les branchements dans le pipeline
Branchement identifié prédiction Adresse de saut relatif chargement décodage Branchement conditionnel exécuté Saut indirect exécuté exécution accès cache écriture registre

Les étapes de la prédiction
Prédire qu’à l’adresse indiquée par le compteur de programme se trouve une instruction de branchement Identifier le branchement branchement conditionnel ou inconditionnel ? appel de fonction ? retour de fonction ? Prédire l’adresse de saut Pour les branchements conditionnels, prédire si le branchement est pris (1) ou non pris (0) En cas de mauvaise prédiction, profiter du temps de réparation du pipeline pour corriger la table de prédiction

Table de prédictions PC suivant prédiction PC courant chargement
Est-ce un branchement ? Si oui : info table= (type, 0/1,adresse saut) PC <== F (PC, info table) Si non : PC <== PC + 4 PC suivant prédiction PC courant chargement décodage Mise à jour si mauvaise prédiction exécution accès cache écriture registre

ou BTB (Branch Target Buffer)
Cache de branchements ou BTB (Branch Target Buffer) étiquettes cibles PC = ? Un branchement est détecté, il est prédit pris adresse de saut

Utilisation du BTB On stocke dans le BTB les sauts inconditionnels et les branchements pris La présence d’une entrée dans le BTB entraîne un saut à l’adresse indiquée par le BTB En l’absence d’une entrée BTB, on suppose que l’instruction n’est pas un branchement ou est un branchement non pris En cas de mauvaise prédiction, corriger le BTB si on a « manqué » un saut, rajouter l’entrée manquante si on a prédit un branchement pris alors qu’en réalité il est non pris, enlever l’entrée du BTB si on a sauté à une mauvaise adresse, corriger l’adresse de saut dans le BTB

BTB: remarques Aussi appelé BTAC (branch target address cache)
Utilisé sur les processeurs Intel P6, AMD Athlon, IBM Power3, HP PA Taille: entrées Associativité: 2/4 Prédiction comme la dernière fois ( = on prédit le même comportement que la dernière fois) fonctionne bien pour les inconditionnels relatifs le comportement est toujours le même pas optimal pour les branchements conditionnels et les retours de fonction le comportement n’est pas toujours le même 20 % de mauvaises prédictions sur les conditionnels

Prédiction comme la dernière fois
direction effective prédiction 1 for (i=0;i<1000;i++) { for (j=0;j<4;j++) { : corps de la boucle } 1 1 1 1 mal prédit 1 mal prédit 1 1 1 1 1 mal prédit 1 mal prédit 1 Branchement mal prédit à la première et à la dernière itération

Exercice On considère un branchement conditionnel ayant une probabilité p d’être pris. En prédisant comme la dernière fois, quel taux de mauvaises prédictions obtient-on sur ce branchement ? Quel taux de mauvaises prédictions obtiendrait-on si on prédisait ce branchement toujours pris ? Est-ce mieux que comme la dernière fois ?

Le compteur 2 bits 3 2 1 1 1 1 1 prédit 1 prédit 0 4 états 2 bits
4 états bits la prédiction est obtenue en lisant le bit de poids fort du compteur il faut 2 mauvaises prédictions consécutives pour changer la prédiction en partant d’un état « fort » (0 ou 3)

Efficacité du compteur 2 bits
for (i=0;i<1000;i++) { for (j=0;j<4;j++) { : corps de la boucle } Branchement mal prédit à la dernière itération seulement Le compteur 2 bits divise par 2 le nombre de mauvaises prédictions sur les branchements conditionnels 10 % de mauvaises prédictions sur les conditionnels

Compteur 2 bits : mise en œuvre
Première possibilité : rajouter un compteur 2 bits dans chaque entrée du BTB on bénéficie de l’associativité du BTB si un branchement est prédit pris mais qu’en réalité il est non pris, on décrémente le compteur et on laisse l’entrée dans le BTB Deuxième possibilité : stocker les compteurs 2 bits dans une table spécifique, la BHT (branch history table) MIPS R10000, IBM Power3, PowerPC, AMD Athlon, HP PA-8500 pas de tags, juste 2 bits dans chaque entrée la BHT peut comporter plus d’entrées que le BTB taille: 256 à 2k entrées quand le compteur passe de l’état 2 à l’état 1, l’entrée dans le BTB n’est plus nécessaire

PC du branchement conditionnel
BHT PC du branchement conditionnel poids forts poids faibles n bits BHT 2n compteurs 2 bits Rem: comme il n’y a pas de tags, on ne peut pas avoir d’associativité. Interférences entre branchements. Problème analogue aux conflits dans un cache direct mapped. Le bit de poids fort du compteur donne la prédiction

Prédire les retours de fonction
Utiliser une pile d’adresses de retour pour chaque call exécuté, on empile l’adresse de retour pour prédire un retour, au lieu d’utiliser l’adresse fournie par le BTB, dépiler l’adresse au sommet de la pile et sauter à cette adresse Peut être utilisé aussi pour prédire les retours d’interruptions et d’exceptions Si pile suffisamment profonde, 100 % de bonnes prédictions UltraSparc-3 (8 entrées), AMD Athlon (12 entr.), Alpha (32 entr.) ne pas abuser de la récursivité Principale « difficulté »: identifier les appels et les retours utiliser le code-op (ex. appel = saut avec lien) le compilateur peut aider le processeur exemple: hint (Alpha), jr $31 (MIPS) ...

BTB / BHT Processeurs ayant à la fois un BTB et une BHT
le BTB permet d’identifier les branchements avant décodage (conditionnel/inconditionnel/appel/retour) et fournit l’adresse de saut (sauf pour les retours) la BHT prédit la direction des conditionnels Processeurs ayant une BHT mais pas de BTB la prédiction se fait à l’étage de décodage si prédit non pris, pas de pénalité exemple MIPS R10000 : 1 bulle sur chaque branchement pris pas viable sur les processeurs CISC (décodage tardif dans le pipeline)

Mauvaises prédictions: 10 % c’est trop
Les processeurs actuels sont superscalaires chaque étage du pipeline peut traiter plusieurs instructions simultanément Le pipeline d’instructions est long Exemple 4 instructions par cycles IPCidéal = 4 7 cycles de pénalité si branchement mal prédit 1 conditionnel pour ~ 6.5 instructions, soit 65 instructions par mauvaise prédiction IPCmaxi = 65 / (65/4 + 7) = 2.8 On sait faire mieux: la prédiction à 2 niveaux d’historique

Remarque: si on permute B1 et B2, c’est moins bien ...
Inter-corrélations cond1 cond2 cond1 ET cond2 B1: SI cond1 ET cond2 … B2: SI cond1 … F V F V F V Supposons les 4 cas équiprobables. La probabilité de bien prédire B2 en se basant sur son comportement passé vaut 50 % Supposons maintenant qu’on connaisse le résultat de B1 au moment de prédire B2 Si cond1 ET cond2 vrai (probabilité 1/4), prédire cond1 vrai % de succès Si cond1 ET cond2 faux (probabilité 3/4), prédire cond1 faux % de succès On peut prédire B2 avec un taux de succès de 1/4 + 3/4 * 2/3 = 75 % Remarque: si on permute B1 et B2, c’est moins bien ...

Auto-corrélation for (i=0; i<100; i++) for (j=0;j<4;j++)
for (i=0; i<100; i++) for (j=0;j<4;j++) : corps de la boucle 1 Si les 3 dernières directions sont des 1, prédire 0, sinon prédire 1 1 100 % de succès

Prédicteur à 2 niveaux d’historique
Premier niveau d’historique historique global pour détecter les inter-corrélations un seul registre à décalage de L bits contient les directions prises par les L derniers branchements rencontrés historique local pour détecter les auto-corrélations un registre à décalage de L bits pour chaque branchement contient les L dernières directions prises par ce branchement prédit bien les boucles faisant au plus L itérations Deuxième niveau d’historique chaque branchement utilise plusieurs compteurs 2 bits, stockés dans une PHT (pattern history table) utiliser la valeur d’historique local ou global pour sélectionner le compteur dans la PHT

Prédicteur à historique global
n bits PC du branchement conditionnel Appliquer une fonction de hachage entre l’adresse et l’historique (par ex. OU exclusif bit à bit) xor histo L bits Prédiction insérée dans l’historique pour prédire le branchement suivant PHT 2n compteurs 2 bits prédiction 0/1

Prédicteur à historique local
m bits PC du branchement conditionnel 2m historiques locaux de L bits histo L bits NB: temps d’accès plus long (2 accès chaînés) PHT 2n compteurs 2 bits Prédiction 0/1

Remarques Si l’historique est de longueur nulle, la PHT est une BHT
Longueur d’historique un historique long permet de capter plus de corrélation, mais ça augmente les interférences entre branchements et le temps de « chauffe » après un changement de contexte entre 4 et 16 bits Exemples de processeurs: Intel P6 512 historiques locaux de 4 bits (en fait, dans le BTB) PHT de 8k compteurs 2 bits UltraSparc-3 un historique global de 12 bits PHT de 16k compteurs 2 bits

Hors contraintes matérielles ...
Les prédicteurs à deux niveaux permettent de diviser par 2-3 le nombre de mauvaises prédictions typique: 5 % de mauvaises prédictions voire moins sur les codes « flottants » Historique global efficace sur les codes « entiers » Historique local plus efficace sur les codes « flottants » beaucoup de boucles, comportement régulier

En pratique ... Beaucoup d’interférences de conflits dans la PHT
« paradoxe » de l’anniversaire: soit une classe de 23 élèves, la probabilité d’avoir 2 élèves qui fêtent leur anniversaire le même jour est de 50 % l’espace de la PHT est très mal utilisé Quelle longueur d’historique ? sur les « grosses » applications, trop d’interférences de capacité, on préfère un historique court (voire une BHT) sur les « petites » applications, on préfère un historique long Historique local ou historique global ? ça dépend de l’application

Prédicteurs hybrides : principe
Quelles étaient les prédictions correctes ? Méta-prédicteur Prédicteur 1 PC du branchement Prédicteur 2 Prédiction • • • Prédicteur N

Un hybride intéressant
historique global adresse mp mp mp mp bp bp bp bp PHT PHT BHT BHT XOR bp bp bp bp mp mp mp mp PHT BHT méta Quand les prédictions sont toutes les deux bonnes ou toutes les deux fausses, la méta-prédiction ne change pas prédiction

Avantages Quand l’application est « grosse » , la BHT subit moins d’interférences que la PHT On peut se permettre de prendre un historique long Conflits évités grâce au méta-prédicteur La BHT se réchauffe plus vite sur un changement de contexte

Le prédicteur de l’Alpha 21264
PC du branchement historique global 12 bits 1k historiques locaux de 10 bits PHT 1k compteurs 3 bits PHT 4k compteurs 2 bits Méta 4k compteurs 2 bits total: 29 Kbits prédiction

Que peut faire le compilateur ?
Rendre les branchements plus faciles à prédire Exploiter les corrélations Exécution conditionnelle : transformer les dépendances de contrôle en dépendances de donnée move conditionnel prédication Utiliser des hints = information passée dans le code de l’instruction

Exécution conditionnelle
if (x<y) { a++; } code initial, avec un branchement move conditionnel prédication saute à SUITE si (r1 >= r2) r4 = mem(a) r4 = r4 + 1 mem(a) = r4 SUITE: r3 = r1 - r2 r4 = mem(a) r5 = r4+1 r4 = r5 si (r3<0) mem(a)=r4 r3 = r1 - r2 p1 = (r3<0) r4 = mem(a) si p1 r4 = r4+1 si p1 mem(a)=r4 si p1 prédication sans supports ? Attention au surcoût en instructions a = a + (((x - y)>>31)&1) ;

Utilisation du hint Le compilateur génère une prédiction statique pour chaque branchement problème 1 : fiabilité le biais de certains branchements dépend des données en entrée si on se trompe sur le biais, ~ 100 % de mauvaises prédictions problème 2 : branchements qui changent de biais en cours d’exécution Autre utilisation méta-prédiction transformer les interférences destructives en interférences neutres

Interférences destructives / neutres
branchement A Branchements de biais opposés interférence destructive branchement B Génère des mauvaises prédictions branchement A Branchements de même biais interférence neutre branchement B

Le agree-predictor Si la probabilité d’avoir un biais pris vaut p, la probabilité d’avoir une interférence destructive vaut pd= 2p(1-p) problème: p est généralement proche de 50 % pd = 50 % Agree-predictor: transformer les interférences destructives en interférences neutres le compilateur fait des prédictions statiques via le hint le processeur dispose d’une BHT ou d’une PHT au lieu de prédire la direction des branchements, la BHT prédit si la direction est conforme ou pas à la prédiction statique même si la prédiction statique est fausse à 100 %, on sait prédire si la prédiction statique est correcte à 90 %, pd =20 % si la prédiction statique est fausse à 50 %, ce n’est pas pire que sans le hint Utilisé sur le processeur HP PA-8500

En résumé ... Le prédicteur de branchement donne souvent des prédictions correctes à plus de 90 % instructions entre 2 mauvaises prédictions Compilateur petites boucles ? ça dépend du type de prédicteur prédicteur à 2 niveaux d’historiques ? local ou global ? quelle longueur ? la prédication peut enlever les branchements difficiles à prédire, mais attention au surcoût en instructions Exercice. Un branchement est mal prédit à 40 %. Chaque mauvaise prédiction coûte 5 cycles. On décide d’enlever le branchement par prédication. Le surcoût en instructions entraîne une pénalité de P cycles. Question: quelle est la valeur maximum de P pour que la transformation soit intéressante ?

Processeurs superscalaires
Accélérer l’exécution en exécutant plusieurs instructions par cycle exploiter le parallélisme d’instructions existant de manière « naturelle » dans la plupart des codes séquentiels 1990: IBM POWER1 jusqu’à 4 instructions exécutées simultanément 2000: tous les processeurs utilisés dans les PC et stations de travail sont superscalaires

« Loi » de Moore Le nombre de transistors sur un micro-processeur double tous les 18 mois 1972: 2000 transistors (Intel 4004) 1979: transistors (Intel 8086) 1989: 1 M transistors (Intel 80486) 1999: 130 M transistors (HP PA-8500)

Utilisation des transistors: évolution
8 => 16 => 32 bits calcul flottant 32 => 64 bits multimédia RISC années 70 années 80 années 90 Étoffer l’ISA pour diminuer le nombre d’instructions exécutées + + + + + de mémoire on-chip (cache,registres) pour diminuer les accès externes + + + + ++ Exécution superscalaire + +

Le plus simple: in-order degré 2
Doubler la largeur du pipeline chargement: charger 2 instructions (PC=PC+8) décodage: décoder 2 instructions (il faut 2 décodeurs) lecture registres: 4 ports de lectures exécution: dupliquer l’ALU cache: 2 ports de lectures, 2 ports d’écritures rem: idem pour le TLB données écriture registre: 2 ports d’écriture Exemples: Intel P5, Alpha 21064

Dépendance RAW: scinder le groupe
Si A et B sont chargées ensemble, et si, au décodage, on trouve que B dépend de A, on retarde le lancement de B et on « gèle » les étages avant décodage Supposons une probabilité p =1/2 qu’une instruction dépende de l’instruction précédente cycle n cycle n+1 cycle n+2 Chargement C D C D E F Décodage A B B C D En moyenne, (1+p) cycles par groupe de 2 instructions Exécution A B Accès cache A IPCmaxi = 2 / (1+p) = 1.33 Écriture registre cache miss, load-use, branchements mal prédits, etc... !

Décaler les groupements
Si B dépend de A, et si C ne dépend pas de B, lancer B et C ensemble Supposons une probabilité p =1/2 qu’une instruction dépende de l’instruction précédente cycle n cycle n+1 cycle n+2 Chargement C D D E F Décodage A B B C D E La probabilité de lancer 2 instructions dans un cycle vaut (1- p) Exécution A B C Accès cache A Écriture registre IPCmaxi = p + 2 (1- p) = 1.5

Utiliser un tampon de chargement
a--A b B--c C d D e E chargement b B c C d D e E B C d D décodage a A b A c B c C d D exécution a b A B c C cache a b A B écriture a b A

In-order degré 2 en pratique ...
Dupliquer le décodeur et les ports registres La deuxième ALU n’a pas besoin d’être complète pas besoin d’un 2ème décaleur ni d’un 2ème multiplieur Un seul port sur le cache de données 2 ports seraient mieux (40 % des inst. sont des load/store), mais cela augmente la complexité du cache En cas de conflit sur le port du cache ou sur un opérateur, le lancement de la 2ème instruction est différé d’un cycle On peut charger plus de 2 instructions par cycle (agrandir le tampon de chargement) permet d’amortir les BTB miss ou les miss du cache d’instruction Le compilateur doit essayer de maximiser le parallélisme si 2 instructions consécutives sont dépendantes ou ont un conflit de ressource, essayer d’intercaler une instructions indépendante

In-order de degré 4 Exemple: alpha 21164, UltraSparc-3
Degré = largeur de décodage = 4 instructions Registres: 8 ports lecture, 4 ports écriture Typique: 2 ALU, 1 unité de branchement, 1 ou 2 unités load/store, 1 FP add, 1 FP mul 1 ou 2 ports sur le cache de données L1 sur l’Alpha 21164, double-port obtenu en dupliquant le cache L1 (rem: les écritures doivent être faites dans les 2 copies) Gros travail du compilateur dépendances RAW, dont load-use conflits de ressources En pratique, IPC < 2

Processeur out-of-order (OOO)
Les instructions sont toujours chargées et décodées dans l’ordre séquentiel, mais peuvent être lancées dans le désordre sur les unités d’exécution instructions A, B, C: si B dépend de A et si est C indépendant de A et B, lancer A et C ensemble Découpler le décodage et le lancement via un tampon = fenêtre d’instructions après décodage, les instructions sont mises en attente d’exécution dans la fenêtre d’instructions à chaque cycle, on regarde dans la fenêtre d’instructions quelles sont les instructions prêtes à être lancées

Graphe data-flow On peut former un graphe data-flow à partir des instructions dans la fenêtre du processeur chaque instruction dans la fenêtre est un nœud du graphe 2 instructions sont reliées s’il y a une dépendance « vraie » entre elles l’une utilise le résultat de l’autre Une instruction peut s’exécuter dès que les instructions dont elle dépend ont été exécutées Chemin critique = plus longue chaîne de dépendances de données détermine le temps d’exécution minimum

Exemple Débit maxi = 1 itération / cycle I5 for (i=0;i<10000;i++) {
c[i] = a[i]+b[i]; } I6 La boucle est « déroulée » dans la fenêtre d’instructions I1 I2 I3 début: I1: r5 = mem(r2+r1) I2: r6 = mem(r3+r1) I3: r5 = r5 + r6 I4: mem(r4+r1) = r5 I5: r1 = r1 - 8 I6: saute à début si r1>=0 I5 I4 I6 Chemin critique I1 I2 I3 Débit maxi = 1 itération / cycle I4

Renommage de registres (1)
Permet au processeur de se construire une représentation du graphe data-flow Registre logique / registre physique registre logique = celui manipulé par le programmeur registre physique = l’endroit dans le processeur où la valeur est physiquement stockée Renommage de registre : chaque instruction dans la fenêtre écrit dans un registre physique distinct Plusieurs instructions dans la fenêtre d’instructions peuvent écrire dans le même registre logique, mais elles écrivent dans des registres physiques distincts Plus de problèmes de dépendances WAR et WAW, on ne conserve que les dépendances « vraies » (RAW)

Renommage: exemple I1: p10 = mem(p2+p1) I2: p11 = mem(p3+p1) I3: p12 = p10 + p11 I4: mem(p4+p1) = p12 I5: p13 = p1 - 8 I6: saute à boucle si p13>=0 début: I1: r5 = mem(r2+r1) I2: r6 = mem(r3+r1) I3: r5 = r5 + r6 I4: mem(r4+r1) = r5 I5: r1 = r1 - 8 I6: saute à début si r1>=0 Boucle «déroulée» dans la fenêtre d’instructions I1: p14 = mem(p2+p13) I2: p15 = mem(p3+p13) I3: p16 = p14 + p15 I4: mem(p4+p13) = p16 I5: p17 = p13 - 8 I6: saute à début si p17>=0 Chaque instruction de la fenêtre écrit dans un registre physique distinct. . . .

Renommage de registres (2)
Une fois les instructions renommées, on peut les exécuter dans le désordre attention aux load/store cependant (cf. plus loin dans le cours) Utiliser une table de renommage, consultée et mise à jour au décodage maintient la correspondance entre registres logiques et physiques pour les opérandes: on présente devant la table les numéros de registres logiques, et elle renvoie les numéros de registres physiques correspondant la table est mise à jour sur chaque instruction écrivant dans un registre on affecte un registre physique libre au registre logique destination de l’instruction en cas de branchement mal prédit ou d’exception, on répare la table de renommage

Mise en œuvre OOO Des structures « invisibles » Questions à préciser
reorder buffer (tampon de réordonnancement) table de renommage points de reprise scoreboard tampon d’amorçage Questions à préciser comment réparer l’état du processeur en cas de branchement mal prédit ou d’exception ? quand un registre physique devient-il libre ? Comment savoir quand une instruction est prête à être lancée ? comment traiter le cas des load/store ?

Exécution spéculative
Branchements mal prédits un ou plusieurs branchements peuvent être en attente d’exécution dans la fenêtre une instruction peut s’exécuter avant un branchement antérieur: elle s’exécute spéculativement si le branchement est mal prédit, c’est une mauvaise spéculation Exceptions tant qu’une instruction susceptible de générer une exception est en attente d’exécution, les instructions plus récentes s’exécutent spéculativement si une exception se produit, c’est une mauvaise spéculation Sur une mauvaise spéculation, il faut annuler les instructions qui se sont exécutées spéculativement

Reorder buffer (ROB) Reorder buffer = tampon matérialisant la fenêtre d’instructions peut être mis en œuvre comme une file circulaire Le ROB maintient l’ordre des instructions vue de l’extérieur du processeur, l’exécution doit paraître séquentielle Les instructions sont insérées dans le ROB au décodage, dans l’ordre séquentiel, et sont retirées du ROB après l’exécution, dans l’ordre séquentiel à la fin du pipeline, il y a un (ou plusieurs) étage de retirement pour traiter ce qui doit être fait dans l’ordre et/ou non spéculativement détection des exceptions écritures mémoire accès en mémoire non-cachables (E/S) pour pouvoir être retirée, une instruction doit attendre que toutes les instructions plus anciennes qu’elle soient exécutées et retirées

Exemple de pipeline OOO
prédiction On identifie la location physique des opérandes, et on affecte un registre physique libre à l’instruction chargement En cas de branchement mal prédit, vider la fenêtre d’instructions décodage / renommage dispatch Instruction insérée dans le ROB lecture registres Attente si opérandes ou ressources pas disponibles exécution accès cache Les instructions sont retirées du ROB dans l’ordre séquentiel écriture registre / retirement

Renommage « permanent »
MIPS R10000, Alpha 21264 1 banc de registres physiques (en fait 2: 1 entier + 1 flottant) on affecte un registre physique libre à chaque nouvelle instruction écrivant dans un registre Taille du banc de registres = nombre de registres logiques + nombres d’entrées du ROB ex. MIPS R10000: ROB 32 entrées, 32 registres logiques entiers, 64 registres physiques entiers (pareil pour les flottants) Un registre physique P associé au registre logique R est libéré lorsqu’une nouvelle instruction I écrit dans R et que cette instruction est retirée du ROB lorsque I est renommée, le registre P est mis en attente de libération dans le ROB lorsque I est retirée, on est sûr qu’on n’aura plus besoin de la valeur, et on peut en toute sécurité libérer P, qui pourra être réutilisé par une autre instruction

Cycle des registres physiques
Numéro de registre actif table de renommage En attente de libération Numéro de registre libre nouveau registre physique ancien registre physique file de registres libres reorder buffer

Variante: renommage « temporaire »
Intel P6, HP PA-8500, AMD Athlon, IBM Power 3, … 1 banc de registres logiques + 1 banc de registres temporaires le nombre de registres temporaires est égal au nombre d’entrées du ROB en général, registres temporaires et ROB sont fusionnés: 1 registre temporaire dans chaque entrée du ROB tant que l’instruction est dans le ROB, registre physique = registre temporaire à l’exécution, l’écriture registre se fait dans le registre temporaire quand l’instruction est retirée du ROB, registre physique = registre logique la valeur stockée dans le registre temporaire est recopiée dans le banc de registres logiques, et le registre temporaire est libéré une écriture associative dans le ROB est nécessaire si la lecture des registres est faite avant l’entrée dans le ROB, il faut, à l’exécution, propager la valeur aux autres instructions dans le ROB si la lecture des registres est faite au lancement, il faut, au retirement, indiquer aux instructions dans le ROB que la valeur est désormais dans le banc de registres logiques

Réparation sur exception
Les exceptions sont déclenchées au retirement La table de renommage doit retrouver l’état qu’elle avait avant que l’instruction fautive soit décodée Renommage « permanent »: plusieurs solutions dépiler les registres physique du ROB et les remettre dans la table utilisé sur le MIPS R10000: prend plusieurs cycles maintenir une copie non-spéculative de la table au retirement points de reprise sur chaque instruction (voir plus loin) Renommage « temporaire » l’état non spéculatif est contenu dans le banc de registres logiques Effacer les instructions spéculatives (en particulier, vider le ROB), libérer les registres physiques spéculativement alloués, puis passer la main au système

Réparation sur branchement mal prédit
Remettre la table de renommage dans l’état où elle était avant qu’on décode le branchement et effacer les instructions spéculatives du processeur Solution 1: réparer la mauvaise prédiction au retirement du branchement, comme pour les exceptions entre l’exécution d’un branchement et son retirement, il peut s’écouler plusieurs cycles, ce qui rallonge la pénalité de mauvaise prédiction Solution 2: réparer la mauvaise prédiction dès que le branchement est exécuté intéressant à condition d’être capable de réparer la mauvaise prédiction rapidement solution: établir des points de reprise

Points de reprise Point de reprise = « photographie » de l’état du processeur avant de décoder un nouveau branchement en particulier, état de la table de renommage Si le branchement est mal prédit, le point de reprise associé est utilisé pour restaurer l’état du processeur Le nombre de branchements dans le ROB est limité par le nombre de points de reprise ex. MIPS R10000: ROB 32 entrées, 4 points de reprise quand il n’y a plus de points de reprise disponibles pour un nouveau branchement, on gèle le décodage et on attend qu’un branchement soit retiré et libère un point de reprise

Table de renommage directe
Mapping (correspondance) des registres logiques vers les registres physiques RAM possédant autant d’entrées qu’il y a de registres logiques, chaque entrée contenant un numéro de registre physique Pour établir un point de reprise, on recopie le mapping dans une table de sauvegarde permet de restaurer le mapping sur mauvaise prédiction les tables de sauvegarde et la table de renommage sont imbriquées, afin que la restauration du mapping soit instantanée Exemple: MIPS R10000 32 registres logiques entiers, 64 registres physiques entiers, 4 points de reprise. Total table = 32*6 + 4*32*6 = 960 bits table de renommage des registres flottants identique

Table de renommage inverse
Mapping des registres physiques vers les registres logiques CAM (content addressable memory) possédant autant d’entrées qu’il y a de registres physiques, chaque entrée comprenant un numéro de registre logique, et un bit de validité pour marquer les registres actifs Pour obtenir le numéro de registre physique associé à un registre logique, on fait une lecture associative. s’il y a plusieurs entrées candidates, c’est celle dont le bit de validité est positionné qui est sélectionnée pour changer le mapping, invalider l’ancienne entrée et valider la nouvelle Utilisé sur l’Alpha et le HAL Sparc64 Point de reprise: sauvegarder seulement les bits de validité la sauvegarde prend peu de place, on peut établir un point de reprise pas seulement sur les branchements, mais sur toutes les instructions dans le ROB ex. Alpha 21264: 32 registres logiques entiers, 80 registres physiques entiers, ROB 80 entrées (80 points de reprise). Total table = 80*5+80*80 = 6800 bits

Scoreboard Scoreboard = table contenant autant d’entrées que de registres physiques dans le processeur, avec 1 bit dans chaque entrée indiquant si la valeur dans le registre physique est disponible ou pas En même que l’instruction est insérée dans le ROB, le bit correspondant au registre physique destination de l’instruction est mis à 0 Quand l’instruction est exécutée, le bit est mis à 1 Pour savoir si les opérandes d’une instruction sont disponibles, on consulte le scoreboard

Tampon d’amorçage En même temps que l’instruction est insérée dans le ROB, une version exécutable de l’instruction est insérée dans un tampon d’amorçage L’instruction attend dans le tampon jusqu’à ce que ses opérandes et les ressources d’exécution nécessaires soient disponibles le tampon d’amorçage « réveille » les instructions dont les opérandes sont prêts et décide quelle instruction doit être lancée sur quelle unité arbitrage entre instructions en cas de conflit Une fois exécutée, l’instruction est retirée du tampon rem: le tampon d’amorçage peut être plus petit que le ROB car il ne contient pas les instructions déjà exécutées et en attente de retirement

Partition du tampon d’amorçage
Tampon d’amorçage unifié Un seul tampon d’amorçage dans le processeur Intel P6 : un tampon d’amorçage de 20 entrées Tampon d’amorçage distribué 1 tampon par type d’instructions: entier, flottant, load/store solution la plus utilisée ex. MIPS R10000, 3 tampons d’amorçage: tampon entier, tampon flottant et tampon load/store de 16 entrées chacun (total: 48) 1 tampon par unité d’exécution arbitrage plus simple utilisé sur les PowerPC et IBM Power ex. PowerPC 604 : 6 tampons de 2 entrées chacun aussi appelé station de réservation

Cas des load/store Une instruction load/store est divisée en deux sous-instructions une sous-instruction qui calcule l’adresse d’accès une sous-instruction qui accède au cache une fois l’adresse calculée Sous-instruction d’accès au cache insérée dans le tampon d’adresses (tampon load/store) dépendante de la sous-instruction de calcul d’adresse Sous-instruction de calcul d’adresse similaire à une instruction entière, sauf qu’au lieu d’écrire le résultat dans le banc de registres, on l’écrit dans l’entrée de la sous-instruction correspondante dans le tampon d’adresses peut s’exécuter sur une ALU ou sur un additionneur dédié

Tampon d’adresses Les load/store sont insérées dans le tampon d’adresses dans l’ordre séquentiel, et ne le quittent que lorsque l’instruction est retirée du ROB tampon d’adresses parfois appelé address reorder buffer Rôle tamponner les stores : un store n’a le droit d’écrire en mémoire que lorsque qu’il est retiré du ROB bypass mémoire: si un load essaye de lire une donnée alors que le store qui écrit cette donnée est encore dans le tampon, possibilité d’obtenir la valeur directement sans attendre qu’elle soit écrite en mémoire le tampon d’adresse doit vérifier que les dépendances load / store sont bien respectées

Dépendances load/store
Pour résoudre les dépendances entre loads et stores, on a besoin de maintenir l’ordre séquentiel Le MIPS R10000 utilise une file circulaire de 16 entrées, commune aux loads et aux stores L’Alpha divise le tampon d’adresses en une file de loads et une file de stores de 32 entrées chacune. L’ordre entre les loads et les stores est connu grâce à un numéro de séquence sur 8 bits. Deux solutions pour maintenir les dépendances Solution simple : ne lancer un load que lorsque les adresses de tous les stores antérieurs au load sont connues on fait attendre certains loads plus que nécessaire Autre solution : loads spéculatifs avec mécanisme de réparation utilisée sur l’Alpha 21264

Caches non bloquants Sur un cache miss, le chargement d’instructions continue, le ROB continue à se remplir, et les instructions qui n’utilisent pas la donnée manquante peuvent continuer à s’exécuter en particulier, les cache hit peuvent continuer à être servis La plupart des processeurs superscalaires OOO autorisent plusieurs défauts de cache en cours de résolution si plusieurs défauts de cache concernent la même ligne, on les fusionne en général, les miss sont pipelinés afin d’exploiter la bande passante au maximum Intel P6: 4 miss L1, Alpha 21264: 8 miss L1,

Un exemple: l’Alpha 21264 COMPAQ / DEC Disponible depuis 1999
Quelques caractéristiques technologiques transistors : 15 Millions (6 M logique, 9 M caches) fréquence : 700 MHz (0.25 microns) puissance dissipée : 75 W (2 V) Marché visé stations de travail, serveurs

21264: caractéristiques générales
adresses logiques sur 64 bits pipeline de 7 étages pour les instructions de calcul entier processeur superscalaire out-of-order de degré 4 cache de données 64 Ko 2-way SA write-back (ligne 64 octets) cache d’instructions 64 Ko 2-way SA (ligne 64 octet) TLB données et TLB instructions de 128 entrées chacune bus cache secondaire 128 bits bus système 64 bits 4 ALU et 2 unités flottantes 2 des ALU peuvent calculer les adresses load/store, et 2 load/store peuvent accéder au cache par cycle au maximum 6 instructions peuvent s’exécuter simultanément

21264: disposition sur silicium
ROB interface L2 fp map int map fp mul ALU ALU tampon amorç fp reg int reg int tampon load /store tampon amorç int reg fp ALU ALU fp add bus load/store I-TLB div/sqrt D-TLB (dupliqué) contrôle cache données gén. PC préd br cache de données cache d’instructions et prédicteur de ligne

Le pipeline du 21264 PC répare 1 2 3 4 5 6 7 calcul entier 5 6 7 8 9
pénalité mini si branch mal prédit: 7 cycles PC répare attente éventuelle 1 2 3 4 5 6 7 calcul entier charg. extrait renom. lance lit reg exec écrit int lecture ligne extrait bloc / transit insert dans fenêtre on peut lancer ? load-use: +2 cycles 5 6 7 8 9 10 load/store lit reg adresse cache 1 cache 2 écrit int transit écrit fp load-use: +3 cycles 5 6 7 8 9 10 calcul flottant lit reg FP 1 FP 2 FP 3 FP 4 écrit fp

21264: chargement d’instructions
Les lignes de cache font 64 octets (1 tag pour 64 octets) Sur un défaut de cache d’instructions, le processeur charge dans le cache la ligne manquante et précharge les lignes en séquence maximum de 4 lignes de 64 octets pré-chargées dans le cache Le chargement travaille en fait sur des quarts de lignes 1 quart de ligne = 4 instructions par commodité, dans la suite, on dira « ligne » pour « quart de ligne » Les lignes de cache comporte des bits de pré-décodage une partie du décodage est effectué sur un défaut de cache bits de pré-décodage utilisés pour la prédiction de branchement

21264: prédiction et chargement
Étage 0: prédiction de ligne chaque ligne du cache d’instructions comporte un pointeur vers la prochaine ligne de cache (index et prédiction de banc 0/1) (accès < 1 cycle) on commence la prédiction de branchement rem: prédicteur hybride pour les conditionnels (cf. transparent 115) Étage 1: chargement et génération PC on charge la ligne prédite à l’étage précédent et les 2 tags ayant le même index que la ligne (cache 2-way SA) la prédiction de branchement commencée au cycle précédent est utilisée pour générer le PC (complet) du bloc en cours de chargement comparaison d’index: si désaccord entre étages 0 et 1, c’est le prédicteur de branchement qui « gagne »: on recharge la ligne (bulle dans le pipeline) sauf pour les sauts indirect qui ne sont pas des retours Étage 2: comparaison du PC avec les 2 tags chargés à l’étage précédent 2 bulles si mauvaise prédiction de banc détection éventuelle d’un cache miss

21264: prédiction et chargement
préd. ligne Cache 2-way SA préd hyb tags bancs et 1 préd. ligne bloc d’instructions préd. br. tags génération PC compare index Étage 0 PC Bloc C Étage 1 Bloc B compare tags Étage 2 Bloc A

21264: remarques En pratique, débit de chargement moyen inférieur à 4
tous les blocs de base ne commencent pas sur un début de ligne et ne se terminent pas sur une fin de ligne le compilateur doit essayer de faire commencer les fonctions et les petites boucles sur des frontières de ligne (insérer des NOP si nécessaire) Une prédiction de ligne pour 4 instructions le compilateur doit essayer de mettre les call en fin de ligne sinon, il y aura 2 successeurs pour la ligne (fonction et retour) Le ne prédit qu’un branchement par cycle le chargement est « gelé » autant de cycles qu’il y a de branchements prédits non pris dans une ligne

Exercice Soit un processeur capable de prédire un branchement par cycle et de charger une ligne de 4 instructions par cycle (dit autrement, le bloc courant s’arrête soit sur le prochain branchement, soit sur la fin de ligne) On a en moyenne un branchement pour 5 instructions. Quel est le débit moyen de chargement en instructions par cycle ? on supposera une prédiction parfaite, et on supposera que la disposition des blocs de base est indépendante des frontières de ligne Conclusion ? Indication: essayer d’abord de répondre à la question en supposant une taille de ligne infinie

21264: lancement OOO Reorder buffer de 80 entrées
80 registres physiques entiers 72 registres physiques flottants grosso-modo, le ROB est plein quand il y a 40 instructions de calcul entier et 40 instructions de calcul flottant en attente de retirement 2 tables de renommage inverses 1 pour le calcul entier, 1 pour le calcul flottant un point de reprise pour chaque instruction du ROB, soit 80 points de reprise Tampons d’amorçage un tampon de 20 instructions pour les instructions de calcul entier (rem: comprenant le calcul d’adresse pour les load/store) un tampon de 15 entrées pour les instructions de calcul flottant les instructions sont maintenues dans l’ordre séquentiel politique d’amorçage: en cas de conflit de ressource, priorité aux plus anciennes une instruction exécutée est retirée du tampon, et le tampon est compressé pour « boucher le trou » tout en maintenant l’ordre séquentiel

21264: clusters d’ALU 4 instructions de calcul entier et 2 load peuvent s’exécuter simultanément Ce qu’on aimerait avoir banc de 80 registres physiques entiers avec 8 ports de lecture et 6 ports d’écriture réseau de bypass 6 vers 8 Problème: impact sur le cycle d’horloge du processeur Sur le : 2 clusters 2 unités de calcul entier par cluster banc de registres entiers dupliqué sur chacun des clusters 4 ports de lecture et 6 ports d’écriture 1 réseau de bypass local à chaque cluster: +0 cycle 1 réseau de bypass entre les cluster: +1 cycle La logique d’amorçage tend à envoyer des instructions dépendantes sur le même cluster

Clusters du 21264 ALU 1 ALU 2 ALU 3 ALU 4 80 registres physiques (int)
+1 cycle ALU 1 ALU 2 ALU 3 ALU 4

21264: tampons d’adresses En fait, séparé en 2 tampons: un tampon de load et un tampon de store de 32 entrées chacun Les instructions dans chaque tampon sont ordonnées quand un load/store est inséré dans le ROB et le tampon d’amorçage entier, une entrée lui est allouée dans le tampon d’adresses correspondant un load/store retiré du ROB retire aussi son entrée dans le tampon d’adresses Le tampon de store comporte également les données à écrire les store peuvent s’exécuter OOO mais écrivent dans le tampon de store les données du tampon sont recopiées dans le cache au retirement, dans l ’ordre séquentiel Un numéro de séquence sur 8 bits affecté à chaque instruction dans le processeur permet (entre autre) de déterminer l’ordre entre les load et les store

21264: exécuter les load sans attendre
Les load peuvent s’exécuter dans le désordre vis-a-vis des autres load, et aussi vis à vis des store Quand un load accède au cache, on consulte en parallèle le tampon de store si un store plus ancien a écrit à la même adresse, c’est la donnée dans le tampon de store qui est mise sur le bus et qui est envoyée au load Si un store s’exécute et qu’on trouve qu’un load plus récent a déjà accédé à la même adresse, le load et les instructions suivantes sont effacées du processeur puis rechargées comme une mauvaise prédiction de branchement: on essaie d’éviter une table de 1k * 1 bits, indexée avec le PC du load, permet de prédire si le load dépend d’un store ou pas si on prédit qu’il sera dépendant, on attend que tous les store antérieurs au load soient exécutés

21264: prédiction de hit/miss
Pénalité load-use de 2 cycles (pipeline de calcul entier) Cela suppose qu’il y a un hit dans le cache si on veut que la pénalité load-use soit vraiment de 2 cycles, on doit lancer l’instruction dépendante 3 cycles après le lancement du load, au moment où celui-ci est dans le premier étage d’accès cache or, à ce moment, le tampon d’amorçage ne sait pas s’il y aura un hit ou un miss: il ne le saura qu’à la fin du deuxième étage d’accès cache: entre temps, 2 cycles de lancement auront eu lieu en cas de miss, les instructions qui ont été lancées pendant les 2 cycles d’incertitude sont arrêtées et sont remises dans le tampon d’amorçage en fait elles n’ont pas encore quitté le tampon: il suffit de les réactiver inconvénient: 2 cycles pendant lesquels aucun travail utile n’a été effectué Prédiction de hit/miss: utilisation d’un compteur 4 bits (partagé) incrémenté de 1 sur hit, décrémenté de 2 sur miss, prédiction = bit poids fort si zone avec beaucoup de miss, pénalité load-use de 4 cycles sur hit

21264: défauts de cache 8 défauts de cache de données peuvent être en cours de résolution 8 requêtes sur des lignes de 64 octets distinctes plusieurs load peuvent être en attente d’une même requête miss peut être sur cache L2 ou sur DRAM Les requêtes peuvent être servies dans le désordre Sur un miss, la ligne remplacée (si modifiée depuis qu’elle est dans le cache) est mise dans un tampon de 8 lignes en attente d’écriture vers le cache L2 miss L1 / hit L2: latence minimum de résolution = 12 cycles (latence pure SRAM 6 cycles + 4 cycles de remplissage + 2 cycles réservés aux load/store) bande passante bus: 16 octets pour 1.5 cycles CPU miss L2 latence typique: 160 ns (DRAM 60 ns) 96 cycles CPU à 600 MHz bande passante bus système: 8 octets pour 1.5 cycles CPU

Exercice Soit un processeur pouvant avoir des défauts de cache sur N lignes distinctes simultanément en cours de résolution. On suppose que la latence de résolution d’un défaut de cache est de L cycles et que les requêtes sont servies dans l’ordre d’émission. En supposant une bande passante illimitée, quel est, en fonction de N et L, le débit mémoire maximum en nombre de lignes par cycles ? Si on a une bande passante de 1 ligne pour 12 cycles et une latence de résolution de 96 cycles par défaut de cache, quelle valeur de N permet d’exploiter au maximum la bande passante ? Supposons que le programme effectue un parcourt de liste et qu’une requête ne puisse pas être émise avant que le défaut de cache précédent soit résolu. Comment s’exprime le débit mémoire en fonction de L ?

Processeurs OOO: bilan (1)
Matériel plus complexe que in-order Une mauvaise prédiction de branchement est plus pénalisante sur un processeur OOO que sur un processeur in-order pipeline OOO en général plus long parallélisme d’instructions: loi empirique en racine carrée soit N le nombre d’instructions entre 2 branchements mal prédits consécutifs modèle empirique: la longueur L (en cycles) du chemin critique du graphe data-flow est proportionnelle à la racine carrée de N N1 N2 si on enlève la mauvaise prédiction ... si N1=N2, N1+N2

Processeur OOO: bilan (2)
Que peut faire le compilateur ? en principe, ordonnancement d’instructions moins critique que pour in-order permet néanmoins de mieux utiliser la fenêtre d’instructions du processeur par exemple, si plusieurs cache miss sont suffisamment rapprochés pour pouvoir se trouver simultanément dans la fenêtre du processeur, les latences d’accès peuvent se recouvrir sur un processeur OOO, certains miss sont moins coûteux que d’autres optimisations « classiques » diminuer le nombre d’instructions exécutées une valeur sûre améliorer la localité dans les caches

Superscalaire: processeurs enfouis ?
si on n’a pas besoin d’une grande performance, un processeur scalaire (=degré 1) pipeliné fait l’affaire voire un simple micro-contrôleur 8 bits … lorsqu’on a besoin d’une haute performance avec une basse consommation électrique, un processeur superscalaire peut être une bonne solution du point de vue de la consommation électrique, il est plus intéressant d’exécuter 2 instructions par cycle que de doubler la fréquence CPU plutôt in-order (voire VLIW, cf. cours sur les optimisations de code) certains processeurs OOO sont déclinés en version low-power ex. PowerPC

Quelques directions nouvelles ...
Processeur SMT (simultaneous multithreading) lorsqu’un seul flot d’instruction s’exécute sur un processeur superscalaire, les ressources matérielles (unités d’exécution, registres physiques, caches, bande passante, …) ne sont généralement pas utilisées à 100 % idée: plusieurs flots d’instructions (indépendants ou pas) se partagent les ressources d’un seul processeur superscalaire but: utiliser les ressources au maximum l’Alpha sera SMT (sortie prévue pour 2002) Multiprocesseur intégré plusieurs processeurs sur une même puce (ex. IBM Power 4 = 2 processeurs) Émulation / compilation de binaire à binaire la compatibilité binaire est une contrainte dont on aimerait s’affranchir idée: ISA simulé via un logiciel d’émulation Transmeta Crusoe : processeur VLIW + logiciel d’émulation + optimisation dynamique du code VLIW généré + supports matériels spécifiques

Architectures des processeurs superscalaires, VLIW et optimisations

Présentations similaires

Présentation au sujet: "Architectures des processeurs superscalaires, VLIW et optimisations"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back

Entrer

S'autoriser via un réseau social:

Architectures des processeurs superscalaires, VLIW et optimisations

Présentations similaires

Présentation au sujet: "Architectures des processeurs superscalaires, VLIW et optimisations"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back