A SystemC programok adattípusai

A SystemC programok adattípusai A negyedik fejezetben bemutatott félösszeadó áramköri példában semmilyen SystemC típus sem szerepelt. Viszont összetettebb áramköri feladatok esetén elengedhetetlen a különböző a digitális áramkörök modellezéséhez jobban illeszkedő típusok bevezetése. Ebben a fejezetben bemutatásra kerülnek a SystemC adattípusai és mind azok a műveletek is, amelyek az egyes típusokon értelmezhetőek, illetve használhatóak. 1

VI.1. Numerikus értéket hordozó típusok Három alapvetően különböző csoportra bonthatóak azok a SystemC-ben definiálható elemek, amelyek valamilyen numerikus értéket tárolhatnak, illetve továbbíthatnak. Változók Jelek Portok 2

Változók A változók deklarálása a C++ programnyelvben megszokott szintaktikai szerkezetnek megfelelően kell elvégezni. A változó típusát és nevét kell megadni. A deklaráció szintaktikai alakja a következő. típus_neve valtozo_nev1, valtozo_nev2,...; Például: long x,y; int a,b,c; 3

Változókat deklarálhatunk egy-egy osztály metódusain (tagfüggvények) belül, amelyekre nézve a változók lokálisak lesznek, azaz mind hivatkozási szempontból, mind pedig a tartalmazott érték szempontjából csak az adott függvényben használhatjuk azt. Valamint egy-egy osztály tulajdonságainak leírására is deklarálhatunk változókat, de azok a folyamatok közötti kommunikációban nem vehetnek részt. 4

Portok Portok deklarálására a következő három kulcsszó használható, attól függően, hogy az adott modulhoz tartozó porton milyen irányú az információáramlás, sc_in, sc_out, sc_inout. 5

A port deklaráció szintaktikai alakja a következő. sc_out<tipus_nev> kimenet_1, kimenet_2; sc_in< tipus_nev> bemenet_1, bemenet_2; sc_inout<tipus_nev> ki_bemenet_1, be_kimenet_2; például sc_out<bool> x,y; sc_in<sc_uint> a,b; sc_inout<sc_bit> m,n; 6

Jelek A jeleket az sc_signal kulcsszó segítségével tudjuk deklarálni, ami meg kell, előzze a jelet azonosító nevet. A jelek elsődleges feladata a folyamatok közötti kommunikáció biztosítása. A deklaráció szintaktikai alakja a következő. sc_signal<tipus_neve> jel_nev1, jel_nev2,...; például sc_signal<bool> x; sc_signal<sc_bit> b; 7

Példák tömbök deklarálására A következő részben különböző típusú tömbök deklarációira láthatunk példákat. A szabványos C/C++ nyelvben megszokott szintaktikai szerkezetben lehet egy és több dimenziós tömböket létrehozni. long tomb_1d[20]; int tomb_2d[5][10]; sc_in<sc_bv<8> > byte_tomb[5]; sc_signal<bool> jelek[4][8]; 8

A tömböknek és pláne a több dimenziós tömböknek nem lehet egyetlen értékadó utasítással a tömb egyes elemeit egy adott értékre beállítani, vagy az egyik tömbből a másikba az egyes értékeket átmásolni. Azokon valamilyen ciklus szervező utasítás segítségével elemről elemre végig kell menni, és egyenként az egyes elemeknek értékeket kell adni. Tehát itt nem működik az a megoldás, ami például C++ban a string típusú változókra igen, hogy a karakterek egy sorozata egyetlen értékadással a string teljes tartalma átadható egy másik stringnek. 9

VI.2. SystemC környezetben használható C/C++ típusok A következő táblázatban látható adattípusok mindegyike használható változók, portok és jelek deklarálására. 10

típus neve A típus rövid leírása bool Egyetlen bit, értéke lehet true, vagy false int Előjeles egész (32/16 bites oper. rendszerfüggő) unsigned int Előjelnélküli egész (32/16 bites oper. rendszerfüggő) long Előjeles egész (32 bites) unsigned long Előjelnélküli egész (32 bites) signed char Előjeles egész (8 bites ) unsigned char Előjelnélküli egész (8 bites ) short Előjeles egész (16 bites oper. rendszerfüggő) unsigned short Előjelnélküli egész (16 bites oper. rendszerfüggő) enum Felsorolási típus a felhasználó által definiált halmazra 11

