Historique de SystemC Regroupe 4 courants didées: SCENIC Project : Synopsys+UC Irvine Philips System-Level Data Types, VSIA SLD DWG IMEC, Hardware-Software.

Présentation au sujet: "Historique de SystemC Regroupe 4 courants didées: SCENIC Project : Synopsys+UC Irvine Philips System-Level Data Types, VSIA SLD DWG IMEC, Hardware-Software."— Transcription de la présentation:

1 Historique de SystemC Regroupe 4 courants didées: SCENIC Project : Synopsys+UC Irvine Philips System-Level Data Types, VSIA SLD DWG IMEC, Hardware-Software CoDesign (CoWare) OSCI, Language Working Group

2 SystemC heritage

3 Why SystemC ?

4 What is SystemC

5 A C++ library

6 SystemC design environment

7 SystemC advantages

8 SystemC layered environment

9 Commencer en SystemC POO : Classe, objet, instance en C++ Application : Réécrire ladditionneur VHDL en SystemC à partir de deux demi-additionneurs.

10 Intérêt de la POO : modularité technique de décomposition de systèmes réduire la complexité dun système par un assemblage de sous- systèmes plus simples La réussite de la technique dépend du degré dindépendance entre les sous-systèmes (ou degré de couplage) on appelle module, un sous-système dont le couplage avec les autres est relativement faible par rapport au couplage de ses propres parties Truisme pour un microélectronicien, déjà confronté au problème

11 Encapsulation technique pour favoriser la modularité (lindépendance) des sous- systèmes séparer linterface dun module de son implémentation, interface (partie publique): liste des services offerts (quoi) implémentation (partie privée): réalisation des services (comment) structure de données instructions et algorithmes protection des données par des règles (dans les instructions): les modules communiquent par messages, pas par accès aux données

12 Représentation dun objet

13 Intérêt des classes Une classe sert à définir les possibilités des objets d'un type donné. décrit un ensemble de données et les opérations possibles sur ces données. une classe sert de "modèle" pour la création d'objets (instances de la classe)

14 Structure des classes Une classe est un agrégat d'attributs et de méthodes : les membres Les membres sont accessibles via une instance de la classe Une méthode particulière, le constructeur, est appelée lors de la création de linstance

15 Héritage le problème : une application a besoin de services dont une partie seulement est proposée par une classe déjà définie, et ce dans un délai très bref. ne pas réécrire le code solution en POO : définir une nouvelle classe à partir de la classe déjà existante, c'est l'héritage le code d'une classe peut ainsi être réutilisé autant de fois que nécessaire pour créer de nouvelles sous-classes Les sous-classes fournissent un comportement spécialisé au comportement commun fourni par la super-classe Permet de créer des nouveaux types ou objets évolutifs très rapidement, contrairement à VHDL Elévation du niveau dabstraction et possibilité de MoC + évolués

16 SystemC et POO Tout module SystemC dérive de la classe module de base Il en a donc le comportement par défaut Un module a des ports Input, output, inout Un module a des processus Correspond à la description comportementale de VHDL

17 En C++ Méthodologie C++ : 2 fichiers.h,.cpp Inclure « systemc.h ».h contient la description du module Linterface du module Les signaux internes Le constructeur Le prototype des méthodes.cpp contient les définitions des méthodes (processus et utilitaires)

18 Creating a module

19 Modules

20 Module example

21 SystemC Module

22 SC_MODULE Skeleton

23 SC_MODULE syntax

24 Ports, channels, interfaces

25 SystemC port

26 SystemC port syntax

27 SystemC signal

28 sc_signal syntax

29 Data member syntax

30 SystemC datatypes

31 sc_int / sc_uint

32 SystemC operators<

33 SystemC SC_CTOR

34 SystemC process

35 SystemC process types

36 Creating a process

37 Member functions

38 Creating a submodule

39 Top-level of design

40 Creating clock and start simulation

41 SystemC clock

42 SystemC system

43 Conceptual thread of executionsc_main

44 Constructeur Données membres, linterface Nom du module half_adder.h // File : half_adder.h #include "systemc.h" SC_MODULE(half_adder) { sc_in a,b; sc_out sum,carry; void prc_half_adder(); SC_CTOR(half_adder) { SC_METHOD(prc_half_adder); sensitive << a << b; } }; half_adder.h

45 SC_METHOD (1) // File : half_adder.h #include "systemc.h" SC_MODULE(half_adder) { sc_in a,b; sc_out sum,carry; void prc_half_adder(); SC_CTOR(half_adder) { SC_METHOD(prc_half_adder); sensitive << a << b; } }; Déclare un process sans mémoire appelé prc_half_adder() Ne peut utiliser les wait Sensibilité « statique » sur a et b

