Introduction à SystemC

Évènements et processus

Tarik Graba

P4 2018-2019

Les évènements

Les sc_event

En SystemC, les évènements sont des objets de type sc_event.

Quand un évènement est instancié, il s’ajoute à la liste des évènements “surveillés” par le simulateur.

Les évènements peuvent ensuite être “notifiés”.

Cette notification déclenchera des actions au niveau du simulateur.

La notification des sc_event

Les sc_event implémentent les méthodes :

Les évènements pour un sc_signal

La classe sc_signal contient un pointeur vers un sc_event.

À l’élaboration, si besoin, il est alloué et ajouté à la liste des évènements du simulateur.

Quand le signal change de valeur, l’évènement est notifié pour la fin du delta.

Les processus

Les processus

En SystemC il existe deux types principaux de processus :

  • Les SC_THREAD
  • Les SC_METHOD

Déclaration d’un processus

Les processus sont des méthodes du sc_module.

Ces méthodes particulières doivent enregistrées en utilisant l’une des macros suivantes dans le constructeur du module :

  • SC_THREAD
  • SC_CTHREAD (cas particulier de SC_THREAD)
  • SC_METHOD

Les SC_THREAD

  • Les SC_THREAD sont des threads indépendants qui sont lancés au début de la simulation (au premier sc_start()) dans le contexte du simulateur.
  • C’est du multitâche collaboratif, les SC_THREAD doivent se mettre en veille pour permettre à la simulation d’avancer.
  • En veille, ils peuvent être réveillés par la notification d’un évènement.

Déclarer un SC_THREAD

La macro SC_THREAD permet de faire cela.

Elle doit être utilisée dans le constructeur du sc_module. Elle prend comme unique argument la méthode associée.

La mise en veille d’un SC_THREAD

La mise en veille d’un SC_THREAD se fait en appelant la méthode wait().

En fonction des arguments passés, le SC_THREAD est alors mis en veille :

  • pour un temps donné,
  • jusqu’à ce qu’un évènement soit notifié.

La liste de sensibilité d’un SC_THREAD

Pour un SC_THREAD on peut définir une liste de sensibilité statique en utilisant la construction sensitive

La remise à zéro d’un SC_THREAD

Pour pouvoir simuler la remise à zéro (reset) d’un bloc matériel ou logiciel, on doit pouvoir durant la simulation demander la réexécution à partir du début d’un processus.

Il existe deux méthodes :

  • reset_signal_is
  • async_reset_signal_is

qui permettent de définir des signaux de remise à zéro synchrone ou asynchrone.

Spécialisation : les SC_CTHREAD

Cas particulier de SC_THREAD pour modéliser le logique synchrone.

On doit y associer un signal d’horloge qui ferra automatiquement partie de sa liste de sensibilité.

Spécialisation : wait dans un SC_CTHREAD

Dans un SC_CTHREAD, la méthode wait() peut prendre un argument entier pour indiquer le nombre de périodes d’horloge à attendre.

Les SC_METHOD

Second type de processus, les SC_METHOD sont équivalentes aux processus des autres HDL. Elles permettent de faire d’écrire des représentations “RTL”.

Contrairement aux SC_THREAD les SC_METHOD ne sont pas autonomes. Elles sont exécutées par le scheduler quand un évènement de leur liste de sensibilité est notifié.

Elles doivent s’exécuter entièrement et rendre la main au scheduler sans quoi la simulation est bloquée. Appeler la méthode wait() dans une SC_METHOD est donc interdit.

La liste de sensibilité d’une SC_METHOD

La déclaration de la liste de sensibilité des SC_METHOD utilise aussi la construction sensitive

Gestion de la remise à zéro dans une SC_METHOD

La remise à zéro des SC_METHOD peut aussi utiliser les méthodes reset_signal_is et async_reset_signal_is.

La méthode async_reset_signal_is ajoute aussi le signal de reset à la liste de sensibilité.

Les SC_METHOD sont toujours exécutées du début à la fin. Le teste de la condition de reset se fait alors dans le code de la méthode.

La méthode dont_initialize

Par défaut, tous les processus sont exécutés au début de la simulation avant le moindre évènement. Si ce comportement n’est pas désiré, il faut appeler la méthode dont_initialize() après l’enregistrement du processus.

Le premier lancement du processus se fait alors au premier évènement notifié.

La méthode dont_initialize() agit sur la dernière méthode enregistrée.

Résumons

Les processus
Les processus

Travail à faire

Modéliser

En reprenant le classe Pixel définie dans la section sur les signaux écrivez les modèles suivants :

  • Deux modules combinatoires faisant la somme saturante de deux pixels.
    • Le premier en utilisant une SC_METHOD
    • Le second en utilisant un SC_THREAD
  • 3 modules séquentiels qui génère successivement, à la cadence d’une horloge externe et de façon cyclique, toutes les couleurs possibles :
    • Vous utiliserez SC_METHOD, SC_THREAD et SC_CTHREAD
    • L’état initial sera la couleur (0,0,0) et pourra être forcé grâce à un signal de remise à zéro asynchrone.

Intégrez ces modules dans un sc_main permettant de vérifier le fonctionnement et générer les chronogrammes.