VI.3. SystemC specifikus típusok A következő táblázatban látható adattípusok mindegyike használható változók, portok és jelek deklarálására. 12

típus neve A típus rövid leírása sc_bit Egyetlen bit két értékkel 1 és 0 sc_bv<n> Tetszőleges szélességű n darab bitből álló tömb sc_logic Egyetlen bit négyértékű logikara 0, 1, X, Z sc_lv<n> Tetszőleges szélességű n elemű logikai tömb (vektor) sc_int<n> Előjeles egész, a mérete 1-től 64 bitig param. sc_uint<n> Előjelnélküli egész, a mérete 1-től 64 bitig param. sc_bigint<n> Tetszőleges méretű (bitek száma) előjeles egész sc_biguint<n> Tetszőleges méretű (bitek száma) előjelnélküli egész 13

Bit típus Az egyszerű bit típus deklarációját az sc_bit kulcsszóval lehet végrehajtani. Az sc_bit típusú lehet változó, port vagy jel. Az értéke 0 és 1 ahol a 0 jelenti egyben a logikai hamis, az 1 a logikai igaz értéket. Az sc_bit típusú operandusok (változó, port, jel) szabadon keverhetőek a különböző műveletekben a C++ logikai (bool) típusú operandusaival. Az alábbiakban egy példát láthatunk erre. 14

sc_out<bool> egyes_lab; // Egy logikai típusú kimeneti portot deklarál. sc_bit kapcsolo; // Egy sc_bit típusú változót deklarál. egyes_lab=1; // Értékadás a kimeneti portra kapcsolo=sc_bit( 0 ); // Értékadás ilyen formátumú is lehet. egyes_lab= egyes_lab & kapcsolo; // A művelet érvényes és végrehajtódik if(egyes_lab!= kapcsolo) // Ez az összehasonlító művelet is működik. 15

Tetszőleges méretű bit típus Tetszőleges hosszúságú bitvektorokat hozhatunk létre az sc_bv azonosító segítségével, ahol a bitvektor egyes elemeinek értéke 0 és 1 lehet. Ez azt is jelenti, hogy az sc_bv-vel létrehozott bittömb (vektor), az sc_bit típusú elemek egy tömbjének is tekinthető egyben. A tömb hosszát a típusazonosító után kell megadni a < > jelek között. A tömb jobboldalról kezdődő első elemének indexe 0 és egyben ez a bit a helyérték sorrendben is a legalacsonyabb helyen szerepel, azaz például ezt kell a 0 pozíciónak tekinteni. Az n-edik bit pedig az n-1-edik helyen található. Az általános szintaktikai szerkezet és néhány példa látható az alábbiakban. 16

Általános szintaktikai szerkezet sc_bv<elemek_szama> bit_tomb; Példák sc_bv<16> szo; sc_in<sc_bv<8> > input_port; 17

Az első utasítás egy 16 bites szo elnevezésű bitvektort deklarál, amelynek indexe 0-tól 15-ig terjed, ahol a szo[0] a legalacsonyabb helyértékű bit. A második utasítás egy input_port nevű bemeneti portot deklarál, amelynek 8 bemenete lehet ebben a példában. Amikor portokat vagy jeleket használunk tetszőleges szélességű típusokkal, nem szabad elfelejteni egy járulékos szóközt kitenni a szélességet lezáró jel > és a port vagy jel szintaktikus formáját lezáró > jel közé, azaz 8>> nem helyes alak szintaktikai szempontból, hanem a következő alak a megfelelő 8> >. 18

A bitvektorok az értékadások során kezelhetőek, mint közönséges string konstansok, amellyel megkönnyítik az értékadást egy-egy bitvektornak, azaz nem szükséges nekünk saját kezűleg egy for ciklussal például a kezdeti értékek beállítását leprogramozni, vagy egyesével, értékadó utasításokkal az egyes elemeket elérve értéket adni a bitvektor elemeinek, hanem egyetlen utasítással az megtehető. 19

