Chemin de données du processeur et exécution en pipeline

Un chemin de données conserve et transforme les valeurs dont une instruction a besoin. L’unité de commande dirige ces valeurs et autorise les écritures. Ensemble, ils exécutent des instructions comme add, sub, and, or, ld, sd et beq.

Suivre les valeurs entre les fronts d’horloge

Un élément de mémorisation conserve une valeur : le compteur ordinal, le banc de registres et la mémoire de données en sont des exemples. Un élément combinatoire produit une sortie à partir de ses entrées actuelles. Les additionneurs, les multiplexeurs, l’unité arithmétique et logique et le générateur de valeurs immédiates effectuent ce travail sans conserver le résultat d’une instruction entre les cycles.

Sur le front actif de l’horloge, les éléments de mémorisation capturent leurs prochaines valeurs. Entre les fronts, leurs sorties alimentent la logique combinatoire. Le PC peut donc fournir l’adresse courante pendant tout un cycle et capturer l’adresse suivante à la fin de celui-ci. La lecture d’un élément de mémorisation ne l’écrase pas en elle-même.

Récupération et accès aux registres

Le compteur ordinal (PC) contient l’adresse de l’instruction. La mémoire d’instructions renvoie l’instruction de 32 bits située à cette adresse. Dans ce modèle, elle est en lecture seule pendant l’exécution du programme et associe une instruction à une adresse. Un additionneur distinct forme PC + 4, car les instructions de ce sous-ensemble occupent 4 octets.

Le banc de registres contient x0–x31. Deux ports de lecture reçoivent les numéros des registres sources rs1 et rs2 et renvoient leurs valeurs. Un port d’écriture reçoit la destination rd, les données à écrire et RegWrite. Les lectures sont combinatoires ; une écriture autorisée est enregistrée sur le front d’horloge. La lecture du registre x0 renvoie toujours zéro et les écritures dans ce registre sont ignorées. Les registres RV64 contiennent 64 bits. Une version RV32 utilise des registres de 32 bits et lw/sw, avec les mêmes connexions de base.

Calculer, sélectionner et accéder à la mémoire

L’unité arithmétique et logique additionne, soustrait ou effectue une opération bit à bit. Un code de commande sur 4 bits sélectionne l’opération. Sa sortie Zero vaut 1 lorsque le résultat est zéro ; une soustraction permet donc de tester si deux valeurs sont égales.

Le générateur de valeurs immédiates, ImmGen, reconstitue la valeur immédiate d’une instruction et effectue son extension de signe sur 64 bits. La copie du bit de signe conserve une valeur négative. La suite de 12 bits 1111 1111 1000 représente −8 ; une extension par des zéros la transformerait en 4 088 et enverrait une opération mémoire à la mauvaise adresse.

Un multiplexeur sélectionne une entrée. Les multiplexeurs choisissent le second opérande de l’unité arithmétique et logique, les données à écrire dans le registre et le prochain PC. Un multiplexeur modifie le chemin emprunté ; un signal d’activation d’écriture détermine si une valeur mémorisée change.

La mémoire de données possède des entrées d’adresse et de données à écrire, une sortie de données lues et les signaux de commande MemRead et MemWrite. Un chargement nécessite la récupération de l’instruction et l’accès aux données pendant le même cycle. Des mémoires d’instructions et de données distinctes assurent les deux accès. Des additionneurs distincts permettent aussi de calculer PC + 4 et la cible de branchement pendant que l’unité arithmétique et logique effectue d’autres opérations.

Les sorties inutilisées peuvent tout de même changer pendant un cycle. Une commande correcte garantit que seules les sorties sélectionnées atteignent les éléments de mémorisation dont l’écriture est autorisée. Une valeur calculée sur un fil non sélectionné n’a aucun effet sur le programme.

Commence par déterminer ce que chaque instruction doit lire et ce qu’elle doit modifier. Le chemin de données partagé réunit ces parcours, avec un multiplexeur partout où plusieurs valeurs possibles arrivent à une même entrée.

Récupérer l’instruction et décoder les champs

La récupération utilise le PC pour lire la mémoire d’instructions et calcule PC + 4 en parallèle. Le code opération occupe les bits 6–0. Lorsqu’ils sont présents, rd occupe les bits 11–7, funct3 les bits 14–12, rs1 les bits 19–15 et rs2 les bits 24–20 ; funct7 des instructions de type R occupe les bits 31–25. Les positions fixes des champs sources permettent de commencer les lectures des registres pendant le décodage de la commande de l’instruction. Un rangement ou un branchement n’a pas de champ rd : les bits 11–7 contribuent à sa valeur immédiate.

Comparer les parcours d’exécution

Pour un chargement, le résultat de l’unité arithmétique et logique est une adresse effective, l’adresse des données à lire. La sortie de la mémoire revient ensuite au banc de registres. Un rangement forme aussi une adresse avec l’unité arithmétique et logique, mais sa seconde valeur source circule séparément vers l’entrée de données à écrire de la mémoire. La sélection d’une valeur immédiate comme opérande de l’unité arithmétique et logique ne doit pas éliminer cette valeur à ranger. ImmGen reconstitue le déplacement du format S à partir de ses deux groupes de bits.

Un branchement effectue deux opérations en parallèle. L’unité arithmétique et logique soustrait les valeurs des registres comparés ; Zero indique si elles sont égales. L’additionneur de branchement ajoute le déplacement signé en octets au PC du branchement lui-même. Le codage du format B omet le bit de poids faible, qui vaut toujours zéro. ImmGen peut reconstituer le déplacement complet en octets, y compris ce zéro ; un schéma qui génère plutôt le déplacement en unités de demi-mots nécessite un décalage d’un bit vers la gauche. Le décalage doit apparaître exactement une fois dans le chemin.

Réunir les parcours avec des multiplexeurs

ALUSrc sélectionne soit la valeur de rs2, soit la valeur immédiate pour la seconde entrée de l’unité arithmétique et logique. MemtoReg sélectionne soit le résultat de cette unité, soit la sortie de la mémoire de données pour l’écriture en registre. PCSrc sélectionne PC + 4 ou la cible de branchement. Deux résultats concurrents nécessitent un sélecteur, et non un fil reliant directement leurs sorties.

