Encapsulation des Modules Pour la Cosimulation

Chaque module de l’environnement de cosimulation se compose d’un modèle adapté pour

la cosimulation et d’un simulateur adéquat pour effectuer la simulation. Les modèles à simuler

doivent donc être transformés et adaptés à la cosimulation avant de pouvoir faire partie d’un

module. Les transformations qui doivent être apportées aux modèles sont décrites ci-dessous :

Avant d’être compilés et simulés, ils nécessitent l’introduction de ports EXINS-EXOUTS

qui permettront à l’environnement de cosimulation de communiquer avec l’intérieur du

mo-dule à cosimuler. Ces ports sont présents dans des bibliothèques de ports EXINS-EXOUTS qui

contiennent toutes les primitives d’entrées/sorties nécessaires pour lier les modèles à simuler

et l’environnement de cosimulation. Une bibliothèque d’EXINS-EXOUTS peut éventuellement

contenir des Exinouts, ports d’entrée et de sortie auxquels certaines conventions, comme la

résolution, seront à appliquer suivant les nécessités.

Il existe exactement une bibliothèque pour chaque langage pouvant être inséré dans

l’envi-ronnement MCI. Les déclarations ajoutées par les bibliothèques de MCI sont dépendantes du

langage, de sa syntaxe et de ses propriétés de description. Le principe général pour

l’élabora-tion des bibliothèques est d’utiliser les déclaral’élabora-tions standards des langages. Les possibilités de

déclaration peuvent être les suivantes :

– la définition de procédures dédiées à la cosimulation pour les langages procéduraux (par

exemple C, C++).

La définition des primitives peut être attribuée à la déclaration de prototypes de fonctions

qui seront liées, à l’édition de lien, aux fonctions équivalentes de la bibliothèque MCI.

Par exemple avant d’intégrer le modèle dans l’environnement de cosimulation, pour le

langage C, le concepteur aura besoin de :

1. Référencer la bibliothèque d’EXINS-EXOUTS :

L’utilisateur inclut la référence à la bibliothèque par la commande :

#include <exinexoutc.h>

2. Définir les ports à cosimuler :

L’utilisateur introduit dans son modèle une déclaration du port qu’il désire

connecter à l’environnement de cosimulation :

Port<Type>(<Nom de la variable>) ;

Principe de Fonctionnement de l’Outil 77

L’utilisateur introduit au début de son programme un appel de fonction pour

initialiser ses ports avant toute exécution, selon le modèle suivant :

CPort<Type>Decl(&<Nom de la variable>,”<Nom de la variable>”,

<Valeur initiale>, <Direction du port>) ;

4. Ajouter des primitives d’échanges :

Pour chaque transmission d’une donnée, le modèle doit contenir une primitive

de communication afin de mettre à jour les ports au niveau du simulateur et/ou

de l’environnement

Output_<Type>(&<Nom de la variable>) ;

ou

Input_<Type>(&<Nom de la variable>) ;

– la définition de composants dans les langages proposant la notion de modules (par exemple

VHDL, COSSAP, MATLAB).

Dans ce cas, la bibliothèque de MCI propose un ensemble de composants qui doivent

connectés aux ports du modèle. Ces composants peuvent se présenter sous forme

gra-phique ou textuelle (VHDL). Pour les modèles gragra-phiques, l’outil MCI dispose de

bi-bliothèques graphiques, et leur utilisation ne consiste qu’en un simple “glisser-poser”

⁹

.

C’est le cas de MATLAB, COSSAP et SABER. Pour les simulateurs graphiques, comme

MATLAB, les EXINS-EXOUTS (e.g., figure 3.4) sont créés de façon à ce que l’utilisateur

n’ait plus qu’à les utiliser grâce à quelques mouvements de la souris. En réalité, sous

l’affichage graphique les EXINS-EXOUTS contiennent une couche écrite en langage C

permettant la connexion à l’environnement de cosimulation lors de l’exécution. Le fait de

les placer sur la feuille de travail équivaut à la déclaration de ces ports au niveau

procé-dural.

Pour un modèle textuel écrit en VHDL, la déclaration consiste uniquement à instancier

les composants de la bibliothèque de cosimulation VHDL. Le concepteur doit :

1. Référencer la bibliothèque pour le VHDL :

L’utilisateur fait référence au composant VHDL de la bibliothèque EXINS

-EXOUTS.

use WORK.EXINEXOUT_COMP.all

2. Définir les ports à cosimuler :

Pour définir un signal comme étant un port à cosimuler, l’utilisateur doit

connec-ter ce signal à une instance de type Exin, Exout, ou Exinout de sa bibliothèque,

suivant son type. Pour réaliser l’instanciation d’un port de sortie, il doit

in-clure :

<Instance Name> : EXOUT_<Type>

Generic Map (“<Nom du signal à cosimuler>”), <Taille du

vecteur si le signal est un tableau>

Port Map (<Nom du signal à cosimuler>)

