B. Miramond - UCP

Chapter 1: SystemC, Chapter 1: SystemC, Joined design at system levelJoined design at system level

(based on SystemC 2.2)(based on SystemC 2.2)

B. MiramondB. MiramondM2 – S2IC/ESAM2 – S2IC/ESA

B. Miramond - UCP

Plan du chapitrePlan du chapitreI.I. IntroductionIntroduction (30min)(30min)II.II. Programmer en SystemCProgrammer en SystemC (1h30)(1h30)III.III. Noyau de simulationNoyau de simulation (1h)(1h)IV.IV. Niveaux d’abstraction : Niveaux d’abstraction :

une méthodologie de conceptionune méthodologie de conception (30min)(30min)VI.VI. Modélisation matérielle en SystemCModélisation matérielle en SystemC (30min)(30min)VII.VII. Modélisation TLMModélisation TLM (1h)(1h)VIII.VIII. Concepts avancés Concepts avancés (30min)(30min)

B. Miramond - UCP

I.I. SystemC …SystemC …What else ?What else ?

B. Miramond - UCP

Plan de la section IPlan de la section I

1.1. MotivationsMotivations2.2. HistoriqueHistorique3.3. Qu’est ce que SystemCQu’est ce que SystemC4.4. Les concurrentsLes concurrents5.5. Les librairies SystemCLes librairies SystemC6.6. Quelques définitions pour démarrerQuelques définitions pour démarrer

B. Miramond - UCP

1) Motivations1) Motivations Changement d’échelle : conception de «systèmes» sur puce.Changement d’échelle : conception de «systèmes» sur puce. Sur des technos plus anciennes, la conception reliait un Sur des technos plus anciennes, la conception reliait un

microprocesseur, une mémoire et un ASIC (accélérateurs microprocesseur, une mémoire et un ASIC (accélérateurs matériels).matériels).

Des experts réalisaient alors le partitionnement de Des experts réalisaient alors le partitionnement de l’application entre les parties logicielles et matérielles.l’application entre les parties logicielles et matérielles.

Pour la partie Hw, la spécification des ASICs correspondait Pour la partie Hw, la spécification des ASICs correspondait à qqs milliers de portes. Ce qui restait exprimable dans un à qqs milliers de portes. Ce qui restait exprimable dans un langage HDL à un niveau RTL.langage HDL à un niveau RTL.

RTL : Register Transfer LevelRTL : Register Transfer Level

B. Miramond - UCP

Register Tranfer LevelRegister Tranfer LevelA legacy from HDLA legacy from HDL

RTL RTL description is a way of describing the operation of description is a way of describing the operation of a synchronous digital circuit. In RTL design, a circuit's a synchronous digital circuit. In RTL design, a circuit's behavior is defined in terms of the flow of signals (or behavior is defined in terms of the flow of signals (or transfer of data) between hardware registers, and the transfer of data) between hardware registers, and the logical operations performed on those signals.logical operations performed on those signals.

process(clk) begin

if rising_edge(clk) then Q <= not Q; end if;

end process; The term refers to the fact that RTL focuses on describing the flow of signals between registers

Vhdl

B. Miramond - UCP

Et maintenant …Et maintenant … Aujourd’hui, la technologie des SoCs autorise la Aujourd’hui, la technologie des SoCs autorise la

présence de présence de plusieurs proc., microcontrôleurs 32 bits ou DSP.plusieurs proc., microcontrôleurs 32 bits ou DSP. On-chip memoryOn-chip memory Accélérateurs matériels pour fonctions dédiéesAccélérateurs matériels pour fonctions dédiées Contrôleurs de périphériquesContrôleurs de périphériques Le tout relié par un réseau complexe de communication.Le tout relié par un réseau complexe de communication.

A ce niveau de complexité, le partitionnement n’est plus A ce niveau de complexité, le partitionnement n’est plus évident entre logiciel et matériel.évident entre logiciel et matériel.

La conception matérielle s’exprime en millions de La conception matérielle s’exprime en millions de portes.portes.

B. Miramond - UCP

SoC ArchitectureSoC Architecture

Bridge

ADC/DACDSP

ARM 946Ecore

ICache

DCache

Boot ROM

DMA Controler

Debug port

JTAGSDRAM/Flash

Multiport memory

Arbiter

Timer

Arbiter

UARTRAM

HW coprocessor

RISC core

B. Miramond - UCP

Conception cost evolutionConception cost evolution

Conception cost

1985 1990 1995 2000 2005 2010 2015 2020$ 10.000.000

$ 100.000.000

$ 10.000.000.000

$ 100.000.000.000

$ 1.000.000.000

In H

ouse

P&

R

Smal

l thi

n En

g.

Smal

l blo

ck R

euse

Larg

e bl

ock

Reu

se

IC Im

plem

enta

trion

Inte

llige

nt T

estb

ecnh

Syst

em L

evel

Met

hodo

logy

[Roadmap for Semiconductors 2001]

predicted

measured

B. Miramond - UCP

Conception niveau systèmeConception niveau système La prise de décision de l’implantation est La prise de décision de l’implantation est

repoussée car elle doit être explorée.repoussée car elle doit être explorée. Donc, pour décrire des systèmes encore à la fois Donc, pour décrire des systèmes encore à la fois

logiciels et matériels il faut aller au-delà du logiciels et matériels il faut aller au-delà du niveau RTL, et à ce niveau les HDLs ne sont niveau RTL, et à ce niveau les HDLs ne sont plus adaptés.plus adaptés.

On parle de On parle de conception au niveau systèmeconception au niveau système.. Et du besoin de Et du besoin de langage de modélisationlangage de modélisation

supportant ce niveau.supportant ce niveau.

B. Miramond - UCP

2) Positionnement du langage2) Positionnement du langage

Transistor

Gates

RTL

Test bench

Functional Verification

Behavior

HW/SWSpecifications

Requirements

Verilog VHDL

SystemVerilog

SystemC

Matlab,SPW,

S. Studio

B. Miramond - UCP

ObjectifsObjectifs Environnement unifié de description matériel et Environnement unifié de description matériel et

logiciellogiciel Explorer les solutions de conception en Explorer les solutions de conception en

travaillant à un niveau systèmetravaillant à un niveau système

=> => Améliorer la productivité des concepteurs de Améliorer la productivité des concepteurs de systèmes électroniques.systèmes électroniques.

B. Miramond - UCP

3) Donc qu’est ce que SystemC ?3) Donc qu’est ce que SystemC ? SystemC est un langage de modélisation au niveau systèmeSystemC est un langage de modélisation au niveau système

Réseau de processus communiquant (HDL)Réseau de processus communiquant (HDL) Supportant différents modèles de traitements (MoCs)Supportant différents modèles de traitements (MoCs) Permettant de modéliser des systèmes logiciels et matérielsPermettant de modéliser des systèmes logiciels et matériels

C’est aussi un environnement de simulation C’est aussi un environnement de simulation temporelletemporelle (event- (event-driven simulation, cf. HDL).driven simulation, cf. HDL).

Basé sur une librairie de classes C++Basé sur une librairie de classes C++ Open SourceOpen Source

SystemC n’est pas une méthodologie, mais vous avez besoin SystemC n’est pas une méthodologie, mais vous avez besoin d’une méthodologie pour l’utiliser !d’une méthodologie pour l’utiliser !

B. Miramond - UCP

Méthodologie de conceptionMéthodologie de conceptionSpécifications

Software (C/C++) Modèle TLMEnvironnement

de test(SystemC)

Modèle RTL(HDL/SystemC)

TestbenchHardwareSoftware

Portes

Layout

CosimulationSynthèse

B. Miramond - UCP

Quelques définitionsQuelques définitions Niveau d’abstractionNiveau d’abstraction = est un niveau de description = est un niveau de description

d’un système apportant un niveau de détails données. d’un système apportant un niveau de détails données. Un flot de conception est une succession de niveaux Un flot de conception est une succession de niveaux d’abstraction.d’abstraction.

