SystemC Version 2 - fiit.stuba.skjelemenska/SystemC.pdf · SystemC údajové typy Celo C++...

Preview:

Citation preview

SystemC Version 2.0

2

Úvod

SystemC je knižnica C++ tried a metodológia, ktorá umožňuje efektívny opis a modelovanie

•programových prostriedkov,

•technických prostriedkov a

•rozhrania navrhovaného systému.

3

Úvod

1999 - Open SystemC Initiative (OSCI) - sprístupnenie jazyka SystemC

Zámerna platforme C++ umožniť, podporovať, urýchliť

•výmenu tzv. system-level intellectual property (IP) models •codesign.

4

Úvod

Open SystemC Initiative (OSCI) - vedúce organizácie

•Texas Instruments, •Synopsys, Inc., •Fujitsu, •Ericsson, •Lucent Technologies, •Sony Corporation STMicroelectonics a mnohé ďalšie.

5

SystemC knižnica tried rozšírila jazyk C++ o•Hardverové časovanie,•Paralelizmy a•Reaktívne správanie

6

Poskytuje• potrebnú abstrakciu údajov a riadenia na kompaktný a efektívny návrh,• podporu pre „hardware-software co-design“

Umožňuje•využívať vývojové prostriedky C++,•vytvoriť vykonateľnú špecifikáciu (t.j. C++ program ktorý vykazuje rovnaké správanie, ako systém),•vytvoriť model na systémovej úrovni,•opísať architektúru zložitého systému (HW, SW komponenty), •simuláciou overiť a optimalizovať návrh.

7

Výhody vykonateľnej špecifikácie(Executable Specification)

•Zaručuje konzistentnosť, •kompletnosť,•bezchybnosť a•jednoznačnú interpretáciu špecifikácie, •umožňuje overiť funkčnosť pred začatím implementácie, •overiť výkonnosť systému v počiatočnom štádiu návrhu, •využiť jeden testbench (zjemnený)

8

SystemC – základné črty

•Moduly – hierarchická entita, ktorá obsahuje procesy a ďalšie moduly•Procesy – opisujú funkciu systému•Porty – na prepojenie modulov•Signály – nerezolučné aj rezolučné•Preddefinované typy portov a signálov – pre podporu rôznych úrovní abstrakcie•Preddefinované údajové typy

9

•Hodiny – špeciálny signál•Simulačný cyklus•Niekoľko úrovní abstrakcie – modely bez časovania až po detailné časovanie•Komunikačné protokoly – viacúrovňová sémantika•Ladenie – run-time error checking•Zobrazenie priebehov – formáty VCD, WIF, ISBD

10

Súčasná metodológia návrhu systému

11

Hlavné problémy•Manuálna transformácia z C na HDL vnáša chyby•Nekonzistencia modelov•Modifikácia testov

12

Metodológia návrhu SystemC

Hlavné výhody•Metodológia zjemňovania•Použitie jediného jazyka•Vyššia produktivita•Testbench reuse•Podpora RTOS v budúcnosti

13

Moduly - deklarácia