Nyilvánvalóan az egyenlőségjel operátor túlterhelésével oldják meg ezt a problémát. A bitet vagy bitek sorozatát idézőjelek között kell megadni, mint például 11001100. Példák bitvektorok értékadására. szo= 1100111011000011 ; input_port= 10101010 ; 20

Ha az értékadás során a karakter konstansként megadott bitsorozat értéke (a bitek száma) nem egyezik meg a bitvektor előre definiált méretével, akkor attól függően, hogy több vagy kevesebb a megadott bitek száma a felsőhelyértékeken nullákkal egészíti, ki a megadott bitsorozatot vagy lecsonkolja azt. Az alábbiakban erre is látható egy példa. szo= 11001110 ; Ennek az utasításnak az eredményeként a 16 bit hosszúságú bitvektor felső nyolc bitjén nulla fog állni, azaz szo= 0000000011001110 21

Művelet jele Rövid leírása Az operátor használata & Bitenkénti és kifejezés1 & kifejezés2 Bitenkénti vagy kifejezés1 kifejezés2 ^ Bitenkénti kizáróvagy ~ Bitenkénti negálás ~ kifejezés << Bitenkénti eltolás balra >> Bitenkénti eltolás jobbra kifejezés1 ^ kifejezés2 kifejezés << konstans kifejezés >> konstans 22

Művelet jele Rövid leírása Az op. használata = Értékadó egyenlőség bitvektor = kifejezés == Egyenlőséget tesztelő egyenlőség!= Nem egyenlőséget tesztelő logikai op. [] Tetszőleges indexű elem kiválasztása (,) Bitsorozatok összefűzése kifejezés1 == kifejezés2 kifejezés1!= kifejezés2 bitvektor[index] (kif1, kif2,..., kifn) 23

A táblázatban felsorolt operátorok közül az összefűzési operátort érdemes külön kiemelni, mivel a többi használata a C/C++ nyelvekből már ismert kell legyen. Fontos megjegyezni viszont, hogy a bitkiválasztó operátor [] portokra és jelekre nem alkalmazható művelet. sc_bv<8> byte; sc_bv<4> fel_byte; byte= 11001110 ; fel_byte=( byte[6], byte[4], byte[2], byte[0]); cout << Az összefűzés műveletének eredménye: << fel_byte << endl; 24

Az első két utasítás sorban egy 8 és egy 4 bites bittömböt hozunk létre, majd a harmadik sorban a byte bittömb egyes elemei értékeket kapnak. A negyedik programsor mutatja be a bitkiválasztó és az összefűző (konkatenáló) műveleteket, aminek eredménye fel_byte= 1010. A bitvektorok tartalma a cout függvény segítségével a képernyőn megjeleníthetőek, amelyre példát a fenti kódrészlet utolsó sorában lát az olvasó, ahol a fel_byte bitvektor tartalmát íratjuk ki a képernyőre. 25

Metódus neve range() and_reduce() or_reduce() xor_reduce() A metódus funkciója A metódus használata Bitsorozat kiválasztása valtozo.range (index_tol, index_ig) 26

A range() metódus segítségével egy bitvektor elemeit tudjuk elérni egy megadott elemtől kezdődően egy második megadott elemig. A range() függvény paraméterként két egész számot vár, amelyek érvényes indexei a valtozo nevű bitvektornak. Nem szükségszerű, hogy az első index kisebb kell legyen mint a második, azaz lehet használni egyrészt a megszokottabb alakban például valtozo.range(2,5) vagy ilyen formában is valtozo.range(6,3), a range() függvényt. 27

sc_bv<8> byte; byte= 10001110 ; byte.range(4,7)=byte.range(3,0); cout << A művelet eredménye : endl; cout << byte= << byte << endl; byte= 10001110 ; byte.range(4,7)=byte.range(0,3); cout << A művelet eredménye : endl; cout << byte= << byte << endl; 28

A minta program harmadik sorában látható a range() függvény alkalmazása a byte nevű bitvektoron, ahol az alsó négy helyértékű bit kerül átmásolásra a felső négy helyérték pozícióba. A másolás egészen pontosan úgy zajlik, hogy a 4. bit helyére a 3. bit értéke a 5. bit helyére a 2. bit, a 6. bit helyére az 1. bit és a 7. bit helyére a 0. bit értéke másolódik. Tehát a cout művelet hatására a következő bitsorozat jelenik meg a képernyőn: byte=01111110. Azaz mint egy tükröztük az alsó négy bitet a felső négybites helyérték pozíciókra. 29