RaffinementRaffinement = Le raffinement est le mécanisme = Le raffinement est le mécanisme permettant de passer d’un niveau d’abstraction à un permettant de passer d’un niveau d’abstraction à un autre. Celui-ci doit être le plus possible automatisable.autre. Celui-ci doit être le plus possible automatisable.

Spécification exécutableSpécification exécutable = est un modèle fonctionnel = est un modèle fonctionnel qui fournit le comportement d’un composant quelque qui fournit le comportement d’un composant quelque soit le niveau d’abstraction et de manière indépendante soit le niveau d’abstraction et de manière indépendante de l’implémentation (plateforme).de l’implémentation (plateforme).

B. Miramond - UCP

Caractéristiques du langage SystemCCaractéristiques du langage SystemC1.1. Spécification et conception à différents niveaux Spécification et conception à différents niveaux

d’d’abstractionabstraction2.2. Intégration de portions de logiciel embarqué, à la fois Intégration de portions de logiciel embarqué, à la fois

sous la forme de modèles et de code : sous la forme de modèles et de code : réutilisationréutilisation,,3.3. Création de Création de spécification exécutablesspécification exécutables..4.4. Création de Création de plateformes exécutablesplateformes exécutables sur lesquelles sur lesquelles

seront mappées les spécifications.seront mappées les spécifications.5.5. SimulationsSimulations rapides pour permettre rapides pour permettre l’l’explorationexploration de de

l’espace de conception (spécifications + plateformes)l’espace de conception (spécifications + plateformes)6.6. Structuration des modèles autorisant la Structuration des modèles autorisant la séparationséparation de la de la

fonctionnalité et de la communicationfonctionnalité et de la communication Adaptation flexible (IPs)Adaptation flexible (IPs) Besoin de réutilisationBesoin de réutilisation

B. Miramond - UCP

Propriétés supplémentairesPropriétés supplémentaires Basé sur un langage de programmation existant Basé sur un langage de programmation existant

pour bénéficier des pour bénéficier des outilsoutils de compilation, de de compilation, de debug, …debug, …

Un langage Un langage orienté objetorienté objet fournirait les fournirait les mécanismes de base pour la flexibilité des mécanismes de base pour la flexibilité des modèles et la réutilisation. (héritage, modèles et la réutilisation. (héritage, templates…)templates…)

B. Miramond - UCP

4) Historique4) HistoriqueSynopsys- SCENIC LWG / OSCI Adelante AJRT Lib

IMEC

CoWare N2CSystemC 1.0

SystemC 1.2.1 Beta

SystemC 2.0

SystemC 2.0.1

SystemC 2.1 puis 2.2

SystemC 3.0RTOS / Software

Dynamic Processes

Bug fix

Channels

Master-Slave Lib

Future

Fixed Point Types

B. Miramond - UCP

4) Les concurrents4) Les concurrents

Sur le créneau de la modélisation niveau système :Sur le créneau de la modélisation niveau système : SpecCSpecC – D. Gajski de l’Université de Irvine – D. Gajski de l’Université de Irvine

http://http://www.ics.uci.eduwww.ics.uci.edu/~/~speccspecc// OCAPIOCAPI - IMEC - IMEC

http://http://www.imec.bewww.imec.be/design//design/ocapiocapi//unified_design.shtmlunified_design.shtml CynlibCynlib – CynApps – CynApps

http://www.forteds.com/technology/esl2gdsii.asphttp://www.forteds.com/technology/esl2gdsii.asp ……

B. Miramond - UCP

5) Librairies SystemC (sup.)5) Librairies SystemC (sup.) The SystemC Verification Library (SCV)The SystemC Verification Library (SCV)

Ajoute de fonctionnalités pour la vérification des design (Cadence)Ajoute de fonctionnalités pour la vérification des design (Cadence) Langage de développement de testbench (Testbuilder)Langage de développement de testbench (Testbuilder) Constrained randomization, introspection, transaction recordingConstrained randomization, introspection, transaction recording http://www.testbuilder.nethttp://www.testbuilder.net

Architecture Description Language : ArchCArchitecture Description Language : ArchC Extension de SystemC pour la description de processeursExtension de SystemC pour la description de processeurs http://www.archc.orghttp://www.archc.org

Master/Slave libraryMaster/Slave library Protocole de communicationProtocole de communication http://http://www.systemc.orgwww.systemc.org

The Boost Library (C++)The Boost Library (C++) Free peer-reviewed portable C++ source librariesFree peer-reviewed portable C++ source libraries http://http://www.boost.orgwww.boost.org

B. Miramond - UCP

BibliographieBibliographieBooksBooks System Design with SystemCSystem Design with SystemC (4th edition), Grötker et al., Kluwer Academic (4th edition), Grötker et al., Kluwer Academic

Publisher, 2004Publisher, 2004 Ensea, empruntéEnsea, emprunté

From the ground-upFrom the ground-up (SystemC 2.1), D. Black & J. Donovan, Kluwer Academic (SystemC 2.1), D. Black & J. Donovan, Kluwer Academic Publisher, 2005Publisher, 2005 Bib. Ensea, dispoBib. Ensea, dispo

Transaction level modeling with SystemC : TLM concepts and applications for embedded Transaction level modeling with SystemC : TLM concepts and applications for embedded systemssystems, by Frank Ghenassia, Springer 2005., by Frank Ghenassia, Springer 2005. Bib. Ensea, dispoBib. Ensea, dispo

SystemC kernel extensions for heterogeneous system modeling : a framework SystemC kernel extensions for heterogeneous system modeling : a framework for Multi-MoC modeling & simulation, by Hiren D. Patel and Sandeep K. for Multi-MoC modeling & simulation, by Hiren D. Patel and Sandeep K. Shukla, 2004Shukla, 2004 Ensea, dispoEnsea, dispo

WeblinksWeblinks http://http://www.systemc.orgwww.systemc.org

B. Miramond - UCP

I. Programmer en I. Programmer en SystemCSystemC

B. Miramond - UCP

Plan de partie IIPlan de partie II1.1. Architecture du langageArchitecture du langage2.2. Les structuresLes structures

1.1. sc_modulesc_module3.3. Ports, Channels et Ports, Channels et

InterfacesInterfaces1.1. PortPort2.2. ChannelsChannels3.3. InterfacesInterfaces4.4. Hierarchical ChannelsHierarchical Channels

4.4. ProcessusProcessus5.5. ÉvènementsÉvènements

1.1. sc_eventssc_events2.2. notificationnotification

1.1. SensibilitéSensibilité1.1. StatiqueStatique2.2. DynamiqueDynamique3.3. Composition d’évènementsComposition d’évènements4.4. TimeoutTimeout

2.2. Exemple de synthèseExemple de synthèse3.3. Quelques exemples Quelques exemples

supplémentairessupplémentaires4.4. DebuggingDebugging

1.1. Debug EnvironnementDebug Environnement2.2. Testbench resultsTestbench results3.3. Waveform tracingWaveform tracing4.4. Resulting waveformsResulting waveforms

B. Miramond - UCP

1. Architecture du langage1. Architecture du langage http://www.systemc.orghttp://www.systemc.org

Librairies SystemC téléchargeables gratuitementLibrairies SystemC téléchargeables gratuitement European SystemC Users GroupEuropean SystemC Users Group

http://www-ti.informatik.uni-tuebingen.de/~systemchttp://www-ti.informatik.uni-tuebingen.de/~systemc

B. Miramond - UCP

Standard ChannelsStandard Channels

Kahn Process Network, Static Dataflow,Kahn Process Network, Static Dataflow,Etc.Etc.

Methodology Specific Methodology Specific LibrariesLibraries

Master/Slave Library, etc.

Elementary ChannelsElementary Channels

Signal, Timer, Mutex, FIFO…

Core LanguageCore LanguageModulesPortsProcessesEventsInterfacesChannels

Event-driven simulation KernelEvent-driven simulation Kernel

C++ Language StandardC++ Language Standard

Data-TypesData-Types4-valued logic types (O1XZ)4valued logic vectorsBits and bit-vectorsArbitrary-precision integersFixed point numbersC++ user-defined types

