Cours intégré SoC : SYSTEM-C

Plan du cours SYSTEM-C

1 Conception des SoC

2 Le langage System-C

3 Exploration Architecturale

4 Raffinement et Implantation

2
 1- Conception des SoC

 Définition
 Enjeux
 Time to market
 Coût de réalisation
 Domaines d’application des SoC
 Exemples
 Automobile, Aviation, Téléphonie, …
 Méthodologie
 Flot de conception
 Outils disponibles
3
 2- Le langage System-C

 Introduction à System-C
 Niveaux d’abstraction
 Modèles de calcul

 Interfaces et canaux
 Vérification fonctionnelle
 Exemple de plate-forme

4
 2- Le langage System-C

 Introduction à System-C
 Niveaux d’abstraction
 Modèles de calcul

 Interfaces et canaux
 Vérification fonctionnelle
 Exemple de plate-forme

5
 2- Le langage System-C

 Introduction à System-C
 Bibliothèque de classes C++ pour la modélisation
de systèmes numériques mixtes
 Pleinement compatible avec C++

 Facile à étendre ou interfacer avec d’autres

enivronnement (Visual C++, Borland C++, gcc,
g++, Eclipse, …)

6
 2- Le langage System-C

 System-C et outils EDA

 Modélisation et vérification de systèmes
• CoFluent Studio ScDE
• Mentor Graphics: Seamless (vérification)
• Summit Design
 Co-Simulation System-C & HDL
• Synopsis
• Mentor Graphics
 Synthèse
• Forte Design Systems: Cynthesizer
• Synopsis

7
 2- Le langage System-C

 Téléchargement
 Site web: [Link]
 Inscription gratuite
 Système d’exploitation
 Linux
 Mac OSX
 Windows (avec Visual C++)
 Stations Sun ou HP

8
 2- Le langage System-C

 Documentation
 Disponible avec le code source
 Language Reference Manual
 User Guide
 Functional Specification
 Application Notes

9
 2- Le langage System-C

 Téléchargement du logiciel
 Commencer par télécharger Microsoft Visual
Studio 2005 or 2008 depuis le site web :
[Link]
 Aller à [Link]
 Créer un nouveau compte d’utilisateur
 Télécharger la bibliothèque SystemC
 Aller à “Downloads->OSCI Standards,”
 Choisir la section “Current Releases”
 Télécharger SystemC 2.2.0 ([Link])

10
 2- Le langage System-C

 Installation sous Visual C++

 Ouvrir Microsoft Visual Studio

11
 2- Le langage System-C

 Installation sous Visual C++

 Ouvrir le projet SystemC qui vient avec la release

12
 2- Le langage System-C

 Installation sous Visual C++

 L’assistant de conversion doit apparaître

13
 2- Le langage System-C

 Installation sous Visual C++

 Activer Solution Explorer depuis le Menu « View »

14
 2- Le langage System-C

 Installation sous Visual C++

 Compiler la bibliothèque SystemC (Appuyer sur F6)

 Ceci doit créer le fichier [Link] dans le dossier :

«\systemc-2.2.0\msvc71\SystemC\Debug\ »
 En cas de messages d’erreur, installer la plateforme
SDK, pour plus d’infos :
[Link]
15
 2- Le langage System-C

 Installation sous Visual C++

 File  New

16
 2- Le langage System-C

 Installation sous Visual C++

17
 2- Le langage System-C

 Installation sous Visual C++

 Project  Settings

18
 2- Le langage System-C

 Installation sous Visual C++

 Cocher l’option “Enable Run-time Type information”

19
 2- Le langage System-C

 Installation sous Visual C++

20
 2- Le langage System-C

 Installation sous Visual C++

 Ajouter la bibliothèque [Link]

21
 2- Le langage System-C

 Installation sous Visual C++

 Ajouter la bibliothèque [Link]

22
 2- Le langage System-C

 Installation sous Visual C++

 Vous pouvez utiliser la bibliothèque [Link]

23
 2- Le langage System-C

 Premier exemple
 Compiler et exécuter le compteur fourni
 A l’aide de GTKWave, ouvrir le fichier .vcd généré

24
 2- Le langage System-C

 Premier exemple
 Rechercher les signaux à visualiser avec GTKWave

25
 2- Le langage System-C

 Premier exemple
 Rechercher les signaux à visualiser avec GTKWave

26
 2- Le langage System-C

 Premier exemple

27
 2- Le langage System-C

 Éléments du langage

28
 02/01/2023

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é!!

29
 02/01/2023

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

30
 02/01/2023

Histoire du SystemC

31
 02/01/2023

SystemC 2.0

32
 02/01/2023

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!!

33
 02/01/2023

Exemple de systèmes

34
 02/01/2023

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.

35
 02/01/2023

Développement en SystemC ()

36
 02/01/2023

Principe

37
 02/01/2023

Module en interne

38
 02/01/2023

Un premier exemple
Voir encore: [Link]/

39
 02/01/2023

Comparaison entre SystemC et VHDL

40
Environnement de Vérification d’un module

02/01/2023
41
 02/01/2023

1
INTRODUCTION

42
 2- Le langage System-C

 Définition d’un Module

 C’est l’entité de base pour décrire un système
 Il peut contenir des :
• Ports
• Cannaux
• Processus
• Fonctions non enregisterées comme processus
• Instances d’autres modules
 Permet donc de décrire la hiérarchie d’un système

43
 2- Le langage System-C

 Un module avec ses sous-modules, ports,

processus et signaux

44
 2- Le langage System-C

 Définition d’un Processus

 Un processus sert à décrire la fonctionnalité d’un
module
 Permet d’émuler le comportement concurrent de ses
composants.
 Il s’exécute dès qu’il y a une modification sur l’un des
signaux ou ports de sa liste de sensibilité
 Les signaux sont utilisés pour les communications
inter-processus

45
 2- Le langage System-C

 Processus
 Chaque processus possède une liste de sensibilité
 Lorsqu’un port sur cette liste est activé, le processus
en question s’ordonnance pour une exécution
 Chaque port décrit son type entre < >
• Exemple: sc_out<int> my_port;
• Exemple d’un tableau de ports :
sc_out<bool> my_array_port[32];

46
 2- Le langage System-C

 Processus
 Il décrit le comportement du module
 Pour fins d’initialisation, chaque processus est
exécuté une fois au moment du démarrage, sauf si
on spécifie dont_initialize() dans sa définition
 Il existe 3 types de processus:
• SC_METHOD :
– Ce processus se termine toujours
– Ce n’est pas un thread : pas de wait ou de boucle infinie, pas de
suspension d’exécution
– Une procédure ou une routine qui s’exécute en entier lorsqu’un
changement sur la liste de sensibilité survient

47
 2- Le langage System-C

 Processus
 SC_THREAD :
• Peut être suspendu et réactivé, avec un wait
• Contrôle par boucle infinie (le SC_THREAD ne peut pas se
terminer où il ne se réordonnancera pas)
• Possibilité de communications bloquantes telles que la
lecture et écriture dans un FIFO

48
 2- Le langage System-C

 Processus
 SC_CTHREAD
• Cas particulier du SC_THREAD
• La liste de sensibilité n’est constituée que des fronts
montants ou descendants d’une horloge
• Notion de temps: wait(n) (n = nombre de cycles)
• Utilisation classique : machine à états finis
• Les signaux d’entrée sont disponibles immédiatement

49
 2- Le langage System-C

 Constructeur d’un module

 Le constructeur (SC_CTOR) associé au module
permet de créer des instances des modules
 On spécifie dans le constructeur
• Les différents processus du module
• Leurs listes de sensibilité
• Des membres privés à ce module
• Initialisation des membres

50
 2- Le langage System-C

 Opérateurs
 Opérateurs
• Bit ~ & | ^ >> <<
• Arithmétique + - * / %
• Assignation += -= *= /= %= &= |= ^= =
 Égalité == !=
 Comparaisons < <= > >=
 Incrém./Décrém. ++ --
 Sélection [] .range(,)
 Concaténation (,)

51
 2- Le langage System-C

 Horloges
 Le sc_clock est un objet particulier de SystemC
servant à la synchronisation des événements
 Plusieurs horloges sont possibles
 Configurable selon:
• Période
• % de temps haut
• Moment et type du premier front
 Les processus SC_CTHREAD ont besoin de
l’horloge et utilisent les ports particuliers comme le
sc_in_clk

52
 2- Le langage System-C

 Canaux de communication
 Pour relier les modules entre-eux
 Des canaux élémentaires sont déjà inclus
• sc_signal
• sc_buffer
• sc_fifo
• sc_mutex

53
 02/01/2023

2
ELÉMENTS DU LANGAGE
SYSTEMC

54
 02/01/2023

Eléments de langage SystemC

plan

55
 02/01/2023

Types de données: Sommaire

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_ »:

56
 02/01/2023

Types de données: Sommaire (suite)

57
 02/01/2023

Le Type Bit
 Peut prendre deux valeurs '0‘ ou '1‘.
 Utilisé quand modéliser des modules où Z (hi
impedance) or X (unknown) ne sont pas
nécessaires.
 Il y a un nombre d’opérateurs logiques que nous
pouvons utiliser

58
 02/01/2023

Exemple SC_BIT

Quelles sont les valeurs de enable et read_en ?

59
Simulation de l’exemple sur 02/01/2023

sc_bit

60
 02/01/2023

Le type SC_LOGIC

 sc_bit types can hold two values so it can not

be used for modelling real hardware. In real
hardware we have '0', '1', 'X' and 'Z'. For this
we have sc_logic type, which can hold all the 4
values.
 '0': false
 '1': true
 'X' or 'x': unknown or
indeterminate value
 'Z' or 'z': high-impedance or
floating value
61
 02/01/2023

Le type SC_LOGIC

• sc_logic et sc_bit peuvent être affectés entre eux.

• on peut comparer sc_bit avec sc_logic.
• sc_logic ont des valeurs de cast prédéfinies quand
affecter des valeurs à des variables sc_logic .
• voir exemple.

62
 02/01/2023
Exemple d’utilisation de
SC_LOGIC

Quelles sont les valeurs

affichées après simulation ?

63
 02/01/2023

Simulation de SC_LOGIC

25

64
 02/01/2023

Exemple d’opérateurs en
SC_LOGIC

Quelles sont les valeurs

affichées après simulation ?

65
 02/01/2023
Simulation des opérateurs sur
SC_LOGIC

66
Opérations logiques sur X et 02/01/2023

67
 02/01/2023

Vecteur de bits (sc_bv)

 Les types vecteurs de bits ne doivent pas être
confondus avec les types entier.
Ce sont des tableaux de bits, pas des nombres. Ils sont
optimisés pour les manipulations de bits, et ne
disposent pas d'opérations arithmétiques.
sc_bv<n>
 Vecteur de bits 2-valués. Il dispose de méthodes de :
 sélection de bit [], sélection d'un ensemble de
bits .range() et concaténation ", "
 réduction : .and_reduce(), .or_reduce(), .xnor_reduce(
), ...
 assignation : =, &=, |=, ^=
 manipulation de bits : ~, &, |, ^, <<, >>
 egalité : ==, !=
 Les valeurs littérales sont représentées par des
chaînes de caractères.
68
 02/01/2023

Les Opérateurs de sc_bv

69
 02/01/2023

Les Méthodes de sc_bv

70
02/01/2023

s
eur ion ?
val t
les ula
ont sim
s s après
elle
Qu hées
c
affi
Exemples d’utilisation de sc_bv

71
 02/01/2023

Exemples d’utilisation de sc_bv

72
 02/01/2023

Vecteur de sc_logic
(sc_lv)
sc_lv<n>

 Vecteur de bits 4-valués (sc_logic). Il accepte donc les

valeurs 'X' et 'Z' en plus de celles des sc_bv.
Il est typiquement utilisé pour modéliser des bus de
données trois-états (sortie de RAM, ...).
 Son comportement est le même que celui des sc_bv,
mais simule moins vite.
 Pour effectuer des opération arithmétiques sur un
sc_bv ou sc_lv, il faut passer par une variable
temporaire de type int, sc_int, ... Lors de la conversion,
si un 'X' ou 'Z' est présent, le résultat est indéfini, et un
warning est déclenché à l'exécution. .

73
 02/01/2023

s
eur ion ?
val t
les ula
ont sim
s s après
elle
Qu hées
c
affi
d’utilisation de sc_lv
Exemples

74
 Exemples 02/01/2023

d’utilisation de sc_lv

75
 02/01/2023

Le type sc_int

 SystemC propose une extension du type int

(généralement sur 32 bits), signés et non-signés,
allant de 1 bit à autant qu'on veut : sc_int,
sc_uint, sc_bigint, sc_biguint.
 sc_int<n>, sc_uint<n>
 Ces types sont des entiers signés et non signés,
représentés sur n bits, n allant de 1 à 64 (inclus).
La version signée est représentée en complément
à 2.
Si les entiers utilisés n'ont besoin que de 32 bits
maximum, on peut compiler son modèle avec
l'option -D_32BIT_ ce qui accélèrera les
simulations.

76
 02/01/2023

Le type sc_int

Bitwise operators work on operands. The not(~) operator will invert all
bits, and the shift operators will shift left(<<) or right(>>) an operand by
the specified number of bits. Type sc_int can be used with C++ integer
types without restriction.

77
 02/01/2023

Le type sc_int

78
 02/01/2023

Le type sc_int

79
 02/01/2023

Le type sc_int

80
02/01/2023

s
eur ion ?
val t
les ula
ont sim
s s après
elle
Qu hées
c
affi
Exemple sc_int

81
 02/01/2023

Exemple sc_int

Interpréter les
résultats !!!!!!!!!!

82
 02/01/2023

Le type sc_uint
 sc_uint is unsigned integer, and it is fixed
precision integer of size 64 bits.
 The underlying operations use 64 bits, but the
result size is determined at object declaration.
 Operands of type sc_uint can be converted to
type sc_int and vice versa by using assignment
statements.
 When assigning an integer to an unsigned operand, the integer
value in 2's complement form is interpreted as an unsigned
number.
 When assigning an unsigned to a signed operand, the unsigned
is expanded to a 64 bit unsigned number and then
truncated to get the signed value.    
 sc_uint has rich operators as in the case of
sc_int. Look at sc_int for details.
83
02/01/2023

s
eur ion ?
val t
les ula
ont sim
s s après
elle
Qu hées
c
affi
Exemple sc_uint

84
 02/01/2023

simulation sc_uint

Interpréter les
résultats
85 !!!!!!!!!!
 02/01/2023

Le type sc_bigint
 There are time when operands need to be larger than
64 bits. For these types of designs sc_int will not
work. For these cases SystemC provides type
sc_bigint (arbitrary sized signed integer).
 sc_bigint allows the designer to work on integers of
any size, limited only by underlying system
limitations. Arithmetic and other operators also use
arbitrary precision when performing operations.
 SystemC define's MAX_NBITS in sc_constants.h to
limit the max size of the bits for sc_bigint to 512.    
 Type sc_bigint is a 2's complement signed integer of
any size.
 sc_bigint has rich operators as in the case of sc_int.
Look at sc_int for details.

86
 02/01/2023

Le type sc_bigint