46 SC_METHOD (2) // File : half_adder.cpp #include "half_adder.h" void half_adder::prc_half_adder() { sum = a ^ b; carry = a & b; }

47 Description de la hiérarchie // File : full_adder.h #include "half_adder.h" SC_MODULE(full_adder) { sc_in a,b,carry_in; sc_out sum,carry_out; sc_signal c1,s1,c2; void prc_or(); half_adder *ha1_ptr,*ha2_ptr; SC_CTOR(full_adder) { ha1_ptr=new half_adder("ha1"); // Named association: ha1_ptr->a(a); ha1_ptr->b(b); ha1_ptr->sum(s1); ha1_ptr->carry(c1); ha2_ptr=new half_adder("ha2"); // Positional association: (*ha2_ptr)(s1,carry_in,sum,c2); SC_METHOD(prc_or); sensitive << c1 << c2; } // A destructor ~full_adder() { delete ha1_ptr; delete ha2_ptr; } }; // File : full_adder.cpp #include "full_adder.h" void full_adder::prc_or() { carry_out = c1 | c2; }

48 driver.h, driver.cpp // File : driver.h #include "systemc.h" SC_MODULE(driver) { sc_out d_a,d_b,d_cin; void prc_driver(); SC_CTOR(driver) { SC_THREAD(prc_driver); } }; // File : driver.cpp #include "driver.h" void driver::prc_driver() { sc_uint pattern; pattern=0; while (1) { d_a=pattern[0]; d_b=pattern[1]; d_cin=pattern[2]; wait(5,SC_NS); pattern++; }

49 monitor.h, monitor.cpp // File : monitor.h #include "systemc.h" SC_MODULE(monitor) { sc_in m_a,m_b,m_cin,m_sum,m_cout; void prc_monitor(); SC_CTOR(monitor) { SC_METHOD(prc_monitor); sensitive << m_a << m_b << m_cin << m_sum << m_cout; } }; // File : monitor.cpp #include "monitor.h" void monitor::prc_monitor() { cout << "At time " << sc_time_stamp() << "::"; cout << "(a, b, carry_in): "; cout << m_a << m_b << m_cin; cout << " (sum, carry_out): " << m_sum << m_cout << endl; }

50 Schématique du toplevel driver full_adder monitor

51 Le toplevel // File : full_adder_main.cpp #include "driver.h" #include "monitor.h" #include "full_adder.h" int sc_main(int argc,char *argv[]) { sc_signal t_a, t_b, t_cin, t_sum, t_cout; full_adder f1("FullAdderWithHalfAdder"); // Connect using positional association: f1 << t_a << t_b << t_cin << t_sum << t_cout; driver d1("GenerateWaveforms"); // Connect using named association: d1.d_a(t_a); d1.d_b(t_b); d1.d_cin(t_cin); monitor mo1("MonitorWaveforms"); mo1 << t_a << t_b << t_cin << t_sum << t_cout; sc_start(100,SC_NS); return(0); } A éviter A utiliser

52 Tracing signals

53 Trace de simulation

54 Pour ajouter des traces (.vcd)

55 Comparaison VHDL-SystemC // File : half_adder.h #include "systemc.h" SC_MODULE(half_adder) { sc_in a,b; sc_out sum,carry; void prc_half_adder(); SC_CTOR(half_adder) { SC_METHOD(prc_half_adder); sensitive << a << b; } }; // File : half_adder.cpp #include "half_adder.h" void half_adder::prc_half_adder() { sum = a ^ b; carry = a & b; } ARCHITECTURE half_adder_d OF half_adder IS BEGIN sum <= (a XOR b); carry <= (a AND b); END half_adder_d; ENTITY half_adder IS PORT( a, b: IN BIT; sum, carry: OUT BIT); END half_adder;

56 VHDL – SystemC (1) entity my_model is port( input1: in BIT; input2: in BIT; output1: out BIT; output2: out BIT; ); end my_model; architecture my_arch of my_model is begin process( input1, input2) variable my_var1,my_var2: BIT; begin my_var1 := not input1; my_var2 := not input2; output1 <= input1 and my_var2; output2 <= input2 and my_var1; end process; end my_arch; #include systemc.h SC_MODULE (my_model) { sc_in input1; sc_in input2; sc_out output1; sc_out output2; SC_CTOR (my_model) { SC_METHOD ( process ); sensitive << input1 << input2; } void process( ) { bool my_var1, my_var2; my_var1 = ~input1; my_var2 = ~input2; output1 = input1 & my_var2; output2 = input2 & my_var1; } };

57 VHDL – SystemC (2) process( input1, input2 ) process(clk)... if ( clkevent and clk = 1) then SC_METHOD ( process ); sensitive << input1 << input2; SC_METHOD ( process ); sensitive_pos << clk;