B. Miramond - UCP

Architecture de SystemCArchitecture de SystemC

Standard Standard ChannelsChannels

Kahn Kahn ProcessProcess Network, Network, StaticStatic DataflowDataflow,,Etc.Etc.

MethodologyMethodology SpecificSpecificLibrariesLibraries

Master/Slave Library, etc.

ElementaryElementary ChannelsChannels

Signal, Timer, Mutex, FIFO…

CoreCore LanguageLanguageModulesPortsProcessesEventsInterfacesChannels

EventEvent--drivendriven simulation simulation KernelKernel

C++ C++ LanguageLanguage StandardStandard

DataData--TypesTypes4-valued logic types (O1XZ)4valued logic vectorsBits and bit-vectorsArbitrary-precision integersFixed point numbersC++ user-defined types

User Applications

WorkStation Environment

SystemCStandard

B. Miramond - UCP

systemcSTL…

Compilation d’un projet SystemCCompilation d’un projet SystemC g++ -I$ (SYSTEMC) /include \g++ -I$ (SYSTEMC) /include \

-L$ (SYSTEMC) /lib-$ (ARCH) –lsystemc \-L$ (SYSTEMC) /lib-$ (ARCH) –lsystemc \$(SRC)$(SRC)

File1.hFile1.cpp

…Filen.h

Filen.cppsystemc.h

g++ ldFile1.o

…Filen.o

.exe

Le résultat contient à la fois votre code applicatif et le code de la machine de

simulation SystemC !!

B. Miramond - UCP

Module Module

ModulesModules (Structure)(Structure) ChannelsChannels (Communication)(Communication) PortPort (Structure)(Structure) InterfacesInterfaces (Communication (Communication

refinement)refinement)

ProcessesProcesses (Concurrency)(Concurrency) EventsEvents (time, (time,

synchronisation)synchronisation) Data typesData types (Hardware, (Hardware,

fixed point)fixed point)

2. Structures2. Structures

Process 1P 2

P 3Channel

Port

Interface

Fonctionnalité / Traitement

Communication

Séparées

B. Miramond - UCP

a. Modulesa. Modules Un module est un conteneur (Un module est un conteneur (containercontainer). ). Il contient :Il contient :

Des ports qui permettent de communiquer avec Des ports qui permettent de communiquer avec d’autres modulesd’autres modules

Des processus qui décrivent la fonctionnalité du Des processus qui décrivent la fonctionnalité du modulemodule

Des données internes représentant l’état et des Des données internes représentant l’état et des canaux internes pour la communication entre les canaux internes pour la communication entre les processus du moduleprocessus du module

Et hiérarchiquement, d’autres modulesEt hiérarchiquement, d’autres modules

sc_module

B. Miramond - UCP

Déclaration par la macro Déclaration par la macro SC_MODULESC_MODULE