87
 02/01/2023

Le type sc_biguint
 sc_biguint is same as sc_bigint, only difference is
sc_biguint is unsigned.
 sc_biguint allows the designer to work on
integers of any size, limited only by underlying
system limitations.
 Arithmetic and other operators also use
arbitrary precision when performing operations.
SystemC defines MAX_NBITS in sc_constants.h
to limit the max size of the bits for sc_biguint to
512.
 sc_biguint has rich operators as in the case of
sc_int. Look at sc_int for details.

88
 02/01/2023

Le type sc_biguint

89
 02/01/2023

Module
 Un module (SC_MODULE) est
un container. C’est le block
basique du SystemC.
 Comme entity en VHDL/module en
Verilog
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

90
 02/01/2023

Syntaxe du module

91
 02/01/2023

Structure de base de modélisation

92
 02/01/2023

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
93
 02/01/2023

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<>
• Output sc_out<>
• Inout sc_inout<>
Le type de donnée est passé en paramètre
template:

94
 02/01/2023

95
 02/01/2023

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.

96
 02/01/2023

Déclaration des signaux

Sont déclarés à l’intérieur du module ou à

l’exterieur.
Il y a un seul type:
 sc_signal <>
 Les données sont passées en paramètre
(template)

97
 02/01/2023

98
 02/01/2023

Exemple ports-signaux

• Les ports et les signaux sont deux données membres du

SC_MODULE

99
 02/01/2023

Lecture/écriture des ports et des signaux

100
 02/01/2023

Les Variables

101
 02/01/2023

Le constructeur

102
Exemple de Constructeur 02/01/2023

103
 02/01/2023

Eléments de langage SystemC

plan

104
Processus (avant propos)
02/01/2023

105
 02/01/2023

Principes de base
 Les événements sont les objets sur lesquels se base toute la