Ces parcours expliquent pourquoi le chargement possède la chaîne la plus longue : la récupération, la lecture des registres, le calcul de l’adresse, la lecture de la mémoire et l’écriture dans le registre contribuent tous au délai. Une opération arithmétique contourne la mémoire de données ; un rangement contourne l’écriture en registre.

Étendre les parcours existants

addi x5, x6, 3 réutilise le parcours qui fournit une valeur immédiate à l’unité arithmétique et logique et celui qui écrit son résultat en registre. Elle nécessite une commande adaptée, mais aucune nouvelle unité dans le chemin de données. jal a une exigence supplémentaire : elle écrit PC + 4 dans rd tout en redirigeant le PC sans test d’égalité. Son sélecteur d’écriture en registre nécessite donc une entrée PC + 4, et la logique du prochain PC doit prendre en charge un saut inconditionnel.

Le suivi d’une instruction relie l’opération en langage d’assemblage aux valeurs réelles sur les fils. Distingue les valeurs calculées pendant le cycle de celles enregistrées sur le front d’horloge qui le termine.

Suivre un ordre constant

1. Récupère l’instruction à l’adresse du PC courant et repère ses champs.
2. Lis les registres sources et forme la valeur immédiate signée.
3. Sélectionne les opérandes de l’unité arithmétique et logique et calcule le résultat.
4. Effectue l’accès demandé à la mémoire de données.
5. Sélectionne les données à écrire dans le registre et le prochain PC.
6. Liste les écritures dans les éléments de mémorisation sur le front d’horloge.

Additionner deux valeurs de registres

À PC 400, add x5, x6, x7 a pour codage 0x007302B3. Ses champs sont le code opération 0110011, rd 5, funct3 000, rs1 6, rs2 7 et funct7 0000000. Avec x6 = 25 et x7 = −9, les ports de lecture produisent 25 et −9. ALUSrc sélectionne la valeur du second registre et l’unité arithmétique et logique produit 16. MemtoReg sélectionne 16 pour l’écriture en registre. Sur le front, x5 devient 16 et le PC devient 404. MemRead et MemWrite valent tous deux zéro.

Charger, puis ranger un double mot

À PC 404, considère ld x5, 16(x6) avec x6 = 1 000 et la mémoire contenant 42 à l’adresse 1 016. ImmGen produit 16. L’unité arithmétique et logique calcule l’adresse 1 016 et la mémoire de données renvoie 42. MemtoReg sélectionne cette valeur de la mémoire : x5 devient donc 42 et le PC devient 408 sur le front. Écrire 1 016 dans x5 reviendrait à confondre l’adresse avec la valeur qui y est stockée.

À PC 408, sd x5, 24(x6) lit x5 = 42 et x6 = 1 000. L’unité arithmétique et logique calcule 1 024 pendant que le chemin de rs2 fournit 42 à la mémoire. MemWrite autorise le rangement ; RegWrite vaut zéro. Sur le front, le double mot à l’adresse 1 024 devient 42 et le PC devient 412. L’adresse mémoire et la valeur à ranger circulent sur des fils différents.

Les déplacements sont mesurés en octets. Les adresses de début de doubles mots RV64 adjacents sont séparées de 8 octets : après le double mot à l’adresse 1 016, le suivant commence à 1 024. Avancer d’un octet ne permettrait pas d’atteindre le double mot suivant.

Décider d’un branchement

À PC 412, beq x8, x9, 12 compare x8 = 7 à x9 = 7. L’unité arithmétique et logique soustrait et obtient zéro. Branch vaut 1, donc Branch AND Zero vaut 1 et PCSrc sélectionne la cible de branchement. L’additionneur de branchement produit 424 en ajoutant 12 à 412. Seul le PC change.

Si x9 vaut 8 à la place, la soustraction produit −1 et Zero vaut 0. Le prochain PC est alors 416. Le déplacement codé est exprimé en unités de 2 octets : la quantité signée stockée pour ce déplacement de 12 octets est donc 6 ; le déplacement complet utilisé par l’additionneur reste 12.

Lire l’état pour l’instruction suivante

Chaque instruction monocycle accomplit son travail entre deux fronts d’horloge consécutifs. L’instruction suivante lit l’état enregistré par le front précédent. Ainsi, le rangement peut lire la nouvelle valeur de x5 issue du chargement au cycle suivant, sans court-circuit dans un pipeline. Chaque instruction prend un cycle d’horloge, ce qui donne un CPI de 1 pour le circuit monocycle, quel que soit le nombre d’unités matérielles utilisées par son parcours.

L’unité de commande principale transforme un code opération en signaux de sélection des chemins et en autorisations d’écriture. C’est une table de vérité combinatoire réalisée avec des portes logiques : une commande câblée.

Attribuer un rôle à chaque signal

RegWrite autorise une écriture dans rd. ALUSrc sélectionne la seconde entrée de l’unité arithmétique et logique : 0 pour rs2, 1 pour une valeur immédiate. MemRead et MemWrite demandent l’accès correspondant à la mémoire de données. MemtoReg sélectionne les données à écrire dans le registre : 0 pour le résultat de l’unité arithmétique et logique, 1 pour les données de la mémoire. Branch indique un branchement sur égalité. ALUOp sur 2 bits indique à l’unité de commande distincte de l’unité arithmétique et logique la classe d’opérations nécessaire.

PCSrc est différent : il dépend de l’instruction et des valeurs comparées. La commande principale active Branch et l’unité arithmétique et logique fournit Zero. Leur ET forme PCSrc ; un résultat arithmétique ordinaire égal à zéro ne peut donc pas provoquer à lui seul un branchement.

Construire la table à partir des opérations nécessaires

Pour ld, l’unité arithmétique et logique a besoin d’un déplacement immédiat, donc ALUSrc vaut 1. Les données chargées vont dans rd, donc MemtoReg et RegWrite valent tous deux 1. La mémoire est lue, pas écrite : MemRead = 1 et MemWrite = 0. Branch vaut 0, et ALUOp = 00 demande l’addition servant à calculer l’adresse.

