Pourquoi ne pouvez-vous pas avoir à la fois des instructions élevées par cycle et une vitesse d'horloge élevée?

37

Le mythe Megahertz est devenu une tactique promotionnelle en raison des différences entre le processeur INTEL 8086 du PC et le processeur Rockwell 6502 d’Apple. Le 8086 fonctionnait à 4,77 MHz tandis que le 6502 fonctionnait à 1 MHz. Cependant, les instructions sur le 6502 nécessitaient moins de cycles; tellement moins, en fait, qu'il a fonctionné plus rapidement que le 8086. Pourquoi certaines instructions nécessitent-elles moins de cycles? Et pourquoi les instructions du 6502, nécessitant moins de cycles, ne peuvent-elles pas être combinées avec un processeur à cycle rapide du 8086?

L'article de Wikipedia pour instructions par cycle (IPC) dit

Facteurs régissant l'IPC
Un niveau donné d'instructions par seconde peut être atteint avec un IPC élevé et une vitesse d'horloge basse ... ou à partir d'un IPC bas et d'une vitesse d'horloge élevée.

Pourquoi ne pouvez-vous pas avoir à la fois des instructions élevées par cycle et une vitesse d'horloge élevée?

Peut-être que cela a à voir avec ce qu'est un cycle d'horloge? Wikipedia mentionne la synchronisation des circuits? Je ne suis pas sûr de ce que cela veut dire.

Ou peut-être que cela a à voir avec le fonctionnement d'un pipeline? Je ne sais pas pourquoi les instructions dans un court pipeline sont différentes des instructions dans un long pipeline.

Toute idée serait géniale! J'essaie juste de comprendre l'architecture derrière le mythe. Merci!

Les références:

Instruction par cycle vs augmentation du nombre de cycles

http://en.wikipedia.org/wiki/Instructions_per_cycle

http://en.wikipedia.org/wiki/Clock_cycle

dobus
la source
1
> Pourquoi certaines instructions nécessitent-elles moins de cycles? RISC / CISC (enfin, en quelque sorte ). Et pourquoi les instructions du 6502, nécessitant moins de cycles, ne peuvent-elles pas être combinées avec un processeur à cycle rapide du 8086? Ils peuvent et ont. Le problème est qu’une fois que vous avez déjà établi une base, il est difficile de tout laisser tomber et de commencer le prochain modèle à partir de zéro.
Synetech
@ Synetech, Intel a fait cela en présentant un jeu d'instructions CISC aux programmeurs, puis en les convertissant en instructions RISCier sur la puce
soandos
Eh bien, quand j'ai dit que les deux avaient été combinés, je voulais dire par des fabricants de puces complètement différents. Je n'ai pas de liste sous la main, mais il y en a d'autres (non-Intel / AMD) qui ont fait des choses comme ça. (La plupart des gens oublient qu'il y a beaucoup de fabricants de puces car Intel et AMD dominent désormais le marché des ordinateurs de bureau.)
Synetech

Réponses:

21

tl; dr

Des pipelines plus courts signifient des vitesses d'horloge plus rapides, mais peuvent réduire le débit. Voir aussi les réponses 2 et 3 en bas (elles sont courtes, je vous le promets).

Version plus longue:

Il y a quelques points à considérer ici:

  1. Toutes les instructions ne prennent pas le même temps
  2. Toutes les instructions ne dépendent pas de ce qui a été fait immédiatement (ou même de dix ou vingt) instructions

Un pipeline très simplifié (ce qui se passe dans les puces Intel modernes est au-delà de la complexité) comporte plusieurs étapes:

Rechercher -> Décoder -> Accès à la mémoire -> Exécuter -> Écriture -> Mise à jour du compteur de programme

