Quelle est la différence entre Superscaling et pipelining?

https://stackoverflow.com/questions/1656608

11-09-2019
|

Question

Eh bien semble trop simple une question à poser, mais j'ai demandé après avoir traversé quelques ppts sur les deux.

Les deux méthodes augmentent le débit d'instruction. Et Superscaling presque fait toujours l'utilisation du pipelining aussi bien. Superscaling a plus d'une unité d'exécution et le fait pipelining ou je me trompe ici?

La solution

conception superscalaire implique le processeur étant en mesure d'émettre plusieurs instructions en une seule horloge, avec des équipements redondants pour exécuter une instruction. Nous parlons dans un seul noyau, l'esprit vous -. Le traitement multicœur est différent

Pipelining divise une instruction en étapes, et étant donné que chaque étape est exécutée dans une autre partie du processeur, de multiples instructions peuvent être de différentes « phases » chaque horloge.

Ils sont presque toujours utilisés ensemble. Cette image de Wikipedia montre à la fois les concepts utilisés, car ces concepts sont mieux expliqués graphiquement:

Ici, deux instructions sont en cours d'exécution à un moment dans un pipeline à cinq étapes.

Pour décomposer plus, compte tenu de votre édition récente:

Dans l'exemple ci-dessus, une instruction passe par 5 étapes pour être « exécuté ». Ceux-ci sont IF (instruction fetch), ID (décodage d'instruction), EX (exécution), MEM (mémoire de mise à jour), WB (écriture différée cache).

Dans une conception de processeur très simple, chaque horloge une autre étape serait terminée si nous aurions:

Ce qui ferait une instruction dans cinq horloges. Si l'on ajoute alors une unité d'exécution redondante et d'introduire la conception superscalaire, nous aurions cela, pour deux instructions A et B:

IF (A) IF (B)
ID (A) ID (B)
EX (A) EX (B)
MEM (A) MEM (B)
WB (A) WB (B)

Deux instructions dans cinq horloges -. Un gain maximum théorique de 100%

permet Pipelining les parties à exécuter simultanément, de sorte que nous retrouverions avec quelque chose comme (pour dix instructions A à J):

IF (A) IF (B)
ID (A) ID (B) SI (C) SI (D)
EX (A) EX (B) ID (C) ID (D) SI (E) IF (F)
MEM (A) MEM (B) EX (C) EX (D) ID (E) ID (F) IF (G) SI (H)
WB (A) WB (B) MEM (C) MEM (D) EX (E) EX (F) ID (G) ID (H) IF (I) IF (J)
WB (C) WB (D) MEM (E) MEM (F) EX (G) EX (H) ID (I) ID (J)
WB (E) WB (F) MEM (G) MEM (H) EX (I) EX (J)
WB (G) WB (H) MEM (I) MEM (J)
WB (I) WB (J)

Dans neuf horloges, nous avons exécuté dix instructions - vous pouvez voir où pipelining bouge vraiment les choses. Et c'est une explication de l'exemple graphique, pas comment il est effectivement mis en œuvre dans le domaine (qui est magie noire ).

Les articles de Wikipedia pour superscalaire et pipeline d'instruction sont assez bonnes.

Autres conseils

il y a longtemps , les processeurs exécutés une seule instruction de la machine à la fois . Seulement quand il a été complètement terminé ne la CPU l'instruction suivante extraction de la mémoire (ou, plus tard, le cache d'instructions).

Finalement, quelqu'un a remarqué que cela signifiait que la plupart d'une unité centrale de traitement n'a rien la plupart du temps, car il y avait plusieurs sous-unités d'exécution (tels que le décodeur d'instructions, l'unité arithmétique entière, et l'unité arithmétique FP, etc.) et de l'exécution une instruction a gardé un seul d'entre eux occupés à la fois.

Ainsi, « simples » pipelining est né: une fois une instruction a été fait le décodage et ensuite vers la sous-unité suivante d'exécution, pourquoi ne pas déjà chercher et décoder l'instruction suivante ? Si vous aviez 10 ces « étapes », puis par ayant chaque processus étape une instruction différente vous pourriez théoriquement augmenter le débit d'instruction dix fois sans augmenter l'horloge CPU du tout! Bien sûr, cela ne fonctionne que parfaitement quand il n'y a pas de sauts conditionnels dans le code (ce qui a conduit à beaucoup d'effort supplémentaire pour gérer les sauts conditionnels spécialement).