Pour sd, l’unité arithmétique et logique ajoute aussi un déplacement, mais la destination est la mémoire. Fixe MemWrite = 1 et RegWrite = 0. MemRead reste à zéro : utiliser la mémoire ne signifie pas la lire. Pour beq, l’unité arithmétique et logique utilise les deux valeurs des registres et les soustrait, tandis que le PC est le seul élément de l’état architectural susceptible d’être mis à jour.

Utiliser les valeurs indifférentes uniquement lorsque les résultats sont ignorés

X est une valeur indifférente : les deux valeurs possibles du signal de sélection donnent le même comportement. MemtoReg peut valoir X pour un rangement ou un branchement, car RegWrite vaut zéro. L’entrée de données à écrire du banc de registres est ignorée ; le concepteur peut donc choisir la valeur de sélection qui simplifie le circuit.

Un signal d’activation d’écriture d’un élément de mémorisation ne peut pas être traité ainsi lorsqu’une écriture est interdite. Un MemWrite accidentel pendant une opération arithmétique peut altérer la mémoire, même si l’instruction arithmétique n’a pas autrement besoin de cette sortie mémoire. RegWrite et MemWrite doivent donc être explicitement à zéro pour les instructions qui n’effectuent pas ces écritures.

Ajouter une ligne pour l’arithmétique avec valeur immédiate

addi x5, x6, 3 prend son second opérande dans ImmGen et écrit la somme produite par l’unité arithmétique et logique. Sa ligne est ALUSrc 1, MemtoReg 0, RegWrite 1, MemRead 0, MemWrite 0, Branch 0, ALUOp 00. Son code opération 0010011 diffère du code opération de type R 0110011 ; la commande principale a donc besoin de cette ligne supplémentaire. La prise en charge de andi et ori nécessite aussi le décodage de leurs valeurs funct3 pour sélectionner l’opération.

Les noms des signaux dépendent du circuit. RegWEn, BSel et WBSel dans les schémas d’autres cours désignent des fonctions apparentées d’activation d’écriture et de sélection d’entrée. Lorsque tu lis un nouveau schéma, suis la définition d’un signal et les entrées de son multiplexeur.

Le code opération seul ne permet pas de distinguer add de sub : les deux appartiennent à la classe de type R. La commande à deux niveaux détermine d’abord la classe, puis utilise les bits de fonction lorsqu’ils sont utiles.

D’ALUOp à l’opération

La commande principale fournit un signal ALUOp sur 2 bits parmi ses autres sorties. La commande de l’unité arithmétique et logique le combine avec funct3 et le bit 30 de l’instruction, qui fait partie de funct7, pour produire quatre bits de commande de l’opération.

Ces codes décrivent cette implémentation de l’unité arithmétique et logique, et non les codages d’instructions RISC-V. Les chargements et les rangements utilisent ALUOp 00, car ils additionnent une base et un déplacement. Les branchements sur égalité utilisent ALUOp 01, car la soustraction active Zero lorsque les opérandes sont égaux. Les instructions de type R utilisent ALUOp 10 et nécessitent un décodage supplémentaire.

Suivre une soustraction codée

sub x5, x6, x7 a pour codage 0x407302B3. Le code opération 0110011 indique le type R et sélectionne ALUOp 10. Son funct3 est 000, ce qui laisse l’addition et la soustraction comme possibilités. Le bit 30 vaut 1, issu de funct7 0100000 ; la commande de l’unité arithmétique et logique produit donc 0110 pour la soustraction.

Mettre ce bit de fonction à zéro donne le codage de l’addition correspondante 0x007302B3, avec funct7 0000000 et la commande 0010 de l’unité arithmétique et logique. La ligne de la commande principale reste la même, car les deux instructions utilisent deux entrées de registres, écrivent un résultat de l’unité arithmétique et logique et n’accèdent pas à la mémoire de données.

Réutiliser l’additionneur pour la soustraction

Dans l’unité arithmétique et logique classique, les lignes de commande représentent Ainvert, Bnegate et un sélecteur d’opération sur 2 bits. La soustraction utilise l’additionneur après inversion du second opérande et fourniture d’une retenue entrante de 1 :

Cette identité du complément à deux permet à l’addition et à la soustraction de partager le matériel. La différence de Bnegate explique les codes 0010 et 0110 ; elle ne nécessite pas de parcours arithmétique distinct pour chaque instruction.

Décoder les bits uniquement selon leur format

Pour ALUOp 00 ou 01, les positions des champs de fonction ne sélectionnent pas l’opération de l’unité arithmétique et logique. Le funct3 011 d’un chargement décrit un accès à un double mot. Les bits de poids fort des rangements et des branchements comprennent des bits de la valeur immédiate. Traiter ces positions comme des champs de fonction de type R reviendrait à confondre la formation d’adresse et le décodage arithmétique.

Pour une vérification rapide du type R, ALUOp 10 avec funct3 110 sélectionne 0001, l’opération OU. Ajouter une autre opération sous le même code opération peut ne nécessiter qu’une modification de la commande de l’unité arithmétique et logique si celle-ci prend déjà en charge l’opération. Une nouvelle classe d’instructions peut aussi nécessiter des modifications de la commande principale, comme pour l’arithmétique avec valeur immédiate.

Un processeur monocycle doit terminer son instruction la plus lente avant le front suivant. Les instructions plus rapides attendent tout de même la même période d’horloge fixe. L’exécution en pipeline modifie la quantité de travail que chaque période d’horloge doit contenir.

Déterminer la limite du circuit monocycle

Utilise les délais de composants suivants, sans tenir compte des multiplexeurs et des petits additionneurs : récupération 250 ps, lecture des registres 150 ps, unité arithmétique et logique 200 ps, mémoire de données 250 ps et écriture dans les registres 150 ps.

Le chargement constitue le chemin critique et fixe la période à 1 000 ps, soit 1 ns. Cela correspond à une fréquence d’horloge de 1 GHz. Une répartition de 25 % de chargements, 10 % de rangements, 50 % d’instructions de type R et 15 % de branchements donne un délai de parcours pondéré de 800 ps. Pourtant, chaque instruction dispose de 1 000 ps, soit 1,25 fois cette moyenne. Un délai moyen ne peut pas fixer une période d’horloge qui doit aussi permettre l’exécution de l’instruction la plus longue.

