Toute instruction de processeur comporte plusieurs étapes dans son fonctionnement. Chacune de ces étapes prend un seul cycle CPU pour se terminer. Ces étapes sont la recherche d'instructions, le décodage d'instructions, l'exécution, l'accès à la mémoire et l'écriture différée. Respectivement, ceux-ci reçoivent l'instruction qui doit être complétée, séparent l'opération des valeurs en cours d'utilisation sur, exécutez le processus, ouvrez le registre sur lequel le résultat sera écrit et écrivez le résultat dans le S'inscrire.
Historique des processeurs de commandes
Dans les premiers ordinateurs, le processeur n'utilisait pas de pipeline d'instructions. Dans ces processeurs, chaque opération à cycle unique devait se produire pour chaque instruction. Cela signifiait qu'il fallait cinq cycles d'horloge pour que l'instruction moyenne soit entièrement traitée avant que la suivante puisse être lancée. Certaines opérations peuvent ne pas avoir besoin d'écrire de résultat dans un registre, ce qui signifie que les étapes d'accès à la mémoire et de réécriture peuvent être ignorées.
Cependant, un problème se cache lors de l'exécution d'une instruction complète dans l'ordre avant de pouvoir passer à l'instruction suivante. Le problème est le manque de cache. La CPU stocke les données qu'elle traite activement dans le registre. Celui-ci est accessible avec une latence d'un cycle. Le problème est que le registre est minuscule car il est intégré au cœur du processeur. Le processeur doit accéder au cache L1 plus grand mais plus lent si les données n'ont pas déjà été chargées. S'il n'y est pas, il doit retourner dans le cache L2 plus grand et plus lent. La prochaine étape est le cache L3; la dernière option est la RAM système. Chacune de ces options nécessite de plus en plus de cycles CPU pour être vérifiée.
Maintenant, cette latence supplémentaire supplémentaire peut être un gros problème dans un système qui doit terminer chaque instruction dans l'ordre dans son intégralité avant de commencer l'instruction suivante. Ce qui était un processeur à 5 cycles par instruction peut soudainement être bloqué sur une instruction pendant des dizaines ou des centaines de cycles d'horloge. Pendant tout ce temps, rien d'autre ne peut se produire sur l'ordinateur. Techniquement, cela peut être quelque peu atténué en ayant deux cœurs indépendants. Rien, cependant, ne les empêche tous les deux de faire la même chose, potentiellement simultanément. Donc, emprunter la route multicœur ne résout pas ce problème.
Le pipeline RISC classique
RISC signifie ordinateur à jeu d'instructions réduit. C'est un style de conception de processeur qui optimise les performances en facilitant le décodage de chaque instruction. Ceci est en comparaison avec CISC ou Complex Instruction Set Computer, qui conçoit des ensembles d'instructions plus complexes permettant à moins d'instructions d'être nécessaires pour effectuer les mêmes tâches.
La conception RISC classique comprend un pipeline d'instructions. Au lieu d'exécuter l'une des cinq étapes d'instruction dans un cycle donné, le pipeline permet d'exécuter les cinq étapes. Bien sûr, vous ne pouvez pas exécuter les cinq étapes d'une instruction dans un cycle. Mais vous pouvez mettre en file d'attente cinq instructions consécutives avec un décalage d'une étape chacune. De cette façon, une nouvelle instruction peut être complétée à chaque cycle d'horloge. Offrant une augmentation potentielle des performances par 5 pour une augmentation relativement faible de la complexité du cœur.
Les processeurs qui n'ont pas de pipeline ne peuvent être que sous-scalaires, car ils ne peuvent pas exécuter une instruction complète par cycle. Avec ce pipeline principal à cinq étapes, vous pouvez créer un processeur scalaire capable de terminer une instruction pour chaque processus. En créant des pipelines encore plus étendus, vous pouvez créer des processeurs superscalaires capables d'exécuter plusieurs instructions par cycle d'horloge. Bien sûr, il y a encore des problèmes potentiels.
Toujours séquentiel
Rien de tout cela ne résout le problème de l'attente de plusieurs cycles pour une réponse lorsqu'il est nécessaire d'interroger les différents niveaux de cache et de RAM. Il introduit également un nouveau problème. Que se passe-t-il si une instruction repose sur la sortie de l'instruction précédente? Ces problèmes sont résolus indépendamment avec un répartiteur avancé. Il planifie soigneusement l'ordre d'exécution afin qu'aucune instruction dépendant de la sortie d'une autre ne soit trop rapprochée. Il gère également les échecs de cache en garant une instruction et en la remplaçant dans le pipeline par d'autres instructions prêtes à être exécutées et ne nécessitant pas son résultat, en reprenant l'instruction lorsqu'elle est prêt.
Ces solutions peuvent fonctionner sur des processeurs non pipelinés, mais elles sont nécessaires pour un processeur superscalaire qui exécute plus d'une instruction par horloge. Un prédicteur de branche est également très utile car il peut essayer de prédire le résultat d'une instruction avec plus d'un résultat potentiel et continuer à supposer qu'il est correct, sauf preuve du contraire.
Conclusion
Un pipeline permet d'utiliser toutes les capacités distinctes du processeur à chaque cycle. Pour ce faire, il exécute simultanément différentes étapes de différentes instructions. Cela n'ajoute même pas beaucoup de complexité à la conception du processeur. Cela ouvre également la voie pour permettre à plus d'une instruction d'effectuer une seule étape par cycle.