Comment un processeur peut-il exécuter plus d'IPS que sa fréquence? [dupliquer]

C'est quelque chose que je n'arrive pas à comprendre. Presque tous les processeurs modernes sont capables d'exécuter plus d'instructions par seconde que sa fréquence.

Je peux comprendre pourquoi les processeurs de classe inférieure peuvent exécuter moins d'IPS que sa fréquence. Par exemple, l' ATmega328 exécute environ 16 MIPS à 16 MHz (ou du moins c'est ce que l'on m'a dit), et le Z80 exécute 0,5 MIPS à 4 MHz. Mais alors, le Pentium 4 Extreme peut exécuter plus de 9 GIPS à seulement 3,2 GHz. Cela représente environ trois instructions par cycle d'horloge!

Comment cela se fait-il et pourquoi cela n'est-il pas implémenté dans des processeurs plus petits, tels que les microcontrôleurs AVR ?

J'ai trouvé toutes mes informations, à l'exception de l'ATmega328, d' ici .

Cela est dû à une combinaison de fonctionnalités des processeurs modernes.

La première chose qui contribue à un IPS élevé est le fait que les processeurs modernes disposent de plusieurs unités d'exécution qui peuvent fonctionner indépendamment. Dans l'image ci-dessous (empruntée à Wikipedia: Intel Core Microarchitecture ), vous pouvez voir en bas qu'il y a huit unités d'exécution (affichées en jaune) qui peuvent toutes exécuter des instructions simultanément. Toutes ces unités ne peuvent pas sécuriser les mêmes types d'instruction, mais au moins 5 d'entre elles peuvent effectuer une opération ALU et il y a trois unités capables SSE.

Combiner cela avec un long pipeline d'instructions qui peut efficacement empiler des instructions prêtes pour que ces unités exécutent des instructions ( hors service , si nécessaire) signifie qu'un processeur moderne peut avoir un grand nombre d'instructions à la volée à tout moment donné.

Chaque instruction peut prendre quelques cycles d'horloge à exécuter, mais si vous pouvez efficacement paralléliser leur exécution, vous pouvez vous donner un coup de pouce massif à IPS au détriment de la complexité du processeur et de la sortie thermique.

Garder ces gros pipelines pleins d'instructions nécessite également un grand cache qui peut être pré-rempli d'instructions et de données. Cela contribue à la taille de la matrice et à la quantité de chaleur produite par le processeur.

La raison pour laquelle cela n'est pas fait sur des processeurs plus petits est qu'elle augmente considérablement la quantité de logique de contrôle requise autour des cœurs de traitement, ainsi que la quantité d'espace requis et également la chaleur générée. Si vous voulez un petit processeur à faible puissance et très réactif, vous voulez un pipeline court sans trop de choses "supplémentaires" entourant les cœurs fonctionnels réels. Donc, généralement, ils minimisent le cache, le limitent à un seul de chaque type d'unité requis pour traiter les instructions et réduisent la complexité de chaque partie.

Ils pourraient rendre un petit processeur aussi complexe que un processeur plus grand et atteindre des performances similaires, mais les besoins en puissance et en refroidissement seraient alors augmentés de façon exponentielle.

Ce n'est pas difficile à imaginer. Un cycle suffit pour commuter plusieurs milliers de transistors. Tant que les instructions sont alignées en parallèle, un cycle peut être suffisant pour toutes les exécuter.

Mieux que d'essayer de l'expliquer moi-même, voici un bon point de départ .

Pour être un peu plus fondamental que la réponse de Mokubai:

Les processeurs superscalaires analysent le flux d'instructions pour les dépendances de données (et autres) entre les instructions. Les instructions qui ne dépendent pas les unes des autres peuvent s'exécuter en parallèle.

Les processeurs de bureau x86 typiques récupèrent 16 ou 32B d'instructions à chaque cycle d'horloge. Les conceptions Intel depuis Core2 peuvent émettre jusqu'à 4 instructions par cycle. (Ou 5, s'il y a une comparaison et une branche qui peuvent fusionner en macro).

Voir la belle réponse de Mobukai pour les liens et les détails sur la façon dont les processeurs dans la pratique se chargent d'extraire autant de parallélisme au niveau des instructions que dans le code qu'ils exécutent.

Voir également http://www.realworldtech.com/sandy-bridge/ et des articles similaires pour d'autres architectures CPU pour une explication approfondie de ce qui se cache sous le capot.

Les réponses précédentes montrent comment on obtient plus d'instructions exécutées par la définition du processeur "instruction" et on imagine que c'est réellement l'intention du questionneur.

Mais une autre source peut être que chaque "instruction" est en fait une certaine quantité de données traitées comme une instruction entrée par le processeur. Si le comptage de sa source ne compte que ce que le processeur considère comme des instructions, ce qui suit n'ajoute rien. Mais si sa source compte tout ce qu'un humain appellerait une «instruction», alors: Ajoutez que toutes les instructions ne sont pas aussi longues physiquement que toutes les autres instructions (une peut être de 12 octets, une autre peut être de 56 octets, etc.). Donc, s'il charge 64 octets de matériel à chaque cycle comme "une instruction" (ou autant d'instructions complètes que possible avant de frapper 64 octets) et que l'un contient six instructions dans ces 64 octets, alors six instructions (comme vous et moi pourrions les considérer ) sera terminé au cours de ce cycle.

Étant donné que de nombreuses instructions très basiques (notre définition "sensée") sont des restes des premiers jours avec des longueurs d'instructions de 8 octets, et que les instructions très basiques sont, par définition, peut-être utilisées de manière disproportionnée, cela irait très loin pour avoir plus "d'instructions" exécutées que la fréquence ne semble le permettre.