A következő esetben, ami a programrészlet 7. sorában látható, a range() függvény alkalmazása teljesen más eredményre vezet, mivel ebben az esetben a 4. bit helyére a 0. bit értéke az 5. bit helyére az 1. bit, a 6. bit helyére a 2. bit és a 7. bit helyére a 3. bit értéke másolódik, valamint a következő bitsorozat jelenik meg a képernyőn: byte=11101110. 30

Amint az röviden már az előzőekben megemlítésre került, a bitkiválasztó művelet és a range() metódus nem alkalmazható portokra és jelekre, felmerül a kérdés, hogy akkor mégis miként lehetne ezeket a hatékony eszközöket a portok és jelek vektoraira (tömbjeire) alkalmazni. A probléma megoldása különféle segédváltozók bevezetése. Az alábbiakban erre láthatunk pár programsort. 31

sc_signal<sc_bv<8> > jelek; sc_in<sc_bv<4> > portok; sc_bv<8> jel_valtozo; sc_bv<4> port_valtozo; port_valtozo= portok.read(); cout << A második bit a bemeneti porton: << port_valtozo[1] << endl; jel_valtozo = 00000000 ; jel_valtozo.range(0,3)= 1011 ; jelek= jel_valtozo; cout << A jelek: << jel_valtozo <<endl; 32

Logikai típus A SystemC-ben definiált logikai típus alapvetően tér el a C ++ fejlesztőrendszerben megszokott logikai típustól, mivel a SystemC logikai típusa négyértékű és nem a megszokott kétértékű logikai típus. A típus azonosító neve sc_logic. A logikai típus az alábbi négy különböző értéket veheti fel: 33

0, SC_LOGIC_0: false azaz hamis 1, SC_LOGIC_1: true azaz igaz X, x, SC_LOGIC_X: unknown azaz ismeretlen, nem meghatározott érték Z, z, SC_LOGIC_Z: high-impedance 34

A bitenkénti logikai és művelet igazságtáblája, négyértékű logikai értékek esetén. & (and) 0 1 X Z 0 0 0 0 0 1 0 1 X X X 0 X X X Z 0 X X X 35

Tetszőleges méretű/hosszúságú logikai típus Tetszőleges hosszúságú négyértékű logikát használó logikai vektorok deklarálhatóak az sc_lv <elemszam> típus azonosító segítségével. A logikai bitek értékei, itt is négy különböző értéket vehetnek fel, amelyek a 0, 1, X, Z. 36

Általános szintaktikai szerkezet sc_lv<elemek_szama> logikai_vektor; Példák sc_lv<16> adatok; sc_in<sc_lv<8> > input_port; Az első deklaráció létrehoz egy 16 elemű logikai vektort, amelynek első eleme adatok[0] szintén a legalsó helyértékű bitpozíciónak tekinthető. A második deklaráció egy 8 elemű bementi portot határoz meg. Fontos megjegyezni itt is a szóköz karaktert a két > > zárótag között. 37

Előjeles egész típus Az előjeles egész típusú változókat, portokat, jeleket az sc_int típus azonosító segítségével hozhatunk létre. Az sc_int típusnak a maximális számábrázolási tartománya 64 bit. A típus számábrázolási tartománya tetszőlegesen, direkt módon megadható. A típus által ábrázolt bináris számot kettes komplemenses szám alakjában tárolják, mint az a C/C++ nyelvekben is szokványos. Egy sc_int típusú változó, port, jel deklarációja során meg kell adni, hogy hány darab bitből álljon az. Ha a bitek száma n akkor a legfelső helyértékű bit az n-1-es pozíción az előjel bit. 38

Az aritmetikai műveletek minden esetben 64 biten kerülnek végrehajtásra függetlenül attól, hogy az adott műveletben szereplő változók, portok, jelek mekkora számábrázolási tartománnyal kerültek deklarálásra. Tehát megállapítható, azaz általános érvényű állítás a SystemC-beli egész típusok kapcsán, hogy az egész típusok számábrázolási tartomány nem kötött mint az a szokványos program nyelvekben (C, C++, Pascal, Basic,...) megszokott, hanem előre definiálható egy rögzített értéktartományon belül, itt például 1-64 bitig. 39