SC_MODULE(transmit) {

alebo

struct transmit : sc_module {

14

Modul môže obsahovať:• porty, • lokálne signály, • lokálne údaje,• moduly, • procesy a• konštruktory.

Tieto implementujú jeho funkciu.

15

Porty modulu

-externé rozhranie – prenos údajov do modulu a z modulu- 3 režimy

• Input• Output• InOut

-majú definovaný údajový typ – podporované sú všetky C++ údajové typy, SystemC údajové typy aj používateľom definované údajové typy

16

Porty modulu

SC_MODULE(fifo) {sc_in<bool> load;sc_in<bool> read;sc_inout<int> data;sc_out<bool> full;sc_out<bool> empty;//rest of module not shown

}

17

Signály modulu

-Slúžia na prepojenie inštancií modulov nižšej úrovne – umožňujú komunikáciu medzi modulmi-prenos údajov medzi modulmi- nemajú definovaný smer-majú definovaný údajový typ – podporované sú všetky C++ údajové typy, SystemC údajové typy aj používateľom definované údajové typy

SystemC existujú 2 možnosti priradenia signálov na porty• menovité priradenie (named mapping)• pozičné priradenie (positional mapping )

18

Signály modulu

// filter.h#include "systemc.h"#include "mult.h"#include "coeff.h"#include "sample.h"

19

Pozičné priradenie

sample *s1;coeff *c1;mult *m1;sc_signal<sc_uint<32> > q, s, c;

SC_CTOR(filter) {s1 = new sample ("s1");(*s1)(q,s);c1 = new coeff ("c1");(*c1)(c);m1 = new mult ("m1");(*m1)(s,c,q);

}}

SC_MODULE(filter) {

20

Menovité priradenie

// filter.h

#include "mult.h"#include "coeff.h"#include "sample.h"

SC_MODULE(filter) {sample *s1;coeff *c1;mult *m1;sc_signal<sc_uint<32> > q, s, c;

SC_CTOR(filter) {s1 = new sample ("s1");s1->din(q);s1->dout(s);c1 = new coeff ("c1");c1->out(c);m1 = new mult ("m1");m1->a(s);m1->b(c);m1->q(q);

}}

#include "systemc.h"

21

Porty a signály modulu

Čítanie portov a signálovMetódy read() a write() – jasný zámer, implicitná konverziaOperátor priradenia – kratší opis

Polia portov a signálovsc_in<sc_logic> a[32]; // creates ports a[0] to a[31]

// of type sc_logicsc_signal<sc_logic> i[16]; // creates signals i[0] to i[15]

// of type sc_logic

22

Porty a signály moduluRezolučné porty a signálysc_in_rv<n> x; //input resolved logic vector n bits widesc_out_rv<n> y; // output resolved logic vector n bits widesc_inout_rv<n> z; // inout resolved logic vector n bits wide

sc_signal_rv<n> g; // resolved logic vector signal n bits wide

23

// count.h

sc_in<bool> load;sc_in<int> din; // input portsc_in<bool> clock; // input portsc_out<int> dout; // output portint count_val; // internal data storagevoid count_up();SC_CTOR(count) {SC_METHOD(count_up); // Method process

sensitive_pos << clock;}

};

Lokálne údaje- ľubovoľného typu- nie sú viditeľné mimo modulu

#include "systemc.h"

SC_MODULE(count) {

24

Lokálne údaje

// count.cc#include "count.h"void count::count_up() {

if (load) {count_val = din;

} else {count_val = count_val + 1; // could also//write count_val++

}dout = count_val;

}

25

SystemC údajové typy

Logické hodnoty

•• sc_bit – 2-j hodnotový 1-bitový typ – odporúča sa nahradiť typom sc_logic

sc_logic – 4 hodnotový 1-bitový typ • sc_bv – bitový vektor ľubovoľnej dĺžky - 2-j hodnotové prvky• sc_lv – bitový vektor ľubovoľnej dĺžky - 4-r hodnotové prvkyCelé čísla• sc_int – 1 až 64 bitové celé číslo so znamienkom (doplnkový kód)• sc_uint – 1 až 64 bitové celé číslo bez znamienka• sc_bigint – celé číslo so znamienkom ľubovoľnej dĺžky• sc_biguint – celé číslo bez znamienka ľubovoľnej dĺžkyČísla v pevnej rádovej čiarke• sc_fixed - čísla v pevnej rádovej čiarke so znamienkom - templated • sc_ufixed - čísla v pevnej rádovej čiarke bez znamienka - templated• sc_fix - čísla v pevnej rádovej čiarke so znamienkom - untemplated • sc_ufix - čísla v pevnej rádovej čiarke bez znamienka - untemplated

26

SystemC údajové typy

Údajový typ sc_logic4 hodnotový údajový typ s hodnotami:

• ’0’ – 0 alebo false SC_LOGIC_0• ’1’ – 1 alebo true SC_LOGIC_1• ’X’ – nedefinovaná alebo neznáma hodnota SC_LOGIC_X• ’Z’ – stav vysokej impedancie SC_LOGIC_Z

27

SystemC údajové typy

Údajový

sc_logic

typ sc_logic

x, y; // object declarationsc_bit z;

