IV. A SystemC alapelemei Ennek a bevezető előadásnak a célja, hogy röviden és mindenekelőtt érthetően bemutassa a SystemC alkalmazását elektronikai eszközök tervezésére. Részletesen ismertetésre kerül egy modul szerkezetének felépítése, hogyan tudunk portokat deklarálni, és miként tudjuk egy modul viselkedését leírni. 1
A modellfejlesztés alapjainak bemutatására két egyszerű példa program kerül részletesen ismertetésre, az első a mára már szinte klasszikussá vált Hello World program, a másik, pedig egy félösszeadó digitális áramkör felépítése és tesztelése SystemC környezetben. 2
IV.1. Modulok felépítése SystemC fejlesztői környezetben A modulok képezik az alapvető építőköveit egy a SystemC fejlesztőrendszerben kidolgozott elektronikai eszköznek. A modul ismertetése mellett szükség van a folyamat (process) fogalmának tisztázására is. A folyamatok feladata, hogy a tervezett elektronikai eszköz funkcionalitásait definiálja, valamint a rendszer párhuzamos (konkurens) működését is lehetővé tegye. Objektum orientált programfejlesztői szempontból a folyamat egy metódusnak (member function, tagfüggvény) felel meg a C++ nyelvben. 3
A folyamatok közötti kommunikáció megvalósítására szolgálnak a jelek (signals). Minden egyes folyamat reagálhat a jelek és a jeleken keresztül kapcsolt portok valamely előre megadott részére, de nem szükségképpen mindegyikre. Egy úgynevezett érzékenységi listát (sensitivity list) hozhatunk létre, amelyen keresztül a jeleken és a portokon létrejövő változásokra reagálhatnak az egyes a modulban definiált folyamatok. A modulok másik fontos tulajdonsága, hogy hierarchikus szerkezeti felépítést is lehetővé tesznek azáltal, hogy egy modulon belül egy másik modul is példányosítható (instantiated). 4
#include systemc.h SC_MODULE (uzenetkiiro) { SC_CTOR(uzenetkiiro) { } void kiir(); IV.2. Első példa }; void uzenetkiiro::kiir() { cout << Hello World! << endl; } 5
Az üzenet kiírás céljára írt program első sora egy #include direktívát tartalmaz, ami a systemc.h fejléc állomány használatát teszi lehetővé. Erre minden SystemC-ben írt programnak szüksége van. Ez teszi lehetővé, hogy a SystemC osztály könyvtárait C++ fejlesztői környezetben elérjük és használhassuk. Az SC_MODULE kulcsszó segítségével lehet egy SystemC modult deklarálni. A modul neve az SC_MODULE kulcsszó után zárójelek között kerül megadásra. 6
SC_MODULE(a_modul_neve), ebben a konkrét esetben ez a SC_MODULE (uzenetkiiro) deklarációs rész adja meg. Az SC_MODULE a valóságban egy C++ makró, ami egy modul osztály deklarációját indítja el. Az SC_MODULE nevét a továbbiakban úgy kell használnunk, mint a C++ nyelvben megszokott osztálynevek azonosítóit. Azaz amikor példányosítani kell egy-egy modult, akkor azt az itt megadott modul névvel lehet megtenni. A modulhoz tartozó konstruktorokat, folyamatokat és egyéb metódusokat a továbbiakban {} zárójel párok között kell megadni. 7
A program következő sorában látható egy SC_CTOR blokk, amivel egy konstruktort tudunk létrehozni, ebben az esetben erre nincsen szükségünk, de ez a rész általában elengedhetetlen rész egy-egy SystemC-ben írt digitális áramköri modellnek. 8
A következő sorban egy a modulhoz tartozó metódust (tagfüggvény, member function) hozunk létre, aminek a neve kiir(). Ez a C++ nyelvben megszokott public hatókörű az adott modulhoz (osztály) tartozó függvény, amit a C++-ban megszokott szintaktikai szerkezetben lehet használni. Ebben a sorban csak a függvény deklarációja látható, magát a függvényt a modulon kívül definiáljuk. A modul kapcsos be zárójele után egy pontosvesszővel záródik. 9
A modul deklarációja után kerül megadásra a kiir nevű metódus, aminek implementációját a C++-ból megszokott szintaktikai szerkezetben kell elvégezni. A metódus most csak egyetlen utasítás sort tartalmaz, ami a képernyőn megjeleníti a Hello World szavakat. A cout függvény a megszokott módon használható SystemC kódok fejlesztése során. 10
Ahhoz hogy a SystemC-ben kidolgozott modell tesztelhető legyen, egy futtató környezetet kell kidolgozni, amiben az előzőekben írt modulok viselkedése minden szempontból vizsgálható. Ez szintaktikai szempontból szintén teljes mértékben megegyezik a C++-ban megismert kódfejlesztéssel, mivel itt is van egy main függvény, ami a belépési pontja a SystemC-ben megírt programnak. Az eltérés mindössze annyi, hogy ezt a függvényt sc_main-nek nevezik, de a függvény argumentumainak struktúrája, azonos a C/C++-beli main függvénnyel. 11
int sc_main(int argc, char *argv[]) { int ch; uzenetkiiro msg( udvozlet ); msg.kiir(); cout << Nyomja meg a q/q billentyűt és azután az Enter-t: ; cin >> ch; return 0; } 12
Az sc_main első sorában egy integer típusú változót definiálunk, aminek célja az, hogy a program futásának befejezése után mielőtt a program végleg befejeződne, még várakozzon egy billentyűzetről érkező nyugtázásra. A következő sorban hajtódik végre az előzőekben deklarált uzenetkiiro modul, a C++ szemszögéből nézve egy osztály példányosítása. Az SC_MODULE kulcsszó után megadott nevet használjuk fel az adott modul példányosítására. A modul neve az angol message szó után msg lesz. 13
A következő sorban kerül meghívásra az msg objektum kiir metódusa, ami megjeleníti a szöveget a képernyőn. 14
15
IV.3. Második példa Félösszeadó digitális áramkör Ha két 1 bites bináris számot szeretnénk összeadni, akkor az összeadásnak négyféle (két elem ismétléses variációja) lehetséges változata van, amit az alábbi logikai táblázat foglal össze. Az első három variációt nem szükséges megmagyarázni, mivel triviálisan következik a hétköznapi összegzés alapján is. De a negyedik eset már nem szükségszerűen nyilvánvaló, valamint itt kell alkalmazni az átviteli bitet is. 16
A legérthetőbb módon a tízes számrendszerrel tudjuk összehasonlítani. Vegyük a következő példát a tízes számrendszerben, össze szeretnénk adni két egyjegyű számot, és hogy a példa minél inkább hasonlítson a kettes számrendszerbeli összegzéshez, legyen ez a két szám az ötös. Ha összeadjuk a két ötöst, akkor az eredmény nulla lesz, valamint keletkezik a következő helyértéken egy átvitel (carry), amit a digitális elektronikában a carry bit segítségével valósítanak meg. 17
átvitel (c) ö s s z e g (s) A fentiek analógiájára kettes számrendszerben két egyjegyű bináris szám összeadási műveletének logikai táblázata az alábbiakban látható. 5 5 + 1 0 = x y s c 0 0 0 0 0 1 1 0 1 0 1 0 1 1 0 1 xor and 18
Figyelmesen megvizsgálva a félösszeadó logikai táblázatát a következő megállapítások tehetőek, amelyek felhasználásával megépíthető az a digitális áramkör, ami az összeadás műveletét végrehajtja. Az összeadás eredménye az összegre (s) egy kizáró-vagy (XOR) művelet, az átviteli bit (c) értékére, pedig egy és (AND) művelet. Ebből az észrevételből már felépíthető egy logikai áramkör, ami képes két egyjegyű bináris szám (félösszeadó) helyes összegzésére. 19
x and c y xor s A következő ábra a félösszeadó logikai áramkört mutatja, a megvalósításhoz felhasznált logikai műveletekkel és a közöttük lévő kapcsolatokkal. Az ábrán a bementi portokat x, y-al, a kimeneti portokat pedig s, c-vel jelöltük. 20
Még magyarázatra szorul, hogy miért is félösszeadó ez a logikai áramkör. Ennek oka abban rejlik, hogy ez a logikai szerkezet még nem képes kezelni azt az esetet, ha nem egyjegyű, hanem több jegyű számokat szeretnénk összeadni. Ez olyan módon valósítható meg, hogy nem két bemenete van (x, y) az áramkörnek, hanem három, ami tartalmazza az előző helyértékből következő átvitel értékét is. Ezt a három bemeneti logikai értéket (x, y, cin) kezelő bemenettel rendelkező összeadó áramkört nevezik teljes összeadó (full adder) áramkörnek. 21
#include systemc.h SC_MODULE (felosszeado) { sc_out<bool> osszeg,atvitel; sc_in<bool> be_jel_1,be_jel_2; void felosszeado_fv(); // Ez itt egy folyamat, a C++ terminológia szerint egy metódus lesz. 22
Az SC_MODULE kulcsszó után zárójelek között került megadásra a modul neve felosszeado. A felosszeado modul rendelkezik két bemeneti és két kimeneti porttal, amelyek deklarációja a harmadik és a negyedik sorban látható a minta programban. A bemeneti portokat be_jel_1-el és be_jel_2-vel azonosítottuk. A portokat logikai típusúnak (bool) deklaráljuk, amit megkönnyít az is, hogy a bool szabványos C++ típus. A modul ezenfelül rendelkezik két kimeneti porttal is, amelyek az összegzés eredményét osszeg és az átvitelt atvitel tartalmazza. 23
A program ötödik sora egy folyamatot leíró függvény (metódus) deklarációjával folytatódik, void felosszeado_fv(). A folyamat (metódus, tagfüggvény) definíciója az SC_MODULE blokkja után kerül implementálásra. Látható, hogy ez a folyamat (metódus) semmit nem vesz át a külvilágtól (üres paraméter lista a folyamat név után) és semmit sem ad (void) annak vissza. Azért használható egyelőre szisztematikusan a metódus elnevezés, mivel itt még nem tudja a fordító, hogy ez majd egy folyamattá válik a későbbiekben, a további deklarációk révén a SC_CTOR blokk belsejében. Jelen állapotában a felosszeado_fv() egy közönséges C++ metódus. 24
SC_CTOR(felosszeado) { SC_METHOD (felosszeado_fv); sensitive << be_jel_1 << be_jel_2; } }; void felosszeado::felosszeado_fv() { osszeg= be_jel_1 ^ be_jel_2; atvitel = be_jel_1 & be_jel_2; } 25
A program hatodik sorában látható SC_CTOR blokk, a konstruktor szerepét tölti be a SystemC-ben a C++ terminológia szerint. Maga az SC_CTOR is egy makró, amelynek szerepe, hogy a modulban használt folyamatokat deklaráljuk, és azt is, hogy milyen folyamatként deklaráljuk, mivel a folyamatot kétféle módon SC_METHOD és SC_THREAD típusú folyamatként is lehet deklarálni. A félösszeadó áramkörben az SC_METHOD-ra láthatunk egy példát. 26
Az SC_CTOR zárójelei között megadott névnek azonosnak kell lennie, a modul nevével, azaz azzal, amit az SC_MODULE( Amit ide írtunk! ) zárójelei közé írtunk. Fontos megjegyezni, hogy az SC_METHOD által deklarált folyamatok működése a wait metódussal nem állítható meg, mivel ennek a függvénynek a használata nem engedélyezett az SC_METHOD blokkban. 27
Az SC_METHOD után zárójelek között meg kell adni a program ötödik sorában deklarált metódus nevét. Ezzel a lépéssel most már void felosszeado_fv() nem csak, mint egy szokványos C++ metódusként létezik a fordító számára, hanem a SystemC rendszerben definiált folyamattá válik. 28
Az SC_METHOD-al deklarált folyamathoz meg kell adni, mely jelek és portok kapcsolódnak a folyamathoz, illetve mely portokon létrejövő változásokra legyen érzékeny (sensitive) az adott folyamat. Ezt az érzékenységi lista (sensitivity list) segítségével lehet megadni. Erre a célra a sensitive kulcsszót használhatjuk, amely után zárójelben megadva fel kell sorolni azokat a portokat ebben az esetben be_jel_1, be_jel_2, amelyek az aktuálisan deklarált folyamat működését befolyásolják. A másik lehetőség az érzékenységi lista megadására a következő szintaktikai szerkezettel lehetséges sensitive << be_jel_1 << be_jel_2; 29
Ez a digitális áramkör működésének szempontjából azt jelenti, hogy amikor bármilyen változás is áll be a két port (x, y) valamelyikén vagy mind kettőn, akkor a felosszeado_fv() folyamat végrehajtásra kerül, mind azokkal az utasításokkal és műveletekkel, amelyekkel definiálásra került (11-14-es sorok a példa programban). A folyamat végrehajtása után, pedig várakozási állapotba kerül, mind addig, amíg újabb esemény, változás nem következik be a hozzá tartozó érzékenységi listában megadott portokon. Ez az utasítás a fenti példa program nyolcadik sorában látható. 30
Fontos megjegyezni, hogy a SC_CTOR blokk bezáró zárójele } után nem kell pontosvesszőt tenni, mivel SC_CTOR-hoz tartozó kódsorok már közvetlenül a konstruktor definíciója és nem deklarációja. Az SC_MODULE blokk bezáró zárójele } után viszont pontosvesszőt kell tenni, mivel SC_MODULE-hoz tartozó kódsorok csak a modul deklarációját tartalmazzák és nem a definícióját, vagy annak példányosítását. 31
A példa program 11-es sorától kezdődően kerül részletesen megadásra (definiálásra) az előzőek során deklarált felosszeado_fv() nevű folyamat. A 12-ik és 13-ik sor tartalmazza azokat a logikai műveleteket, amelyek segítségével a két kimeneti port logikai értéke meghatározásra kerül. A példa programban használt logikai műveletek (and, xor) teljes egészében a szabványos C/C++ nyelvekben definiált logikai operátorokkal egyezik meg, tehát ez sem SystemC specifikus eszköz, hanem a korábban már megismert C/C++ programozási nyelvekben használt operátorok. 32
IV.4. A SystemC-ben kidolgozott digitális áramköri modell működésének, funkcionalitásának tesztelése, vizsgálata A félösszeadó áramkörre az előzőekben megírt modell tesztelését végezzük el. A feladat megvizsgálni a félösszeadó áramkör válaszát a bemeneti paraméterek összes lehetséges variációjára. Minden egyes bemeneti adat kombináció 5 nano szekundumos késleltetéssel lesz a félösszeadó áramkör bementi portjaira küldve, aminek hatására a félösszeadó áramkör kimeneti értékei a képernyőn megjelenítésre kerülnek. 33
Első lépésben egy tesztkörnyezetet kell felépítenünk, ami tartalmazza, egyrészről a bementi adatok generálására szolgáló kódot, valamint a képernyőn való megjelenítésre szolgáló metódust is el kell készítenünk. Az alábbiakban az erre a célra szolgáló deklarációkat egy teszt.h nevű fejléc állományban helyezzük el, valamint a felösszeadó áramkörre kidolgozott modul is ebben a fejléc állományban kerül elhelyezésre. Nagyobb méretű programok esetén praktikusabb a tesztelendő modulokat és a tesztkörnyezethez tartozó modulokat külön választani és külön-külön fejléc állományokban elhelyezni a rájuk vonatkozó deklarációkat. 34
A teszt.h állomány. #include systemc.h SC_MODULE (jel_gen) { sc_out<bool> gen_x, gen_y; void signal_gen(); SC_CTOR(jel_gen) { SC_THREAD (signal_gen); } }; 35
Az első modul a bemeneti jeleket generáló modul, amelynek két kimeneti (output) portja van, bementi porttal pedig nem rendelkezik. A jelgeneráló modul SC_CTOR blokkja tartalmaz egy SC_THREAD típusú folyamatot, amely működésének szempontjából alapvetően tér el az SC_METHOD típusú folyamatoktól. Egy SC_THREAD folyamatnak meg van az a képessége, hogy az ilyen módon deklarált folyamatok a működésüket/futásukat egy meghatározott időre felfüggesszék. A futási folyamat megállítására a wait függvény szolgál. A wait függvény egy előre meghatározott ideig felfüggesztheti az adott SC_THREAD típusú folyamat működését, vagy arra is van lehetőség, hogy a wait függvény egy adott esemény bekövetkeztekor függessze fel a folyamat működését. 36
SC_MODULE (kiir) { sc_in<bool> a, b, s, c; void kiir_kepernyore(); SC_CTOR(kiir) { SC_METHOD (kiir_kepernyore); sensitive << a << b << s << c; } }; 37
A következő modul a kiir, amelynek négy kimeneti portja van, amelyek logikai (bool) típusúak. A modul egy kiir_kepernyore() nevű metódust deklarál, amit aztán az SC_CTOR blokkban az SC_METHOD segítségével folyamatként deklarálunk tovább, amely folyamat a négy (a, b, s, c) bemeneti portra lesz érzékeny (sensitive). Azaz bármelyik porton változás következik be akkor a kiir_kepernyore() nevű folyamat meghívódik és a folyamat utasításai végrehajtódnak. 38
SC_MODULE (felosszeado) { sc_out<bool> osszeg, atvitel; sc_in<bool> x, y; void felosszeado_fv(); SC_CTOR(felosszeado) { SC_METHOD (felosszeado_fv); sensitive << x << y; } }; A teszt.h állomány tartalmának vége. 39
#include teszt.h void jel_gen::signal_gen() { sc_uint<2> bitminta; bitminta=0; while(1) { gen_x=bitminta[0]; gen_y=bitminta[1]; wait(5,sc_ns); bitminta++; } } A teszt.cpp állomány. 40
Az első metódus a jel_gen modulhoz tartozó signal_gen() folyamat. A jelgeneráló modul signal_gen() folyamata egy bitminta nevezetű 2 bites előjelnélküli egész számokat tároló, sc_uint típusú változót definiál. A gyakorlott programozók számára első látásra szokatlan lehet, hogy egy előre definiált típus méretét, mint például ebben az esetben sc_uint megtudjuk adni. De éppen ezek azok a lehetőségek, amelyek a SystemC-t alkalmassá teszik digitális áramköri modellek gyors és egyszerű kidolgozására és azok tesztelésére. A bitminta nevezetű változó deklarációja után a változó értékét nullára állítjuk, azaz minden egyes bitjének értéke zérus lesz. 41
Mindezek után, egy while ciklus segítségével, egyesével generáljuk a bemeneti bit variációkat, ami esetünkben négy különböző állapotot jelent. Az egyes bementi bit variációk előállítása a bitminta nevű változó értékének növelésével bitminta++ állítható elő. A bitminta nevű változó értékadással szembeni viselkedése a megszokott módon zajlik le, azaz azonnal átveszi az inkrementáló operátor hatására megnövelt értéket. Azaz a deltakésleltetés (delta delay) a közönséges változókra nem érvényes, mint az a portok és jelek esetén fenn áll. 42
A bitminta nevű változó egyes bitjeit az index operátor [] segítségével, egyesével eltudjuk érni, ami szintén szokatlan egy a C/C++ környezetet már alaposan ismerő programozónak, de rendkívül hasznos lehetőség egy SystemC-ben fejlesztő programozó számára. Például a bitminta[0] a nulladik azaz a legalsó helyértékű bitje az előjelnélküli egész számnak. A while ciklus belsejében látható első két értékadó utasítás a gen_x és a gen_y kimeneti portokhoz rendeli hozzá a bitminta nevű változó nulladik és első bitjét, a gen_x-hez a nulladikat a gen_y-hoz az első bitet. 43
A következő utasítás a wait, ami ebben az esetben felfüggeszti a folyamat futását 5 nano szekundumos időre. Az SC_NS az időegységet határozza meg. Azaz a wait egyik lehetséges használatának általános szintaktikai szerkezete. wait(időegységek_száma, időegység_dimenziója); 44
void kiir::kiir_kepernyore() { cout << Időlépés: << sc_time_stamp() << a bemeneti paraméterek: x= ; cout << a << y= << b << endl; cout << a kimeneti eredmények: osszeg= ; cout << s << atvitel= << c<< endl << endl; } void felosszeado::felosszeado_fv() { osszeg= x ^ y; atvitel = x & y; } 45
int sc_main(int argc, char *argv[]) { int ch; sc_signal<bool> x1, x2, sum, carry; felosszeado f( fel_ossz ); f.x(x1); f.y(x2); f.osszeg(sum); f.atvitel(carry); jel_gen jel( Input_Signal ); jel << x1 << x2; 46
A modell funkcionalitását tesztelő kódsorok az sc_main() függvényen belül kerültek megadásra. Négy darab jelet definiálunk az sc_signal kulcsszóval, amelyek logikai típusúak bool. A következő sorban kerül példányosításra a félösszeadó áramkör modellje, a létrejött objektum azonosítója f. A következő sorban négy az előzőekben definiált jel (x1, x2, sum, carry) kerül összerendelésre nevesített hivatkozás útján (named association) az f objektum egyes lokális változóival. 47
A félösszeadó áramkört leképező modult tesztelő jelet a jel_gen modul példányosításával hozzuk létre, amelynek a neve jel. A jel nevű objektum (modul) két kimeneti portját, pozícionális hivatkozással (positional association) kapcsoljuk össze a félösszeadó modul bementi portjaival az (x1, x2) jeleken (signal) keresztül. 48
} kiir res( result ); res << x1 << x2 << sum << carry; sc_start(20,sc_ns); cout << endl << endl; cout << Nyomjon le egy tetszőleges karaktert majd, Entert! ; cin >> ch; return 0; 49
A harmadikként létrehozott objektum neve res, a feladata, pedig a képernyőn megjeleníteni a teszt adatokat. Esetünkben a teszt adatok a két bemeneti és a másik két kimeneti port értékeinek változása a szimuláció időbeli előrehaladása folyamán. A res nevű objektum SC_METHOD típusú kiir_kepernyore() nevű folyamata, 5 nano szekundumos időközönként a modul valamelyik bemeneti jele változásának hatására hajtódik végre és kiírja a be és kimeneti portok aktuális értékeit. 50
A szimulációt 20 ns hosszúságú időtartamon keresztül hajtjuk végre, amit az sc_start() metódus segítségével valósítunk meg. Az sc_start() metódus első paramétere az időegységek száma, a második paramétere, pedig az alapértelmezett időegység, ebben az esetben nano szekundum. 51
52