Cours en ligne SystemC

Préambule

Objectifs

Les éléments de base de SystemC (signaux, ports, ...) sont des classes génériques, des template au sens C++. Selon les objets qu'ils représentent, on doit les spécialiser pour un type particulier, préciser leur nombre de bits, leur nature (entier ou flottant), ...

L'objectif de ce chapitre est de vous présenter les types additionnels définis par SystemC. A l'issue de ce chapitre, vous serez en mesure de choisir le meilleur type pour l'objet que vous voulez modéliser, en termes d'adéquation et de vitesse de simulation.

Plan du chapitre

Les modèles SystemC peuvent manipuler différents types de données : les types natifs C++ bien sûr, mais aussi certains types évolués spécifiquement dédiés au matériel. Les types natifs simulant souvent plus vite que les types évolués SystemC...

Voici les principaux types de SystemC :

• les types bits
• les vecteurs de bits
• les types entiers
• les nombres en virgule fixe
• les types temporels

Les types bits

SystemC propose deux types de bit : sc_bit et sc_logic

sc_bit

Attention : ce type est maintenant obsolète (depuis SystemC 2.2.0). Il n'est cité ici qu'à titre indicatif. On utilisera plutôt le type bool.

Ce type est destiné à représenter un bit ne pouvant prendre que deux valeurs, '0' (false) et '1' (true). Si on besoin de Z et X, il faut prendre sc_logic.

Il dispose de tous les opérateurs habituels logiques et de comparaison. Il peut aussi être mixé à volonté avec le type bool et les expressions logiques C/C++.

Exemple :

sc_bit a;
sc_bit b;
bool c;

a = '1';
b = a;
a &= b;

if((i==0) || c || a) {...}

sc_logic

Ce type est une extension de sc_bit à la logique 4-valuée. Il représente un bit pouvant prendre les valeurs '0', '1', 'Z' et 'X'. Par défaut, un object sc_logic non initialisé vaut 'X'.