x = SC_LOGIC_1; //x = ’1’; // assign a 1 valuex = SC_LOGIC_Z; //x = ’Z’; // assign a Z valuex &= y; // x assign a value of x & y

z == y; // sc_bit and sc_logicy != x; // sc_logic and sc_logicy == ’1’; // sc_logic and character literaly == SC_LOGIC_1; // spoľahlivejšie

z = y; // sc_logic to sc_bit // 0–>0 1–>1 X–>1 Z–>1x = z; // sc_bit to sc_logic // 0–>0 1–>1

28

SystemC údajové typyÚdajový typ sc_bv < n >

• Bitový vektor ľubovoľnej dĺžky, bity môžu nadobúdať hodnoty ’0’(false)alebo ’1’(true)• Vhodný ak nepotrebujem 3-j hodnotovú logiku ani aritmetické operácie• Vhodný na operácie s bitovými vektormi• Rýchlejšia simulácia ako pri použití sc_lv < n >

29

SystemC údajové typyÚdajový typ sc_bv < n >

sc_bv<64> databus;

result = databus.or_reduce();

sc_bit y;sc_bv<8> x; //bit 7 to bit 0bool z;

y = x[6];z = x[0].to_bool();

sc_bv<16> x;sc_bv<8> y;

y = x.range(0,7); // differ from x.range(7,0);

sc_logic result;

30

SystemC údajové typyÚdajový typ sc_bv < n >

sc_bv<16> data16= "1111111111111111"; // inicializáciadata32;

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

sc_bv<2> z1;bool y=true;

z1 = ((sc_bv<1>)y, y); //one needs to be of a vector type

sc_bv<16> val;val = "1111111111111111";

sc_bv<32>

31

SystemC údajové typy

Údajový typ sc_lv < n >

• Bitový vektor ľubovoľnej dĺžky, bity môžu nadobúdať hodnoty ’0’(false), ’1’(true), ’X’ (unknown) alebo ’Z’ (hi impedance)• Vhodný ak potrebujem 3-j hodnotovú logiku • Vhodný ak nepotrebujem aritmetické operácie• Pomalšia simulácia ako pri použití sc_bv < n >

•Rovnaké operácie ako pre údajový typ sc_bv < n >

sc_lv<5> z2 = "10101"; // inicializáciasc_lv<4> in(SC_LOGIC_1); // in = "1111";bool y=true;

//zreťazeniez2 = (SC_LOGIC_0, in) ; // or ((sc_logic) '0', in)

//one needs to be of a vector type

32

SystemC údajové typy

Údajový

Deklarácia signálu:

typ sc_lv < n >

sc_signal<sc_lv<64> > databus; // extra space is required

Konverzia údajového typu sc_lv <n > na celočícelný údajový typ:sc_uint<8> uint8;sc_int<8> int8;sc_lv<8> lv8 = "11111111";

lv8 = uint8; // convert sc_uint to sc_lvint8 = lv8; // convert sc_lv to sc_int -1uint8 = lv8; // convert sc_lv to sc_uint 255

33

SystemC údajové typy

Údajový

Odpojenie ovláda

typ sc_lv < n >

čov od zbernice:sc_lv<16> bus1;

if (enable) {bus1 = in1;} else {bus1 = "ZZZZZZZZZZZZZZZZ";}

Užitočné metódy pre údajové typy SystemC:to_bool()to_int()to_uint()

switch (some_sc_vector.to_int()){ ..}

34

SystemC údajové typy

Celo

C++

číselné údajové typy

celočíselné údajové typy sú zvyčajne obmedzené na 32 bitov- rýchlejšia simulácia

SystemC celočíselné údajové typy môžu mať 1 až 64 bitovsc_int<n> celé čísla so znamienkom (Fixed Precision Signed Integer) a sc_uint<n> celé čísla bez znamienka (a Fixed Precision Unsigned Integer )

Prípadne neobmedzený počet bitovsc_biguint <n> celé čísla so znamienkom (Arbitrary Sized Signed Integer) asc_bigint <n> celé čísla bez znamienka (Arbitrary Size Unsigned Integer)- najpomalšia simulácia

35

SystemC údajové typy