Faire se chevaucher cinq étages

Le pipeline divise l’exécution en IF (récupération), ID (décodage et lecture des registres), EX (exécution ou calcul d’une adresse), MEM (accès à la mémoire de données) et WB (écriture dans un registre). Des instructions différentes occupent simultanément des étages différents.

Le débit compte les instructions achevées par unité de temps. La latence mesure le temps qu’une instruction passe entre son entrée et son achèvement. Une chaîne de montage peut terminer un article à chaque intervalle même si chaque article a besoin de plusieurs intervalles pour la traverser. La même distinction s’applique ici.

L’étage le plus lent prend 250 ps. Avec 20 ps de surcoût temporel des registres de pipeline, la période d’horloge est de 270 ps, soit environ 3,70 GHz. Une instruction traverse cinq périodes, ce qui prend 1 350 ps. Cela dépasse sa latence en monocycle, mais un pipeline rempli peut achever une instruction toutes les 270 ps.

Inclure le temps de remplissage et d’achèvement

Sans blocage, un pipeline à k étages exécute n instructions en k + n − 1 cycles. Pour cinq étages, cela donne n + 4. Quatre instructions nécessitent huit cycles, soit 2 160 ps, contre 4 000 ps dans le processeur monocycle. L’accélération est d’environ 1,85.

Pour 1 000 000 instructions, le pipeline nécessite 1 000 004 cycles, soit environ 270,0 μs. Le circuit monocycle nécessite 1 000 μs. L’accélération se rapproche du rapport 1 000/270, soit environ 3,70, à mesure que le coût fixe de remplissage et de vidange devient faible.

Une accélération parfaite d’un facteur cinq nécessiterait cinq étages de 200 ps de même durée, sans surcoût lié aux registres ni délai dû aux aléas. Des étages de durées inégales obligent les plus rapides à attendre le plus lent. Un plus grand nombre d’étages ajoute aussi du surcoût et peut augmenter le coût des aléas.

Les instructions de taille fixe de 32 bits de ce sous-ensemble simplifient la récupération. Les positions fixes des champs de registres facilitent ID, et la restriction des accès à la mémoire de données aux chargements et aux rangements convient à un calcul d’adresse en EX suivi de MEM. Ces propriétés de l’architecture du jeu d’instructions rendent les frontières entre étages pratiques.

Plusieurs instructions partagent le chemin de données en même temps : chaque étage a donc besoin des valeurs de sa propre instruction. Les registres de pipeline conservent ces valeurs et leurs signaux de commande à chaque front d’horloge.

Associer le contenu au travail à venir

Chaque registre porte le nom des étages qu’il relie. Il capture les sorties du premier étage pour les utiliser dans le second. Il n’y a pas de registre de pipeline supplémentaire après WB ; WB écrit dans l’état architectural. Le PC fournit l’état au début de la récupération.

Le contenu de EX/MEM ci-dessus correspond à une architecture qui utilise les informations de branchement en MEM. Une architecture qui résout les branchements en EX renvoie ces informations plus tôt à l’étage de récupération. L’étage de résolution détermine la pénalité due à l’aléa de contrôle.

Garder la destination et les données ensemble

Un chargement est décodé en ID mais écrit dans rd trois cycles plus tard en WB. À ce moment-là, IF/ID contient une instruction plus récente. Si le port d’écriture utilisait rd de cette instruction plus récente, la valeur chargée irait dans le mauvais registre. Le numéro de destination du chargement doit donc traverser ID/EX, EX/MEM et MEM/WB à côté de son résultat.

De même, un rangement transmet sa valeur de rs2 à travers ID/EX et EX/MEM. Son adresse et ses données doivent correspondre au même rangement lorsqu’elles atteignent la mémoire de données. Les registres de pipeline préservent l’identité d’une instruction grâce à ces valeurs associées, même si plusieurs autres instructions sont actives à proximité.

Transmettre la commande avec l’instruction

La commande est générée en ID. EX utilise ALUSrc et ALUOp ; MEM utilise Branch, MemRead et MemWrite ; WB utilise MemtoReg et RegWrite. Chaque étage transmet les signaux de commande nécessaires plus tard avec les données.

Si la commande de l’unité arithmétique et logique est décodée en EX, ID/EX doit transmettre le bit 30 et funct3 ainsi qu’ALUOp. Les opérations de type R partagent ALUOp 10 ; cette seule valeur ne peut donc pas distinguer add, sub, ET et OU. Une autre architecture valide décode l’opération complète sur 4 bits en ID et transmet ce code à la place.

Garder un passage régulier dans les étages

Une instruction de type R traverse MEM sans utiliser la mémoire de données. Un rangement traverse WB sans écrire dans un registre. Faire passer toutes les instructions par les cinq mêmes étages préserve l’ordre des écritures dans les registres. Si une instruction de type R sautait MEM, elle pourrait atteindre l’unique port d’écriture des registres pendant le même cycle que le chargement qui la précède immédiatement.

Le banc de registres sert WB et ID pendant un même cycle en écrivant pendant la première moitié et en lisant pendant la seconde. ID peut alors voir une valeur écrite par une instruction plus ancienne pendant ce cycle. Des mémoires d’instructions et de données distinctes permettent à IF et MEM de fonctionner simultanément.

La plupart des informations progressent dans le pipeline. L’écriture en registre renvoie un résultat au banc de registres, et la commande de branchement renvoie une décision sur le prochain PC à la récupération. Ces longs chemins de retour expliquent pourquoi les instructions ultérieures peuvent avoir besoin d’aide avant qu’une instruction plus ancienne soit terminée.

Un diagramme de pipeline rend le chevauchement explicite. Les lignes présentent les instructions dans l’ordre du programme et les colonnes représentent les cycles d’horloge. Chaque case indique l’étage occupé par l’instruction pendant ce cycle.

Construire un escalier