class Adder : public sc_module {class Adder : public sc_module {// Ports, processes, internal data …// Ports, processes, internal data …

Adder (sc_module_name name, int other_param) : sc_module(name){Adder (sc_module_name name, int other_param) : sc_module(name){// Body of constructor :// Body of constructor :// Process declaration, sensitivities// Process declaration, sensitivities}}

};}; Cette déclaration crée une nouvelle classe d’objets de type Adder.Cette déclaration crée une nouvelle classe d’objets de type Adder. Les définition sont réalisées dans des fichier .CPP.Les définition sont réalisées dans des fichier .CPP. Les déclaration dans des fichiers .HLes déclaration dans des fichiers .H

B. Miramond - UCP

Instanciation de SC_MODULEInstanciation de SC_MODULELes SC_MODULE peuvent être instanciés Les SC_MODULE peuvent être instanciés lors de la phase d’élaboration uniquement (cf. section III)lors de la phase d’élaboration uniquement (cf. section III) En précisant un nom de moduleEn précisant un nom de module Avec la syntaxe suivante :Avec la syntaxe suivante :

Adder MyAdder(‘’MyAdder’’);Adder MyAdder(‘’MyAdder’’);

B. Miramond - UCP

3. Interfaces, Ports et channels3. Interfaces, Ports et channels En modélisation matériel classique (RTL), le signal est le En modélisation matériel classique (RTL), le signal est le

moyen de communication entre processus.moyen de communication entre processus. Au niveau système, le moyen de communication n’a pas Au niveau système, le moyen de communication n’a pas

encore d’implantation établie (bus Hw, appel de service encore d’implantation établie (bus Hw, appel de service logiciel comme FIFO, mutex…).logiciel comme FIFO, mutex…).

SystemC offre cette flexibilité par la séparation entre SystemC offre cette flexibilité par la séparation entre Les canaux qui sont le moyen de transmission des donnéesLes canaux qui sont le moyen de transmission des données Les interfaces qui fournissent les prototypes des services Les interfaces qui fournissent les prototypes des services

d’accès au canald’accès au canal Les ports qui sont une instanciation des interfaces dans un Les ports qui sont une instanciation des interfaces dans un

module client.module client.

B. Miramond - UCP

a. Interfacesa. Interfaces Un canal exporte son interface à travers la classe abstraite Un canal exporte son interface à travers la classe abstraite

sc_interface.sc_interface. L’interface spécifie donc uniquement la signature (le L’interface spécifie donc uniquement la signature (le

prototype) des opérations/services fournies par son prototype) des opérations/services fournies par son canal.canal.

Rappel :Rappel : Les Les sc_interfacesc_interface sont des classes templates C++. Une sont des classes templates C++. Une

classe template permet de paramétrer le type des données classe template permet de paramétrer le type des données qu’elle manipule en placant le type entre ‘<T>’.qu’elle manipule en placant le type entre ‘<T>’.

B. Miramond - UCP

ExempleExemple sc_signal_in_if<T>sc_signal_in_if<T>Dérive directement de sc_interface et est paramétrée par Dérive directement de sc_interface et est paramétrée par

le type T.le type T.Elle ne fournit qu’un seul service : read() qui retourne une Elle ne fournit qu’un seul service : read() qui retourne une

référence à la valeur de type T.référence à la valeur de type T. sc_signal_inout_if<T>sc_signal_inout_if<T>Celle-ci fournit en plus une fonction virtuelle write() qui Celle-ci fournit en plus une fonction virtuelle write() qui

prend en paramètre la valeur à placer.prend en paramètre la valeur à placer.Cette seconde interface dérive de sc_signal_in_if et hérite Cette seconde interface dérive de sc_signal_in_if et hérite

donc de la fonction read().donc de la fonction read().

B. Miramond - UCP

sc_interface

sc_signal_in_if<T>

sc_signal_inout_if<T>write()

read()

register_port()(virtual)

sc_signal est utilisé pour la communication à l’intérieur d’un module entre processus.

class sc_signal_in_if : virtual public sc_interface{public :virtual const T& read() = 0;}

B. Miramond - UCP

Built-in primitive ChannelsBuilt-in primitive Channels sc_signal<int> S1, S2;sc_signal<int> S1, S2; // déclaration// déclaration sc_buffer<T> B;sc_buffer<T> B; sc_fifo<T> F;sc_fifo<T> F;

sc_mutex M;sc_mutex M; sc_semaphore P(1);sc_semaphore P(1);

S1.write(S2.read());S1.write(S2.read()); // Affectation// Affectation

B. Miramond - UCP

b. Portsb. Ports Les ports sont utilisés comme déclaration de connexion Les ports sont utilisés comme déclaration de connexion

à un canal via son interface.à un canal via son interface. La déclaration doit spécifier l’interface à laquelle il La déclaration doit spécifier l’interface à laquelle il

correspond.correspond.

DéclarationDéclaration sc_port<sc_signal_inout_if<int> > p;sc_port<sc_signal_inout_if<int> > p; p->read();p->read(); p->write();p->write();

Ceci est un exemple d’IMC (Interface Method Call).Ceci est un exemple d’IMC (Interface Method Call).

B. Miramond - UCP

Ports prédéfinis dans SystemCPorts prédéfinis dans SystemC

Template <class T>Template <class T>class class sc_insc_in : : public sc_port<sc_signal_in_if<T> > …;public sc_port<sc_signal_in_if<T> > …;

Template <class T>Template <class T>class class sc_inoutsc_inout : : public sc_port<sc_signal_inout_if<T> > …;public sc_port<sc_signal_inout_if<T> > …;

B. Miramond - UCP

Exemple (suite)Exemple (suite)class Adder : public sc_module {class Adder : public sc_module {// Ports, processes, internal data …// Ports, processes, internal data …sc_in <int> a;sc_in <int> a;sc_in <int> b;sc_in <int> b;sc_in <int> c;sc_in <int> c;

Adder (sc_module_name name, int Adder (sc_module_name name, int other_param) : sc_module(name){other_param) : sc_module(name){// Body of constructor :// Body of constructor :// Process declaration, sensitivities// Process declaration, sensitivities}}

};};

Adder

La déclaration des ports doit intervenir en premier dans le

module!!Et l’ordre a une

importance.

B. Miramond - UCP

c. Channelsc. Channels Alors que les ports et interfaces définissent Alors que les ports et interfaces définissent

quelles fonctions sont disponibles, le canal décrit quelles fonctions sont disponibles, le canal décrit l’implémentation de ces fonctions.l’implémentation de ces fonctions.

Tous les canaux héritent de Tous les canaux héritent de sc_prime_channelsc_prime_channel..

La classe canal doit gérer les accès multiples (tel La classe canal doit gérer les accès multiples (tel que sur un bus).que sur un bus).

Ses méthodes d’accès suivent un schéma dit : Ses méthodes d’accès suivent un schéma dit : Request-UpdateRequest-Update

sc_channel

B. Miramond - UCP

L’avantage des ports et interfaces est donc clair, ils permettent de découpler l’interface de son implémentation et donc de raffiner les communications (par ex.) d’un canal simple à un canal hiérarchique.

d. Hierarchical Channelsd. Hierarchical Channels Plusieurs canaux peuvent implémenter la même interface.Plusieurs canaux peuvent implémenter la même interface. Ainsi, un ‘primitive channel’ ne contient pas d’autres Ainsi, un ‘primitive channel’ ne contient pas d’autres

structures SystemC (modules, process…).structures SystemC (modules, process…). Au contraire, il est parfois nécessaire de modéliser des Au contraire, il est parfois nécessaire de modéliser des

structures de communication plus complexes :structures de communication plus complexes : Le standard OCB = On-Chip Bus de VSIA :Le standard OCB = On-Chip Bus de VSIA :

Arbitrer Control Program Unit

Decoder Unit

B. Miramond - UCP

4. Processus4. Processus La nature parallèle des systèmes électronique La nature parallèle des systèmes électronique

nécessite la description de fonctionnalités nécessite la description de fonctionnalités concurrentes.concurrentes.

A process SystemC doit être contenu dans un A process SystemC doit être contenu dans un module.module.

Le code associé au process doit être une Le code associé au process doit être une fonction membre du SC_MODULEfonction membre du SC_MODULE

Les processus accèdent aux canaux extérieurs Les processus accèdent aux canaux extérieurs par l’intermédiaire des ports de leur module.par l’intermédiaire des ports de leur module.

Process

B. Miramond - UCP

Exemple (suite)Exemple (suite)class Adder : public sc_module {class Adder : public sc_module {// Ports, processes, internal data …// Ports, processes, internal data …sc_in <int> a;sc_in <int> a;sc_in <int> b;sc_in <int> b;sc_out<int> c;sc_out<int> c;

void compute (){void compute (){c = a + b;c = a + b;}}

SC_HAS_PROCESS(Adder);SC_HAS_PROCESS(Adder);Adder (sc_module_name name, int other_param) : sc_module(name){Adder (sc_module_name name, int other_param) : sc_module(name){// Process declaration, sensitivities// Process declaration, sensitivitiesSC_METHOD(compute);SC_METHOD(compute);

sensitive << a << b;sensitive << a << b;}}

};};

Adder

B. Miramond - UCP

PiègesPièges Le fait de déclarer une nouvelle méthode dans un Le fait de déclarer une nouvelle méthode dans un

SC_MODULE ne fait pas d’elle un process.SC_MODULE ne fait pas d’elle un process. C’est l’appel à SC_METHOD qui enregistre la C’est l’appel à SC_METHOD qui enregistre la

méthode en paramètre auprès du scheduler de méthode en paramètre auprès du scheduler de SystemC.SystemC.

Cet enregistrement (l’appel à SC_METHOD) ne Cet enregistrement (l’appel à SC_METHOD) ne peut être fait qu’à la phase d’élaboration, pas peut être fait qu’à la phase d’élaboration, pas pendant la simulation.pendant la simulation.

Les SC_METHOD ne peuvent être intérrompus, il Les SC_METHOD ne peuvent être intérrompus, il ne doivent donc pas contenir de boucle infinies !!ne doivent donc pas contenir de boucle infinies !!

B. Miramond - UCP

Plusieurs sortes de processPlusieurs sortes de process SC_METHOD()SC_METHOD()

Processus ne pouvant être interrompus (ils ne peuvent appelé Processus ne pouvant être interrompus (ils ne peuvent appelé waitwait())()) Le code doit être fonction membre d’un SC_MODULELe code doit être fonction membre d’un SC_MODULE Le plus rapide à la simulation.Le plus rapide à la simulation.

SC_THREAD()SC_THREAD() Processus pouvant être interrompus (par wait)Processus pouvant être interrompus (par wait) Ses variables sont persistantes (contrairement au SC_METHOD)Ses variables sont persistantes (contrairement au SC_METHOD) Le code n’est pas nécessairement fonction membre du moduleLe code n’est pas nécessairement fonction membre du module

sc_spawn() sc_spawn() // cf. Chapitres suivants// cf. Chapitres suivants Autorise la création dynamique de processus, donc après la phase Autorise la création dynamique de processus, donc après la phase

d’élaboration.d’élaboration. Le code n’est pas nécessairement fonction membre du moduleLe code n’est pas nécessairement fonction membre du module

B. Miramond - UCP

Structure of a processStructure of a process SC_METHOD : simulation engine call them repeatedlySC_METHOD : simulation engine call them repeatedlyvoid my_process (){ void my_process (){ // run to completion scheme// run to completion scheme // treatment// treatment}} SC_THREAD :SC_THREAD :void my_thread(){ void my_thread(){ // infinite loop scheme// infinite loop scheme while (1){while (1){ // treatment// treatment wait(); wait(); // static event// static event }}}}

B. Miramond - UCP

5. Events5. Events Un processus dispose d’une liste de sensibilité Un processus dispose d’une liste de sensibilité

décrivant les événements auxquels il doit réagir.décrivant les événements auxquels il doit réagir. Lorsque l’exécution d’un processus rencontre un Lorsque l’exécution d’un processus rencontre un

wait(),wait(), il est interrompu. il est interrompu. Il attend le déclenchement (implicite) d’un des Il attend le déclenchement (implicite) d’un des

évènements de sa liste de sensibilité statique.évènements de sa liste de sensibilité statique. Lorsqu’un de ses événements est déclenché, le Lorsqu’un de ses événements est déclenché, le

scheduler place le Thread dans la liste des scheduler place le Thread dans la liste des processus READY.processus READY.

B. Miramond - UCP

a. sc_eventa. sc_event Un event est un objet de classe sc_event.Un event est un objet de classe sc_event.

sc_event e;sc_event e; Il n’a ni durée, ni valeur.Il n’a ni durée, ni valeur. L’acte d’indiquer une modification d’un évènement est L’acte d’indiquer une modification d’un évènement est

appelé notification.appelé notification. e.notify();e.notify(); notify(e);notify(e);

L’évènement garde une liste des processus qui lui sont L’évènement garde une liste des processus qui lui sont sensibles (par wait(e)).sensibles (par wait(e)).

Lorsque un event est notifié, il informe le scheduler des Lorsque un event est notifié, il informe le scheduler des processus à (re)lancer.processus à (re)lancer.

B. Miramond - UCP

b. Notificationb. Notification Immediate : Immediate : e.notify();e.notify();

Notification immédiate, le processus en attente est Notification immédiate, le processus en attente est replacé immédiatement dans la liste Readyreplacé immédiatement dans la liste Ready

Delta_delay : Delta_delay : e.notify(SC_ZERO_TIME);e.notify(SC_ZERO_TIME); Notification après un cycle d’évaluation appelé Notification après un cycle d’évaluation appelé

Delta-cycle, lorsque tous les processus en attente se Delta-cycle, lorsque tous les processus en attente se seront exécutés.seront exécutés.

Non-zero delay : Non-zero delay : e.notify(t);e.notify(t); Place l’évènement en fil d’attente jusqu’à la durée Place l’évènement en fil d’attente jusqu’à la durée

indiquée.indiquée.

B. Miramond - UCP

6. Sensitivity6. Sensitivity a. Sensibilité statique =a. Sensibilité statique =

La liste des évènements d’activation d’un process est La liste des évènements d’activation d’un process est déterminé avant la simulation (dans les constructeurs).déterminé avant la simulation (dans les constructeurs).

sensitive << a << b;sensitive << a << b; b. Sensibilité dynamique =b. Sensibilité dynamique =

Permet de remplacer la liste statique par un évènement Permet de remplacer la liste statique par un évènement désigné lors de la simulation.désigné lors de la simulation.

Le processus n’est alors plus sensible aux évènements de sa Le processus n’est alors plus sensible aux évènements de sa liste statique.liste statique.

wait(e);wait(e);

B. Miramond - UCP

Exemple (suite)Exemple (suite)class Adder : public sc_module {class Adder : public sc_module {// Ports, processes, internal data …// Ports, processes, internal data …sc_in <int> a;sc_in <int> a;sc_in <int> b;sc_in <int> b;sc_out<int> c;sc_out<int> c;

void compute (){void compute (){c = a + b;c = a + b;}}

SC_HAS_PROCESS(Adder);SC_HAS_PROCESS(Adder);Adder (sc_module_name name) : sc_module(name){Adder (sc_module_name name) : sc_module(name){// Process declaration, sensitivities// Process declaration, sensitivitiesSC_METHOD(compute);SC_METHOD(compute);

sensitive << a << b;sensitive << a << b;}}

};};

Adder

Cas particulier :Ici a et b sont des sc_ports.La sensibilité se fait par l’intérmédiaire de la fonction default_event associée.

B. Miramond - UCP

c. Composition d’évènementsc. Composition d’évènements Conjonction :Conjonction :

wait (e1 & e2 & e3); ou wait (timeout | e1 | e2);wait (e1 & e2 & e3); ou wait (timeout | e1 | e2); Activation si les 3 Activation si les 3 eventevent sont déclenchés sont déclenchés

Disjonction :Disjonction : wait(e1 | e2 | e3);wait(e1 | e2 | e3); ouou wait (timeout | e1 | e2);wait (timeout | e1 | e2); Activation si 1 des 3 event est déclenché ou bien un timeoutActivation si 1 des 3 event est déclenché ou bien un timeout Il n’est pas possible de savoir quel événement a provoqué le Il n’est pas possible de savoir quel événement a provoqué le

déclenchement.déclenchement. Par contre il est possible de savoir si c’est le timeout :Par contre il est possible de savoir si c’est le timeout :

wait(t_Delay | ack_event | bus_error_event);wait(t_Delay | ack_event | bus_error_event); if (timed_out())if (timed_out()) … // action associated to timeout … // action associated to timeout

B. Miramond - UCP

d. Attente d’un TimeOutd. Attente d’un TimeOut Attente de 200 nanosecondes :Attente de 200 nanosecondes :

wait(200, SC_NS);wait(200, SC_NS); Ou bienOu bien sc_time t(200, SC_NS);sc_time t(200, SC_NS); wait(t);wait(t);

Attente d’un Delta-cycle :Attente d’un Delta-cycle : wait(0);wait(0);

Combinaisons event(s) | timeout:Combinaisons event(s) | timeout: wait(200, SC_NS, e);wait(200, SC_NS, e);

B. Miramond - UCP

7. Final Example7. Final Example A la manière des classes et des objets, les A la manière des classes et des objets, les

modèles sont à opposés aux instances (de modèles sont à opposés aux instances (de modules et de canaux) en SystemC comme en modules et de canaux) en SystemC comme en HDL.HDL.

Exemple hiérarchique :Exemple hiérarchique :

Adder1

Adder2

in1

in2

in3sum

Add3

B. Miramond - UCP

class Add3 : public sc_module {sc_in<int> in1;sc_in<int> in2;sc_in<int> in3;sc_out<int> sum;

// signal (channel) internesc_signal<int> temp;

Adder* adder1;Adder* adder2;

Add3(sc_name name) : sc_module(name){adder 1 = new Adder(‘’Adder1’’);(*adder1)(in1, in2, temp); // Connectique forme positionnelle

adder 2 = new Adder(‘’Adder2’’);adder2->a(temp); // Connectique forme nomméeadder2->c(sum); // Pas d’ordre imposéadder2->b(in3);

}}

Adder1

Adder2

in1

in2

in3sum

Add3

Adder1

Adder2

in1

in2

in3sum

Add3

temp

B. Miramond - UCP

int sc_main(int argc, char* argv[]){// initialisation// simulationtop_level();// Nettoyage des structuresreturn 0;

}

top_level(){sc_signal <int> sig_a, sig_b, sig_c;Add3 my_adder(‘’my_adder’’);

//Autres modules et tesbenchs qui positionnent// les valeurs de sig_a et sig_b

//Lance la phase d’Elaboration puis celle de Simulation//Exécution durant 1000 secondes (de temps de simulation)sc_start(1000, SC_SEC);//Suite de la simulation pendant 100 ms sc_start(100, SC_MS);}

Adder1

Adder2

in1

in2

in3sum

Add3

Adder1

Adder2

in1

in2

in3sum

Add3

temp

B. Miramond - UCP

8. Debugging8. Debugging#include “systemc.h“Class nand2 : public sc_module{sc_port<sc_signal_in_if<bool>, 1> A; //input signal portsc_in<bool> B; //other writingsc_out<bool> F; //output signal port

void do_nand2(){F.write( !(A.read() && b.read()) );

}

SC_HAS_PROCESS(nand2); nand2 (sc_name name) : sc_module(name){ // Constructor

SC_METHOD(do_nand2);// register do_nand2 with schedulersensitive << A << B;

}

};

A

B

F

B. Miramond - UCP

2-input xor2-input xor

A

B

F

S2

S3

S1

)).(( BABABAF ++=⊕=

B. Miramond - UCP

#include “systemc.h“#include “nand2.h“

class xor2 : public sc_module{sc_in<bool> A, B;sc_out<bool> F;

nand2 n1, n2, n3, n4;

sc_signal<bool> S1, S2, S3;…

…

xor2(sc_name name) : n1(‘N1’), n2(‘N2’), n3(‘N3’), n4(‘N4’)

{

n1.A(A);n1.B(B);n1.F(S1);

(*n2)(A, S1, S2);

n3.A(S1);n3.B(B);n3.F(S3);

n4.A(S2);n4.B(S3);n4.F(F);

}};

A

B

F

S2

S3

S1

B. Miramond - UCP

a. Debug Environnementa. Debug Environnement

A

B

F

S2

S3

S1Stimuli

Generator Monitor

B CK

A

Clock

xor2

B. Miramond - UCP

#include ‘’systemc.h’’class stim : public sc_module{sc_out<bool> A, B;sc_in_clk Clk;

void StimGen(){ A.write(false); B.write(false); wait(); A.write(false); B.write(true); wait(); A.write(true); B.write(false); wait(); A.write(true); B.write(true); wait(); sc_stop();}

SC_HAS_PROCESS(stim); stim(sc_name name) : sc_module(name){

SC_THREAD(StimGen);sensitive << Clk.pos();

}};

#include ‘systemc.h’#include <iomanip.h>class monitor : public sc_module{sc_in<bool> A,B, F;sc_in<bool> Clk;

void do_monitor(){ cout << setw(10) << ‘time’; cout << setw(2) << ‘A’; // … while(true){ cout << setw(10) << sc_time_stamp(); cout << setw(2) << A.read(); // … wait(); }}

SC_HAS_PROCESS(monitor);monitor(sc_name name) : sc_module(name){ SC_THREAD(monitor): sensitive << Clk.pos();}};

B. Miramond - UCP

b. Testbench resultsb. Testbench results#include ‘systemc.h’#include ‘systemc.h’#include ‘stim.h’#include ‘stim.h’#include ‘exor2.h’#include ‘exor2.h’#include ‘mon.h’#include ‘mon.h’int sc_main (…){int sc_main (…){sc_signal<bool> ASig, BSig, FSig;sc_signal<bool> ASig, BSig, FSig;sc_clock TestClk(‘TestCk’, 10, SC_NS, sc_clock TestClk(‘TestCk’, 10, SC_NS,

0,5);0,5);stim Stim1(‘Stimulus’);stim Stim1(‘Stimulus’);exor2 DUT(‘exor2’);exor2 DUT(‘exor2’);monitor Monitor1(‘Monitor’);monitor Monitor1(‘Monitor’);

// Connection with ASig, BSig et FSig// Connection with ASig, BSig et FSig

sc_start(); // run foreversc_start(); // run forever

return 0;return 0;}}

Time A B FTime A B F,,,,,,1 ns 0 0 0,,,,,,1 ns 0 0 0 11 ns 0 0 011 ns 0 0 0 21 ns 0 1 121 ns 0 1 1 31 ns 1 0 131 ns 1 0 1 41 ns 1 1 041 ns 1 1 0

B. Miramond - UCP

c. Waveform c. Waveform tracingtracing

#include ‘systemc.h’#include ‘stim.h’#include ‘exor2.h’#include ‘mon.h’

int sc_main(int argc, char *argv[]){sc_signal<bool> ASig, BSig, FSig;sc_clock TestClk(‘TestClock’, 10, SC_NS, 0,5, 1, SC_NS);

… instance of stimexor2 DUT(‘exor2’);DUT.A(ASig); DUT.B(BSig); DUT.F(FSig);… instance of monitor

sc_trace_file* Tf;Tf = sc_create_vcd_trace_file(‘traces’);Tf->set_time_unit(1, SC_NS);//deprecated ://((vcd_trace_file*)Tf)->sc_set_vcd_time_unit(-9);sc_trace(Tf, ASig, ‘A’);sc_trace(Tf, BSig, ‘B’);sc_trace(Tf, FSig, ‘F’);sc_trace(Tf, DUT.S1, ‘S1’);sc_trace(Tf, DUT.S2, ‘S2’);sc_trace(Tf, DUT.S3, ‘S3’);

sc_start();sc_close_vcd_trace_file(Tf);return 0;}

•Declare the trace

•Create trace file

•(optional : specify the trace time unit)

•Register signals or variables for tracing(even hierarchically : DUT.S1)// DUT = Design Under Test

•Run the simulation•Close the trace file

B. Miramond - UCP

d. Resulting waveformsd. Resulting waveforms

B. Miramond - UCP

III. Simulation III. Simulation KernelKernel

B. Miramond - UCP

Concurrence simuléeConcurrence simulée L’objectif du scheduler SystemC est de simuler L’objectif du scheduler SystemC est de simuler

l’exécution parallèle de la plateforme matérielle l’exécution parallèle de la plateforme matérielle décrite bien que la simulation tourne sur une décrite bien que la simulation tourne sur une station de travail mono-processeur.station de travail mono-processeur.

La concurrence simulée en SystemC n’est pas La concurrence simulée en SystemC n’est pas préemptive, c’est le code de chaque processus préemptive, c’est le code de chaque processus qui redonne la main au scheduler (wait).qui redonne la main au scheduler (wait).

B. Miramond - UCP

Section organisationSection organisation1.1. Time managementTime management2.2. SystemC schedulerSystemC scheduler3.3. SystemC scheduling stepsSystemC scheduling steps

1.1. Delayed notificationDelayed notification2.2. Timed notificationTimed notification3.3. Immediate notificationImmediate notification4.4. Simulation steps synthesisSimulation steps synthesis5.5. Dont_intialize !Dont_intialize !6.6. Ending simuationEnding simuation

4.4. The case of Channels : Evaluate-updateThe case of Channels : Evaluate-update5.5. Concurrency and timeConcurrency and time

1.1. Perceived concurrencyPerceived concurrency2.2. Zero-time executionZero-time execution3.3. Scheduled concurrencyScheduled concurrency

6.6. Event-driven simulators (not yet)Event-driven simulators (not yet)

B. Miramond - UCP

1.1. Gestion du tempsGestion du tempsa) sc_timea) sc_time