Celočíselné údajové typy sc_int < n > a sc_uint < n >

36

SystemC údajové typy

Celočíselné údajové typy sc_int < n > a sc_uint < n >

37

SystemC údajové typy

Celo

sc_int<16>

číselné údajové typy sc_int < n > a sc_uint < n >

x, y, z;z = x & y; // perform and operation on x and y bit by bitz = x >> 4; // assign x shifted right by 4 bits to z

x = x + y; // traditional wayx += y; // terse method

sc_logic mybit;sc_uint<8> myint;mybit = myint[7]; //select one bit

sc_uint<4> myrange;sc_uint<32> myint;myrange = myint.range(7,4); //select more than one bit

38

SystemC údajové typy

Celo

sc_uint<4>

číselné údajové typy sc_int < n > a sc_uint < n >

inta;sc_uint<4> intb;sc_uint<8> intc;intc = (inta, intb); //zreťazenieinta++; //auto increment operator

sc_uint<8> uint1, uint2;sc_int<16> int1, int2;uint1 = int2; // convert sc_int to sc_uintint1 = uint2; // convert sc_uint to sc_int

39

SystemC údajové typy

Celo

sc_biguint<128>

číselné údajové typy sc_bigint < n > a sc_biguint < n >

b1;sc_biguint<64> b2;sc_biguint<150> b3;b3 = b1*b2; // b1 (128 bit ) multiplied by b2 (64 bit)

// result (192 bit) 42 bits will be removed // before assignment to b3.

40

Procesy

•Proces je C++ funkcia, ktorá sa zaregistruje na SystemC jadre a zavolá sa pri udalosti na signáli, naktorý je proces citlivý•Emulujú správanie sa modelovaného zariadenia.•Všetky procesy bežia súbežne v čase ale obsahujú sekvenčné príkazy.•Typ procesu určuje spôsob volania a vykonania procesu.

SystemC poskytuje 3 typy procesov:• Methods• Threads• Clocked Threads – neodporúča sa používa

41

Method Proces

•Pri aktivácii sa celý proces vykoná a potom vráti riadenia simulačnému kernelu•Nemôže byť pozastavený a teda nemôže obsahovať príkaz wait()•Nemôže obsahovať nekonečný cyklus•Zoznam citlivosti sa definuje v konštruktore•Vhodný na opis kombinačnej logiky, hoci dá sa opísať aj sekvenčná logika

Procesy

42

Method Proces

// andgate.h

SC_MODULE(and_gate) {

sc_in<sc_logic> a;sc_in<sc_logic> b;sc_out<sc_logic> dout; // output port

void do_and();SC_CTOR(and_gate)

{SC_METHOD(do_and); // Method processsensitive << a; // sensitive to port or signal, sensitive << b; // not data member}

};

Procesy

// andgate.cpp#include "andgate.h"

void and_gate :: do_and(){

dout = a.read() & b.read();};

#include "systemc.h"

43

ProcesyMethod Proces

// m_dff.h

SC_MODULE(m_dff) {sc_in<bool> din;sc_in<bool> clock;sc_out<bool> dout;

void doit();

SC_CTOR(m_ďff) {SC_METHOD(doit);

sensitive_pos << clock;}

};

#include "systemc.h"

// m_dff.cc#include " m_dff.h"

void m_dff::doit() {dout = din;

}

44

Thread Proces

•Thread procesy sú implementované ako súbežné •Môže byť pozastavený príkazom wait() a znovu aktivovaný udalosťou•Pri opätovnej aktivácii vykonávanie pokračuje od bodu, v ktorom bol pozastavený•Spravidla obsahuje nekonečný cyklus•Zoznam citlivosti definuje signály a porty na ktoré bude citlivý•Vhodný na opis sekvenčnej logiky a generátora testovacích vzoriek•Simulácia je pomalšia ako pri použití Method procesu

Procesy

45

// dff.cpp#include "dff.h"

void dff :: doit(){

while(true){

if (reset == SC_LOGIC_0){

temp = SC_LOGIC_0;}else {

temp = d.read();}q = temp;nq = ~ temp;wait();

}}

Thread Proces

#include "systemc.h"

SC_MODULE(dff) {

sc_in<sc_logic> d, reset;sc_in_clk clk;//or sc_in<sc_logic> clk;sc_out<sc_logic> q, nq;

sc_logic temp;

void doit();SC_CTOR(dff)

{SC_THREAD(doit); // Thread processsensitive_pos << clk;sensitive_neg << reset;

}};

// dff.h

46

//maintest.cpp

//int sc_main() not supported in Modelsim!!!{ sc_signal<sc_logic> a, b, d, reset;

sc_signal<sc_logic> and_out, q, nq;sc_clock clk;

and_gate And1;dff dff1;

void sc_main_body ();SC_CTOR (my_test)

:dff1 ("dff1"),And1 ("And1"),clk ("clk", 10, SC_NS, 0.5, 0.0, SC_NS, false)

Thread Proces

#include "andgate.h"#include "dff.h"

SC_MODULE (my_test)

{dff1.d(d);dff1.reset(reset);dff1.clk(clk.signal());dff1.q(q);dff1.nq(nq);

And1.a(a);And1.b(b);And1.dout(and_out);

SC_THREAD (sc_main_body);}

};// pokračuje