Principe de Fonctionnement de l’Outil 78

Ports d’entrées EXIN

Ports de sorties EXOUT

FIG. 3.4 – Modèle MATLAB avec ses EXINS-EXOUTS.

C=A+B

A

B

C

FIG. 3.5 – Exemple d’un additionneur

Lorsque l’utilisateur a instancié tous les signaux qu’il veut cosimuler, son modèle

est prêt pour être compilé et exécuté dans l’environnement de cosimulation.

– L’utilisation de propriétés syntaxiques du langage (par exemple SDL).

Le langage SDL est un cas particulier car il communique via un canal connecté vers

l’environnement. Cet environnement est considéré à défaut comme étant l’interface

uti-lisateur. Néanmoins, Object_Geode propose une API permettant d’intercepter ce canal.

Ainsi, si l’utilisateur désire cosimuler un port, il doit utiliser un canal SDL connecté à

l’environnement. Lors de la connexion avec MCI, tout ce qui passe dans ce canal est pris

en compte par la cosimulation. La déclaration du canal peut être faite de façon graphique

comme textuelle.

3.3.2.1 Exemple de modification de modèles pour la cosimulation

Deux exemples de programme contenant les modifications apportées sont représentés dans

les tableaux 3.1 et 3.2. Le premier est un programme C et le second est un modèle VHDL.

Le même programme consiste à lire 2 entiers, à calculer leur somme et la communiquer à

l’environnement (cf. figure 3.5).

Dans tous les cas, pour insérer un modèle dans l’environnement de cosimulation,

l’utilisa-teur doit déclarer les ports qui doivent être cosimulés à l’intérieur des différents modèles.

L’ar-chitecture des ports est contenue dans les bibliothèques de MCI. Le lien entre ces déclarations

et les architectures équivalentes est établi au moment de l’édition de liens ou à la compilation

des différents modèles.

3.3.2.2 Compilation des Modèles adaptés pour la cosimulation

La compilation des modèles est en général relativement facile ou du moins elle n’est pas

plus contraignante que la compilation classique d’un modèle sans ports EXINS-EXOUTS.

Principe de Fonctionnement de l’Outil 79

Avant Transformation Modèle adapté à la cosimulation

#include <exinexoutc.h>

Portint(a) ;

Portint(b) ;

Portint(c) ;

int main() { int main() {

CPortintDecl(&a,”a”,0,EXIN) ;

CPortintDecl(&b,”b”,0,EXIN) ;

while (1) { while (1) {

scanf(“%d”,a) ; Input_int(&a) ;

scanf(“%d”,b) ; Input_int(&b) ;

c=a+b ; c=a+b ;

printf(“c=%d\n”,c) ; Output_int(&c) ;

} /* End While */ } /* End While */

} /* End Main */ } /* End Main */

TAB. 3.1 – Transformation d’un programme C

Avant Transformation Modèle adapté à la cosimulation

library Synopsys ; library Synopsys ;

use Synopsys.types.all ; use Synopsys.types.all ;

use Synopsys.attribute.all ; use Synopsys.attributes.all ;

use work.EXINEXOUT_COMP.all ;

entity Addition is entity Addition is

Port (a,b : in integer Port (a,b : in integer

c : out integer c : out integer

) ; ) ;

end Addition ; end Addition ;

architecture behavioral of Addition is architecture behavioral of Addition is

Instance_A :EXIN_INTEGER

Generic Map(“a”)

Port Map(a) ;

Instance_B :EXIN_INTEGER

Generic Map(“b”)

Port Map(b) ;

Instance_C :EXOUT_INTEGER

Generic Map(“c”)

Port Map(c) ;

begin begin

c<=a+b ; c<=a+b ;

end Behavioral ; end Behavioral ;

Principe de Fonctionnement de l’Outil 80

– Dans le cas de modèles graphiques, la compilation, si elle a lieu, est relativement

trans-parente et ne pose pas de problèmes.

– Dans les autres cas, elle consiste à utiliser les outils traditionnels de compilation en

fonc-tion des langages (e.g., gcc ou cc pour le C, vhdlan pour le VHDL, gsmcomp pour le

SDL).

C’est l’édition de liens qui, dans la plupart des cas, va établir l’association des primitives

ajou-tées au modèle avec les architectures de ces primitives contenues dans les bibliothèques de MCI.

Ces bibliothèques, chacune associée à un langage particulier, sont statiques ou dynamiques.

Dans le premier cas, la bibliothèque sera reliée au moment de l’édition de lien, avant la

simula-tion (Par exemple pour le langage C : gcc -o ModelExecutable Model.c -lexinexoutc). Dans le

deuxième cas, le lien est établi en standard par le compilateur, mais sera effectivement réalisé

au moment de l’exécution lorsque le simulateur fera appel à une primitive de cosimulation (e.g.

VHDL).

Dans le document Cosimulation multiniveaux dans un flot de conception multilangage (Page 78-82)