Pour cinq instructions indépendantes, inscris IF pour I1 au cycle 1, puis ID, EX, MEM et WB aux cycles 2–5. Commence I2 un cycle plus tard et répète l’opération. Les noms des étages forment un escalier en diagonale.

Au cycle 5, I1 est en WB, I2 en MEM, I3 en EX, I4 en ID et I5 en IF. Lire une colonne de haut en bas donne une vue à un cycle donné. Suivre une ligne donne l’historique d’une instruction.

Numérote les étages de IF = 1 à WB = 5. Sans blocage, l’instruction i atteint l’étage s au cycle i + s − 1. I3 atteint donc MEM au cycle 6. La dernière case WB donne le cycle d’achèvement : cinq instructions se terminent au cycle 9.

Ajouter des valeurs à une vue à un cycle donné

Soit I1 l’instruction ld x5, 16(x6), avec x6 = 1 000 et la mémoire contenant 42 à l’adresse 1 016. Soit I2 une addition indépendante, I3 une soustraction indépendante et I4 une opération OU indépendante. Au cycle 4, le chargement lit la mémoire à l’adresse 1 016, I2 utilise l’unité arithmétique et logique, I3 lit les registres et I4 est récupérée. Au cycle 5, le chargement écrit 42 dans x5. Une colonne contient le travail de plusieurs instructions, et non plusieurs étages du chargement.

Représenter un blocage sans arrêter les instructions plus anciennes

Utilise maintenant ld x10, 0(x20) suivie de add x11, x10, x12, puis d’une instruction indépendante. Avec le court-circuit, l’instruction consommatrice immédiate nécessite toujours un blocage :

• Le chargement occupe IF au cycle 1, ID au cycle 2, EX au cycle 3, MEM au cycle 4 et WB au cycle 5.
• L’instruction add occupe IF au cycle 2, ID au cycle 3, encore ID au cycle 4, EX au cycle 5, MEM au cycle 6 et WB au cycle 7.
• La troisième instruction occupe IF au cycle 3, encore IF au cycle 4, ID au cycle 5, EX au cycle 6, MEM au cycle 7 et WB au cycle 8.

L’instruction add attend en ID pendant qu’une bulle traverse EX. Le chargement continue normalement ; le figer retarderait précisément la valeur dont add a besoin. Chaque instruction plus récente est retardée avec add.

Compter la séquence une seule fois

Un pipeline à cinq étages nécessite n + 4 cycles sans blocage. Chaque blocage inséré ajoute un cycle, ce qui donne n + 4 + nombre de blocages lorsqu’il n’y a pas d’autres pertes. L’exemple à trois instructions se termine au cycle 8 : trois instructions, quatre intervalles supplémentaires pour les étages et un blocage.

Les quatre premiers cycles remplissent le pipeline et les quatre derniers le vident. Ce sont deux façons de voir le même déroulement en n + 4 cycles, et non deux ajouts distincts de quatre cycles. Pour une longue séquence, leur contribution fixe est faible ; pour une courte séquence, elle peut dominer l’accélération.

Un aléa empêche l’instruction suivante de s’exécuter au cycle prévu. Pour le diagnostiquer, repère la ressource ou la valeur nécessaire, le cycle où elle est nécessaire et celui où elle devient disponible.

Distinguer trois types d’aléas

Des mémoires d’instructions et de données distinctes suppriment le conflit structurel entre IF et MEM. Écrire dans le banc de registres pendant la première moitié d’un cycle et le lire pendant la seconde permet aussi à WB et ID de le partager. Avec ces dispositions, il ne reste aucun aléa structurel dans ce modèle à cinq étages.

Repérer l’instruction qui produit réellement la valeur

Une dépendance de lecture après écriture (RAW) existe lorsqu’une instruction ultérieure lit une valeur écrite par une instruction précédente. Dans add x1, x2, x3 suivie de sub x4, x1, x5, l’instruction add produit x1 et l’instruction sub la consomme. Sans aide, sub lit x1 en ID au cycle 3, avant que add l’écrive en WB au cycle 5.

Une dépendance d’écriture après lecture (WAR) réutilise un registre après qu’une instruction plus ancienne l’a lu. Une dépendance d’écriture après écriture (WAW) donne la même destination à deux instructions. Ces dépendances de nom ne provoquent pas d’aléas dans le circuit à cinq étages exécuté dans l’ordre : les lectures ont lieu en ID et les écritures en WB dans l’ordre du programme. Elles comptent lorsqu’on détermine si le logiciel peut réordonner les instructions.

Suivre une séquence avec des destinations répétées

Considère :

ld  x5, 0(x10)
add x6, x5, x7
sub x5, x8, x9
or  x9, x6, x5

Les liens RAW sont chargement → addition par x5, addition → OU par x6 et soustraction → OU par x5. L’opération OU a besoin de la nouvelle valeur de x5 produite par la soustraction, et non de l’ancienne valeur chargée. Chercher uniquement des noms de registres identiques peut masquer ce changement d’instruction productrice.

La soustraction écrit x5 après que l’addition a lu x5 : c’est une dépendance WAR. Le chargement et la soustraction ont aussi une dépendance WAW sur x5. L’opération OU écrit x9 après que la soustraction l’a lu : c’est une autre dépendance WAR. Aucune ne crée d’aléa matériel WAR ou WAW dans ce pipeline exécuté dans l’ordre.

Compter les attentes sans court-circuit

Avec le seul banc de registres où l’écriture précède la lecture, une instruction consommatrice immédiate nécessite deux cycles de blocage. Elle doit retarder sa lecture en ID du cycle 3 au cycle 5. Une instruction indépendante entre la productrice et la consommatrice réduit l’attente à un blocage. Deux instructions indépendantes permettent à la consommatrice d’atteindre ID pendant le cycle WB de la productrice, sans blocage.

Une dépendance est une propriété du programme ; le fait qu’elle crée un blocage dépend du moment des opérations et des chemins disponibles. Une dépendance RAW éloignée peut ne nécessiter aucune intervention. Le registre x0 ne fournit jamais de résultat en attente, car sa lecture renvoie toujours zéro et il ignore les écritures.

