Modélisation de CarCore par des graphes d’exécution

Le jeu d’instructions

Le jeu d’instructions utilisé par CarCore comporte des instructions de 16 bits et des instructions de 32 bits. Elles sont discriminées par le bit de rang 0 de l’instruction.

Le bus de données a une largeur de 64 bits. A chaque cycle, entre 2 et 4 instructions peuvent être chargées : 2 instructions de 32 bits, 4 instructions de 16 bits ou une ins-truction de 32 bits et 2 insins-tructions de 16 bits. Dans le cas où une insins-truction de 32 bits suit une paire d’instructions de 32 et 16 bits, seules les deux premières peuvent être chargées.

Pour modéliser cela, nous utilisons les arcs qui séparent les nœuds de chargement des instructions. Lorsque les instructions peuvent être chargées dans le même cycle, leurs nœuds de chargement sont séparés par un arc barré. On utilise un arc plein pour deux instructions qui ne peuvent pas être chargées dans le même cycle.

La figure 3.5 montre la modélisation sur les quatre cas cités ci-dessus. Dans cette figure, les nœuds des instructions chargées dans le même cycle sont en gris. Les ins-tructions seize bits en gris clair et les insins-tructions trente deux bits en gris plus foncé.

IF (I0)

IF (I₁) IF (I₀) IF (I₀) IF (I₀)

IF (I2) IF (I1) IF (I1) IF (I1)

IF (I3) IF (I2) IF (I2) IF (I2)

IF (I4) IF (I3)

FIG. 3.5 – Modélisation du chargement des instructions de taille variable

IF (I0) SI(I0) ID(I0) EX(I0) W B(I0)

IF (I1) SI(I1) ID(I1) EX(I1) W B(I1) FIG. 3.6 – Une instruction pour le pipeline adresse suivie de n’importe quelle autre

IF (I0) SI(I0) ID(I0) EX(I0) W B(I0) IF (I₁) SI(I₁) ID(I₁) EX(I₁) W B(I₁)

FIG. 3.7 – Une instruction pour le pipeline entier suivie d’une instruction pour le pipe-line adresse

Les deux pipelines

CarCore est muni de deux pipelines, l’un que nous appellerons ”adresse“, l’autre que nous appellerons ”entier“. On discrimine les instructions qui vont dans l’un ou l’autre pipeline par le bit de rang 1 de l’instruction. Lorsqu’une instruction est lancée dans le pipeline adresse, l’instruction suivante de la même tâche doit attendre que celle qui la précède sorte du pipeline pour être lancée. Cette limitation ne s’applique pas au pipeline entier, on peut ainsi lancer une instruction dans le pipeline adresse dans le même cycle que l’instruction qui la précède si celle-ci est destinée au pipeline entier.

Pour modéliser le blocage de la tâche, on utilise un arc plein entre le nœud d’écri-ture des registres de l’instruction destinée au pipeline adresse et le nœud d’ordonnan-cement de celle qui la suit, comme représenté sur la figure 3.6.

On utilise des arcs barrés entre les nœuds d’ordonnancement, de décodage, d’exé-cution et d’écriture des registres d’une instruction destinée au pipeline entier et l’ins-truction destinée au pipeline adresse qui la suit, comme sur la figure 3.7. Les arcs ver-ticaux barrés entre les nœuds SI(I0)et SI(I1), ID(I0)et ID(I1), EX(I0)et EX(I1)et enfin W B(I0)et W B(I1) indiquent que les deux instructions peutvent parcourir leur pipeline respectif en même temps (ou dans l’ordre). Mais I1 ne peut pas être lancée dans son pipeline si I0ne l’est pas.

Les accès mémoire

Les accès mémoire se font en deux phases. D’abord la requête est envoyée et l’ins-truction continue son chemin dans le pipeline. Ensuite l’accès proprement dit est réa-lisé.

Pour un rangement en mémoire, cette seconde phase n’a pas d’impact. La donnée à écrire est transmise à l’unité de gestion de la mémoire lors de la requête. Il n’est pas nécessaire d’attendre que la transaction soit terminée pour continuer l’exécution du programme.

Pour une lecture en mémoire, l’instruction qui a besoin de la donnée l’attend dans la fenêtre d’instructions. On doit donc mettre un arc plein entre le nœlud d’exécution de la lecture et le nœud d’ordonnancement de l’instruction qui attend la donnée. Or toutes les instructions mémoire sont exécutées dans le pipeline adresse, et un arc plein indique déjà le blocage de la tâche (comme dans la figure3.6). De plus, la latence de la mémoire de données est de trois cycles, ce qui est inférieur ou égal au temps né-cessaire à une instruction pour traverser le pipeline. La requête est lancée dans l’étage d’exécution.

La combinaison de ces deux caractéristiques permet de se passer de l’arc entre la lecture et l’instruction qui attend la donnée.

Les instructions microcodées

Les instructions à latence longue sont exécutées sous la forme de microinstructions. Celles-ci sont identiques aux autres instructions mais elles n’ont pas besoin d’être char-gées et s’exécutent toujours dans le pipeline adresse, ce qui assure que les autres ins-tructions attendent qu’elles soient terminées.

Parmi les microinstructions, certaines font des accès mémoires. Pour modéliser une instruction microcodée I, nous avons choisi d’utiliser la latence LSI

I de son étage d’or-donnancement. Nous l’exprimons comme la somme des latences (li)des microinstruc-tions i qui composent I.

L^SI_I =X

i∈I

li

Les latences (li)sont un peu particulières puisqu’elle correspondent aux latences des microinstructions i pour l’étage SI (lSI

i ) auxquelles on ajoute les latences liées aux éventuels accès mémoires (lM EM

i ).

∀i ∈ I, li = l^SI_i + l^{M EM}_i

Cette modélisation est correcte parce que les microinstructions sont toujours exé-cutées par le pipeline adresse, elles obéissent donc à la règle que veut que d’autres instructions de la même tâche ne peuvent pas être exécutées avant que l’instruction mi-crocodée ne soit terminée. Les seules interactions qui peuvent se produire avec d’autres instructions se font au travers de la première (arcs entrant de l’instruction microcodée) et de la dernière (arcs sortant de l’instruction microcodée) microinstruction. L’instruc-tion microcodée se comporte comme une instrucL’instruc-tion normale à latence longue.