Plus tard, avec la loi de Moore continue d'être correct pour plus longtemps que prévu, les fabricants de CPU se sont retrouvés avec toujours plus de transistors à utiliser et pensé « pourquoi avoir qu'une seule de chaque sous-unité d'exécution? ». Ainsi, superscalaire processeurs avec plusieurs sous-unités d'exécution capable de faire les même chose en parallèle sont nés, dessins et modèles de processeurs sont devenus beaucoup, beaucoup plus complexe distribuer des instructions sur ces unités entièrement parallèles, tout en assurant les résultats étaient les mêmes que si les instructions ont été exécutées en séquence.

Analogie: Vêtements de lavage

Imagine un magasin de nettoyage à sec avec les installations suivantes:. Un bâti pour suspendre les vêtements sales ou propres, un lave-linge et un sèche-linge (dont chacun peut laver le vêtement à la fois), une table de pliage, et une planche à repasser

Le préposé qui fait tout le lavage réel et le séchage est witted-dim plutôt si le propriétaire du magasin, qui prend les commandes de nettoyage à sec, prend un soin particulier pour écrire chaque instruction très attentivement et explicitement.

Un jour typique de ces instructions peuvent être quelque chose le long des lignes de:

prendre la chemise du rack
se laver la chemise
sécher la chemise
fer la chemise
Replier la chemise
mettre la chemise de retour sur le rack
prendre le pantalon du rack
laver le pantalon
sécher le pantalon
plier le pantalon
mettre le pantalon en arrière sur le rack
prendre le manteau du rack
laver la couche
sécher la couche
fer manteau
mettre le manteau en arrière sur la grille

Le préposé suit ces instructions au départ, en faisant très attention de ne pas faire quoi que ce soit jamais hors d'usage. Comme vous pouvez l'imaginer, il faut beaucoup de temps pour la lessive de la journée fait parce qu'il faut beaucoup de temps pour se laver complètement sec et plier chaque pièce de linge, et il doit être fait un à la fois.

Cependant, un jour, le préposé quitte et une nouvelle, plus intelligent, préposé est embauché qui remarque que la plupart de l'équipement est ralenti à la pose tout moment pendant la journée. Alors que le pantalon séchaient ni la planche à repasser, ni la machine à laver étaient utilisés. Il a donc décidé de faire un meilleur usage de son temps. Ainsi, au lieu de la série d'étapes ci-dessus, il ferait ceci:

prendre la chemise du rack
se laver la chemise, prendre le pantalon du rack
sécher la chemise, se laver les pantalons
fer la chemise, sécher le pantalon
plier la chemise, (prendre le manteau du rack)
mettre la chemise de retour sur le rack, plier le pantalon , (laver le manteau)
mettre le pantalon en arrière sur le rack , (sécher la couche)
(fer manteau)
(mettre le manteau en arrière sur le rack)

Ceci est pipelining. Séquençage des activités non liées telles qu'elles utilisent des composants différents en même temps. En gardant autant des différents composants actifs à la fois que vous maximiser l'efficacité et accélérer le temps d'exécution, dans ce cas, la réduction de 16 « cycles » à 9, une accélération de plus de 40%.

Maintenant, le petit magasin de nettoyage à sec ont commencé à faire plus d'argent parce qu'ils pourraient travailler beaucoup plus vite, de sorte que le propriétaire a acheté un lave-glace, sèche-linge, planche à repasser, plier, et même embauché un autre agent. Maintenant, les choses sont encore plus rapides, au lieu de ce qui précède, vous avez:

prendre la chemise du rack, prendre le pantalon du rack
se laver la chemise, se laver le pantalon , (prendre le manteau du rack)
sécher la chemise, sécher le pantalon , (laver le manteau)
fer la chemise, plier le pantalon , (sécher la couche)
Replier la chemise, mettre le pantalon en arrière sur le rack , (fer manteau)
mettre la chemise de retour sur le rack, (mettre le manteau en arrière sur le rack)

