Intel Core 2 Duo

Publié le 22/06/2006 par et
Envoyer Imprimer
IPC et fréquence
La performance d’un CPU peut être évaluée par la quantité d’instructions qu’il exécute à chaque seconde, soit le rapport i/s. Cette donnée peut se décomposer comme suit :

i/s = i/c x c/s

où c correspond au nombre de cycles processeur, i/c correspond au nombre moyen d’instructions exécutées à chaque cycle (c’est l’IPC) et c/s est le nombre de cycles par seconde, soit la fréquence d’horloge, notée F.

Ainsi :

i/s = IPC x F

Cette formule simple nous montre que l’IPC et la fréquence sont les deux principaux facteurs de performance. Or, IPC et fréquence sont intimement liés à l’architecture du processeur, et notamment à la profondeur du pipeline de traitement.

Considérons par exemple un processeur définit de telle manière que l’instruction la plus rapide s’effectue en 10 ns. S’il utilise un pipeline de traitement composé de 10 étapes, une étape s’effectue en 1 ns (10 ns / 10 étapes), ce qui correspond au temps de cycle minimal. La fréquence maximale atteignable est alors l’inverse de ce temps de cycle, soit 1 GHz. Si le pipeline comporte 20 étapes, le temps de cycle vaut alors 0,5 ns (10 ns / 20 étapes), soit une fréquence maximale de 2 GHz. Comme on le voit, la fréquence maximale de fonctionnement augmente avec la profondeur du pipeline.

L’IPC est quant à lui une donnée intrinsèque à l’architecture du processeur, et dépend notamment des capacités des unités de calcul. Par exemple, si le processeur possède une seule unité de traitement des additions, il pourra fournir un débit maximal de une addition par cycle. S’il en possède deux, ce sont deux additions qui seront susceptibles de s’effectuer en un cycle. « Susceptibles », car ce scénario optimal implique que le pipeline de traitement fournisse un débit constant et maximal. Or, en pratique, le flux d’instructions qui est traité par le pipeline comporte des dépendances qui imposent des états d’attente au pipeline, brisant ainsi son débit, et qui tendent à faire baisser l’IPC. Deux types de dépendances sont particulièrement néfastes pour le pipeline : les branchements, et surtout les accès à la mémoire.

Voyons par exemple le cas d’un processeur possédant deux unités de calcul sur les entiers, lui conférant ainsi un IPC maximal de 2 sur ces instructions. Ajoutons lui un sous-système de cache qui présente un taux de succès de 98%, et une mémoire centrale affichant un temps d’accès de 70 ns.

Un code x86 comporte en moyenne 20% d’instructions accédant à la mémoire. Parmi ces instructions, 98% trouveront la donnée dans le sous-système de cache, et 2% devront accéder à la mémoire centrale. Pour les 80% de code restant et pour les 98% d’instructions accédant avec succès au cache, nous allons supposer que le processeur peut fournir son IPC maximum de 2, ce qui représente 0,5 cycle par instruction.

Le nombre de cycles moyen par instruction vaut alors :

c/i = 20% x (98% x 0,5 + 2% x M) + 80% x 0,5

où M représente le temps d’accès à la mémoire centrale en cycles.
  • avec un pipeline à 10 étapes, un accès à la mémoire nécessite 70 cycles à 1GHz. Le rapport c/i vaut donc 0,778, ce qui correspond à un IPC moyen de 1,28, soit 64% de l’IPC maximal théorique.
  • avec un pipeline à 20 étapes, seul change le temps d’accès à la mémoire en cycles. A 2 GHz, les 70ns correspondent à 140 cycles. Dans ce cas c/i = 1,06, soit un IPC moyen de 0,95, ou encore 47% de l’IPC théorique.
  • Les branchements ont un impact un peu moins important, mais il dépend également de la profondeur du pipeline. En effet, en cas de mauvaise prédiction de branchement, le contenu du pipeline est erroné car il contient les instructions de la mauvaise branche. La pénalité est alors égale, en cycles, à la profondeur du pipeline. Si l’on part avec les hypothèses de 10% d’instructions de branchements et un taux de succès du mécanisme de branchement de 96%, on obtient :

    c/i = 10% x (96% x 0,5 + 4% x P) + 90% x 0,5


    où P est la profondeur du pipeline.
  • avec un pipeline à 10 étapes, on obtient c/i = 0,538, soit un IPC égal à 1,85 (92,5% de l’IPC théorique).
  • avec un pipeline à 20 étapes, on obtient c/i = 0,578, soit un IPC égal à 1,74 (87% de l’IPC théorique).

  • L’IPC qui découle des pénalités dues aux branchements et aux accès mémoire tombe ainsi à 1,19 pour le pipeline à 10 étapes, et 0,82 pour celui à 20 étapes. Ce qui nous intéresse n’est pas tant l’IPC que son produit par la fréquence, qui fournira le nombre d’instructions traitées à chaque seconde.


    On s’aperçoit alors que la fréquence maximale permise par l’utilisation d’un pipeline à 20 étapes compense la baisse de l’IPC, si tant est qu’au final le pipeline à 20 étapes se montre plus rapide que la version à 10 étapes. Il n’en a pas fallu plus à Intel pour que le constructeur fasse des longs pipeline sa nouvelle philosophie, et Netburst était née.
    Vos réactions

    Top articles