processor - processeurs - Quelle est la différence entre Superscaling et Pipelining?



pipelining definition (4)

Le pipeline est ce qu'une entreprise automobile fait dans la fabrication de ses voitures. Ils décomposent le processus de montage d'une voiture en étapes et exécutent les différentes étapes à différents points de la chaîne de montage effectuée par différentes personnes. Le résultat final est que la voiture est fabriquée à la vitesse de la seule étape la plus lente.

Dans les CPU, le processus de traitement en pipeline est exactement le même. Une "instruction" est décomposée en différentes étapes d'exécution, généralement quelque chose comme: 1. instruction d'extraction, 2. opérandes d'extraction (registres ou valeurs de mémoire lues), 2. exécution de calculs, 3. écriture de résultats (dans la mémoire ou dans les registres) . La partie la plus lente de ce processus pourrait être la partie calcul, auquel cas la vitesse de traitement globale des instructions passant par ce pipeline est simplement la vitesse de la partie calcul (comme si les autres parties étaient "libres").

Super-scalaire dans les microprocesseurs fait référence à la possibilité d'exécuter plusieurs instructions à partir d'un seul flux d'exécution à la fois en parallèle. Donc, si une entreprise automobile exploitait deux chaînes de montage, elle pourrait évidemment produire deux fois plus de voitures. Mais si le processus consistant à attribuer un numéro de série à la voiture en était à la dernière étape et devait être effectué par une seule personne, il leur faudrait alors alterner entre les deux pipelines et garantir qu’ils pourraient le faire en deux fois moins de temps. le stade le plus lent pour éviter de devenir le stade le plus lent eux-mêmes.

Super-scalaire dans les microprocesseurs est similaire mais comporte généralement beaucoup plus de restrictions. Ainsi, l’étape d’extraction d’instructions produira généralement plus d’une instruction au cours de cette étape - c’est ce qui permet la super-scalaire dans les microprocesseurs. Il y aurait alors deux étapes d'extraction, deux étapes d'exécution et deux étapes d'écriture arrière. Cela généralise évidemment plus que deux pipelines.

Tout cela est beau et dandy, mais du point de vue de la bonne exécution, les deux techniques peuvent poser problème si elles sont effectuées à l’aveugle. Pour une exécution correcte d'un programme, il est supposé que les instructions sont exécutées complètement l'une après l'autre dans l'ordre. Si deux instructions séquentielles ont des calculs interdépendants ou utilisent les mêmes registres, il peut y avoir un problème. L'instruction ultérieure doit attendre que l'écriture de l'instruction précédente soit terminée avant de pouvoir effectuer l'étape d'extraction d'opérande. Ainsi, vous devez bloquer la deuxième instruction de deux étapes avant de l'exécuter, ce qui irait à l'encontre de l'objectif de ce que ces techniques ont permis de gagner.

Il existe de nombreuses techniques utilisées pour réduire le problème de décrochage, qui sont un peu compliquées à décrire, mais je les énumérerai: 1. transfert de registre, (également stockage pour transfert de chargement) 2. changement de nom de registre, 3. affichage du score, 4 exécution dans le désordre. 5. Exécution spéculative avec annulation (et retrait) Tous les processeurs modernes utilisent à peu près toutes ces techniques pour implémenter le super-scalaire et le traitement en pipeline. Cependant, ces techniques ont tendance à avoir des rendements décroissants par rapport au nombre de pipelines dans un processeur avant que les stalles ne deviennent inévitables. En pratique, aucun fabricant de CPU ne fabrique plus de 4 pipelines dans un seul cœur.

Multi-core n'a rien à voir avec ces techniques. Il s’agit essentiellement de regrouper deux microprocesseurs pour mettre en œuvre le multitraitement symétrique sur une seule puce et de ne partager que les composants qu’il est judicieux de partager (généralement le cache L3 et les E / S). Cependant, une technique appelée "hyperthreading" par Intel est une méthode consistant à essayer de mettre en œuvre virtuellement la sémantique de la technologie multicœur dans le cadre super-scalaire d’un cœur unique. Ainsi, une seule micro-architecture contient les registres de deux cœurs virtuels (ou plus) et extrait les instructions de deux (ou plus) flux d’exécution différents, mais s’exécutant à partir d’un système super-scalaire commun. L'idée est que, comme les registres ne peuvent pas interférer les uns avec les autres, il y aura plus de parallélisme conduisant à moins de stalles. Donc, plutôt que d’exécuter simplement deux flux d’exécution de cœur virtuel à une vitesse deux fois moins rapide, c’est mieux en raison de la réduction globale des blocages. Cela semblerait suggérer qu'Intel pourrait augmenter le nombre de pipelines. Cependant, il a été constaté que cette technique manquait quelque peu de mises en œuvre pratiques. Comme cela fait partie intégrante des techniques super-scalaires, je l’ai quand même mentionné.

https://src-bin.com

Bien, la question est trop simple pour être posée, mais j’ai posé la question après avoir parcouru quelques points à la fois.

Les deux méthodes augmentent le débit d'instruction. Et Superscaling utilise presque toujours le traitement en pipeline. Superscaling a plus d’une unité d’exécution, de même que le traitement en pipeline ou est-ce que je me trompe ici?


Answer #1

Le pipeline est une exécution simultanée de différentes étapes de plusieurs instructions au même cycle. Il est basé sur la division du traitement des instructions en étapes et sur la création d'unités spécialisées pour chaque étape et de registres pour le stockage des résultats intermédiaires.

Superscaling consiste à envoyer plusieurs instructions (ou micro-instructions) à plusieurs unités d’exécution existantes dans la CPU. Il repose donc sur des unités redondantes en CPU.

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


Answer #2

La conception superscalaire implique que le processeur puisse émettre plusieurs instructions dans une seule horloge, avec des fonctionnalités redondantes pour exécuter une instruction. Remarquez que nous ne parlons que d'un seul cœur: le traitement multicœur est différent.

Le traitement en pipeline divise une instruction en étapes et, comme chaque étape est exécutée dans une partie différente du processeur, plusieurs instructions peuvent figurer dans des "phases" différentes pour chaque horloge.

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

Ici, deux instructions sont exécutées à la fois dans un pipeline en cinq étapes.

Pour le décomposer davantage, compte tenu de votre récente modification:

Dans l'exemple ci-dessus, une instruction passe par 5 étapes pour être "exécutée". Ce sont IF (récupération d’instructions), ID (décodage d’instructions), EX (exécuter), MEM (mémoire de mise à jour), WB (écriture dans le cache).

Dans une conception de processeur très simple, chaque horloge d'une étape différente serait complétée, de sorte que nous aurions:

  1. SI
  2. ID
  3. EX
  4. MEM
  5. WB

Ce qui ferait une instruction sur cinq horloges. Si nous ajoutons ensuite une unité d'exécution redondante et introduisons une conception superscalaire, nous aurions ceci, pour deux instructions A et B:

  1. SI (A) SI (B)
  2. ID (A) ID (B)
  3. EX (A) EX (B)
  4. MEM (A) MEM (B)
  5. WB (A) WB (B)

Deux instructions sur cinq horloges - un gain maximum théorique de 100%.

Le pipelining permet aux pièces d'être exécutées simultanément, nous obtenons donc quelque chose comme (pour dix instructions de A à J):

  1. SI (A) SI (B)
  2. ID (A) ID (B) SI (C) SI (D)
  3. EX (A) EX (B) ID (C) ID (D) IF (E) IF (F)
  4. MEM (A) MEM (B) EX (C) EX (D) ID (E) ID (F) IF (G) IF (H)
  5. WB (A) WB (B) MEM (C) MEM (D) EX (E) EX (F) ID (G) ID (H) IF (I) IF (J)
  6. WB (C) WB (D) MEM (E) MEM (F) EX (G) EX (H) ID (I) ID (J)
  7. WB (E) WB (F) MEM (G) MEM (H) EX (I) EX (J)
  8. WB (G) WB (H) MEM (I) MEM (J)
  9. WB (I) WB (J)

En neuf horloges, nous avons exécuté dix instructions - vous pouvez voir où le traitement en pipeline déplace vraiment les choses. Et c’est une explication de l’exemple graphique, pas de la manière dont elle est réellement mise en œuvre sur le terrain (c’est de la magie noire ).

Les articles de Wikipedia sur Superscalar et Pipeline d’instruction sont plutôt bons.


Answer #3

Une analogie: laver les vêtements

Imaginez un magasin de nettoyage à sec doté des équipements suivants: une grille pour suspendre des vêtements sales ou propres, une laveuse et une sécheuse (pouvant chacune laver un vêtement à la fois), une table pliante et une planche à repasser.

Le préposé qui effectue tous les travaux de lavage et de séchage est plutôt confiant. Le propriétaire du magasin, qui prend les commandes de nettoyage à sec, prend donc le soin d’écrire chaque instruction très attentivement et de manière explicite.

Au cours d’une journée type, ces instructions peuvent ressembler à:

  1. prendre la chemise du rack
  2. laver la chemise
  3. sécher la chemise
  4. repasser la chemise
  5. plier la chemise
  6. remettez la chemise sur la grille
  7. prendre le pantalon de la grille
  8. laver le pantalon
  9. sécher le pantalon
  10. plier le pantalon
  11. remettre le pantalon sur la grille
  12. prendre le manteau de la grille
  13. laver le manteau
  14. sécher le manteau
  15. repasser le manteau
  16. remettre le manteau sur la grille

Le préposé suit ces instructions sur le tee-shirt, en faisant très attention à ne jamais faire quelque chose d'inacceptable. Comme vous pouvez l’imaginer, le linge de la journée prend beaucoup de temps, car il faut beaucoup de temps pour le laver, le sécher et le plier complètement, et le tout doit être fait un à la fois.

Cependant, un jour, l’agent s’arrête et un nouvel agent, plus intelligent, est embauché et constate que la majeure partie de l’équipement est inutilisée à tout moment de la journée. Pendant que les pantalons étaient en train de sécher, ni la planche à repasser ni la machine à laver n'étaient utilisées. Il a donc décidé de mieux utiliser son temps. Ainsi, au lieu de la série d'étapes ci-dessus, il ferait ceci:

  1. prendre la chemise du rack
  2. laver la chemise, prendre le pantalon de la grille
  3. sécher la chemise, laver le pantalon
  4. repasser la chemise, sécher le pantalon
  5. pliez la chemise, (prenez le manteau de la grille)
  6. remettez la chemise sur la grille, pliez le pantalon , (lavez le manteau)
  7. remettez le pantalon sur la grille , (séchez le manteau)
  8. (repasser le manteau)
  9. (remettez le manteau sur la grille)

C'est pipelining. Séquençage d'activités non liées de sorte qu'elles utilisent différents composants en même temps. En gardant autant de composants actifs actifs en même temps, vous maximisez l'efficacité et accélérez le temps d'exécution. Dans ce cas, réduisez de 16 "cycles" à 9, soit une accélération de plus de 40%.

Maintenant, le petit magasin de nettoyage à sec a commencé à gagner plus d'argent parce qu'il pouvait travailler beaucoup plus vite. Le propriétaire a donc acheté une machine à laver, une sécheuse, une planche à repasser, une station de pliage et même embauché un autre employé. Maintenant, les choses sont encore plus rapides, au lieu de ce qui précède, vous avez:

  1. prendre la chemise du rack, prendre le pantalon du rack
  2. laver la chemise, laver le pantalon , (prendre le manteau de la grille)
  3. sécher la chemise, sécher le pantalon , (laver le manteau)
  4. repasser la chemise, plier le pantalon (sécher le manteau)
  5. plier la chemise, remettre le pantalon sur la grille , (repasser le manteau)
  6. remettez la chemise sur la grille, (remettez le manteau sur la grille)

Ceci est la conception superscalaire. Plusieurs sous-composants capables d'effectuer la même tâche simultanément, mais le processeur décide de la manière de le faire. Dans ce cas, il en résultait une augmentation de la vitesse de près de 50% (en 18 "cycles", la nouvelle architecture pouvait exécuter 3 itérations de ce "programme", tandis que l’architecture précédente ne pouvait fonctionner que sur 2).

Les processeurs plus anciens, tels que les processeurs 386 ou 486, sont de simples processeurs scalaires, ils exécutent une instruction à la fois dans l'ordre exact dans lequel elle a été reçue. Les processeurs grand public modernes depuis le PowerPC / Pentium sont en pipeline et superscalaires. Un processeur Core2 est capable d’exécuter le même code que celui qui a été compilé pour un 486 tout en tirant parti du parallélisme des instructions car il contient sa propre logique interne qui analyse le code machine et détermine le mode de réorganisation et d’exécution (ce qui peut être exécuté en parallèle). , ce qui ne peut pas, etc.) C’est l’essence même du design superscalaire et pourquoi il est si pratique.

En revanche, un processeur vectoriel parallèle exécute des opérations sur plusieurs données à la fois (un vecteur). Ainsi, au lieu d’ajouter simplement x et ya, le processeur vectoriel ajouterait, disons, x0, x1, x2 à y0, y1, y2 (résultant en z0, z1, z2). Le problème de cette conception est qu’elle est étroitement liée au degré de parallélisme spécifique du processeur. Si vous exécutez du code scalaire sur un processeur vectoriel (en supposant que vous le puissiez), la parallélisation vectorielle ne présentera aucun avantage, car elle doit être explicitement utilisée, de même si vous souhaitez tirer parti d'un processeur vectoriel plus récent avec davantage d'unités de traitement parallèles (par exemple, capable d’ajouter des vecteurs de 12 nombres au lieu de 3), vous devrez recompiler votre code. Les concepteurs de processeurs vectoriels étaient populaires dans la génération la plus ancienne de super-ordinateurs, car ils étaient faciles à concevoir et que de nombreux problèmes se posaient dans les domaines de la science et de l'ingénierie, avec beaucoup de parallélisme naturel.

Les processeurs superscalaires peuvent également avoir la capacité d'effectuer une exécution spéculative. Plutôt que de laisser les unités de traitement inactives et d’attendre la fin de l’exécution d’un chemin de code avant de créer une branche, le processeur est en mesure de deviner et commence à exécuter le code au-delà de la branche avant la fin du traitement du code précédent. Lorsque l'exécution du code précédent rattrape le point de branche, le processeur peut alors comparer la branche réelle avec l'estimation de branche et poursuivre si l'hypothèse est correcte (déjà bien avant où elle aurait été juste en attente) ou elle peut invalider les résultats de l'exécution spéculative et exécuter le code pour la branche correcte.