Le simulateur SystemC est discret. Il utilise un quantum Le simulateur SystemC est discret. Il utilise un quantum de temps minimal qui peut être définit par de temps minimal qui peut être définit par sc_set_time_resolution(int, sc_time_unit)sc_set_time_resolution(int, sc_time_unit)

Par défaut, la plus petite résolution du temps est 1 Par défaut, la plus petite résolution du temps est 1 picoseconde (10picoseconde (10-12-12s)s)

SystemC définit un type énuméré des unités de temps, SystemC définit un type énuméré des unités de temps, sc_time_unitsc_time_unit : :

SC_FSSC_FS femtosecondefemtoseconde (10-15s)(10-15s) SC_PSSC_PS picoseondepicoseonde (10-12s)(10-12s) SC_NSSC_NS nanosecondenanoseconde (10-9s)(10-9s) SC_USSC_US microsecondemicroseconde (10-6s)(10-6s) SC_MSSC_MS milliseconde milliseconde (10-3s)(10-3s) SC_SECSC_SEC

Default

B. Miramond - UCP

SC_TIMESC_TIME sc_timesc_time est le type utilisé pour déclarer des variables de est le type utilisé pour déclarer des variables de

tempstempsDéclaration : Déclaration : sc_time t1(42, SC_PS);