Ceci est la conception superscalaire. sous-composants multiples capables de faire la même tâche en même temps, mais avec le processeur de décider comment le faire. Dans ce cas, il a donné lieu à une augmentation de la vitesse de près de 50% (en 18 « cycles » la nouvelle architecture pourrait courir à travers 3 itérations de ce « programme » tandis que l'architecture précédente ne pouvait courir à 2).

processeurs plus anciens, tels que le 386 ou 486, sont de simples processeurs scalaires, ils exécutent une instruction à la fois exactement l'ordre dans lequel il a été reçu. processeurs de consommation modernes since PowerPC / Pentium sont et superscalaire pipe-line. Un processeur Core2 est capable d'exécuter le même code qui a été compilé pour un 486 tout en tirant parti du parallélisme au niveau des instructions car il contient sa propre logique interne qui analyse le code de la machine et détermine comment réorganiser et l'exécuter (ce qui peut être exécuté en parallèle , ce qui ne peut pas, etc.) Ceci est l'essence du design superscalaire et pourquoi il est si pratique.

En revanche un processeur de vecteur parallèle effectue des opérations sur plusieurs morceaux de données à la fois (un vecteur). Ainsi, au lieu de simplement ajouter x et y un processeur vectoriel ajouterait, disons, x0, x1, x2 à y0, y1, y2 (résultat z0, z1, z2). Le problème avec cette conception est qu'elle est étroitement couplé au degré de parallélisme spécifique du processeur. Si vous exécutez le code scalaire sur un processeur vectoriel (en supposant que vous pourrait) vous verriez aucun avantage du vecteur parallélisation, car il doit être utilisé de façon explicite, de même si vous voulez profiter d'un nouveau processeur vectoriel avec des unités de traitement plus parallèles (par exemple capable d'ajouter des vecteurs de 12 numéros au lieu de seulement 3) dont vous auriez besoin de recompiler votre code. conceptions de processeur vectoriel ont été très populaires dans la génération la plus ancienne des super ordinateurs parce qu'ils étaient faciles à concevoir et il y a de grandes classes de problèmes en sciences et en génie avec beaucoup de parallélisme naturel.

processeurs superscalaires peuvent également avoir la possibilité d'effectuer une exécution spéculative. Plutôt que de laisser des unités de traitement au ralenti et en attente d'un chemin de code pour terminer l'exécution avant de bifurquer un processeur peut faire une meilleure estimation et commencer l'exécution du code passé la branche avant le code avant la fin du traitement. Lorsque l'exécution du code avant rattrape le point de branchement du processeur peut alors comparer la branche réelle avec la conjecture de branche et soit continuer si la conjecture était correcte (déjà bien avant l'endroit où il aurait été simplement en attente) ou il peut invalider les résultats de l'exécution spéculative et exécuter le code pour la branche correcte.

est Pipelining ce qu'une entreprise automobile fait dans la fabrication de leurs voitures. Ils rompent le processus de mettre sur pied une voiture en étapes et effectuer les différentes étapes à différents points le long d'une ligne d'assemblage fait par différentes personnes. Le résultat net est que la voiture est fabriquée exactement la vitesse la plus lente seule fin.

Dans le processus de processeurs est pipelining exactement la même chose. Une « instruction » se décompose en différentes étapes d'exécution, quelque chose comme 1. d'extraction d'instruction, 2. (registres opérandes chercher ou valeurs mémoire qui sont lus), 2. effectuer des calculs, 3. les résultats d'écriture (à la mémoire ou registres) . Le plus lent de cela pourrait être la partie de calcul, auquel cas la vitesse globale du débit des instructions à travers ce pipeline est que la vitesse de la partie de calcul (comme si les autres parties étaient « libres »).

Super-scalaire dans les microprocesseurs se réfère à la possibilité d'exécuter plusieurs instructions à partir d'un seul flux d'exécution à la fois en parallèle. Donc, si une compagnie de voiture a couru deux lignes d'assemblage alors il est évident qu'ils pouvaient produire deux fois plus de voitures. Mais si le processus de mettre un numéro de série sur la voiture était à la dernière étape et a dû être fait par une seule personne, alors ils doivent alterner entre les deux pipelines et garantir qu'ils pourraient obtenir chacun fait dans la moitié du temps de étape la plus lente afin d'éviter de devenir la plus lente étape eux-mêmes.

superscalaire dans les microprocesseurs est similaire, mais a généralement beaucoup plus de restrictions. Donc, l'instruction produira étape d'extraction généralement plus d'une instruction au cours de sa phase - c'est ce qui rend super-scalaire dans les microprocesseurs possibles. Il y aurait alors deux étapes Fetch, deux étapes d'exécution et deux étapes d'écriture en arrière. Cela généralise évidemment plus que deux pipelines.

Ceci est bien beau, mais du point de vue de l'exécution de son deux techniques pourrait conduire à des problèmes si elle est faite à l'aveuglette. Pour l'exécution correcte d'un programme, on suppose que les instructions sont exécutées complètement l'un après l'autre dans l'ordre. Si deux instructions successives ont des calculs inter-dépendants ou utilisent les mêmes registres alors il peut y avoir un problème, l'instruction a ensuite besoin d'attendre le retour d'écriture de l'instruction précédente pour terminer avant de pouvoir effectuer l'opérande chercher scène. Ainsi, vous devez décrocher la deuxième instruction par deux étapes avant son exécution, qui contrecarre le but de ce qui a été acquise par ces techniques en premier lieu.

Il existe de nombreuses techniques utilisent pour réduire le problème d'avoir besoin de décrochage qui sont un peu compliqué à décrire, mais je vais les énumérer: 1. le transfert de registre, (stocker également charger la transmission) 2. changement de nom de registre, 3. Score- embarquement, 4. out-of-order exécution. 5. l'exécution Speculative avec rollback (et retraite) Tous les processeurs modernes utilisent à peu près toutes ces techniques pour mettre en œuvre super-scalaire et pipelining. Cependant, ces techniques ont tendance à avoir des rendements décroissants par rapport au nombre de pipelines dans un processeur avant stands deviennent inévitables. Dans la pratique, aucun fabricant de CPU fait plus de 4 pipelines dans un seul noyau.

Multi-core n'a rien à voir avec l'une de ces techniques. Ceci est essentiellement deux micro précipite l'adoption de processeurs ensemble pour mettre en œuvre multitraitement symétrique sur une seule puce et de partager uniquement les composants qui ont du sens à partager (généralement le cache L3, et E / S). Cependant, une technique qu'Intel appelle « hyperthreading » est une méthode d'essayer de mettre en œuvre pratiquement la sémantique multi-core dans le cadre de super-scalaire d'un seul noyau. Ainsi, une micro-architecture unique contient les registres de deux noyaux virtuels (ou plus) et récupère les instructions à partir de deux (ou plus) différents flux d'exécution, mais l'exécution d'un système super-scalaire commune. L'idée est que parce que les registres ne peuvent pas interférer les uns avec les autres, il y auraont tendance à être plus parallélisme menant à moins de stands. Ainsi, plutôt que d'exécuter simplement deux flux d'exécution de base virtuels à la moitié de la vitesse, il est préférable en raison de la réduction globale des stands. Cela semble suggérer que Intel pourrait augmenter le nombre de pipelines. Cependant a trouvé cette technique pour être quelque peu défaut dans les implémentations pratiques. Comme il fait partie intégrante de techniques super-scalaire, bien que, je l'ai mentionné de toute façon.

Pipelining est l'exécution simultanée de différentes étapes de plusieurs instructions dans le même cycle. Il est basé sur le traitement d'instruction de séparation en phases et ayant des unités spécialisées pour chaque étage et des registres pour stocker les résultats intermédiaires.

Superscaling expédie plusieurs instructions (ou) à plusieurs microinstructions unités d'exécution existantes CPU. Il est donc basé sur des unités redondantes dans CPU.

Bien sûr, cela approches peuvent se compléter.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow