s
19 708 Pages

L 'parallélisme niveau d'instruction (Au parallélisme de niveau d'éducation) est une mesure de instructions dans un programme qui peuvent être effectuées en parallèle par un système informatique.

La recherche de niveau d'instruction de code parallèle est une priorité moderne microprocesseurs qu'ils sont dotés de nombreux unité de calcul suivent généralement une structure à pipeline Par conséquent, l'identification et l'exploitation des instructions exécutables en parallèle permet l'utilisation des unités fonctionnelles du processeur en augmentant la performance.

Considérons l'extrait suivant de pseudo-code:

1) h = a + b

2) f = c + d

3) g = h * f

L'instruction et l'instruction 1 2 peuvent être exécutées en parallèle car ils nécessitent les données (a, b, c, d) qui ne sont pas utilisés par d'autres instructions et sont donc libres. Au lieu de l'éducation 3 à exécuter doit attendre la fin des deux premières déclarations depuis le h de données et f dépendent du fait que les deux premières déclarations. En supposant que l'unité de calcul (ALU) Indépendant alors vous pouvez exécuter les instructions 1 et 2 en parallèle alors que le 3 doit attendre les deux autres. En supposant que vous avez des unités qui effectuent les opérations dans un cycle d'horloge en effectuant les opérations en parallèle peut compléter le code en deux cycles d'horloge pendant une exécution en série du code nécessiterait trois cycles d'horloge. Avec ce changement, l'ILP devient 3/2 étant donné que trois exécuter des instructions dans deux cycles d'horloge.

histoire

Depuis les premiers jours des concepteurs ont essayé d'effectuer certaines opérations en parallèle afin d'obtenir une augmentation des performances des systèmes de traitement. déjà Z3, le premier ordinateur numérique a été en mesure d'effectuer certains des éléments de traitement en parallèle, afin d'améliorer ses performances. Les principales innovations liées ILP étaient les suivants:[1]

1940

  • Z3 (1941, brevet 1949) - exécution en parallèle de certains composants d'instruction.
  • Z4 (1944, reconstruit en 1949) de chargement de deux instructions en parallèle si non contraint, de manière à réduire les temps d'accès.
  • Bell Labs Modèle V (1946), deux processeurs avec un gestionnaire qui a distribué les instructions de base à l'unité libre.
  • en 1946 Alan Turing Il propose la construction de 'moteur de calcul automatique, le système a un format d'instructions complexes avec des temps d'exécution mode charge. en ACE pilote l'insertion de données dans des emplacements de mémoire spécifiques a produit l'exécution de certaines opérations, comme par exemple leur somme.
  • IBM SSEC (1948), deux instructions si les employés ont été fusionnées en une seule ligne afin qu'il puisse être exécuté en parallèle à l'ordinateur.[2] Le transfert de données a été réalisée de manière asynchrone.[3]

1950

  • Gene Amdahl (1950) dans sa thèse décrit une pipeline quatre étapes (chargement d'instructions, le chargement de données, l'exécution, les résultats d'économie).[4]
  • Dans le système Elliott 152 (1950) est inséré dans un dispositif capable de réaliser jusqu'à 4 instructions de 20 bits par cycle d'horloge.
  • Sur l'ordinateur Harvard Mark IV (1952) multiplication et la division sont effectuées en parallèle en même temps que les autres instructions les plus lents (temps de multiplications six autres instructions et les divisions sont vingt fois plus lents que d'autres instructions).
  • Un article de Wilker et Stinger (1953) suggère la possibilité de recueillir des déclarations séparées dans une macro à charger à l'ordinateur.
  • Dans le système Elliot 153 (1954), l'instruction de 64 bits qui spécifient plusieurs chargements dans les registres.
  • IBM 7030 extensible (Fin 1950, sorti en 1961) supercalculateur avec des capacités de pré-exécution, exécution spéculative et la récupération d'erreur prédiction de branchement.
  • ordinateur UNIVAC LARC (Fin 1950) à quatre étages de pipeline.[5]
  • IBM 1956 offre jusqu'à six instructions exécutées par cycle d'horloge dans un nouveau décodeur d'instructions pour l'IBM 7030 extensible.

1960

  • CDC 6600 (1964) avec processeur scalaire exécution dans le désordre, dix unités fonctionnelles dans la CPU. La CPU décode une instruction par cycle d'horloge, et l'envoie au tableau de bord qui peut lancer jusqu'à trois instructions en même temps (limité à la présence de registres triple-port). Jusqu'à quatre instructions peuvent mettre fin par cycle d'horloge. Découvertes des conditions de conflit entre les instructions et le dépannage sur éventaires. Capacité à mettre en œuvre une exécution rudimentaire multithreading.
  • 1966 Article sur les systèmes informatiques à grande vitesse Flynn, cela conduira à taxonomie de Flynn.[6]
  • IBM S / 360 Modèle 9 (1967), d'un pipeline scalaire avec de l'exécution des ordres par l'intermédiaire du 'l'algorithme Tomasulo flottante unité à virgule.
  • IBM ACS (Fin 1960) a proposé un moyen processeur superscalaire 7.
  • 1969 article sur un développement du système primitif VLIW de Melliar-Smith.

1970

  • Article 1970 sur plusieurs instructions de décodage du 7094 écrit par Tjaden et Flynn.[7]
  • Elbrus 1 "Mise en œuvre superscalaire" (1973-1978).
  • brevet Burroughs[8] octobre 1971, « Mécanisme pour commander le séquencement des instructions partiellement dans un système de traitement de données en parallèle », sur la gestion des séquences d'instructions partiellement ordonnées dans des systèmes parallèles.
  • Culler des brevets (Culler-Harrison) (1973) "processeur de données avec des opérations en parallèle par l'instruction"[9] traitement des données par l'intermédiaire d'instructions exécutées en parallèle.
  • Les systèmes à virgule flottante FPS produit AP-120B (1975) / FPS-164 (1980) avec deux coprocesseurs mathématiques comme l'architecture VLIW.
  • Article 1978 sur le bit contrôle partagé de gestion par Lee Higbie. A des instructions sont ajoutées aux bits de contrôle gérés à partir du programme ou le compilateur.[10]
  • Processeur flexible CDC (1979) - VLIW.[11]

1980

  • Octobre 1981 brevets James H. Pomerene (IBM), "Machine pour l'exécution d'instructions multiples",[12] sur la réalisation de systèmes qui traitent les groupes d'instructions indépendants simultanément.
  • Projet d'architecture Bob Rau VLIW (1981) - Projet polycyclique architecture à TRW / ESL.[13]
  • Projet d'architecture Jim Smith DAE (1982) - Astronautique ZS-1.[14]
  • ELI-512 du projet de 1983 Josh Fisher l'architecture VLIW, le projet met à profit la ordonnancement de trace mis au point par Fisher.[15]
  • cydrome (1983-1988) - VLIW.
  • multiflot (1984-1990) VLIW.
  • en 1985, Yale Patt Il analyse la capacité de gérer les instructions VAX (CDCI) de manière dynamique en vue d'augmenter le parallélisme.[16]
  • Article Hwa C. Torng en 1986 sur l'envoi empiler plusieurs unités.[17]
  • Culler-7 (1986) Architecture DAE / LIW fonctionne.
  • Chopp (mi-1980) - un système neuf voies.
  • Deux voies IBM Cheetah et Panther (prédécesseurs mi-1980 des quatre voies Amérique et IBM RS / 6000, fondée sur l'article 1986 des compilateurs FJCC pour les machines à deux voies).
  • bell Labs CRISP (1987) Organisation des sauts dans le cache de données.
  • Horizon, un système développé en 1988 par Burton Smith à l'identification des instructions et leur exécution indépendante.
  • Stellar GS-1000 (1988) de multitreading quatre voies, deux instructions par cycle.
  • Apollo DN10000 (1988) Processeur Apollo PRISM, LIW deux façons.
  • Intel i860 (1988) dans les deux sens LIW.
  • Intel i960CA (1989) à trois voies superscalaire.
  • IBM RS / 6000 (1989) à quatre voies superscalaire.
  • Processeur Hatfield RISC (1989) VLIW avec prédication et écriture différée, permet la transmission d'opérandes entre les étages du pipeline sans stocker les données dans les registres afin de réduire les enregistrements dans les registres.

1990

  • national Semiconductor espadon (1990) processeur superscalaire avec deux instances de conception LIW et le décodage des données dans le cache d'instructions.
  • IBM ES / 9000-900 (1990) avec la mise en œuvre superscalaire de l'exécution des ordres de l'ordinateur central IBM.
  • METAFLOW Foudre / Tonnerre (1991/1995) simplement l'exécution de la commande conçu pour les processeurs SPARC.
  • Transmeta processeurs VLIW avec Code Morphing Software.

2000

Degré de parallélisme

Le nombre maximum d'instructions exécutables en parallèle est limité par trois problèmes (définis en anglais alee); le nombre d'unités fonctionnelles, les dépendances et les dépendances sur les données de la commande. Plus précisément:

  • Nombre d'unités fonctionnelles: trivialement si le processeur est équipé de quatre unités de ce calcul ne peut pas effectuer plus de quatre instructions en parallèle, même si le code étaient présentes instructions plus exécutables en parallèle.
  • Les données sur les toxicomanies: Le processeur ne peut pas exécuter (ou complète) l'éducation, sinon toutes les données, certaines données ne sont pas encore à traiter (comme dans l'exemple de l'éducation 3) le processeur ne peut pas fonctionner réellement (ou complet, selon la façon dont il est construit l'unité fonctionnelle) l'éducation.
  • Contrôle de la toxicomanie: Le code situé après un saut conditionnel ne peut être effectuée sans détermine d'abord le résultat de la branche conditionnelle.

Niveaux de Parallélisme

Pour augmenter le niveau de parallélisme dans les microprocesseurs sont essentiellement deux stratégies.

  • La première implique l'augmentation des étapes dans le pipeline, ce qui est la profondeur de la canalisation. Pipeline à étages multiples peut être réalisée, en théorie, plus d'instructions en parallèle, car ils ont plus de chances de superposer les instructions dans les différentes étapes du pipeline. De plus (et surtout) de nombreuses étapes impliquent que chaque étape doit effectuer une formation de fraction plus simple et peut donc exécuter plus rapidement, ce qui permet d'augmenter la fréquence de fonctionnement des microprocesseurs. Par exemple, certains modèles Pentium 4 Ils ont plus de 30 étapes dans le pipeline. Cette stratégie a ses limites puisque, par exemple pipeline très longtemps devenu très inefficace dans le cas des sauts et en fait la plupart des microprocesseurs ont un certain nombre d'étapes comprises entre 10 et 15.
  • La deuxième stratégie implique l'utilisation de plusieurs unités d'exécution indépendantes qui exécutent des instructions en parallèle. Cette technique est appelée question multiple et son principal inconvénient est une plus grande complexité du processeur en effet, en plus de la présence de plus de l'unité de calcul du processeur doit avoir un grand bus interne de façon à transporter des données entre les différentes unités sans goulots d'étranglement. De plus, les unités fonctionnelles individuelles telles que cachette Ils doivent être en mesure de libérer davantage de données en parallèle et même journaux Ils doivent être capables de lire et écrire des données en parallèle. Les architectures capables d'exécuter plusieurs instructions en parallèle sont appelées superscalaire et analyse au parallélisme au niveau de l'instruction de ce type de processeurs est bien sûr indispensable.

Les processeurs modernes afin d'obtenir des performances maximales ont tendance à utiliser les deux techniques en même temps, prendre le plus long pipeline du minimum nécessaire (10/15 étapes) et exécuter plusieurs instructions en parallèle.

Types de ILP

L'analyse du code à la recherche de ILP peut être divisé en deux grandes catégories, ILP statiques et dynamiques ILP.

Nell'ILP statique le processeur reçoit les opérations déjà divisées en blocs d'instructions exécutables indépendants en parallèle, le processeur doit exécuter uniquement les instructions étant donné que l'analyse du code a déjà été effectuée par le compilateur qui a déjà identifié et mis en évidence les parties exécutables parallèle. Cette approche permet de réaliser des processeurs simples et rapides, mais présente l'inconvénient que les programmes sont spécialement compilés pour un seul type de processeur et des changements internes à l'architecture du processeur peut produire des réductions significatives des performances et dans les cas extrêmes, même les erreurs d'exécution. processeurs mot d'instruction très longue suivre cette philosophie.

Au lieu de cela nell'ILP dynamique le compilateur ne pas analyser le code à la recherche d'instructions parallélisables étant donné que cette tâche est effectuée par le processeur lors de l'exécution de décider dynamiquement quelles instructions peuvent être exécutées en parallèle. Cela permet de ne pas lier l'architecture de code d'un seul processeur, mais présente l'inconvénient de rendre le microprocesseur beaucoup plus complexe et potentiellement plus lente. Le processeur a quelques nanosecondes de décider s'il y a des instructions parallélisables et de décider comment les organiser, alors qu'un compilateur peut faire une analyse approfondie du code ayant beaucoup de temps processeur.

Les microprocesseurs informatiques mettent en œuvre ILP dynamique bien que beaucoup peuvent également utiliser certaines techniques ILP statiques pour augmenter les performances.

dynamique ILP

Lors de l'exécution du processeur pour détecter des instructions parallélisables peut utiliser un grand nombre, les principales techniques sont les suivantes:

  • Exécution de l'ordre:

Tous les processeurs modernes utilisent le pipeline, le pipeline quand ils sont en présence de défauts dans le flux de données ou de contrôle doit présenter pour permettre la résolution de alee les stalles (aussi appelées ampoules). Les risques peuvent être réduits en réorganisant les instructions de façon appropriée, par exemple dans le code suivant:

1) h = a + b

2) = F h - d

3) g = w + 100

la deuxième instruction dépend du résultat de la première instruction et la troisième instruction est indépendant des autres. En exécutant les instructions dans un pipeline à 5 étages il y aurait un décrochage (ou deux dépend de la façon la canalisation) est mise en oeuvre entre la première et la seconde instruction. En réorganisant les instructions et l'envoi au premier pipeline d'instructions, puis la troisième instruction (indépendant des autres), et enfin la seconde instruction est obtenue sans stands d'exécution. Ce mode d'exécution est appelé Out-of-order étant donné que les déclarations sont exécutés et complétés hors d'usage en ce qui concerne le code développé par le programmeur.

Les microprocesseurs presque toujours inclure un certain type d'unité de prédiction de branchement, l'appareil conserve la trace des instructions de branchement, et si elle rencontre une instruction de saut analysant l'histoire passée de l'instruction essaie de prédire si le saut sera exécuté ou non. La prédiction de branchement vous permet de charger à l'avance les étapes après saut et dans le cas de la prédiction correcte du saut le processeur ne doit pas bloquer ou de vider le pipeline.

Certains processeurs mettent également en œuvre une certaine forme d'exécution spéculative. En supposant qu'un saut conditionnel dépend des données non traitées de certains processeurs basés sur l'histoire passée des processeurs d'éducation saut peut faire une prédiction sur le résultat du saut (spéculer sur l'issue possible) et des instructions de charge atteint les prévisions. Ce type d'exécution nécessite beaucoup de transistors à mettre en œuvre en raison de la spéculation sur l'unité doit garder une trace des exécutions d'instruction qui dépendent de la spéculation et la prévision erronée de ces instructions doivent être éliminées et leurs effets sur les données annulées.

  • registres Changement de nom:

Certains risques dépendent du fait que les instructions utilisent les mêmes registres ou les mêmes emplacements de mémoire, par exemple, pour écrire les résultats du traitement. Par exemple:

1) h = a + b

2) h = c - d

L'instruction 1 et 2 sont du point de vue des données indépendantes mais ne peuvent pas être échangés puisque les deux écrivent les résultats dans h, inversant les instructions à la fin du traitement serait la valeur calculée par a + b cd ne pas obtenir un " mauvaise exécution du programme. Ce n'est pas un véritable risque des données puisque, en réalité, les deux instructions ne sont pas vraiment limités par les données, mais sont limitées par des registres qui stockent des données. Le microprocesseur peut alors mettre en œuvre le renommage de registre, en substance introduire les registres utilisés pour enregistrer les données temporaires afin d'exécuter des instructions indépendamment, étant donné que, à la fin de l'exécution sera l'unité de changement de nom pour enregistrer les données dans les administrateurs correct. Dans le code ci-dessus deviendrait:

1) h = a + b

2) k = c - d

La deuxième instruction enregistre les données dans le registre k temporaire, puis les deux instructions peuvent être exécutées en parallèle autant à la fin de l'unité de changement de nom stocker les données contenues dans le journal k h dans le maintien de la cohérence logique du programme. La programmation de pipeline dynamique et enregistrer le renommage élimine la plupart des risques en réduisant considérablement les stands dans le pipeline. L'utilisation de ces techniques est régie par 'l'algorithme Tomasulo ou ses variantes plus modernes et efficaces.

Souvent, les programmes sont constitués de groupes d'instructions qui sont exécutées plusieurs fois en séquence. Utilisation de l'unité de planification dynamique du pipeline et d'enregistrer des processeurs renommer peut exécuter des instructions des différents cycles en parallèle et peut éliminer certains sauts conditionnels, par exemple, le code:

1) a = 0

2) POUR à< 2

3) k = k - d

4) a = a + 1 // end

après la boucle déroulage get:

1) a = 0

2) k = k - d

3) a = a + 1

4) k = k - d

5) a = a + 1

Sans dérouler le processeur doit exécuter des instructions 8 (1 2 3 4 2 3 4 2), dont il existe trois sauts conditionnels (l'instruction 2), après le déroulement obtenir 5 instructions, les sauts ont été éliminés et les instructions peuvent être exécutées par pipeline sans stands.

statique ILP

ILP statique contrairement ILP dynamique fonctionne lors de la compilation du code, le compilateur analyse le code de détection d'instructions parallelisable et des signaux de telle sorte que lors de l'exécution du processeur connaît déjà presque les instructions sont exécutées parallélisables et comment ils vont. L'ILP statique est particulièrement utilisé par les processeurs embarqués que pour des raisons de coût et de consommation d'énergie ne peut pas mettre en œuvre les méthodes d'analyse complexes requises par dynamique inclusive. Cependant, l'ILP statique est utilisé dans certains modes aussi par des processeurs haute performance et la famille des processeurs itanium Elle est basée sur cette philosophie.

ILP statique comme ILP dynamique vise à optimiser les performances et de le faire essayer d'utiliser le plus de minimiser les stalles de pipeline, ceci est réalisé en réorganisant les instructions de la même manière que le fait l'ILP dynamique. Le compilateur afin de produire du code efficace doit connaître en détail les caractéristiques du processeur; Il a besoin de connaître les détails tels que la longueur du pipeline, leur organisation, les temps d'exécution, et ainsi de suite. Deux processeurs avec le même jeu d'instructions (ISA) Mais avec différents microarchitecture exécuter le même code avec des optimisations statiques peuvent fournir des performances très différentes. Un changement de microarchitecture peut exiger une recompilation du code pour pouvoir exploiter les performances réelles du microprocesseur, ce qui est nécessaire avec l'ILP dynamique.

L'ILP statique utilise de nombreuses techniques d'analyse et des améliorations communes à l'ILP dynamique, mais ne pas avoir à effectuer des analyses d'optimisation en temps réel peut être beaucoup plus profond et donc une meilleure performance. Par exemple, dans le cas de la technique boucle du déroulement compilateur en analysant le code peut reconnaître la boucle et l'optimiser. Par exemple, supposons que vous avez le code de type:

1) i = 0

2) POUR i <1000

3) x [i] = x [i] + s

4) i = i + 1 end // POUR

Le compilateur reconnaît le code peut remarquer que la boucle est exécutée mille fois et depuis la partie critique est le saut conditionnel (instruction 2) pouvait écrire:

1) i = 0

2) POUR i <1000

3) x [i] = x [i] + s

4) i = i + 1

5) x [i] = x [i] + s

6) i = i + 1 end // POUR

Cette boucle est exécutée seulement 500 fois depuis l'intérieur d'une seule boucle ont été insérés les instructions qui ont été précédemment effectuées dans deux boucles. Le processus peut être répété pour inclure d'autres instructions, réduisant ainsi le nombre de sauts à effectuer, qui sont des instructions que du point de vue du programme ne produisent pas des résultats utiles car elle ne touche pas directement les données, mais seulement le déroulement du programme. Le code généré par la boucle de déroulement peut être améliorée en effectuant un changement de nom de registres et une réorganisation des instructions qui améliore les performances. Par exemple, le code initial qui exécute sur un processeur MIPS sans aucune optimisation nécessite 10 cycles d'horloge pour chaque boucle, en appliquant les différentes optimisations est obtenu par l'exécution en 3,5 cycles d'horloge pour chaque boucle. Le compilateur lors de l'application de ces techniques doit également tenir compte des problèmes que ceux-ci apportent. Le déroulage boucle augmente la taille du code et ne peut donc pas trouver les données mises en cache. En outre, une utilisation excessive des registres de renommage peut mettre fin aux registres temporaires forçant le processeur à utiliser la mémoire système plus lent pour enregistrer les registres ne sont pas utilisés.

Le ILP statique cherche évidemment à exploiter la présence de plusieurs unités de calcul, dans l'exemple de la boucle en supposant que d'avoir un processeur pipeline avec deux indépendant, il peut réduire le temps d'exécution de 3,5 cycles d'horloge par boucle de 2,5 cycles d'horloge pour boucle. Les processeurs qui utilisent le ILP statique généralement mieux utiliser les pipelines, car le compilateur peut analyser le code en profondeur et peut chercher la meilleure organisation des instructions afin de maximiser l'utilisation du pipeline. Souvent, ces compilateurs de regroupement des instructions en paquets qu'une fois reçus par le processeur sont simplement envoyés à la canalisation, le processeur ne doit pas contrôler les risques ou d'autres données que tout a été analysé par le compilateur et les problèmes ont déjà été résolus, ces processeurs sont dits processeurs mot d'instruction très longue (VLIW).

Dans le processeur VLIW effectue toutes les optimisations du compilateur alors que le processeur ne fait que recevoir des instructions, puis d'exécuter un processeur VLIW est beaucoup plus facile qu'un processeur avec la vitesse de la main ILP dynamique. Selon total ainsi par le compilateur pour les compilateurs de performance utilisent des techniques avancées d'analyse de code pour trouver le parallélisme instrinseco. Les principaux sont les suivants:

  • prédiction de branchement statique:

Le compilateur essaie de prédire l'issue des sauts (branche) par l'analyse statistique du code afin de garder le pipeline toujours chargé. Ces techniques sont similaires à celles appliquées par les processeurs ILP dynamiques avec, mais dans ce cas fournir une performance moyenne inférieure à celles fournies par les microprocesseurs avec l'unité de prédiction de l'état de branchement de l'art étant donné que le microprocesseur est capable d'adapter l'exécution dynamique du tout programme le compilateur ne peut estimer statistiquement la façon dont le programme se comportera pendant l'exécution.

  • Boucle Niveau Parallélisme.

Ces tentatives techniques pour localiser le parallélisme entre les itérations successives de la boucle dans le cas de boucles ayant des cycles non indépendants.

  • boucle symbolique déroulage.

Avec cette technique, vous décidez de ne pas dérouler la boucle, mais à ajouter à des instructions indépendantes afin d'éviter de caler lors de l'exécution.

  • les files d'attente de planification globale.

Cette technique analyse le code à la recherche d'auto-apprentissage, l'exploration se poursuit même si le compilateur trouve de l'instruction conditionnelle (comme les sauts ou cycles).

  • Techniques prédicative

Les techniques d'analyse de code fonctionnent bien quand vous pouvez prédire avec une grande marge de précision le comportement des sauts conditionnels. Les sauts conditionnels sont très fréquents dans le code (en moyenne tous les 7 à 10 des instructions qu'il a un saut) et peut appuyer sur les performances des architectures nettement canalisées. Les techniques d'analyse statistique bien dans le cas des instructions de branchement qui se répètent sur une base régulière (par exemple pour les cycles), tandis que dans d'autres cas, les sauts sont difficilement prévisibles. Pour limiter l'impact de ces sauts peuvent utiliser ses déclarations prédicatif (ou conditionné). Les instructions prédicative convertissent une dépendance pour contrôler une dépendance des données dans certains cas, les sauts conditionnels éliminant difficilement prévisibles. Les instructions sont prédicative des instructions normales qui, cependant, sont exécutées si une certaine condition est vraie (ou fausse selon le cas). L'exemple le plus simple (et commune) est le mouvement conditionné. Cette instruction copie la valeur d'un registre dans un autre registre si la condition associée est vrai. Par exemple, le code

si (A == 0) H = J

Il sera traduit sans instructions conditionnées:

1) Si A = 0 -> passez à 2) autrement -> 3)

2) H = J

Avec des instructions conditionnelles se place

1) A = 0, H = J

Le nouveau code utilise une instruction unique il est plus compact et élimine également un saut au lieu d'une instruction de saut et un mouvement que je déplace simplement une condition qui dépend uniquement des données, donc je supprimé l'instruction de branchement, qui étant unique et non lié à une logique est difficile à prévoir. Cette stratégie plus être étendue à la quasi-totalité des instructions du processeur, par exemple les processeurs Itaniuim ont des instructions prédicats qui peuvent remplacer toutes les instructions standard (le type de processeur plein predication). Cependant, la majorité des processeurs est limitée à déplacer prédicative étant donné que dans d'autres cas, l'utilisation d'instructions prédicative augmente la taille du processeur sans nécessairement augmenter les performances du même. Cependant, le mouvement prédicative sont si utiles que de nombreux processeurs qui mettent en œuvre des techniques sophistiquées ILP dynamiques utilisent également l'offre conditionnelle pour améliorer les performances.

Une autre façon d'améliorer la performance est la charge spéculative, le compilateur en analysant le code permettant d'identifier les instructions ou les données sont susceptibles d'être nécessaires et demander à la charge spéculative. Ces données de chargement de charge ou des instructions avant qu'ils ne soient effectivement demandé en éliminant ou au moins limiter le temps de chargement de la mémoire. De toute évidence, les problèmes peuvent survenir si les données chargées ont été modifiées avant leur utilisation réelle. Dans le cas de l'écriture des processeur vérifie si les cellules écrites ont été chargées d'une manière spéculative et dans ce cas les élimine de manière à éviter les incohérences d'exécution.

notes

  1. ^ Ligne du temps fondée sur l'article Niveau Instruction- Parallel Processing: Histoire, Vue d'ensemble et perspectives B. Ramakrishna Rau, Joseph A. Fisher Computer Systems Laboratory HPL-92-132 Octobre 1992, avec des ajouts ultérieurs.
  2. ^ US Patent 2636672
  3. ^ (Annexe A de Bashe, Johnson, Palmer et Pugh, 1986) [cf. Harvard Mark II]
  4. ^ (FR) Thèse Gene Amdahl
  5. ^ (FR) Considérations techniques du LARC
  6. ^ Très systèmes informatiques à grande vitesse Actes du volume IEEE 54, numéro 12, décembre 1966 Page (s): 1901-1909
  7. ^ Détection et exécution parallèle des instructions indépendantes Tjaden, G.S;. Flynn, M.J;. Ordinateurs, IEEE Transactions sur le volume C-19, numéro 10, octobre 1970 Page (s): 889-895
  8. ^ (FR) US 3611306
  9. ^ (FR) US Patent 3771141
  10. ^ Opération avec microprogramming chevauché IEEE: Transactions sur les ordinateurs C-Volume 27, Numéro 3, Mars 1978 page (s): 270-275
  11. ^ datapath rappelle Elliott 152/153]
  12. ^ US 4.295.193 en 1981
  13. ^ Certaines techniques de planification et une architecture horizontale facilement planifiable pour le calcul scientifique haute performance Symposium international sur les archives Microarchitecture Actes du 14e atelier annuel sur la table des matières microprogramming Chatham, Massachusetts, États-Unis Pages: 183-198 année 1981 ISSN: 1050-916X
  14. ^ accès découplé / exécuter les architectures informatiques Symposium international sur l'architecture informatique d'archives Actes du 9e colloque annuel sur l'architecture informatique table des matières Austin, Texas, États-Unis Pages: 112-119 année 1982 James E. Smith
  15. ^ Très longue architectures de mots d'instruction et l'ELI-512 IEEE-CS: Computer Society, SIGARCH: ACM Groupe d'intérêt spécial sur l'architecture informatique Pages: 140-150 année 1983 ISBN 0-89791-101-6
  16. ^ Rééquipement du VAX-11/780 microarchitecture pour les questions de mise en œuvre arithmétique à virgule flottante IEEE, mesures et analyse David B. Aspinwall, Yale N. Patt; IEEE Transactions on archive Ordinateurs Volume 34, Numéro 8 (Août 1985) Table des matières Pages: 692-708 Année de publication: 1985 ISSN: 0018-9340
  17. ^ Une instruction d'émission approche visant à améliorer la performance dans plusieurs processeurs d'unité fonctionnelle Acosta, R.D;. Kjelstrup, J;. Torng, H.C;. IEEE: Transactions on Computers C-Volume 35, numéro 9, septembre 1986 Page (s): 815-828
  18. ^ 30e édition annuelle du Symposium international sur l'architecture informatique (de ISCA), pp. 422-433
  19. ^ Accord sur les ADPIC, le calcul teraherz, La science, 04/27/2007. Récupéré le 16-10-2007.

liens externes