Az sc_int típuson számos olyan művelet van definiálva, ami a szokványos szoftver fejlesztő nyelvekben használt integer típusok esetén nem működik. Ilyen például az index operátor [], aminek segítségével az előjeles egész típusú változó tetszőleges bitje elérhető. Ezen felül a range() metódus tetszőleges számú bit tartomány elérésére az sc_int típus esetében is használható. Használható továbbá az összefűzési (konkatenálás) operátor () tetszőlegesen választott bitsorozatok összefűzésére. Az alábbiakban számos példa látható a típus deklarálására és annak használatára, különböző körülmények között. 40

Rövid áttekintésként a bináris számok kettes komplemenses alakját az a változó értékének (-72) esetére részletesen ismertetjük. Lényegében egyetlen fontos dolgot kell ismerni, még pedig azt, hogy a kettes komplemenses alakú bináris számok legfelső helyértéke mindig negatív súllyal szerepel a bináris szám numerikus értékének meghatározásában. 1 0 1 1 1 0 0 0-2 7 2 6 2 5 2 4 2 3 2 2 2 1 2 0 41

sc_int<8> a, b; sc_int<16> c; c=-18; // c=-18 d =1111 1111 1110 1110 b a = c << 2; // a=1011 1000b =-72 d Az első két utasítás sorban három darab változót hozunk létre, az első kettő 8 bites a harmadik, pedig 16 bites. A harmadik sorban egy szokványos értékadás látható a 16 bites változónak c, amelynek bináris értéke megjegyzésben az utasítás mellett látható. A változó numerikus értékét -18d bináris kettes komplemenses alakban kell értelmezni. 42

A negyedik sorban a bal oldali irányú eltolás (shift) operátor << alkalmazására látható egy példa, valamint arra is, hogy miként értelmezi a SystemC azt a körülményt, ha egy nagyobb számábrázolású változó tartalmát adjuk át egy kisebb számábrázolási tartományú változónak. A shift operátor hatására két bittel baloldali irányba tolódik minden bit a 16 bites c változóban. A két jobb oldalon üresen maradt helyre nulla értékek íródnak. 43

Mivel a balérték, azaz a nevű változó 8 bites, a kifejezés jobb oldalán, pedig egy 16 bites változó áll, ezért egy vágásra is sor kerül, még pedig olyan módon, hogy a legalsó helyértékű bitektől kiindulva tartja meg az értékadás a biteket, azaz most a felső nyolc bit értéke nem kerül/ kerülhet át az a nevű változóba. 44

a=12; b=-5; // a=12 d = 0000 1100 b // b=-5 d = 1111 1011 b b= a ^ b // b= 1111 0111 b =-9 d A következő három sorban egy bitenkénti kizáró-vagy művelet látható a két 8 bites változón. Az eredményt a b nevű változó tartalmazza. 45

c=300; // c=300 d =0000 0001 0010 1100 b a=c.range(7,0); // a=12 d = 0010 1100 b b=c.range(15,8); // b=1 d = 0000 0001 b a=0; a.range(3,0)=(c[8],c[5],c.range(3,2)); // a=15 d = 0000 1111 b 46

Az ezután következő három sorban a range() metódus használatára lehet látni egy példát. A példában a 16 bites változó c alsó 8 bitje az a nevű, a felső 8 bitje, pedig a b nevű változóba kerül. Az utolsó példa, pedig az összefűző operátor használatára mutat be egy példát. 47

VI.4. Portok és jelek írása, olvasása Az eddigi példákban a jelek és a portok értékeit közvetlenül a port vagy a jel nevére való hivatkozással lehetett elérni, azaz adtunk neki, vagy kaptunk tőle értéket. Vannak esetek, amikor ez nem működik, például akkor, amikor az egyik port a másiknak értéket kíván átadni és a portok típusai, eltérnek egymástól. A C/C++ban megismert implicit típus konverzió itt nem működik. Ebben az esetben a portok és jelek read() és a write() metódusaival lehet értéket adni (írni) és kapni (olvasni) az egyes portokról és jelekről. 48