Le logiciel peut insérer des instructions nop ou déplacer des instructions indépendantes dans les intervalles d’attente. Le matériel peut transmettre les résultats par court-circuit ou insérer automatiquement des blocages. Les deux approches doivent permettre à chaque instruction consommatrice de recevoir la valeur écrite par son instruction productrice dans l’ordre du programme.

Un résultat de l’unité arithmétique et logique existe avant d’être écrit dans le banc de registres. Le court-circuit, aussi appelé transmission par court-circuit, dirige ce résultat directement vers l’entrée d’une instruction ultérieure, sans attendre son passage par le banc de registres.

Sélectionner la source de chaque opérande

Deux multiplexeurs alimentent les chemins d’exécution. ForwardA sert rs1 et ForwardB sert rs2. Chaque opérande est vérifié indépendamment.

Le chemin depuis EX/MEM atteint l’instruction immédiatement suivante. Le chemin depuis MEM/WB atteint une instruction située deux places plus loin et peut transmettre soit un résultat de l’unité arithmétique et logique, soit des données chargées. ForwardB alimente aussi le chemin des données à ranger avant qu’ALUSrc choisisse entre cette valeur et une valeur immédiate.

Vérifier l’autorisation, la destination et la correspondance

Pour ForwardA = 10, l’instruction dans EX/MEM doit avoir RegWrite = 1, un rd non nul et un rd égal à ID/EX.rs1. Remplace rs1 par rs2 pour le test de ForwardB. Un rangement ou un branchement ne doit pas être considéré comme une instruction productrice simplement parce que ses bits ressemblent à un numéro de destination. Les écritures dans x0 ne doivent pas non plus devenir des valeurs transmises par court-circuit.

Pour ForwardA = 01, effectue les vérifications correspondantes de RegWrite, de rd non nul et de correspondance des registres sur MEM/WB. Utilise ce résultat plus ancien uniquement si EX/MEM ne fournit pas déjà l’opérande nécessaire. ForwardB suit indépendamment la même règle de priorité.

Suivre un résultat auprès des instructions consommatrices suivantes

Commence par add x1, x2, x3, avec x2 = 10 et x3 = 5. Cette instruction produit 15 à la fin de EX au cycle 3.

• L’instruction suivante, sub x4, x1, x5, atteint EX au cycle 4. Avec x5 = 3, ForwardA = 10 fournit 15 et la soustraction donne 12.
• and x6, x7, x1 atteint EX au cycle 5. ForwardB = 01 prend x1 dans MEM/WB.
• or x8, x1, x9 lit les registres en ID au cycle 5, après l’écriture de add pendant la première moitié du cycle. Elle n’a pas besoin de court-circuit en EX.

Aucun blocage n’est nécessaire pour ces dépendances portant sur un résultat de l’unité arithmétique et logique. L’instruction consommatrice reçoit la valeur lorsqu’elle utilise cette unité, même si sa lecture précédente en ID a obtenu une valeur périmée.

Résoudre deux correspondances avec des instructions qui écrivent

Dans les trois instructions consécutives add x1, x1, x2, add x1, x1, x3 et add x1, x1, x4, EX/MEM et MEM/WB correspondent tous deux à rs1 de la troisième instruction. EX/MEM contient le résultat de la deuxième instruction add, la valeur de x1 la plus récente. MEM/WB contient le résultat de la première instruction add et ne doit pas être prioritaire.

Les mêmes chemins permettent à add x5, x6, x7 d’alimenter sd x5, 0(x8) sans blocage. La valeur x5 transmise par court-circuit atteint le chemin des données à écrire dans la mémoire pendant que l’unité arithmétique et logique du rangement utilise le déplacement immédiat.

Le court-circuit ne peut pas fournir des données avant qu’elles existent. Pour un chargement, EX/MEM contient son adresse, et non la valeur chargée. L’instruction consommatrice immédiate doit attendre que le chargement termine MEM ; transmettre l’adresse par court-circuit conduirait à calculer sans avertissement avec la mauvaise quantité.

Un chargement produit les données à la fin de MEM. L’instruction qui le suit immédiatement aurait besoin de ces données au début de EX pendant le même cycle. Un blocage décale l’étage EX de l’instruction consommatrice au cycle suivant, lorsque MEM/WB peut fournir la valeur.

Détecter la valeur manquante en ID

L’unité de détection des aléas examine l’instruction en EX et l’instruction en cours de décodage. Le test de base vérifie que ID/EX.MemRead = 1 et que ID/EX.rd correspond à l’un des champs de numéro source dans IF/ID. Un test affiné exclut rd = x0 et vérifie quels champs sources l’instruction décodée lit réellement.

Cette dernière vérification évite un blocage injustifié sur une instruction de type I dont les bits de valeur immédiate occupent la position habituelle de rs2. Comparer les positions brutes des champs est sans danger, mais peut retarder une instruction qui ne lit pas réellement le registre.

Retenir les instructions plus récentes et faire avancer le chargement

Le blocage effectue trois actions coordonnées :

1. Mettre à zéro les signaux de commande entrant dans ID/EX, en insérant une bulle.
2. Fixer PCWrite = 0 pour conserver l’adresse de récupération inchangée.
3. Fixer IF/IDWrite = 0 pour conserver l’instruction qui attend en ID.

Le chargement et les instructions plus anciennes continuent d’avancer. La bulle traverse les étages suivants sans écrire dans les registres ou la mémoire. Figer ID/EX alors qu’il contient encore le chargement répéterait celui-ci au lieu d’insérer une opération vide.

Pour ld x10, 0(x20) suivie de add x11, x10, x12, le chargement est en EX et l’instruction add en ID pendant le cycle 3. Au cycle 4, le chargement est en MEM, la bulle en EX et add toujours en ID. Au cycle 5, le chargement est en WB et add atteint EX avec ForwardA = 01.

Ordonnancer des instructions indépendantes

Considère :

ld  x10, 0(x20)
ld  x11, 8(x20)
add x12, x10, x11
sd  x12, 24(x20)
ld  x13, 16(x20)
add x14, x10, x13
sd  x14, 32(x20)

