System c eniso_jan_fev_07

CoursFondamentalduSystemC
1
CAO Électronique et Co-design
Chapitre 2
YOUNES LAHBIB
Jan-Fev 2008
younes.lahbib@gmail.com
lahbibyounes@yahoo.fr

14/05/15
2
PLAN DU COURS
Partie 1Partie 1 Du C au C++: une courte
présentation du langage C++ et ses
différences avec C.
Partie 2Partie 2 Les concepts clés de l’extension du
C++ au SystemC pour la modélisation des
circuits intégrés.
Partie 3Partie 3 Le langage SystemC

14/05/15
3
Premiers pas:
 Déclaration des variables
 Les références
 Passage des arguments des fonctions par référence
 Surcharge des fonctions
 Paramètres par défaut
 Allocation dynamique de la mémoire
 Les streams C++
Partie 1Partie 1 Du C au C++

14/05/15
4
Les variables peuvent être déclarés n’importe où dans
le code (pas nécessairement au début du code)
ex. 1ex. 1
{
int a=0;
a++;
// not allowed in C// not allowed in C
float b;;
...
}
ex. 2ex. 2
/* the i counter is defined directly inside
the block, and it is visible only inside it. */
for( int i=0; i<20; i++ )
{
...;
}
Du C au C++ premiers pas: déclaration
des variables

14/05/15
5
Considérer le code suivant:
int a;
int & b = a;
b = 5;
L’opérateur & signifie que « b » est:
- une référence de a, et non une copie de a,
- la meme variable avec un nom différent;
- un changement sur « b » est refleté sur a et viceversa.
Syntaxe:
datatype & var1 = var2;
Note: une variable référence doit toujours être
initialisée à une autre variable lors de la déclaration;
Du C au C++ premiers pas: les
références « & »

14/05/15
6
Passage des arguments des fonctions
par références
Le passage des variables par
référence est l’application la
plus importante des références.
Dans l’exemple, chaque fois
qu’une variable de type int est
passée à la fonction mult, « a »
devient une référence de
l’argument passé
Un changement quelconque
de cet argument ( a) sera reflété
sur la variable passée (val).
void mult(int & a)
{
a *= 2;
}
void main()
{
int val = 3;
mult(val); // now val = 6
}

14/05/15
7
Premiers pas: surcharge des fonctions
C++ permet le surcharge des fonctions:
– Plus q’une fonction peut avoir le même nom et le
même cadre.
– Les fonctions doivent différer par au moins un
paramètre
void mult(int &a)
{
a *= 2;
}
void mult(int &a, int n)
{
a *= n;
}
void main()
{
int val = 3;
mult(val); // val = 6;
mult(val,4); // val = 24;
}

14/05/15
8
Arguments par défaut
C++ permet des arguments par défaut pour
les fonctions
void mult(int & a, int n = 10)
{
a *= n;
}
void main( )
{
int val = 3;
mult(val); // val = 30;
mult(val,4); // val = 120;
}

14/05/15
9
Allocation Dynamique
C++ fournit deux opérateurs spéciaux, new et
delete, pour allouer et détruire des objets.
int *p;
p = new int; // p points to an int location;
....
delete p; // destroy the int memory location pointed by p
Ex of dynamic vectors
int *p = new int[num]; // now p points to a vector of num integers
...
delete [ ] p; // needed syntax to destroy a dynamic vector
/* Note: num can be a runtime value, elaborated during the
execution of the code;*/

14/05/15
10
CIN COUT C++ Streams
<< et >> sont surchargés pour les types natifs du
C.
Il peuvent être surchargé pour tout type définie
par l’utilisateur.
#include <iostream.h>
void main()
{
char * c[20] = “Hello world !”;
float z = 0.8;
int a = 23
cout << “c = “ << c << endl;
cout << “z = “ << z << endl;
cout << “a = “ << a << endl;
}

14/05/15
11
Programmation Objet
Classes et objets
Constructeurs et destructeurs
Polymorphisme
Surcharge des opérateurs
Héritage
Templates
Partie 1Partie 1 Du C au C++

14/05/15
12
Les objets interagissent entre eux par les fonctions dans la POO
Principe de la POOPrincipe de la POO

14/05/15
13
Classes et objets: introduction

14/05/15
14
Objets
OBJECTS – utilisés pour modéliser des entités réelles:
personnes, place vecteur, temps, liste …
Comment définir un objet ?
Chaque objet peut être définie pour contenir des
données et des fonctions manipulant ces données.

14/05/15
15
Classes
Les classes permettent de modéliser les objets
Les classes contiennent des attributs (données) et des
méthodes
class StudentRecord
{
private:
int SSN; //ATTRIBUTES
char first_name[20]; char last_name[20], int grade;
public:
void get_name(); //Methods :OPERATIONS on
ATTRIBUTES
void print_name();
};

14/05/15
16
Lien entre Classes et objets

14/05/15
17
Classes et objets: pointeur « this »
« This » pointe sur l’objet de la classe elle-même.
La fonction membre peut trouver l’adresse de l’objet
auquel elle appartient
/* Function taking an object of type signal as an argument.*/
void bind(signal s);
[…]
class signal
{
void bindme( )
{
bind(*this); // *this is the current object which is of type signal
}
}

14/05/15
18
Pointeur « this » (suite)
Peut être utilisé pour entre un argument et une variable
de classe:
class A {
int x = 3;
void f(int x) {
cout << "x= " << x << ", this->x= " << this->x << endl;
}
};
int main() {
A instance;
instance.f(1); // x= 1, this->x= 3
}

14/05/15
19
Les Constructeurs
Quand un objet de classe est créé, leurs membres
peuvent être initialisés par le constructeur de cette
fonction.
Le constructeur est exécuté quand un objet est déclaré
ou créé dynamiquement (utilisant new)
Définir les constructeurs
– A le même nom que la classe elle-même
– Ne retourne pas des valeurs.
– Ne peut pas être appelé explicitement
– Peut passer des arguments.

14/05/15
20
Constructeurs: exemple
class StudentRecord
{
private:
int SSN;//ATTRIBUTES
char first_name[20], last_name[20], address[40],
grade;
public:
StudentRecord(int SSN);//Constructor
- -
- -
};
StudentRecord::StudentRecord(int SSN)//Constructor Definition
{
this->SSN = SSN;
}

14/05/15
21
Passage des arguments au
constructeurs
Quand déclarer une instance:
– ClassName instance(arg1, arg2, …);
Quand utiliser l’opérateur new:
– ptr = new ClassName(arg1, arg2, …);

14/05/15
22
Polymorphisme de fonction
Exemple de surcharge de la fonction add() suivante:
/* The correct function to be invoked is determined by checking
the number and type of argument*/
//Declarations
int add(int a,int b); //prototype 1
int add(int a,int b,int c); //prototype 2
int add(double a,int b); //prototype 3
//Function calls
cout<<add(5,10) //uses prototype 1
cout<<add(5,10,20) //uses prototype 2
cout<<add(0.72,10) //uses prototype 3

14/05/15
23
Surcharge des opérateurs
C++ a plusieurs opérateurs:
– +, -, *, /, %, ++, --, =, +=, …
Il est nécessaires d’utiliser ces opérateurs avec des
objets. Exemple: si on veut ajouter deux strings,
utiliser + est plus intuitive d’utiliser la fonction strcat.
Ceci peut se faire en traitant les opérateurs comme
des fonctions.
La définition de ces fonctions peut se faire par:
– a = +(b, c); pour faire a = b+c

14/05/15
24
Surcharge des opérateurs (suite)
// string.cc
/* This is a memory efficient string class. It allocates just enough
memory to store the string passed to it! It demonstrates overloading the
+= operator. This is overloaded as a MEMBER FUNCTION */
#include <iostream.h>
#include <string.h>
class String {
private:
char *str;
public:
// Constructor
String(char* ptr);
// member functions
void print();
// Overloaded operators
const String& operator+=(const String& a);
};

14/05/15
25
Surcharge des opérateurs (suite)

14/05/15
26
Héritage

14/05/15
27
Héritage: Exemple (1/3)

14/05/15
28

14/05/15
29

14/05/15
30
Héritage Multiple

14/05/15
31
Généricité « Template »
Templates: utilise la même classe pour
différents types de données.
Exemple:
On peut représenter une pile comme un
tableau d’éléments, un entier indiquant le
sommet de la pile (LIFO), et des méthodes
comme « push et pop ».

14/05/15
32
Classes templates
On veut faire des piles
d’entiers, de double et de
réels sans écrire plus qu’une
fois ce code.
Pour cela on va utiliser les
classes templates

14/05/15
33
Classes templates
Si une classe est entrain d’utiliser « int » pour les opérations de la pile
une autre qui utilise des « strings » alors il n’y a pas besoin de d’utiliser
deux classes différentes mais utiliser des templates.

14/05/15
34
Classes templates
La classe template qui a été définie utilise un
type paramètre T.
Pour créer une classe on doit spécifier quel
est le type de T. exemple:
– Stack<int> iStack
– Stack<string> fStack;
Mettant ‘int’ dans <> on dit que T est assigné
à un entier ‘int’.

14/05/15
35
Plus q’un paramètre ?
Il est possible de créer des classes templates
avec plus qu’un seul paramètre.
template <class X, class Y>
class SampleClass
{
// code
};
Dans ce cas X et Y ont besoin d’être
spécifiés lorsque on crée un objet:
SampleClass<int, bool> S;

14/05/15
36
Fonctions Templates (exemple)
On peut déclarer la fonction qui calcule le carré par :
On peut utiliser la fonction ainsi :
T réfère ici au type du paramètre (entier, réel, …)

14/05/15
37
Exemple d’affichage d’un tableau
Cette fonction template affiche un tableau de types
de données quelconque. Si le tableau doit contenir
des objets définis par l’utilisateur, l’opérateur <<
dot être surchargé correctement.

38
Partie N°2
Du C++ au SystemC

14/05/15
39
Partie 2Partie 2
Du C++ au SystemC
Les concepts clés de l’extension du
C++ au SystemC pour la
modélisation des circuits intégrés.

14/05/15
40
Besoin des langages de modélisation
mixte logicielle/matérielle
=>Problématique: on veut un langage permettant de modéliser à la
fois du HW et du SW dans les SoCs (systèmes sur puces)!!
Les langages de description du matériel
– Verilog, VHDL
– ne sont pas dédiés à la modélisation du software
Langages de programmation généralistes
– C, Ada, langages Orientés Objet
– Manque de primitives permettant la modélisation du Hardware
– Besoin d’implémenter un cœur de simulation
Permettre une co-simulation hétérogène
Apparition de Langages dédiés au hard basées sur le C
– HardwareC, Hpascal, SpecC, cowareC…
– ce sont des langages propriétaires (académiques, CAD vendeurs)
=>Besoin d’un Langage à la fois pour la modélisation et la
programmation!!

14/05/15
41
Peut-on utiliser le C++ tel qu’il
est pour le HW-SW?
C++ ne supporte pas:
Communication hardware : Signaux, protocoles, …
Notion de temps : opérations séquencées par le temps
(cycles, délais en ns …)
Concurrences: HW et SW opèrent en parallèle
Réactivité: le HW réponde au stimuli et il a une
interaction constante avec son environnement, ce qui
nécessite le traitement des exceptions.
Types de données HW : Bit, bit-vector, multi-valued
logic (0, 1, « x », « z »), signed et unsigned, integer,
fixed-pointed, float …
Un cœur de simulation intégré!!

14/05/15
42
SystemC approbation ?
 Développé à l’origine par Synopsys, Frontier Design
et Coware
 OSCI (Open SystemC initiative) lancé en Sep 27,
1999
 Supporté par plus que 45 sociétés avec 10 membres

14/05/15
43
Histoire du SystemC

14/05/15
44
SystemC 2.0

14/05/15
45
Modélisation d’un Système
avec SystemC
 Un système est modélisé par:
 un ensemble de modules (instances de C++ classes),
organisées de façon hiérarchiques et fonctionnent de
façon concurrente.
 un ensemble d’élément de communication (signals,
channels …)
 interconnexions (binding) entre des éléments de
communication
 Tout est basée sur des objets (POO)
 l’ordonnancement (Scheduling) est assuré par le cœur du
SystemC!!

14/05/15
46
Exemple de systèmes

14/05/15
47
Caractéristiques de SystemC
Haute vitesse de simulation
Plusieurs niveaux d’abstraction
– Haut niveau fonctionnel (algorithmique, TLM, PV, PVT)
– CA (Cycle Accurate)
– RTL
– Classique flow de conception
Protocoles de communication – Channels
– Capacité de raffinement
Support de déboguage
– Approache C++ -> débuggeurs classiques (gdb, …)
– Prendre en compte du paradigme multi-threading pour le
déboguage.

14/05/15
48
Partie 3Partie 3
les concepts de SystemC
1. Introduction
2. Les éléments de langage SystemC
3. Le cœur de la simulation
4. Les niveaux d’abstraction

14/05/15
49
Introduction (1)
SystemC =
Librairie de classe C++ => Approche objet
Initiative OpenSource: http://www.systemc.org
Modélisation du hard et du soft
Méthodologie de conception et raffinement
des modèles de simulation :
untimed => timed => bus cycle accurate => cycle accurate
Steering Group de 13 companies
9 Université et +50 compagnies participent à
l’initiative

14/05/15
50
SystemC motivation (intro 2)
Un langage de description d’architectures et
de logiciels
Une méthodologie pour affiner les modèles
de simulation jusqu’à des simulateurs précis
au cycle
Un seul langage pour tous les niveaux
d’abstraction : C, C++

14/05/15
51
SystemC design flot (Intro 3)

14/05/15
52
Développement en SystemC (intro 4)

14/05/15
53
Principe (intro 5)

14/05/15
54
Module en interne (intro 6)

14/05/15
55
Comparaison entre SystemC et VHDL

14/05/15
56
Environnement de Vérification d’un
module

14/05/15
57
Eléments de langage SystemC
plan

14/05/15
58
Types de données: avant propos
Les types de C++ peuvent être utilisés mais ne sont pas
adéquate pour le hardware:
SystemC fournis d’autres types qui sont nécessaires
pour la modélisation des systèmes hard-soft. Il
commencent par le préfixe « SC_SC_ »:

14/05/15
59
Syntaxes de sc_int, sc_uint,
sc_bigint

14/05/15
60
plan

14/05/15
61
Module
Un module (SC_MODULE)(SC_MODULE) est un
container. C’est le block basique du
SystemC.
– Comme entityentity en VHDL
L’interface du module est dans le fichier
header (ending.h)
Fonctionnalités dans le CPP
Module Contient:
– Port
– Signaux et variables internes
– Processus de différents types
– Des méthodes C++
– Instances d’autres modules
– Constructeur

14/05/15
62
Syntaxe du module

14/05/15
63
Structure de base de modélisation

14/05/15
64
Ports (avant propos)
Les ports sont l’interface externe du module
– Passe des information au et à partir du module
– Contient trois types (in, out, et inout)
– Ports sont toujours mappés au signaux (binding,
port-map)
– Ports sont des membres du module ( de la classe
sc_module)
– Chaque port a un type de donnée passé comme un
template

14/05/15
65
Déclaration des ports
Les ports sont déclarés dans le module
– La direction du port est spécifiée par son type:
 Input sc_in<>sc_in<>
 Output sc_out<>sc_out<>
 Inout sc_inout<>sc_inout<>
Le type de donnée est passé en paramètre template:

14/05/15
66
Les signaux (avant propos)
Les signaux sont utilisés pour la communication
Echange les données entre les modules et les
processus.
Il y a un seul type de signaux
Les signaux peuvent ne pas être mappées aux ports
Les signaux peuvent être:
– Des données membres du SC_MODULE
– Utilisés au top pour la connexion entre les modules
Les types de données des signaux sont passés en
paramètre.

14/05/15
67
Déclaration des signaux
Sont déclarés à l’intérieur du module ou à l’exterieur.
Il y a un seul type:
– sc_signal <>sc_signal <>
Les données sont passées en paramètre (template)

14/05/15
68
Exemple ports-signaux
• Les ports et les signaux sont deux données membres du
SC_MODULE

14/05/15
69
Lecture/écriture des ports et des
signaux

14/05/15
70
Les Variables

14/05/15
71
Le constructeur

14/05/15
72
Exemple de Constructeur

14/05/15
73
plan

14/05/15
74
Processus (avant propos)

14/05/15
75
SC_METHOD (1)

14/05/15
76
SC_METHOD (2)

14/05/15
77
SC_METHOD: sensitivité

14/05/15
78
SC_METHOD : Exemple

14/05/15
79
SC_METHOD : Mode d’exécution

14/05/15
80
Les Processus de type thread

14/05/15
81
Utilisation des Threads

14/05/15
82
Fonctions du contrôle de temps

14/05/15
83
La fonction wait()

14/05/15
84
Mode d’exécution d’une
SC_THREAD

14/05/15
85
SC_THREAD exemple

14/05/15
86
Les événement spéciaux
(la classe: sc_event)
Events are special objects which can be specified inside a
module and invoked by thread processes of this module to
synchronize those other threads who are waiting on them.
To declare an event, you have just to instantiate it calling its
constructor without arguments:
sc_eventsc_event my_event;my_event;
To notify this event, you call its member function notify:
– examples
sc_time t( 10, sc_ns );
my_event.notify( t ); // notify in 10 ns
– ex 2
my_event.notify(0); // notify on the next delta cycle

14/05/15
87
Notification des events

14/05/15
88

14/05/15
89
Formes de wait()

14/05/15
90
Implémentation du Système

14/05/15
91
Implémentation du Système: définir
les signaux internes

14/05/15
92
Implémentation du Système: définir
des objets des sous-systèmes

14/05/15
93
Implémentation du Système: créer des
instances des sous-systèmes

14/05/15
94
Implémentation du Système:
interconnexion des sous modules

14/05/15
95
Exemple d’une Bascule D

14/05/15
96

14/05/15
97

14/05/15
98
Exemple d’un générateur
d’interruptions (exercice)

14/05/15
99

100
Le cœur de simulation du SystemC

14/05/15
101

14/05/15
102

14/05/15
103

14/05/15
104

14/05/15
105

14/05/15
106
SystemC Scheduler

14/05/15
107
SystemC Scheduler

108
Les niveaux d’abstraction en
SystemC

14/05/15
109

14/05/15
110

14/05/15
111

14/05/15
112

14/05/15
113

System c eniso_jan_fev_07

Contenu connexe

Tendances

Similaire à System c eniso_jan_fev_07

System c eniso_jan_fev_07