47

// pokračovanie

while (true){ a = SC_LOGIC_0; b = SC_LOGIC_0;

d = SC_LOGIC_1;wait(20, SC_NS);a=SC_LOGIC_0; b=SC_LOGIC_1;reset=SC_LOGIC_0;wait(20, SC_NS);a=SC_LOGIC_1;reset=SC_LOGIC_1;wait(20, SC_NS);b=SC_LOGIC_0;d=SC_LOGIC_1;

}}

SC_MODULE_EXPORT(my_test); // required in Modelsim

Thread Procesvoid my_test :: sc_main_body(){

48

Clocked Thread Proces

SC_CTHREAD proces sa líši od SC_THREAD procesu v nasledujúcom:• SC_CTHREAD proces špecifikuje clock objekt• Nemá zoznam citlivosti, je citlivý len na jednu hranu špecifikovaného clock objektu• watching konštrukcia (povolena iba pre SC_CTHREAD procesy) sa používa na monitorovanie zadanej podmienky. Pri splnení podmienky sa riadenie presunie na začiatok procesu, kde môže byť spracovaná.• Simulácia je pomalá• Nevykonáva sa vo fáze inicializácie

Procesy

49

ProcesyClocked Thread Proces

// datagen.h#include "systemc.h"

SC_MODULE(data_gen) {sc_in_clk clk;sc_inout<int> data;sc_in<bool> reset;

void gen_data();SC_CTOR(data_gen){SC_CTHREAD(gen_data, clk.pos());watching(reset.delayed() == true);}};

// datagen.cpp#include "datagen.h"

void gen_data() {if (reset == true) {

data = 0;}

while (true) {data = data + 1;wait();data = data + 2;wait();data = data + 4;wait();

}}

50

Konštruktory

#include "systemc.h"

SC_MODULE(ram) {sc_in<int> addr;sc_in<int> datain;sc_in<bool> rwb;sc_out<int> dout;// local memory storageint memdata[64]; int i;

void ramread();void ramwrite();

SC_CTOR(ram){SC_METHOD(ramread);

sensitive << addr << rwb;SC_METHOD(ramwrite)

sensitive << addr << datain << rwb;

for (i=0; i++; i<64) {memdata[i] = 0;

}}

};// rest of module not shown

// ram.h

51

TestBench

52

// count_stim.h#include "systemc.h„

SC_MODULE(count_stim) {sc_out<bool> load;sc_out<int> din; // input portsc_in<bool> clock; // input portsc_in<int> dout;

void stimgen();SC_CTOR(count_stim) {SC_THREAD(stimgen);

sensitive_pos (clock);}

};

53

// count_stim.cc#include "count_stim.h"void count_stim::stimgen() {

while (true) {load = true; // load 0din = 0;wait(); // does not count up, value = 0

load = false;wait(); // count up, value = 1wait(); // count up, value = 2wait(); // count up, value = 3wait(); // count up, value = 4wait(); // count up, value = 5wait(); // count up, value = 6}

}

54