Les utilisations de x11 et x13 suivent immédiatement leurs chargements. Avec le court-circuit, elles provoquent deux blocages, ce qui donne 7 + 4 + 2 = 13 cycles. Déplace ld x13, 16(x20) en troisième position, avant la première instruction add. Elle sépare le chargement de x11 de l’instruction qui le consomme et place x13 suffisamment loin devant l’instruction qui le consomme. La séquence prend maintenant 7 + 4 = 11 cycles.

Le déplacement est valide, car le chargement lit x20, que les instructions franchies ne modifient pas. Sa destination x13 n’affecte pas ces instructions. Son adresse x20 + 16 est distincte de l’adresse x20 + 24 du rangement franchi. Un chargement ne peut pas être déplacé avant un rangement susceptible d’écrire les octets qu’il lit. Le réordonnancement doit préserver les dépendances RAW, WAR, WAW et mémoire.

Combiner blocages et court-circuit

Pour ld x5, 0(x10), add x6, x5, x7, sub x5, x8, x9 et or x9, x6, x5, seule la paire immédiate de chargement-utilisation provoque un blocage. Lorsque l’opération OU atteint EX, ForwardA = 01 fournit x6 de l’addition et ForwardB = 10 fournit x5 de la soustraction. Le total est de 4 + 4 + 1 = 9 cycles.

La récupération a besoin d’une nouvelle adresse à chaque cycle. Un branchement conditionnel ne fournit le bon choix qu’après sa comparaison et le calcul de sa cible. Ce décalage crée un aléa de contrôle.

Relier l’étage de résolution à la pénalité

Dans un pipeline à cinq étages avec redirection après l’étage de résolution, une issue connue à la fin de ID fait perdre un créneau de récupération en cas d’erreur de prédiction. Une résolution à la fin de EX en fait perdre deux ; à la fin de MEM, elle en fait perdre trois. Des instructions plus récentes sont déjà entrées pendant ces créneaux.

Une stratégie consiste à bloquer la récupération jusqu’à la décision de chaque branchement. Elle est simple, mais les branchements pris et non pris subissent tous deux l’attente complète. La stratégie prédire que le branchement n’est pas pris continue à PC + 4. Une prédiction correcte ne nécessite aucune correction. Un branchement pris redirige la récupération et abandonne les instructions plus récentes du chemin séquentiel.

Suivre un branchement pris

Récupère beq x1, x2, 16 à l’adresse 100 au cycle 1 et résous le branchement à la fin de EX au cycle 3. La prédiction de branchement non pris récupère les instructions aux adresses 104 et 108 aux cycles 2 et 3. Si le branchement est pris, ces deux instructions appartiennent au mauvais chemin. La récupération commence à l’adresse 116 au cycle 4, après une pénalité de deux cycles.

Une purge du pipeline empêche ces entrées plus récentes de modifier l’état architectural ou de déclencher des exceptions. L’implémentation peut invalider les entrées ou neutraliser leurs signaux de commande et leurs effets sur les exceptions. Un rangement du mauvais chemin ne doit jamais aboutir à une écriture effective en mémoire.

Une bulle n’est pas la même chose qu’une instruction RISC-V dont tous les bits sont à zéro. Le codage entièrement nul est illégal. Si un véritable codage d’instruction est inséré, le nop canonique est addi x0, x0, 0, codé par 0x00000013. Une entrée de pipeline annulée ne représente, elle, aucune instruction exécutée.

Résoudre plus tôt, mais obtenir les opérandes plus tôt

Déplacer le comparateur et l’additionneur de la cible de branchement en ID réduit la pénalité de redirection à un cycle. La comparaison a désormais besoin des valeurs sources en ID ; le seul court-circuit habituel vers EX ne suffit donc pas. Avec un court-circuit adapté vers ID, un branchement placé immédiatement après l’instruction arithmétique ou logique qui produit sa valeur attend un cycle. Immédiatement après un chargement producteur, il en attend deux. Une résolution plus précoce réduit le nombre de créneaux de récupération perdus, mais rend l’acheminement des opérandes plus exigeant.

La prédiction statique fixe une règle à l’avance. Les règles courantes sont toujours non pris, toujours pris, et pris vers l’arrière ou non pris vers l’avant. Un branchement vers l’arrière à la fin d’une boucle répète souvent la boucle, ce qui fait de cette direction un indice utile.

RISC-V ne possède pas de case de délai de branchement. Si un branchement est pris, son successeur séquentiel n’est pas exécuté simplement parce qu’il a été récupéré. Certaines anciennes architectures MIPS exécutaient ce successeur comme instruction d’une case de délai définie ; c’est une règle différente de l’architecture du jeu d’instructions.

Préserver une frontière d’exception précise

Une instruction illégale ou ecall transfère le contrôle à un gestionnaire. Les instructions plus anciennes se terminent ; l’instruction fautive et les instructions plus récentes ne valident pas leurs effets normaux. Le processeur enregistre le PC de l’instruction fautive et la cause, à l’aide de registres comme sepc/scause en mode superviseur ou mepc/mcause en mode machine, puis récupère les instructions à l’adresse du gestionnaire. Cette exception précise présente l’état comme une frontière entre les instructions plus anciennes terminées et les opérations ultérieures non achevées.

La prédiction dynamique apprend à partir des issues observées pendant l’exécution d’un programme. Une table d’historique des branchements (BHT) stocke de petites entrées d’état sélectionnées à l’aide de bits d’une adresse de branchement. Prédis d’abord, compare plus tard avec l’issue réelle, puis mets l’entrée à jour.

Comprendre pourquoi un bit se trompe deux fois dans une boucle

Un prédicteur à 1 bit mémorise l’issue précédente. Si le dernier branchement était pris, il prédit qu’il sera pris la prochaine fois ; sinon, il prédit qu’il ne sera pas pris. Pour une boucle exécutée à répétition dont le branchement est pris neuf fois puis non pris une fois, la sortie laisse le bit à non pris.

À l’exécution suivante, le premier branchement pris est mal prédit. Les branchements pris intermédiaires font passer le bit à pris, de sorte que la sortie finale non prise est elle aussi mal prédite. En régime établi, cela fait deux erreurs pour dix issues, soit 80 % de réussite.