sc_time sc_time_stamp() retourne le temps courant de simulation

double sc_simulation_time() retourne le temps courant de simulation en unité de temps par défaut

B. Miramond - UCP

b) Déclaration d’horloges : sc_clockb) Déclaration d’horloges : sc_clock

Utilisées pour la synchronisationUtilisées pour la synchronisation Les arguments sont :Les arguments sont :

Un label,Un label, La période de l’horloge : valeur + unitéLa période de l’horloge : valeur + unité Le temps passé à l’état hautLe temps passé à l’état haut La date du premier frontLa date du premier front Et un booléen indiquant si le premier front est montant ou Et un booléen indiquant si le premier front est montant ou

descendant.descendant. sc_clock(« Clk », 1, SC_NS);sc_clock(« Clk », 1, SC_NS); sc_clock(« Clk », 1, SC_NS, 0.5, 0, SC_NS, true);sc_clock(« Clk », 1, SC_NS, 0.5, 0, SC_NS, true);

B. Miramond - UCP

Services de l’horlogeServices de l’horloge En SystemC les horloges sont des canaux hiérarchiques,En SystemC les horloges sont des canaux hiérarchiques, Ils offrent les services suivants :Ils offrent les services suivants : periodperiod();(); // returns sc_time// returns sc_time duty_cycle()duty_cycle();; // returns a double (fraction of the period)// returns a double (fraction of the period) posedgeposedge();(); // returns a reference to the positive clock // returns a reference to the positive clock

edge;edge; negedgenegedge();(); // negative…// negative… readread();(); // return the current value// return the current value eventevent();(); // detects if there has been a change on // detects if there has been a change on

clockclock posedge_eventposedge_event();(); // returns an event notification for pos // returns an event notification for pos

clock edgeclock edge negedge_eventnegedge_event();(); // returns an event notification for neg // returns an event notification for neg

