Cas d’étude

Nous considérons un processeur superscalaire de degré 2 avec une exécution non- ordonnée qui implante le jeu d’instructions ARMv5. Ce cas d’étude, présenté par la Fi- gure 3.2 (p. 66), bien qu’il ne corresponde pas à un modèle réel de processeur commercialisé, réunit plusieurs caractéristiques techniques trouvées dans les processeurs commercialisés les plus récents.

3.4.2.1 Architecture matérielle

Le processeur admet un pipeline à 5 étages : un étage fetch, un étage de décodage, un étage sélecteur d’instructions, un étage d’exécution et un étage de commit. L’étage d’exécution est composé de trois unités fonctionnelles, à savoir deux unités logiques et arithmétiques et une unité d’accès à la mémoire. Une des unités ALUs est spécialisée pour l’exécution des opérations de multiplication. Les instructions sont chargées du cache d’ins- tructions puis décodées dans l’ordre du programme. Les unités fonctionnelles procèdent à une exécution non-ordonnée des instructions. Les résultats des instructions sont validés par l’étage commit dans l’ordre du programme. Nous supposons qu’au plus deux instruc- tions peuvent être chargées, décodées, sélectionnées et commitées en parallèle. Une fois chargées, les instructions sont stockées dans un buffer à 4 emplacements, qu’on appelle le

Fetch Buffer. L’étage Decode retire les instructions du Fetch buffer pour les décoder. A la

fin du décodage, une instruction passe à l’étage IS5 et est stockée dans un emplacement

5

d’un buffer de ré-ordonnancement : Re-order Buffer. Ce buffer, à 8 entrées, est utilisé pour rétablir l’ordre du programme au niveau des instructions et validera les résultats dans l’ordre du programme à l’étape commit. Les instructions sont ordonnancées pour accéder aux unités fonctionnelles selon la disponibilité de ces dernières et les dépendances entre les instructions. Le Re-order buffer stocke les instructions du moment qu’elles finissent le décodage jusqu’à la fin de l’exécution sur les unités fonctionnelles. L’étage sélecteur d’ins- tructions envoie au plus deux instructions prêtes à s’exécuter et non-dépendantes pour s’exécuter sur les unités fonctionnelles. Si deux instructions, prêtes à s’exécuter, sont dé- pendantes, alors l’ordre du programme est appliqué pour les ordonnancer. La plus ancienne dans le programme est sélectionnée pour s’exécuter. La description Sim-nML complète de ce processeur est donnée dans le Listing 3.21. Elle est éditée dans un fichier d’extension « .nma ».

Listing 3.21 – Description Sim-nML du processeur : « use_case.nma » // e t a g e s

stage FE , DE, IS , ALU [ 2 ] , MEM, CM

// e x t e n s i o n de l a d e f i n i t i o n d e s e t a g e s e x t e n d FE , DE, I S , CM inorder = t r u e // e x e c u t i o n o r d o n n e e , v a l e u r p a r d e f a u t capacity = 2 // d e g r e de s u p e r s c a l a r i t e , 1 p a r d e f a u t e x t e n d ALU , MEM inorder = f a l s e // e x e c u t i o n non−o r d o n n e e , d e g r e de s c a l a r i t e = 1 // s t r u c t u r e du p i p e l i n e e x t e n d FE blocked = 64 // t a i l l e du b l o c de c a c h e en b i t f i r s t = t r u e // FE e s t l ’ e t a g e d ’ e n t r e e du p i p e l i n e

next = {DE} // FE admet un s e u l s u c c e s s e u r e t p a s de p r e d e c e s s e u r

e x t e n d DE

next = { I S }

pred = {FE}

e x t e n d I S

next = {ALU, MEM} // I S admet deux s e c c e s s e u r s

pred = {DE} e x t e n d ALU next = {CM} pred = { I S } e x t e n d MEM next = {CM} pred = { I S } e x t e n d CM l a s t = t r u e // CM e s t l ’ e t a g e de s o r t i e du p i p e l i n e

pred = {ALU , MEM}

// F e t c h B u f f e r a 4 e m p l a c e m e n t s e t Re−o r d e r B u f f e r a 8 e m p l a c e m e n t s

b u f f e r FBuf [ 4 ] , RoB [ 8 ]

// R e g i s t r e s e t memoires

r e g PC [ 1 , c a r d( 3 2 ) ] // compteur de programme

// 2^32 r e g i s t r e s de 32 b i t s

memM [ 3 2 , c a r d( 8 ) ] // memoire p r i n c i p a l e de t a i l l e 2^32 mots de 8 b i t s

3.4.2.2 Jeu d’instructions

L’extension du langage Sim-nML permet de donner la définition des modèles d’exé- cution des instructions dans un module indépendant de la spécification initiale du jeu d’instructions, qui contient la description du comportement, de la syntaxe et du binaire. La grammaire est donnée à l’Annexe A.