À chaque -> il y a un coût de temps qui est engagé. De plus, à chaque tick (cycle d'horloge), tout se déplace d'une étape à l'autre, de sorte que votre étape la plus lente devient la vitesse de TOUTES les étapes (il faut vraiment que leur durée soit aussi semblable que possible).

Supposons que vous avez 5 instructions et que vous voulez les exécuter (photo prise sur wikipedia, ici la mise à jour de l'ordinateur n'est pas terminée). Cela ressemblerait à ceci:

entrez la description de l'image ici

Même si chaque instruction nécessite 5 cycles d'horloge, une instruction terminée sort du pipeline à chaque cycle. Si le temps nécessaire pour chaque étape est de 40 ns et de 15 ns pour les bits intermédiaires (en utilisant mon pipeline à six étages ci-dessus), il faudra 40 * 6 + 5 * 15 = 315 ns pour obtenir la première instruction.

En revanche, si je supprimais complètement le pipeline (tout en conservant le même principe), il ne faudrait que 240 ns pour obtenir la première instruction. (Cette différence de vitesse pour obtenir la "première" instruction s'appelle latence. Elle est généralement moins importante que le débit, qui correspond au nombre d'instructions par seconde).

La vraie différence cependant est que dans l'exemple en pipeline, je reçois une nouvelle instruction (après la première) toutes les 60 ns. Dans le cas d'un pipeline, il en faut 240 à chaque fois. Cela montre que les pipelines sont efficaces pour améliorer le débit.

Pour aller un peu plus loin, il semblerait qu’au stade de l’accès à la mémoire, il me faudra une unité supplémentaire (pour effectuer les calculs d’adresse). Cela signifie que si une instruction n'utilise pas l'étape meme de ce cycle, je peux faire une autre addition. Je peux donc effectuer deux étapes d’exécution (dont l’une en phase d’accès mémoire) sur un processeur en un seul clic (la planification est un cauchemar, mais n'y allons pas. En outre, la phase de mise à jour de l'ordinateur nécessitera également une unité d'addition en plus. le cas d'un saut, donc je peux faire trois additions exécuter des états en un tick). Grâce à un pipeline, il peut être conçu de sorte que deux instructions (ou plus) puissent utiliser différentes étapes (ou étapes de sauts de brouillard, etc.), permettant ainsi de gagner un temps précieux.

Notez que pour ce faire, les processeurs font beaucoup de "magie" ( exécution dans le désordre , prédiction de branche , etc.), mais cela permet à plusieurs instructions de sortir plus rapidement que sans pipeline (notez que les pipelines trop volumineux). sont très difficiles à gérer et entraînent des coûts plus élevés simplement en attendant entre les étapes). Le revers de la médaille est que si le pipeline est trop long, vous pouvez obtenir une vitesse d'horloge insensée, mais perdre l'essentiel des avantages initiaux (avoir le même type de logique pouvant exister à plusieurs endroits et être utilisé simultanément). ).

Réponse n ° 2

Les processeurs SIMD (à instructions multiples multiples) (comme la plupart des GPU) travaillent beaucoup sur de nombreuses informations, mais leur traitement prend plus de temps. La lecture de toutes les valeurs prend plus de temps (signifie une horloge plus lente, bien que ce décalage soit compensé par un bus beaucoup plus large), mais vous pouvez obtenir beaucoup plus d'instructions à la fois (instructions plus efficaces par cycle).

Réponse # 3:

Parce que vous pouvez "tricher" et allonger artificiellement le nombre de cycles de manière à pouvoir exécuter deux instructions à chaque cycle (réduire de moitié la vitesse d'horloge). Il est également possible de ne faire quelque chose que tous les deux ticks au lieu d'un (en donnant une vitesse d'horloge 2x, mais sans changer les instructions une seconde).

soandos
la source
3
Des pipelines courts signifient des vitesses d'horloge plus lentes! WP: "NetBurst se distinguait du P6 (Pentium III, II, etc.) par un pipeline d’instructions très profond permettant d’atteindre des vitesses d’horloge très élevées". Le fait est que vous faites peu par étape pour atteindre des vitesses élevées. Cela n’a cependant pas fonctionné, et Intel a perdu un énorme élan face à AMD pour cette raison. Ils sont revenus à l’architecture Pentium 3 et ont proposé "Core".
Stolsvik
@stolsvik, pouvez-vous expliquer cela? Cela n'a aucun sens pour moi (avoir moins d'étages interstitiels, toutes choses étant égales par ailleurs, les cycles d'horloge seront plus courts, ce qui donnera une vitesse d'horloge plus élevée)
soandos
4
Une étape de pipeline est effectuée par cycle d'horloge ; L'ensemble du pipeline avance d'une étape par horloge - en récupérant de nouvelles instructions en bas, en "émettant" des instructions terminées en haut. Par conséquent, l’idée avec Pentium4 était de faire de très petites étapes rapides à réaliser, donnant des horloges hautes, mais nécessitant ainsi un long pipeline. L’idée d’un pipeline (tous les processeurs en utilisent un) est que vous avez plusieurs instructions en cours de traitement à tout moment. Un long pipeline signifie que de nombreuses instructions sont en cours - et si une prédiction de branche échoue, vous devrez vider tout le canal.
Stolsvik
Pour votre réponse n ° 2, la CPU n'accède aux données que via le cache (l'accès à la mémoire est généralement transparent du point de vue de l'instruction). Le ralentissement de la fréquence d'horloge n'affectera pas le temps nécessaire pour que les données proviennent de la RAM (si elles ne sont pas dans le cache). De plus, la largeur du bus n’affecte que la vitesse des opérations SIMD par rapport à la taille de vos opérandes (c’est-à-dire que je peux charger 8 opérandes 8 bits sur un bus 64 bits à la fois, mais je dois toujours charger manuellement 8 valeurs 64 bits. si j'ai des opérandes 64 bits).
Percée
2
Aussi pour la réponse n ° 1, quand vous dites "s'il y a une instruction qui n'utilise pas l'étape meme de ce cycle, alors je peux faire une autre addition", c'est faux. L'exécution hors service est appliquée au niveau instruction, pas au niveau micro-opération. Si une instruction nécessitait deux exécutions dans le pipeline, cela entraînerait une bulle dans le pipeline . Enfin, l'architecture x86 dispose d'une unité ALU distincte pour calculer les adresses de mémoire à la volée pendant les lectures / écritures en mémoire (permet l' [EBX+ECX*4+100]adressage de style).
Percée
8

Je simplifie énormément cela, mais le point important à retenir est que ces termes comparent des pommes à des oranges. Un "cycle" n'est pas une unité de mesure unifiée qui soit identique pour tous les processeurs, comme un "deuxième" est une mesure unifiée du temps. Au lieu de cela, un cycle représente une certaine unité de travail, qui est définie de manière quelque peu arbitraire mais limitée par la complexité de la conception du pipeline et bien sûr par la physique.

Dans de nombreux cas, beaucoup de travail en un cycle peut vous permettre de vider tout le pipeline. En cas de succès, cela signifie que votre prochain cycle ne sera pas optimisé, car vous devrez remplir à nouveau le pipeline, ce qui peut prendre un certain temps.

Je pouvais concevoir un processeur très simpliste qui traite une étape d’une instruction RISC à chaque cycle, et si c’était là la base de mon processeur, je pourrais probablement atteindre un nombre de cycles très élevé par seconde en raison de la complexité réduite de ce cycle".

Les détails entrent dans beaucoup de physique et d'ingénierie électrique que je ne comprends pas vraiment, mais rappelez-vous que la fréquence d'horloge n'est pas obtenue en ajoutant simplement naïvement la tension d'entrée au processeur et en espérant que tout se passe pour le mieux. À tout le moins, le profil thermique est une autre préoccupation nécessaire.

allquixotic
la source
Cela ne répond pas vraiment à sa question (ce qui n'a rien à voir avec pourquoi les choses ne peuvent pas être accélérées). Il demande combien de cycles = = plus de travail tout le temps
soandos
Cette réponse aborde toutefois un problème que je n’ai pas vu dans les autres réponses, à savoir l’inclusion de jeux d’instructions particuliers qui effectuent des opérations avec moins de cycles d’horloge et la possibilité de mesurer des cycles d’horloge en fonction des ensembles d’instructions les plus lents. ne pas être aussi efficace. (Je pourrais très bien me tromper ... Je trouve l'architecture fascinante, mais je ne me considère absolument pas comme un expert.)
Stephen R
5

Voici une explication très simple (peut-être excessivement simpliste): Disons que vous avez un travail particulier à faire, ajoutons deux nombres 32 bits. Vous pouvez prendre deux approches. Vous pouvez le diviser en un très grand nombre de très petites étapes ou en un petit nombre de très grandes étapes.

Par exemple, vous pouvez simplement dire "additionnez les deux nombres". Maintenant, vous n'avez plus qu'une étape. Mais cette étape comporte plusieurs parties et prendra plus de temps. Vous avez donc des instructions élevées par cycle - une dans ce cas. Mais votre vitesse d'horloge ne peut pas être élevée parce que vous avez beaucoup à faire dans ce cycle.

Vous pouvez aussi alternativement dire: "Récupérez le premier nombre dans un registre. Ensuite, récupérez le deuxième nombre. Ajoutez ensuite les bits les moins significatifs. Ajoutez ensuite le deuxième bit le moins significatif avec le report d'avant. Ajoutez ensuite le troisième ... Ajoutez ensuite les bits les plus significatifs. S'il y a eu un report, activez l'indicateur de dépassement. Ensuite, écrivez le résultat en mémoire. " Maintenant, vous avez un grand nombre d'étapes. Mais chaque étape peut être absurdement rapide. Donc, vous avez peu d'instructions par cycle (1/36 ou plus dans ce cas). Mais votre vitesse d'horloge peut être très élevée car chaque cycle n'a qu'un tout petit peu à faire.

Pour avoir à la fois des instructions élevées par cycle et une vitesse d'horloge élevée, vous devez diviser une instruction complexe en un très petit nombre d'étapes très simples. Mais cela ne peut pas être fait parce que l'instruction est complexe.

Les compromis spécifiques et les numéros de cycle sont très différents, car les processeurs modernes sont des instructions en pipeline et se chevauchent. Mais l'idée de base est correcte.

David Schwartz
la source
2

Vous pouvez avoir à la fois des instructions élevées par cycle et une vitesse d'horloge élevée. Vous rencontrez des limites lorsque le délai de propagation du circuit numérique dépasse la largeur d'impulsion d'un cycle d'horloge. Cela peut être surmonté en augmentant la tension du processeur, mais il convient de noter que cela augmentera la consommation d'énergie (et donc la chaleur dissipée).

Donc, si vous voulez une vitesse d'horloge plus rapide, vous devez augmenter la tension (en augmentant la vitesse de dérive des électrons ) pour réduire le délai de propagation. Si ce délai dépasse un cycle d'horloge, le processeur ne se comportera probablement pas comme prévu, et le logiciel qui s'exécute sur celui-ci se bloque ou génère une exception. Il existe évidemment une limite à la tension que vous pouvez utiliser avec un processeur, mais cela est dicté par la conception même du processeur, principalement par la capacité de transport de courant des voies électriques internes.


Le pipelining permet des vitesses d'horloge plus élevées dans certains cas, car chaque instruction est divisée en plusieurs "micro-opérations" plus petites. Ces micro-opérations sont des opérations très simples, utilisant des circuits beaucoup plus petits interconnectés dans une chaîne (au sens physique, car moins les électrons doivent parcourir une distance importante, plus le délai de propagation à travers une sous-unité particulière est court).

L'avantage supplémentaire d'un processeur en pipeline est que vous pouvez augmenter considérablement le nombre d'instructions exécutées par unité de temps, au détriment d'une conception plus complexe.

Quant à savoir pourquoi certaines instructions nécessitent plus ou moins de cycles, cela dépend de l’instruction que vous exécutez. Par exemple, dans le jeu d'instructions x86, il existe une MOVSinstruction qui peut déplacer une chaîne entière en mémoire d'un endroit à un autre. Clairement, vous ne pouvez pas copier instantanément une longue chaîne, mais vous pouvez le copier mot par mot en prenant plusieurs cycles d'horloge. Ainsi, l' MOVSinstruction prend un temps variable (en fonction du nombre de caractères à copier).

L'effet des opérations multi-cycles est moins visible sur une conception RISC (c'est-à-dire ARM) par opposition à une conception CISC (c'est-à-dire x86). En effet, les conceptions basées sur RISC ne comporteront que les opérations élémentaires les plus couramment utilisées et sont beaucoup plus faciles à canaliser de manière à obtenir un débit d'une instruction par cycle.

Percée
la source
1

Le temps que prend votre ordinateur pour terminer une tâche particulière ne dépend pas de la vitesse d'horloge de l'ordinateur ... cela dépend de la façon dont les unités de calcul sont conçues et conçues.

La vitesse d'horloge est en réalité une décision (plus ou moins) arbitraire prise par le concepteur de la CPU, parfois pour de bonnes raisons (efficacité), parfois pour de mauvaises raisons (publicité).

Supposons qu'un processeur donné ait un mélange d'instructions qui prennent entre 1 et 100 nanosecondes (ns) pour terminer. Vous pouvez définir une fréquence d'horloge telle que 1 "tick" soit égal à 100 ns (10 MHz), ce qui signifie que chaque instruction se termine avec exactement 1 tick. Toutefois, si les temps d'exécution des instructions sont répartis de manière égale, cela signifie que vos unités de calcul resteront inactives 50% du temps (la vitesse d'exécution moyenne serait de 50 ns, laissant les 50 nd restant inactifs). Si, en revanche, vous définissez votre tick comme étant 10ns, les instructions allaient de 1 à 10 ticks, mais l'unité ne serait jamais inactive plus de 9ns avant le début de l'instruction suivante et le temps d'inactivité moyen serait de 5ns.

Au cours du développement, un processeur sera conçu pour fonctionner à une certaine vitesse, en fonction de la quantité de travail qu’il est capable de réaliser. Si vous augmentez ou diminuez la vitesse d'horloge, vous ne modifiez pas réellement la quantité de travail que le processeur peut accomplir, vous ne faites que gâcher le taux d'efficacité.

(Et avant de pleurer sur les processeurs d'overclocking: cela vous donne deux avantages qui permettent des gains de vitesse réels: des instructions d'exécution rapides (qui prennent moins d'un cycle) aboutissent à des temps d'exécution plus courts et toutes les instructions ont moins de temps d'inactivité. votre ordinateur peut en réalité augmenter la quantité de travail que vous pouvez effectuer, mais vous constaterez que l'overclocking d'un processeur de X% n'équivaut pas toujours à une augmentation de X% du travail effectué lorsque vous le comparez.)

TL; DR

Un processeur peut accomplir X travail en une seconde. Si vous utilisez la vitesse d'horloge H et I IPC, nous avons I = X / H. Changer H ne change pas X, mais cela affecte I.

Benjamin Chambers
la source
1
La vitesse d'horloge est loin d'une décision arbitraire. Il doit être choisi avec soin en fonction de la tension d'alimentation de la CPU, ainsi que de la longueur des traces IC (pour éviter les retards de propagation excessifs).
Percée
Je pense que vous avez oublié le fait qu’un processeur est un circuit numérique synchrone . Les instructions ne prennent pas X nanosecondes (en supposant que votre cycle d'horloge est inférieur au délai de propagation), tout se passe sur un front d'horloge en hausse ou en baisse, ou les deux. Les instructions prennent X cycles, pas X unités de temps. Oui, vous pouvez modifier la durée d' un cycle, mais la distinction est ce qui se passe quand. Enfin, la quantité de travail qu'un processeur peut effectuer en une seconde est fonction de la vitesse d'horloge. Votre formule ne vérifie donc pas vraiment ici.
cp2141
Une CPU est une fusion synchrone de plusieurs unités asynchrones. Les ticks d’horloge sont utilisés pour bien aligner les choses, mais ils ne déterminent pas le temps d’exécution. Par exemple, un ajout d’entier prendra un certain temps en fonction de la distance parcourue par le courant dans le processeur et de la rapidité avec laquelle les transistors changera d'état. Le résultat est READ au prochain tick d'horloge, mais le calcul réel est effectué de manière asynchrone tout au long du tick.
Benjamin Chambers
0

On ne peut pas avoir à la fois des instructions élevées par cycle et une vitesse d'horloge élevée car les exigences sont contradictoires.

On peut montrer que, en première approximation, la CIB dépend de la complexité (A) de la conception

IPC = a sqrt (A)

alors que la fréquence maximale (F) pouvant être atteinte par la conception est à l'échelle [1]

F = 1 / {b + c sqrt (A)}

avec a, b et c paramètres.

Ainsi, augmenter la complexité du muarque augmente l'IPC au détriment de la réduction de la fréquence de travail, alors que la réduction de la complexité augmente la fréquence au détriment de l'IPC. Cela correspond aux deux cas extrêmes mentionnés dans l'article de Wikipédia, mais celle-ci ne mentionne pas les noms: Brainiac et speed-demon.

  • Conception Brainiac: IPC élevé et basse fréquence
  • Conception rapide: Haute fréquence et faible IPC.

[1] Certains auteurs affirment que l'expression correspondant à la fréquence est plutôt "1 / {b + c A}", mais dans les deux cas, une complexité croissante réduit la fréquence maximale réalisable.

juanrga
la source