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

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

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:

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

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.

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.

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.

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.

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.