Nous avons mis en place une description hiérarchique du modèle de ressources des ins- tructions. La racine de la description du modèle de ressources du jeu d’instructions est l’opération instruction, à laquelle nous avons défini un attribut uses qui est partagé par tout le jeu d’instructions. Dans ce modèle commun, une partie dépend de l’instruction et sera définie plus tard. Les deux parties de la définition sont réparties sur deux fichiers différents comme décrit par le Tableau 3.3. A gauche, le fichier arm.nml contient la spéci- fication de la sémantique du jeu d’instructions. A droite, le fichier arm_rum.nma contient la spécification du modèle d’exécution du jeu d’instructions.

arm.nml

op i n s t r u c t i o n ( arm_i : ARM_instr )

image = arm_i .image s y n t a x = arm_i .s y n t a x a c t i o n = { PC = PC + 4 ; arm_i .a c t i o n; } arm_rum.nma // chemin d ’ e x e c u t i o n de l a r a c i n e e x t e n d i n s t r u c t i o n

uses = FE & FBuf &R [ 1 5 ] . r e a d , DE,

RoB & IS , arm_i .uses, CM

Tab. 3.3 – Description de l’instruction racine du jeu d’instructions.

Les modes d’adressage sont utilisés comme des types pour les opérandes des instruc- tions. Quand on définit un attribut uses à un mode d’accès, tout paramètre (opérande) d’instruction faisant référence à ce mode hérite de cet attribut. Dans le Tableau 3.4, nous donnons la définition initiale en Sim-nML du mode d’adressage regShift, utilisé par l’ar- chitecture ARMv5, placé dans un fichier modes_arm.nml. Le mode d’adressage est étendu par un attribut uses, qui définit quels registres sont accédés, si l’instruction utilise ce mode d’adressage.

Ensuite, de la même manière, nous avons spécifié les attributs uses pour les instruc- tions par extension. Le Listing 3.22 montre l’extension de certaines instructions (ce code Sim-nML fait partie du fichier arm_rum.nma). Certains paramètres de l’instruction font référence à des modes d’adressage que nous avons étendu par des modèles de ressources. Pour ces paramètres, nous faisons appel à l’attribut uses du mode par la syntaxe : ID [

modes_arm.nml type i n d e x = c a r d( 4 ) mode REG_INDEX( r : i n d e x ) = r . . . mode r e g S h i f t ( s h i f t A m t : REG_INDEX, s h i f t K i n d : u2 , r : REG_INDEX) = . . . s y n t a x = f o r m a t( "%s , %s %s " , r .s y n t a x, s w i t c h ( s h i f t K i n d ) { c a s e LSL : " l s l " c a s e LSR : " l s r " c a s e ASR : " a s r " c a s e ROR: " r o r " } , s h i f t A m t .s y n t a x) arm_rum.nma e x t e n d i m m S h i f t uses = R [ r ] . r e a d e x t e n d r e g S h i f t uses = R [ s h i f t A m t ] . r e a d & R [ r ] . r e a d e x t e n d c o n d i t i o n

uses = (i f ! ( ( cond == 1 4 )| |( cond == 1 5 ) ) t h e n Ucpsr . r e a d e l s e (i f ( ( cond == 1 4 )| |( cond == 1 5 ) ) t h e n Ucpsr . w r i t e e n d i f) e n d i f) e x t e n d s e t S uses = (i f s e t t h e n Ucpsr . w r i t e e n d i f)

Tab. 3.4 – Description Sim-nML des modes d’adressage.

’[’ Expr ’]’ ] ’.’uses. Nous supposons que notre processeur utilise la technique de bypass. Les registres sont produits et disponibles à la lecture à l’étage d’exécution.

Listing 3.22 – Modèle d’exécution du jeu d’instructions ARMv5 // i n s t r u c t i o n s a r i t h m e t i q u e s

e x t e n d ADD_shr , ADC_shr , BIC_shr

uses = ALU & R [ r d ] . w r i t e &R [ r n ] . r e a d & s h i f t e r _ o p e r a n d .uses & ( s e t s .uses) & ( cond .uses)

// i n s t r u c t i o n de m u l i p l i c a t i o n u t i l i s e l ’ALU s p e c i a l i s e e

e x t e n d MLA

uses = ALU [ 0 ] & R [ r d ] . w r i t e & R [ r n ] . r e a d & R [ rm ] . r e a d

& R [ r s ] . r e a d & ( s e t s .uses) & ( cond .uses)

// i n s t r u c t i o n de branchement

v a r t a k e n [ 1 ,c a r d( 1 ) ]

e x t e n d B_Cond

uses = ALU & (i f ( s e t l ) t h e n R [ 1 4 ] . w r i t e e n d i f)

& (i f ( t a k e n ==1) t h e n R [ 1 5 ] . w r i t e e n d i f) & ( cond .uses)

// p a r a m e t r e temps d ’ a c c e s a l a memoire v a r mem_read_time [ 1 ,c a r d( 8 ) ] v a r mem_write_time [ 1 ,c a r d( 8 ) ] // i n s t r u c t i o n de l o a d / s t o r e m u l t i p l e e x t e n d Mem_load_store_multiple uses = i f ( s e t l ==1) // i n s t r u c t i o n l o a d t h e n