Il dispose des même opérateurs que les types sc_bit et bool, et peut être intermixé avec eux (le type de l'expression résultante est alors sc_logic).

On peut affecter un sc_logic à un sc_bit et vice-versa. L'affectation de 'X' ou 'Z' à un sc_bit provoquera un résultat indéfini et un warning à l'exécution.

Exemple :

sc_logic out;
bool data, enable;

if(enable)
  out = data;
else
  out = 'Z';

 

 

Les types entiers

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 (resp.), 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.

Ces types sont utiles pour les opération arithmétiques, mais beaucoup moins rapides à la simulation que le type natif int / unsigned int. Toutes les opérations arithmétiques sont effectuées sur 64 bits, puis tronquées à la taille correcte.

Ils supportent les opération arithmétiques habituelles, ainsi que :

• des méthodes de sélection de bit [], de sélection d'un ensemble de bits .range() et de concaténation ", " / .concat()
• des méthodes de réduction : .and_reduce(), .or_reduce(), .xnor_reduce(), ...

Le MSB est à gauche (n-1), le LSB est à droite (0).

Exemple :

sc_int<12> val1, val2; // entiers signés sur 12 bits
sc_int<64> res; // entier signé sur 64 bits
sc_uint<10> val3; // entier non signé sur 10 bits
sc_int<3> val4; // entier signé sur 3 bits

val1 = 13; // val1 prend "0000000001101"
val2 = val1.range(3,1); // val2 prend "0000000000110", soit +6
val4 = val1.range(3,1); // val4 prend "110", soit -2

res = (val1, val2); // res vaut "00000000011010000000000110"

bool c = val4[1]; // c vaut '1' (true)

 

sc_bigint<n>, sc_biguint<n>

Ces types sont des extensions de sc_int et sc_uint à un nombre de bits arbitraire illimité (en fait, le nombre maximal de bits est fixé par la constante MAX_NBITS dans le fichier sc_constants.h. Pour accélérer les simulations, il peut être nécessaire de la redéfinir).

Ces types se comportent exactement comme sc_int et sc_uint, mais simulent beaucoup plus lentement.

Exercice

• à quoi servent les opérateurs de réduction ? Testez rapidement sur quelques entiers pour essayer de deviner. 

 

Les vecteurs de bits

Les types vecteurs de bits ne doivent pas être confondus avec les types entiers.
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.

Exemple :

sc_bv<8> x;
sc_bit y;

x = "01000111";
y = x[6]; // y vaut '1'

sc_bv<16> data16;
sc_bv<32> data32;

data32.range(15,0) = data16;
data16 = (data32.range(7,0), data32.range(23,16));
(data16.range(3,0),data16.range(15,12)) = data32.range(7,0);
 

 

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.

 

 

Les nombres en virgule fixe

Attention : pour accélérer les temps de compilations, ces types ne sont normalement pas disponibles. Pour pouvoir les utiliser, il est nécessaire de spécifier #define SC_INCLUDE_FX avant #include "systemc.h" dans votre code.

Les système numériques travaillant sur des nombres décimaux les représentent souvent en virgule fixe. SystemC propose quatre types pour représenter ces nombres en virgule fixe, avec différents modèles de quantification et de dépassement.

	signés	non-signés
paramètres déterminés à la compilation	sc_fixed	sc_ufixed
paramètres dynamiques	sc_fix	sc_ufix

Types flottants en virgule fixe

Ces types acceptent aussi une version suffixée par "_fast" si la mantisse est sur moins que 53 bits.

sc_fixed<>, sc_ufixed<>

Ces types ont des paramètres de quantification et de débordement définis à la compilation, et sont respectivement signés et non signés.

Syntaxe :

sc_fixed<wl, iwl, q_mode, o_mode, n_bits> object_name, object_name, ... ;

sc_ufixed<wl, iwl, q_mode, o_mode, n_bits> object_name, object_name, ... ;

• wl: nombre total de bits dans le mot
  
• iwl: nombre de bits de la partie entière
  
• q_mode: mode de quantification (SC_RND, SC_RND_ZERO, SC_RND_MIN_INF, SC_RND_INF, SC_RND_CONV, SC_TRN, SC_TRN_ZERO)
  Détermine le comportement du mot lors d'une opération qui génère plus bits après la virgule qu'il n'y en a de disponibles.
  Exemple : tronque, arrondi vers zéro, vers moins l'infini, ...
  Pour plus de précision, se reporter à la documentation SystemC
  
• o_mode: mode de dépassement (SC_SAT, SC_SAT_ZERO, SC_SAT_SYM, SC_WRAP, SC_WRAP_SM )
  Détermine le comportement du mot lors d'une opération qui génère plus de bits avant la virgule qu'il n'y en a de disponibles.
  Exemple : sature, met à zéro, boucle, ...
  Pour plus de précision, se reporter à la documentation SystemC
  
• n_bits: nombre de bits saturés en cas de dépassement

Exemple :

float adder(float a, float b)
{
  sc_fixed_fast<4,2,SC_RND,SC_WRAP> Inputa = a;
  sc_fixed_fast<6,3,SC_RND,SC_WRAP> Inputb = b;
  sc_fixed_fast<7,4,SC_RND,SC_WRAP> Output;

  Output = (Inputa + Inputb);
  return (Output);
}

 

sc_fix<>, sc_ufix<>

Ces types sont les mêmes que sc_fixed et sc_ufixed, mais leurs paramètres peuvent être changés lors de l'exécution.

Les paramètres sont précisés à l'aide du type sc_fxtypes_params, qui prennent en arguments les même paramètres que sc_fixed et sc_ufixed.
sc_fxtypes_context précise les paramètres par défaut des sc_fix et sc_ufix.

Exemple :

sc_fxtype_params param1 (10,4,SC_RND, SC_SAT); 
// xxxxxx.yyyy 
// round to closest representable number 
// saturate on overflow 

sc_fix_fast valeur (param1); 
	
sc_fxtype_params myparams(SC_RND, SC_SAT);
sc_fxtype_context mycontext(myparams);
sc_fix_fast adder(sc_fix_fast a, sc_fix_fast b)
{
  // specify output wl and iwl to be one bit larger
  // than wl and iwl of a sc_fix_fast Output(a.wl() + 1, a.iwl() + 1);
  sc_fix_fast Output(a.wl() + 1, a.iwl() + 1);
  Output = a + b;
  return(Output);
} 

 

 

Le temps

En SystemC 2.x, comme en Verilog et VHDL, le modèle sous-jacent pour le temps est de type entier non signé sur 64 bits. La résolution par défaut est 1ps.

Une valeur temporelle est de type sc_time, et demande deux arguments lors de sa création :

• un argument de type double spécifiant la valeur,
• un argument de type énuméré sc_time_unit en spécifiant l'unité.

sc_time_unit peut valoir :

• SC_FS : femtosecondes
• SC_PS : picosecondes
• SC_NS : nanosecondes (unité par défaut)
• SC_US : microsecondes
• SC_MS :millisecondes
• SC_SEC : secondes

sc_time est muni de méthodes de :

• d'affectation (=)
• de comparaison et d'égalite

Exemple :

sc_time t1( 20, SC_NS );

 

ExerciCES

Question 1

• Reprenez la RAM que vous avez modélisée au dernier chapitre. Avec vos connaissances actuelles, quels sont les types plus adaptés pour modéliser cette RAM (bus de données, bus d'adresses, tableau interne, ...) 
• Même question en remplaçant les deux bus de données par un seul bus bidirectionnel
• Même question si les bus de données sont sur 16 bits, 32 bits, 23 bits, 64 bits.

Question 2

• Écrivez le modèle d'un mélangeur vidéo qui prend en entrée deux pixels, et sort le résultat de leur mélange. Chaque pixel est un quadruplet :
• R, G, B : composantes Rouge, Vert et Bleu, chacune sur 8 bits
• A : transparence, sur 8 bits. '0' = transparent, '255' = opaque.

Question 3

• sur combien de bits sont représentés les types suivants en C et C++ : char, short, int, long, long long ?

Pour les questions 1 et 2, vous justifierez vos choix des types de données. La question 3 est une question de culture générale, mais importante car beaucoup de mythes circulent à ce sujet !
Réponses à déposer sur votre dépôt Git.