synchronisation des processus. Ils déterminent quand est-ce qu'un
processus doit être déclenché ou réveillé.
 Il peuvent représenter des événements concrets (changement d'état
d'un signal), ou abstraits.
 Les événements sont des objets très simples, disposant de très peu de
méthodes. Tout ce qu'on peut en faire c'est :les mettre dans les listes
de sensibilité des processus, et, quand on le souhaite, les déclencher
(on dit "notifier"). Un processus qui avait ces événement dans sa liste
de sensibilité est alors réveillé.on peut aussi les annuler...
 En fait, ce que fait la méthode sensitive (et ses dérivés), c'est
récupérer un événement associé au signal en question, et c'est cet
événement qui est placé dans la liste de sensibilité. L'événement par
défaut des signaux est inactif a plupart du temps, mais se trouve
activé (on dit "notifié) lors d'un changement d'état du signal.
Autrement dit, quand un signal change d'état, son événement associé
est notifié, et cela réveille le processus qui l'a dans sa liste de
sensibilité.

106
 02/01/2023

PROCESSUS
 Les processus de SystemC se comportent comme les processus de
Verilog ou VHDL. Ils décrivent la fonctionnalité d'un module.
 Ce sont des fonctions membres des modules, de type void f(void). On
ne les appelle pas directement, c'est le scheduler SystemC qui se
charge de les appeler en se basant sur leur liste de sensibilité. Un
processus peut appeler une méthode membre de son module, mais pas
un autre processus.
 Les processus utilisent les événements et les canaux pour
communiquer entre eux. Il est possible de faire communiquer des
processus par des variables, mais c'est fortement déconseillé : les
variables sont affectées immédiatement. L'ordre d'exécution des
processus étant indéterminé, cela peut conduire à des conditions de
course (race condition), de l'indéterminisme, des comportements
erratiques, etc.

107
 02/01/2023

 Un processus peut accéder directement à un canal qui fait partie du même

module, mais est obligé de passer par un port pour communiquer avec l'extérieur
du module.
 Il existe deux types de processus en SystemC : SC_METHOD et SC_THREAD. En
fait, il en existe un troisième, SC_CTHREAD, qui ne fait plus partie la norme. Il
existe encore dans la bibliothèque, pour maintenir la compatibilité avec les
versions précédentes, mais son emploi est déconseillé. Nous ne le présenterons
donc pas ici.
 Un module peut avoir un ou plusieurs processus, de même type ou de type
différent.
 Les deux types de processus sont instanciés en 4 étapes :
 déclaration du processus : c'est une méthode du module, comme toute méthode
il doit avoir une déclaration et une implémentation
 enregistrement : les processus ne sont pas appelés directement, c'est le
scheduler SystemC qui les appelle. Mais il doit savoir quelle méthode appeler, et
quel est son type (SC_METHOD ou SC_THREAD). C'est le rôle de cette étape.
 déclaration de la liste de sensibilité par défaut : le scheduler doit aussi savoir
quand appeler ou réveiller le processus. Pour cela on attribue au processus une
liste de sensibilité par défaut. Une fois que la simulation a démarré, les
processus ont le droit de modifier leur propre liste de sensibilité.
 implémentation : comme toutes les méthodes, il faut fournir une implémentation.
Préférez les fichiers séparés pour les déclarations et implémentations.
 L'objectif des prochaines section est d'étudier chaque type de processus, leurs
comportements et objectifs étant différents.
108
 02/01/2023

SC_METHOD (1)
sont, du point de vue du scheduler, des fonctions normales
 ils sont appelés par le scheduler à chaque notification d'événement de
leur liste de sensibilité
 ils s'exécutent en entier, dans le contexte du scheduler, puis exécutent
un return(), qui redonne la main au scheduler.
 
 Ceci est très important : le scheduler SystemC est multi-thread. Mais les
SC_METHOD ne sont pas des threads. Ce sont des fonctions normales,
que le scheduler appelle les unes après les autres, quand un événement
de leur liste de sensiblité est notifié. Quand le SC_METHOD se termine (
return() ), il redonne la main au scheduler. Si, pour une raison ou pour
une autre, le SC_METHOD ne retourne pas (s'il est bloqué, s'il est dans
une boucle infinie), le scheduler est bloqué, la simulation n'avance
plus !
 Les variables locales des SC_METHOD sont donc ré-initialisées à chaque
entrée dans le processus (à moins de les avoir déclarées statiques). Si
le SC_METHOD a besoin de sauvegarder des informations, cela doit être
fait dans des variables ou signaux membre du processus.
 Création des SC_METHOD Comme tous les processus, leur création se
fait en 4 étapes :
 Déclaration , EnregistrementDéclaration de la liste de sensibilité par
défaut
 Implémentation
109
 02/01/2023

SC_METHOD (2)

110
 02/01/2023

SC_METHOD: sensitivité

111
 Exemple de SC_METHOD 02/01/2023

Exercice: modélisez un compteur 4-bits

avec reset et un signal enable active haut ?

1 //-----------------------------------------------------
2 //
3 // Design Name : first_counter
4 // File Name : first_counter.cpp
5 // Function : This is a 4 bit up-counter with
6 // Synchronous active high reset and
7 // with active high enable signal
8 //-----------------------------------------------------

112
113
 02/01/2023

SC_METHOD : Mode d’exécution

114
 02/01/2023

SC_METHOD : Exemple Mode d’exécution

115
 02/01/2023

Les Processus de type thread

 sont des threads indépendant du scheduler
 ils sont lancés une seule fois, au début de la simulation, et plus jamais après
 ce sont des boucles infinies, qui peuvent et doivent être mises en veille à intervalle
réguliers. Le temps peut alors s'écouler. Les SC_THREAD sont réveillés par leur liste
de sensibilité.
 La différence avec les SC_METHOD doit maintenant être claire :
 un SC_METHOD est lancé à chaque fois que sa liste de sensibilité le demande, et ne se
suspend pas (sinon le scheduler bloque).
 un SC_THREAD est lancé une seule fois, c'est un thread (au sens Unix du terme)
indépendant. Sa liste de sensibilité sert à le sortir de veille. Il peut bloquer (veille,
boucle infinie, ...), ça ne gêne pas le simulateur.

 la liste de sensibilité d'un SC_METHOD spécifie quand est-ce qu'il doit être exécuté
 la liste de sensibilité d'un SC_THREAD spécifie quand est-ce qu'il doit être réveillé.
 Un SC_THREAD est mis en veille par la fonction wait(). Le scheduler SystemC ne fait
avancer les delta_cycle que lorsque tous les SC_THREAD sont en veille. Si un
SC_THREAD se termine (return() ), il ne s'exécute plus. Donc s'il doit ête exécuté de
façon cyclique, à chaque coup d'hologe par exemple, il faut l'implémenter sous forme
d'une boucle infinie (while(1) {...} ), et exécuter wait(clk) là où c'est nécessaire dans
cette boucle.
 Lorsqu'un SC_THREAD exécute wait(), il est mis en veille. Il est réveillé sur
notification de sa liste de sensibilité et reprend son exécution là où il en était. Ses
variables locales ont bien entendu gardé leur valeur.

116
 02/01/2023

Utilisation des Threads

117
 02/01/2023

Fonctions du contrôle de temps

118
 02/01/2023

La fonction wait()

119
 Exemple SC_THREAD 02/01/2023

 Même exemple du compteur avec

SC_THREAD
1 //-----------------------------------------------------
2 //
3 // Design Name : first_counter
4 // File Name : first_counter.cpp
5 // Function : This is a 4 bit up-counter with
6 // Synchronous active high reset and
7 // with active high enable signal
8 //-----------------------------------------------------

120
 02/01/2023

121
Mode d’exécution d’une 02/01/2023

SC_THREAD

122
 02/01/2023

SC_THREAD exemple

123
 02/01/2023

SC_CTHREAD vs. SC_THREAD

 The SC_CTHREAD process specifies a clock object.
When other process types are described in a module
constructor they only have the name of the process
specified, but the SC_CTHREAD process has the
name of the process and the clock that triggers the
process.

 An SC_CTHREAD does not have a separate

sensitivity list like the other process types.
The sensitivity list is just the specified
clock edge. The SC_CTHREAD process will
be activated whenever the specified clock
edge occurs.
124
 02/01/2023

Exemple de SC_CTHREAD
 Même exemple: compteur avec
SC_CTHREAD
 In this example the positive edge of
the clock is specified so process
incr_count will execute on every
positive edge of the clock.

125
 02/01/2023

126
 02/01/2023

SC_CTHREAD: wait_until et delayed

 In an SC_CTHREAD process wait_until() methods can be

used to control the execution of the process.
 The wait_until() method will halt the execution of the
process until a specific event has occurred. This specific
event is specified by the expression to the wait_until()
method.

 This statement will halt execution of the process until

the new value of "expr" is true. The delayed() method is
required to get the correct value of the object.
 A compilation error will result if the delayed() method is
not present. Only a boolean expression is allowed as
argument of the wait_until() function and only boolean
signal objects can be used in the boolean expressions.
 Boolean signal objects include clock type sc_clock,
signal type sc_signal, and port types sc_in, sc_out, and
sc_inout 127
 02/01/2023

wait_until and delayed example

(compteur)

128
 2- Le langage System-C

 Exemple : ½ Additionneur

129
 2- Le langage System-C

 Exemple : ½ Additionneur (2)

1. // File : half_adder.h 1. // File : half_adder.cpp

2. #include "systemc.h" 2. #include "half_adder.h"
3. 3.
4. SC_MODULE(half_adder) 4. void half_adder::prc_half_adder()
5. { 5. {
6. sc_in<bool> a,b; 6. sum = a ^ b;
7. sc_out<bool> sum,carry; 7. carry = a & b;
8. 8. }
9. void prc_half_adder();
10.
11. SC_CTOR(half_adder)
12. {
13. SC_METHOD(prc_half_adder);
14. sensitive << a << b;
15. }
16.};

130
 2- Le langage System-C

 Exemple : ½ Additionneur (3)

 Le fichier half_adder.h (fichier include C++) contient
la description du module et la déclaration des
processus qui le composent
 Le fichier half_adder.cpp (fichier source C++) contient
la définition de ces processus
 SC_MODULE commence la déclaration d’un
nouveau module SystemC
 Le nom du module est : half_adder
 2 ports d’entrée a et b de type bool
 2 ports de sortie sum et carry de type bool

131
 2- Le langage System-C

 Exemple : ½ Additionneur (4)

 Le bloc SC_CTOR à la ligne 11 déclare les
processus et types de processus pour décrire le
comportement du module
 Le type de processus est SC_METHOD
 Le processus est ré-exécuté une fois que a ou b
change d’état  Il est sensible aux entrées a et b
 Le nom du processus est défini dans la déclaration
du processus SC_METHOD (dans notre cas, le nom
est prc_half_adder déclaré à la ligne 9)
 D’après C++, prc_half_adder est une fonction
membre (de type void, et pas d’arguments)
132
 2- Le langage System-C

 Rappel
 Une description SystemC est construite à partir d’une
hiérarchie de modules
 Le module (SC_MODULE) contient un ou plusieurs
processus qui implantent son comportement
 Hiérarchie structurelle : un module peut contenir
d’autres modules
 Le module communique avec l’extérieur grâce à ses
ports d’entrée (sc_in), de sortie (sc_out) et
bidirectionnel (sc_inout)

133
 2- Le langage System-C

 Processus
 Chaque processus possède une liste de sensibilité
 Lorsqu’un port sur cette liste est activé, le processus
en question s’ordonnance pour une exécution
 Chaque port décrit son type entre < >
• Exemple: sc_out<int> my_port;
• Exemple d’un tableau de ports :
sc_out<bool> my_array_port[32];

134
 2- Le langage System-C

 Processus
 Il décrit le comportement du module
 Pour fins d’initialisation, chaque processus est
exécuté une fois au moment du démarrage, sauf si
on spécifie dont_initialize() dans sa définition
 Il existe 3 types de processus:
• SC_METHOD :
– Ce processus se termine toujours
– Ce n’est pas un thread : pas de wait ou de boucle infinie, pas de
suspension d’exécution
– Une procédure ou une routine qui s’exécute en entier lorsqu’un
changement sur la liste de sensibilité survient

135
 2- Le langage System-C

 Processus
 SC_THREAD :
• Peut être suspendu et réactivé, avec un wait
• Contrôle par boucle infinie (le SC_THREAD ne peut pas se
terminer où il ne se réordonnancera pas)
• Possibilité de communications bloquantes telles que la
lecture et écriture dans un FIFO

136
 2- Le langage System-C

 Processus
 SC_CTHREAD
• Cas particulier du SC_THREAD
• La liste de sensibilité n’est constituée que des fronts
montants ou descendants d’une horloge
• Notion de temps: wait(n) (n = nombre de cycles)
• Utilisation classique : machine à états finis
• Les signaux d’entrée sont disponibles immédiatement

137
 2- Le langage System-C

 Exemple 4 : Additionneur à H.N.

 Les modules sont programmés dans deux fichiers

• Déclaration dans le fichier d’en-tête (.h)
• Implantation dans le fichier source (.cpp)
 Une fonction sc_main() instancie les processus et
démarre la simulation138
 2- Le langage System-C

 Exemple 4 : Le générateur d’entiers

139
 2- Le langage System-C

 Exemple 4 : L’additionneur

140
 2- Le langage System-C

 Exemple 4 : Additionneur + Générateur

141