(i f r e g l i s t & ( 1 << 0 )

t h e n MEM&M. r e a d & R [ r n ] . r e a d & R [ 0 ] . w r i t e #{mem_read_time} e n d i f) , . . . ,

(i f r e g l i s t & ( 1 << 1 5 )

t h e n MEM&M. r e a d & R [ r n ] . r e a d & R [ 1 5 ] . w r i t e #{mem_read_time} e n d i f)

e l s e // i n s t r u c t i o n s t o r e (i f r e g l i s t & ( 1 << 0 )

t h e n MEM&M. w r i t e &R [ r n ] . r e a d & (i f s e t w t h e n R [ r n ] . w r i t e e n d i f) &

R [ 0 ] . r e a d#{mem_write_time} e n d i f) , . . . ,

(i f r e g l i s t & ( 1 << 1 5 )

t h e n MEM&M. w r i t e &R [ r n ] . r e a d & (i f s e t w t h e n R [ r n ] . w r i t e e n d i f) &

R [ 1 5 ] . r e a d #{mem_write_time} e n d i f)

e n d i f

3.4.3 Synthèse

La micro-architecture et les comportements liés sont décrits explicitement au niveau Sim-nML. La grammaire de l’attribut uses, qui a déjà été proposé par [78] a été simplifiée et modifiée pour l’adapter à nos besoins. Le modèle de ressources a été enrichi afin d’expliciter le type des composants matériels de l’architecture (les étages, les mémoires tampons). Nous avons explicité les propriétés fonctionnelles des étages, ce qui n’était pas le cas dans les extensions Sim-nML déjà proposées. Nous avons aussi introduit la description de la structure du pipeline, utilisée pour la validation des chemins d’instructions. La spécification du modèle de ressources est indépendante de la sémantique des instructions. Nous avons pu décrire explicitement des particularités du jeu d’instruction ARMv5. Le langage Sim-nML étendu se prête facilement à la génération de simulateur de pipeline grain-fin. Nous avons vu dans la Section 3.2.4.3 qu’il est possible de spécifier une action pour l’instruction, à chaque étape de son exécution sur le pipeline. Un travail a déjà été commencé dans ce sens, permettant de décrire le comportement des instructions au niveau pipeline.

Dans l’implantation de l’extension OTAWA, nous avons suivi une démarche incrémen- tale. Nous avons préservé les fonctionnalités de l’environnement, plus précisément celles relatives à l’outil GLISS, à savoir la génération d’assembleurs, de désassembleurs, des si- mulateurs, etc. Nous avons intégré la génération de la représentation interne du modèle de ressources à la chaîne de génération d’outils déjà existante dans GLISS.

La spécification du modèle de ressources du jeu d’instruction ARMv5 mis en place est contenu dans un seul fichier de 200 lignes de codes Sim-nML, ce qui représente ∼ 5% de l’ensemble de la description Sim-nML du processeur (ISA et modèle de ressources ∼ 4000). Ce qui ne représente pas beaucoup de code par rapport à la description du niveau ISA, utilisée pour la génération des simulateurs, assembleurs, etc.

La représentation interne est générique et basée sur un formalisme dédié qui capte le modèle d’architecture, le modèle temporel des instructions et le modèle d’utilisation des res- sources. Le formalisme a été implanté à l’aide des types récursifs et des types polymorphes OCaml. Cette représentation interne inclut toute information utile pour l’étape d’analyse

ultérieure. Ceci nous a permis de séparer la partie analyse du temps de la partie description d’architecture. Il sera alors possible d’adopter différentes méthodes de résolution pour le calcul du temps d’exécution, à partir de la représentation interne.

Les entrées de l’approche sont indépendantes. L’utilisateur peut changer le modèle du processeur, indépendamment du programme et inversement. La modification de la partie micro-architecture se fait indépendamment de la description du niveau ISA, puisque les deux descriptions ont été séparées.

Nous n’avons pas traité certaines fonctionnalités de pipeline comme la prédiction de branchement, le scoreboard. Notre description matérielle du processeur s’est limitée aux étages, buffers, mémoires et registres. Cependant d’autres composants matériels comme les bus, les caches de niveau 2, etc. doivent aussi être inclus dans la description Sim-nML. Ceci est une perspective envisagée.

Conclusion

Ce chapitre a présenté le langage d’architecture Sim-nML étendu, permettant la des- cription de l’architecture matérielle et du jeu d’instruction d’un processeur. La description de processeur inclut une description des composants matériels et de leurs caractéristiques, une description du modèle d’exécution des instructions qui donne les étapes d’exécution sur le pipeline et les ressources utilisées et enfin la description du comportement des ins- tructions. Nous avons montré comment décrire des architectures ayant des fonctionnalités spécifiques et complexes, avec le langage Sim-nML étendu. La représentation interne est une abstraction de l’architecture et des instructions. Elle inclut les éléments de l’architec- ture pertinents pour l’analyse du temps et le comportement des instructions donné par un formalisme des clauses, que nous avons défini. Dans le chapitre suivant, nous présentons l’étape d’analyse du temps

Description à base de contraintes

et Calcul du temps

Sommaire

4.1 Approche à base de contraintes pour le calcul du temps . . . 102