clock edgeclock edge

B. Miramond - UCP

Ports dédiésPorts dédiés Un module peut utiliser les ports dédiés de Un module peut utiliser les ports dédiés de

l’horloge pour pouvoir être synchrone :l’horloge pour pouvoir être synchrone : sc_in_clocksc_in_clock sc_out_clocksc_out_clock sc_inout_clocksc_inout_clock

Ce ne sont rien de plus que des sc_in<bool>Ce ne sont rien de plus que des sc_in<bool> Mais ils fournissent les méthodes Mais ils fournissent les méthodes pos()pos() et et neg()neg()

qui font appel à pos_edge_event() et qui font appel à pos_edge_event() et neg_edge_event()neg_edge_event()

Les horloges ne sont lancées qu’après l’appel à sc_start()

B. Miramond - UCP

2. Scheduler SystemC2. Scheduler SystemC Le séquencement des opération réalisé par Le séquencement des opération réalisé par

SystemC estSystemC est Déterministe : l’ordre des opérations sera toujours le Déterministe : l’ordre des opérations sera toujours le

même dans les même conditionsmême dans les même conditions Mais l’utilisateur n’a pas de moyen de connaître ce Mais l’utilisateur n’a pas de moyen de connaître ce

séquencement à l’avanceséquencement à l’avance Il est donc déconseillé de faire communiquer 2 Il est donc déconseillé de faire communiquer 2

processus par variable partagé globale, car l’ordre de processus par variable partagé globale, car l’ordre de lecture/écriture n’est pas spécifié.lecture/écriture n’est pas spécifié.

B. Miramond - UCP

3. Simulation steps3. Simulation steps

Elaboration

Cleanup

sc_start(); Initialize Evaluate Advance Time

sc_main() SystemC Simulation Kernel

.notify(SC_ZERO_TIME); // delayed

.notify(); // immediate

.notify(t); // timed

∆while process ready

B. Miramond - UCP

Simulation stepsSimulation steps ElaborationElaboration

Les modules SystemC sont construitsLes modules SystemC sont construits Les SC_METHOD et SC_THREAD sont créées.Les SC_METHOD et SC_THREAD sont créées.

InitialisationInitialisation Débute après l’appel à sc_start()Débute après l’appel à sc_start() Les processus créées à l’élaboration sont lancés.Les processus créées à l’élaboration sont lancés. Tous les processus sont placés dans la file READY.Tous les processus sont placés dans la file READY.

Evaluate-UpdateEvaluate-Update Les processus sont exécutés en fonction de leur sensibilitéLes processus sont exécutés en fonction de leur sensibilité

Advance timeAdvance time Time managementTime management

CleanupCleanup Clean objects and structuresClean objects and structures

B. Miramond - UCP

RappelRappel Seul les SC_THREAD font des appels à wait()Seul les SC_THREAD font des appels à wait()

Ils ne sont exécutés qu’une seule fois, mais peuvent Ils ne sont exécutés qu’une seule fois, mais peuvent être interrompus.être interrompus.

Tous les SC_METHOD ont une liste statique et Tous les SC_METHOD ont une liste statique et sont re-déclenché à chaque nouvelle notification.sont re-déclenché à chaque nouvelle notification. Ils sont exécutés autant de fois que nécessaire.Ils sont exécutés autant de fois que nécessaire.

B. Miramond - UCP

Après un Delta-cycle

Files d’attente du schedulerFiles d’attente du schedulera. Delayed notificationa. Delayed notification

P4

Ready Running Waiting Events

P1

P2P3

P5

P6E1@0E2@t1E3@t2E4@()

Un par un, les processus sont pris aléatoirement de la

file Ready et désignés comme Running jusqu’à

rencontrer un wait() ou un return().

Durant son exécution, un processus peut réaliser des

notifications qui réveillent d’autres processus en attente (Waiting).

B. Miramond - UCP

Simulation stepsSimulation steps

Elaboration

Cleanup

sc_start(); Initialize Evaluate Advance Time

sc_main() SystemC Simulation Kernel

.notify(SC_ZERO_TIME); // delayed

∆while process ready

Les processus attendant un événement notifié avec un délai SC_ZERO_TIME(.notify(0)) sont replacés dans la

file Ready au prochain cycle de simulation. Ce cycle est appelé Delta-Cycle Delay.

B. Miramond - UCP

b. Timed notificationb. Timed notification

P4

Ready Running Waiting Events

P1

P2P3

P5

P6E1@0E2@t1E3@t2E4@()

Après un temps t1

B. Miramond - UCP

Simulation stepsSimulation steps

Elaboration

Cleanup

sc_start(); Initialize Evaluate Advance Time

sc_main() SystemC Simulation Kernel

∆while process ready

.notify(t); // timed

Les processus attendant un événement notifié avec un délai non-nul sont placés dans la file Waiting et le temps est avancé jusqu’au temps du premier événement de la

liste. A cet instant les processus en attente sont placés en file Ready.

B. Miramond - UCP

c. Immediate notificationc. Immediate notification

P4

Ready Running Waiting Events

P1

P2P3

P5

P6E1@0E2@t1E3@t2E4@()

Dans le même cycle

B. Miramond - UCP

Simulation stepsSimulation steps

Elaboration

Cleanup

sc_start(); Initialize Evaluate Advance Time

sc_main() SystemC Simulation Kernel

∆while process ready

Une notification immédiate place directement les processus en attente durant le même delta-cycle. Ceci peut se produire plusieurs fois jusqu’à rencontré une

notification timée.

.notify(); // immediate

B. Miramond - UCP

d. Synthèse des étapes de simulation d. Synthèse des étapes de simulation du scheduler SystemCdu scheduler SystemC

1.1. InitialisationInitialisation2.2. EvaluationEvaluation3.3. S’il y a encore des processus prèt, retour en 2S’il y a encore des processus prèt, retour en 24.4. UpdateUpdate5.5. S’il y a eu des notifications Delta-cyle, déterminer les S’il y a eu des notifications Delta-cyle, déterminer les

processus READY et retour en 2.processus READY et retour en 2.6.6. S’il n’y a plus de ‘non-Zero notifications’, la S’il n’y a plus de ‘non-Zero notifications’, la

simulation est terminéesimulation est terminée7.7. Sinon, avancer le temps au prochain temps de Sinon, avancer le temps au prochain temps de

notificationnotification8.8. Déterminer les processus READY, retour en 2.Déterminer les processus READY, retour en 2.

B. Miramond - UCP

e. La fonction dont_initialize()e. La fonction dont_initialize() Normallement tous les processus sont exécutés la Normallement tous les processus sont exécutés la

première fois durant la phase d’initialisation.première fois durant la phase d’initialisation. SystemC permet de spécifier que certains processus ne SystemC permet de spécifier que certains processus ne

seront pas exécutés à cette phase :seront pas exécutés à cette phase : SC_METHOD(waiting_method)SC_METHOD(waiting_method) sensitive << a << b;sensitive << a << b; dont_initialize();dont_initialize();

La fonction nécessite une liste de sensibilité statique !! La fonction nécessite une liste de sensibilité statique !! Sinon, le processus ne sera pas démarré.Sinon, le processus ne sera pas démarré.

B. Miramond - UCP

f. End of simulationf. End of simulation1.1. sc_start(argument); // where argument precise the sc_start(argument); // where argument precise the

amount of simulation time. Only used with timed amount of simulation time. Only used with timed models !!models !!

2.2. sc_stop(); // inside a component. It terminates sc_stop(); // inside a component. It terminates simulation when a specified functional condition is simulation when a specified functional condition is atteined. Too local !atteined. Too local !

3.3. Terminator module, which call the sc_stop() primitive Terminator module, which call the sc_stop() primitive only when the logical sum of products on the end-only when the logical sum of products on the end-proces boolean condition is true. Global untimed halt proces boolean condition is true. Global untimed halt condition.condition.

B. Miramond - UCP

4) Le cas des channels : 4) Le cas des channels : evaluate-updateevaluate-update