Ajouter un second bit pour maintenir la prédiction

Un compteur saturant à 2 bits possède les états de 0 à 3. Les états 0 et 1 prédisent que le branchement n’est pas pris ; 2 et 3 prédisent qu’il est pris. Une issue prise incrémente le compteur et une issue non prise le décrémente. Les valeurs s’arrêtent à 0 et 3.

Depuis l’état 3, une sortie non prise fait passer l’état à 2, qui prédit toujours que le branchement est pris. La prochaine entrée dans la boucle est donc prédite correctement. Pour cette même boucle de dix issues, il y a une erreur par exécution en régime établi, soit 90 % de réussite. Deux issues contraires consécutives sont nécessaires pour inverser une prédiction à partir d’un état fort.

Suivre les prédictions avant la mise à jour

Pars de l’état 1 et observe pris, pris, non pris, pris :

1. L’état 1 prédit non pris : incorrect. Incrémente à 2.
2. L’état 2 prédit pris : correct. Incrémente à 3.
3. L’état 3 prédit pris : incorrect. Décrémente à 2.
4. L’état 2 prédit pris : correct. Incrémente à 3.

Il y a deux erreurs et l’état final est 3. Mettre à jour avant de prédire donnerait à tort au prédicteur accès à l’issue qu’il est censé deviner.

Distinguer direction, cible et interférence

Deux adresses de branchement peuvent indexer la même entrée de la table d’historique des branchements. Cette collision permet à leurs issues d’interférer. Une erreur de prédiction coûte des cycles, mais la correction vérifie l’issue réelle et préserve la justesse du résultat.

Un tampon des cibles de branchement (BTB) fournit une adresse, et pas seulement un bit de direction. Consulté avec le PC pendant IF, il peut fournir la cible prédite d’un branchement pris pour le cycle de récupération suivant, avant le décodage. La prédiction de direction décide d’utiliser ou non cette cible.

Un historique simple a ses limites. Pour une alternance stricte pris/non pris, un prédicteur à 1 bit se trompe constamment une fois qu’il suit cette alternance. Un compteur à 2 bits a raison au plus une fois sur deux ; s’il commence à l’état 1 avant une issue prise, il se trompe à chaque fois. Les prédicteurs à corrélation ajoutent l’historique des branchements récents, les prédicteurs à tournoi choisissent entre des prédicteurs, et une pile des adresses de retour prédit les cibles des retours de procédure. Les pipelines plus profonds rendent la correction plus coûteuse, car davantage d’opérations plus récentes s’accumulent avant la résolution.

La vitesse du pipeline dépend à la fois de la période d’horloge et des cycles passés à attendre ou à corriger une erreur. Le CPI effectif mesure ces cycles supplémentaires en moyenne sur le flux d’instructions.

Pondérer chaque coût par les instructions touchées

Pour une longue séquence à émission simple, pars du CPI idéal de 1. Ajoute chaque source distincte et non chevauchante de cycles perdus sous la forme de la fraction d’instructions touchées multipliée par le nombre de cycles perdus par événement. Un taux conditionnel nécessite aussi la fraction dont il dépend.

Supposons que 25 % des instructions soient des chargements et que 40 % de ces chargements soient suivis d’une instruction consommatrice immédiate. Chaque paire de ce type subit un blocage, donc la contribution des aléas de chargement-utilisation est de 0,25 × 0,40 × 1 = 0,10 cycle par instruction. Supposons que 15 % des instructions soient des branchements, que 10 % de ces branchements soient mal prédits et que la correction coûte deux cycles. La contribution des branchements est de 0,15 × 0,10 × 2 = 0,03.

L’addition des coûts indépendants donne CPI = 1 + 0,10 + 0,03 = 1,13. Imputer un blocage à chaque chargement donnerait 0,25 au lieu de 0,10. Appliquer le taux d’erreur de 10 % des branchements à chaque instruction conduirait de même à un décompte trop élevé.

Inclure la période d’horloge et le nombre d’instructions

Le temps d’exécution est égal au nombre d’instructions exécutées × CPI × période d’horloge. Une horloge à 4 GHz a une période de 0,25 ns. Pour 10⁹ instructions avec un CPI de 1,13, l’exécution prend 10⁹ × 1,13 × 0,25 ns = 0,2825 s. Le temps moyen par instruction est de 0,2825 ns.

Pour une courte séquence, compte explicitement les cycles de remplissage, de vidange et d’aléas. Le CPI de base idéal de 1 décrit le débit en régime établi ; un pipeline à cinq étages qui n’exécute que quelques instructions comporte aussi une contribution de quatre cycles pour son remplissage et l’achèvement de la séquence.

Comparer les stratégies de branchement à conditions égales

Conserve le coût de chargement-utilisation de 0,10, la fraction de branchements de 0,15 et la pénalité de deux cycles :

À période d’horloge et nombre d’instructions identiques, la prédiction dynamique est environ 1,24 fois plus rapide que l’attente, car 1,40/1,13 ≈ 1,24.

Pour comparer différents processeurs, compare CPI × période. Un circuit monocycle à 1 000 ps prend 1 000 ps par instruction. Un pipeline à 270 ps avec un CPI de 1,13 prend 305,1 ps par instruction, soit une accélération d’environ 3,28. Comparer le seul CPI favoriserait le CPI de 1 du circuit monocycle et conduirait à une conclusion erronée.

Comprendre le compromis suivant dans la conception

Un plus grand nombre d’étages de pipeline peut réduire le travail combinatoire par cycle. Il introduit aussi un surcoût lié aux registres et peut augmenter les pénalités de chargement-utilisation et d’erreur de prédiction. La seule fréquence d’horloge ne permet pas de décider si le circuit plus profond l’emporte.

L’émission multiple commence plusieurs instructions par cycle, ce qui permet un CPI inférieur à 1 et un nombre d’instructions par cycle (IPC) supérieur à 1. Les groupes d’émission statique sont choisis par le compilateur ; l’émission dynamique, ou exécution superscalaire, est décidée par le matériel et utilise souvent la spéculation et l’exécution dans le désordre. Les dépendances de données et la prédiction des branchements limitent toujours le chevauchement utile.