Les canaux simples utilisent une procédure de Les canaux simples utilisent une procédure de mise à jour particulière appelée :mise à jour particulière appelée :request_update/updaterequest_update/update scheme. scheme.

Ce schéma permet de construire des canaux Ce schéma permet de construire des canaux supportant des changements d’état intervenant supportant des changements d’état intervenant sur des durées infinitésimales (sur des durées infinitésimales (∆∆Cycle) et donc Cycle) et donc d’exprimer la concurrence à son niveau le plus d’exprimer la concurrence à son niveau le plus précis.précis.

B. Miramond - UCP

Exemple 1Exemple 1

On cherche à swapper la valeur présente dans 2 On cherche à swapper la valeur présente dans 2 registres au moment de l’horloge.registres au moment de l’horloge.

Si on modélise les registres par des variables, il Si on modélise les registres par des variables, il est nécessaire d’utiliser une 3e variable est nécessaire d’utiliser une 3e variable temporaire pour faire le swap.temporaire pour faire le swap.

Si on utilise des signaux, 2 sont suffisants car Si on utilise des signaux, 2 sont suffisants car l’écriture et la lecture ne se font pas dans le l’écriture et la lecture ne se font pas dans le même cycle.même cycle.

B. Miramond - UCP

Exemple 2Exemple 2

D Q D Q D Q D QDATA

SYNC

Reg1 Reg2 Reg3 Reg4Q1 Q2 Q3 Q4

Comportement attendu :2. Q4 = Q33. Q3 = Q24. Q2 = Q15. Q1 = DATA

Pour que la fonctionnalité soit respectée, L’ordre est importantChaque registre est un processus indépendant.Or le simulateur ne précise aucun ordre sur les processus.

B. Miramond - UCP

Solution : 2 données du canal ‘Signal’Solution : 2 données du canal ‘Signal’ Chaque signal a deux lieux de mémorisation :Chaque signal a deux lieux de mémorisation :

New valueNew value Et current valueEt current value

Lors d’une écriture, Lors d’une écriture, 3.3. le signal place la valeur dans ‘New value’le signal place la valeur dans ‘New value’4.4. Puis le processus appelle Puis le processus appelle request_updaterequest_update() pour que le simulateur () pour que le simulateur

appelle à son tour la fonction appelle à son tour la fonction updateupdate() du canal lors de la () du canal lors de la prochaine phase.prochaine phase.

5.5. Lorsque la phase d’évaluation est réellement terminée (il n’y a Lorsque la phase d’évaluation est réellement terminée (il n’y a plus de processus en état Ready), le simulateur appelle plus de processus en état Ready), le simulateur appelle updateupdate() () pour chaque canal ayant fait un appel à pour chaque canal ayant fait un appel à request_updaterequest_update().().

6.6. Le canal recopie la nouvelle valeur et notifie un sc_event pour Le canal recopie la nouvelle valeur et notifie un sc_event pour indiquer un changement de valeur.indiquer un changement de valeur.

Donc si un process écrit sur un signal et lit immédiatement, il Donc si un process écrit sur un signal et lit immédiatement, il trouvera la valeur inchangé !!trouvera la valeur inchangé !!

B. Miramond - UCP

New/Current valueNew/Current value

S1 = V2

S2 = V3

S1=

S2=

New Value Current Value

Canaux

Update()

V0

V1

Delta-Cycle

B. Miramond - UCP

The Update Simulation stepThe Update Simulation step

Elaboration

Cleanup

sc_start(); Initialize Evaluate Advance Time

sc_main() SystemC Simulation Kernel

∆

Update

B. Miramond - UCP

ExempleExemple// DeclarationInt count;sc_string message_tmp;sc_signal<int> count_sig;sc_signal<sc_string> message_sig;// Intializing during first delta cyclecount_sig.write(10);message_sig.write(‘Hello’);count = 11;message_temp = ‘Bonjour’;print_state(count, count_sig, message_temp, message_sig);wait(SC_ZERO_TIME);// 2nd delta cyclecount = 20;count_sig.write(count);print_state(count, count_sig, message_temp, message_sig);wait(SC_ZERO_TIME);// 3rd delta cyclemessage_sig.write(message_temp = ‘New message’);print_state(count, count_sig, message_temp, message_sig);

// Konsole

// First delta cyclecount is 11count_sig is 0message_temp is Bonjourmessage_sig is ‘’// 2nd delta cyclecount is 20count_sig is 10message_temp is Bonjourmessage_sig is Hello// 3rd delta cyclecount is 20count_sig is 20message_temp is New Messagemessage_sig is Hello

B. Miramond - UCP

Guide d’utilisationGuide d’utilisation Pour bien utiliser ces canaux :Pour bien utiliser ces canaux :

1.1. Utiliser comme convention de nommage pour les Utiliser comme convention de nommage pour les signaux avec le suffixe signaux avec le suffixe _sig_sig

2.2. Lire tous les ports et signaux dans une variable Lire tous les ports et signaux dans une variable localelocale

3.3. Réaliser les traitements sur ces variables localesRéaliser les traitements sur ces variables locales4.4. Écrire le résultat sur les ports et les signauxÉcrire le résultat sur les ports et les signaux

Concept proche d’un automate de Moore…Concept proche d’un automate de Moore…

B. Miramond - UCP

Résumé du schéma Résumé du schéma request_update/updaterequest_update/update

Ce schéma correspond à dire que la mise à jour Ce schéma correspond à dire que la mise à jour de ces signaux est retardée d’un Delta-cycle.de ces signaux est retardée d’un Delta-cycle.

Ce schéma ne s’applique qu’aux canaux Ce schéma ne s’applique qu’aux canaux primitifs, mais pas à tous :primitifs, mais pas à tous : sc_signalsc_signal sc_fifosc_fifo mais pas sc_mutex et sc_semaphore (cf. section IV)mais pas sc_mutex et sc_semaphore (cf. section IV)

B. Miramond - UCP

5) Concurrence 5) Concurrence et évolution du tempset évolution du temps

Process A(){// @ t0codeA1;codeA2;wait(t1);codeA3;codeA4;wait(t2);codeA5;codeA6;wait(t3);}

Process B(){// @ t0codeB1;codeB2;wait(t1);codeB3;codeB4;wait(t2);codeB5;codeB6;wait(t3);}

Process C(){// @ t0codeC1;codeC2;wait(t1);codeC3;codeC4;wait(t2);codeC5;codeC6;wait(t3);}

Process D(){// @ t0codeD1;codeD2;wait(t1);codeD3;wait(0);codeD4;wait(t3);}

B. Miramond - UCP

Activité perçue lors de la simulationActivité perçue lors de la simulation

t1 t3

A1; A2;

B1; B2;

C1; C2;

D1; D2;

A3; A4;

B3; B4;

C3; C4;

D3; D4;

A5; 16;

B5; B6;

C5; C6;

…

t2

A

B

C

D

B. Miramond - UCP

Activité réelle lors de la simulation (1)Activité réelle lors de la simulation (1)

t1 t3

A1; A2;

B1; B2;

C1; C2;

D1; D2;

A3; A4;

B3; B4;

C3; C4;

D3; D4;

A5; 16;

B5; B6;

C5; C6;

…

t2

A

B

C

D

Chaque portion de code est exécutée en temps nul !!!

Ce sont les wait(t) qui font avancer le temps !

B. Miramond - UCP

A1; A2;

B1; B2;

C1; C2;

D1; D2;

Activité réelle lors de la simulation (2)Activité réelle lors de la simulation (2)

t1 t3t2

A

B

C

D

A1; A2;

B1; B2;

C1; C2;

D1; D2;

A5; 16;

B5; B6;

C5; C6;

A3; A4;

B3; B4;

C3; C4;

D4;

Rq: Extansion du temps

Les opérations qui apparaissent concurrentes à l’utilisateur sont séquencées par le scheduler SystemC.Cet ordre est déterministe

mais non prévisible !

B. Miramond - UCP

6. Event-based simulators6. Event-based simulators VHDL, Verilog …VHDL, Verilog …

B. Miramond - UCP

End of GreenEnd of Green