HIERARCHIKUS RENDSZER-SZINTŰ SZINTÉZIS

Átírás

1 Budapesti Műszaki és azdaságtudományi Egyetem Irányítástechnika és Informatika Tanszék HIERARCHIKUS RENDSZER-SZINTŰ SZINTÉZIS Ph.D. értekezés Kandár Tibor Témavezető: Dr. Arató Péter egyetemi tanár, a Magyar Tudományos Akadémia rendes tagja Budapest 27

2 Tartalmi kivonat A technológiai fejlődés következtében a rendszerek, a felhasználandó komponensek és az alkatrészek komplexitása egyre nő. A tervezők rendelkezésére állnak készen kapható, komplex funkcionális egységek, mint építőelemek (IP-k), amelyek többnyire viselkedési szinten specifikáltak. Az ilyen komponensek adaptálhatósága, programozhatósága és újrakonfigurálhatósága kedvező lehetőséget nyújt azonos típusok ismételt felhasználására. A megfelelő hardver architektúra kiválasztása hagyományosan a tervező tapasztalatán múlott. Ezek az intuitív lépések gyakran a komponensek nem optimális kihasználását eredményezték, valamint a rendszer szimulációja és tesztelése is nehézkes volt valamilyen szisztematikus módszertan alkalmazása hiányában. A tervezés automatizálása döntő jelentőségű a rendszer-szintű szintézisben (SLS), mert a legtöbb lépés NP-teljes jellegű, így nem mindig kerülhetők el a közelítő optimumkereső eljárások. Az egyik legnagyobb előnye ennek a módszernek, hogy egyidőben több globális optimalizációs tényezőt (pl. ár, sebesség, szilícium felület, költségek, stb.) is figyelembe tud venni. Így felülről lefelé haladó (top-down) metodika szerint az SLS a globális optimalizációt helyezi előtérbe a hagyományos, felfelé (bottom-up) haladó, lokális optimalizációt megvalósító módszertannal szemben. Jelenleg az ismert szakirodalomban nem található olyan eredmény, amely szisztematikusan, hierarchikus megközelítésben az eredeti elemi műveletekkel együtt, alapműveletként tudná kezelni a pipeline módon is működtethető, bonyolult (nem elemi) funkcionális elemeket. Ezért az értekezés elsődleges célja az, hogy olyan tervezési módszert mutasson be, amely a magas szintű szintézis során az ismert eljárásokhoz illeszkedő módon lehetővé teszi a tetszőleges bonyolultságú pipeline működésű műveletek kezelését az elemi műveletekhez hasonlóan. Ebből a célból meg kell vizsgálni az újraindítási idő beállítását végző, a szinkronizációt biztosító, az ütemező és allokációs algoritmusok kiegészítésének lehetőségét, hogy a tetszőleges bonyolultságú pipeline működésű műveletek alkalmazhatóak legyenek a tervezési eljárás során. A kidolgozott modell a tetszőleges bonyolultságú pipeline működésű műveleteket többszörözött elemi műveleteknek felelteti meg. Az értekezés további célja, hogy a rendszer előre megadott vagy a tervezési eljárás során kiadódó komplex funkcionális egységekből felépíthető legyen minél kevesebb funkcionális egység felhasználásával. ontos figyelembe venni a tervezés során, hogy a rendszer költségét minimálisan tartsuk, és előnybe részesítsük az egyes komplex funkcionális egységek ismételt felhasználását (reusing). Ezen probléma kezelésére kerültek kidolgozásra a COMPALL, a REDIN és a MACOMP algoritmusok. A magas szintű szintézis során az allokáció eredményeként a kiadódó processzorok között igen bonyolult adatutak alakulhatnak ki, és ezen adatutak megvalósításához nagyszámú multiplexer felhasználására van szükség, amely hátrányos és csökkenti a magas szintű szintézis módszerek hatékonyságát. Ezért célom olyan módszer kidolgozása, amely olyan összeköttetés-rendszert, sínrendszert eredményez, amely a multiplexerek és a sínek számát is jelentősen képes csökkenteni (MURED és BUSRED algoritmusok). A rendszer-szintű szintézis lépései közül nagyon fontosak a szimuláció, a tesztelés, valamint az ezeken alapuló gyors prototípus készítés. Ezért olyan eszköz került kidolgozásra, amely automatikusan előállítja az előzőleg kiadódó tetszőleges bonyolultságú pipeline működésű funkcionális egységek és a közöttük lévő adatkapcsolatok VHDL nyelven történő leírását. Az így adódó hierarchikus rendszer közvetlenül szintetizálható PA áramkörökre vagy VLSI építőelemekre kereskedelmi szintézis tervezőrendszerekkel. i

3 Abstract Due to the technological progress the complexity of the systems, the built-in components and the parts is growing extremely. Ready-made complex functional units are at designers disposal as building blocks (IPs), which are usually specified on behaviour level. The adaptability, the programmability and the reconfigurablility of such a component support the reuse of the same functional unit types. The selection of the proper architecture to be applied is traditionally based on the experience of the designer. These intuitive steps often lead to non-optimal use of the system parts. The simulation and the verification of the system are also difficult because of lacking a systematic methodology. The design automation has a crucial importance in system-level synthesis (SLS), because the most steps are NP-complete. Therefore there is no possibility to avoid the optimum finding algorithms. One of the most important advantages of the methodology presented is to handle many global optimization parameters (e.g. price, speed, silicon area, costs, etc.) simultaneously. Due to the top-down methodology, it prefers the global optimization to the local optimization used by the bottom-up methodology. No such results can be found in the current literature, which could apply the complex (not elementary) pipeline functional units as basic operations together with the elementary operations in a systematic, hierarchical approach. or this reason, the primary goal of the dissertation is to present such a design methodology, which allows handling the arbitrarily complex pipeline operations similarly to the elementary operations. Besides this methodology should be compatible to the traditional high level synthesis steps. Therefore, the adaptation of the traditional synchronization, scheduling and allocation algorithms have to be investigated how they can use the complex pipeline operations during the whole development process. An arbitrarily complex pipeline operation can be handled formally as a multiplied elementary operation by the elaborated model. The additional target of the dissertation is that the system should be built up from previously specified complex functional units or from such functional units, which are yielded by the designing procedure. In the same time, the number of the complex functional units has to be as smart as possible. It is important during the designing that the system cost has to be minimized and the reuse of the individual complex functional units has to be preferred. The COMPALL, the REDIN and the MACOMP algorithms were developed for handling the above problem. The high-level synthesis methods may result very complex connections between the allocated processors. To establish all the required data connections, a large number of multiplexers and demultiplexers would be required. The large number of multiplexers and demultiplexers is a disadvantage, and so it may make the high level synthesis methods less efficient. or this reason, elaborating a simple bus system, minimizing the number of the buses and multiplexers (algorithms MURED and BUSRED) are also targeted in the dissertation. The simulation, the verification and the rapid prototyping are very important steps in system-level synthesis. Therefore, a tool has been developed, which systematically generates the VHDL description of the complex pipeline functional units yielded above and of the datapath between them. So, this hierarchical system can directly be synthesized and mapped into an PA or a VLSI circuit by applying a commercial silicon compiler. ii

4 Nyilatkozat Alulírott Kandár Tibor kijelentem, hogy ezt a doktori értekezést magam készítettem és abban csak a megadott forrásokat használtam fel. Minden olyan részt, amelyet szó szerint, vagy azonos tartalomban, de átfogalmazva más forrásból átvettem, egyértelműen, a forrás megadásával megjelöltem. A dolgozat bírálatai és a védésről készült jegyzőkönyv a későbbiekben, a dékáni hivatalban elérhetők. Budapest, 27. október. iii

5 Köszönetnyilvánítás Hálás köszönettel tartozom konzulensemnek, Dr. Arató Péternek a sok segítségért. Tanácsai, javaslatai és hasznos észrevételei nagymértékben hozzájárultak a sikeres kutatói munka végzéséhez. Rengeteg gondolatom született a közös munka és a beszélgetéseink során. Külön köszönöm azt a türelmet, amit irányomban tanúsított. Szeretnék köszönetet mondani Dr. Visegrády Tamásnak a PIPE tervezőrendszer használatához, módosításához nyújtott segítségéért, továbbá a kutatói munka során tett hasznos megjegyzéseiért. A szerző kutatói munkáját az OTKA T378 és az OTKA T4333 számú programjai támogatták a Budapesti Műszaki és azdaságtudományi Egyetem Irányítástechnika és Informatika Tanszékén. iv

6 Tartalomjegyzék. Bevezetés.. Az értekezés célkitűzése Az értekezés felépítése Hierarchikus tervezés komplex pipeline műveletekkel Bevezetés és szakirodalmi eredmények áttekintése A probléma megfogalmazása és kiindulási definíciók Komplex pipeline műveletek alkalmazása Az újraindítási idő csökkentése Szinkronizáció Ütemezés Allokáció Alkalmazási példák Első tézis Szisztematikus dekompozícó és erőforrás kiosztás Bevezetés és szakirodalmi áttekintés Dekompozíció komplex funkcionális egységekre A COMPALL algoritmus A REDIN algoritmus A MACOMP algoritmus Alkalmazási lehetőségek Az algoritmusok alkalmazásának módszere Az algoritmusok alkalmazása tesztfeladatokra Második tézis Adatkapcsolatok optimális, sínszerű megvalósítása Bevezetés és szakirodalmi áttekintő A probléma megfogalmazása Kompatibilitás vizsgálata Processzorok közötti sínszerű összeköttetésrendszer optimális megvalósítása A MURED algoritmus A BUSRED algoritmus Alkalmazási lehetőségek Harmadik tézis v

7 TARTALOMJEZÉK vi 5. VHDL leírás szisztematikus előállítása komplex, pipeline funkcionális elemek alkalmazása esetén Bevezetés és szakirodalmi áttekintés Szisztematikus kódgenerálás Előkészítő lépések Adatfolyam létrehozása Vezérlés tervezése Teszt-környezet Alkalmazási lehetőségek Negyedik tézis Alkalmazás, MRI agyfelvételek feldolgozása Bevezetés Kohonen hálózat tervezése VHDL leírás generálása Kohonen hálózatból Szimulációs eredmények A 2D fuzzy algoritmus leképezése

8 Ábrák jegyzéke.. Rendszer-szintű szintézis folyamata Műveletek jelölése, a) komplex pipeline művelet b) elemi művelet Komplex pipeline művelet, mint többszörözött elemi művelet Többszörözött komplex pipeline művelet Szinkronizációs probléma Konkurens szituáció két művelet között A Taylor-soros közelítés költségfüggvénye A Taylor-soros közelítés egy lehetséges megvalósítása, valamint az ütemezési és allokációs információk R = 2-nél Az eredeti feladat és a módosított EO a koszinusz tétel kiszámítására A koszinusz függvény ütemezése és allokációja R = 2-nél A Taylor-soros közelítés egy másik lehetséges megvalósítása, valamint az ütemezési és allokációs információk R = 6-nál Processzorok száma az újraindítási idő függvényében A megvalósítás költsége az újraindítási idő függvényében A tervezéshez szükséges idő (futtatási idő) Lépcsős tábla, művelet kompatibilitások Alkalmazási példa a MACOMP algoritmusra A szisztematikus dekompozíció megvalósításához kidolgozott algoritmusok kapcsolódása a tervezési folyamatba Különböző futtatási módok az eltérő tervezési célok megvalósításához A költség, S i értékek és a hatékonysági tényezők alakulása a felhasználó által előre megadott komplex funkcionális elemkészletből történő választás esetén A költség, S i értékek és a hatékonysági tényezők alakulása fiktív komplex funkcionális elemkészletből kiindulva Eredmények 8-pontos T esetén, fiktív komplex funkcionális elemkészletből kiindulva uttatási eredmények 8-pontos T esetén, a komplex funkcionális elemkészlet a felhasználó által előre megadott Adatkapcsolatok megvalósítása multiplexerek felhasználásával Adatkapcsolatok értelmezése Adatkapcsolatok tranzitivitásának vizsgálata A MURED algoritmus alkalmazása után kiadódó sínszerű összeköttetésrendszer A BUSRED algoritmus alkalmazása után kiadódó sínszerű összeköttetésrendszer Hierarchikus sínrendszer megvalósítása komplex funkcionális elemekkel Multiplexer egységek beillesztése komplex funkcionális egységek közé vii

9 ÁBRÁK JEZÉKE viii 5.2. Az adatfolyam vezérlése Teszt-környezet létrehozása funkció ellenőrzés céljából pontos T DSP jelfolyam ábrája és az ennek megfelelő elemi műveleti gráf Allokáció eredményeként az adatkapcsolatok megvalósítása multiplexerek felhasználásával, 8-pontos T esetén Áramköri elrendezési rajz hagyományos összeköttetésrendszer használata esetén Áramköri elrendezési rajz sínszerű összeköttetésrendszer használata esetén A MURED algoritmus alkalmazása után kiadódó sínszerű összeköttetésrendszer, 8- pontos T A koszinusz tétel kiszámításának idődiagramja R = 2-nél Az ál-véletlenszám generátor működésének idődiagramja A neuron memória egység olvasásának folyamata Az MRI modul szerkezeti felépítése Eredeti T2 súlyozású MRI agyfelvétel A Kohonen hálózattal osztályozott kép Az MRI modul szerkezeti felépítésének módosítása fuzzy algoritmus esetén Az öt osztálynak megfelelő tagsági képek A fuzzy módszerrel osztályozott kép

10 Táblázatok jegyzéke 2.. Végrehajtási idők a közelítés esetén Taylor-soros közelítés eredménye Taylor-soros közelítés eredménye párhuzamos szervezésű EO-ból Processzorszám összehasonlítás a hagyományos és hierarchikus tervezési eljárás esetén A futtatási idők összehasonlítása MARS algoritmushoz használt műveletek tulajdonságai elhasználó által megadott komplex funkcionális elemkészlet Eredmények minimális költség preferálása esetén, a komplex funkcionális elemkészlet a felhasználó által előre megadott Eredmények ismételt felhasználás preferálása esetén, a komplex funkcionális elemkészlet a felhasználó által előre megadott enerált, fiktív komplex funkcionális elemkészlet Eredmények minimális költség preferálása esetén, fiktív komplex funkcionális elemkészletből kiindulva Eredmények ismételt felhasználás preferálása esetén, fiktív komplex funkcionális elemkészletből kiindulva Kiinduló maximális kompatibilitási osztályok elemszáma 8-pontos T esetén Kiinduló komplex funkcionális elemkészlet 8-pontos T esetén Nemzetközi benchmark feladatok A MURED algoritmus által szolgáltatott eredmények A BUSRED algoritmus által szolgáltatott eredmények pontos T művelet végrehajtási idők A PIPE tervezőrendszer által szolgáltatott eredmények különböző újraindítási időknél A generált VHDL kódból történő hardver szintézis eredménye 8-pontos T esetén Az C2S2 PA áramkör felületi kihasználtságának alakulása hagyományos tervezési eljárás alkalmazása esetén A sínszerű összeköttetést megvalósító VHDL kódból történő hardver szintézis eredménye 8-pontos T esetén Az C2S2 PA áramkör felületi kihasználtságának alakulása sínrendszer alkalmazása esetén A VHDL kódból történő hardver szintézis eredménye a koszinusz tétel megvalósítása esetén Az C2S2 PA áramkör felületi kihasználtságának alakulása a koszinusz tétel megvalósítása esetén Műveletek száma és a lappangási idő ix

11 TÁBLÁZATOK JEZÉKE x 6.2. unkcionális elemek száma részfeladatok szerint bontva

12 . fejezet Bevezetés A mikroelektronikai ipar gyors fejlődése egyre bonyolultabb rendszereket eredményez, következésképpen az átláthatóságuk is egyre bonyolultabbá válik. A mai modern beágyazott rendszerek túlnyomó részt egy bonyolultabb rendszer (pl. jármű) alkalmazás-specifikus elektronikus alrendszerei. A komplex rendszerekben egymással kölcsönhatásban álló, kommunikáló speciális hardver és processzor(ok) által futtatott szoftver komponensek is megtalálhatók. A technológiai fejlődés lehetővé tette azt, hogy egyre komplexebb rendszerek hozhatók létre egyetlen integrált áramköri tokban (SoC ). Az új alkalmazásspecifikus áramkörök (ASIC 2 ) több mint 9%-a már 25-ben is tartalmazott 3 nm-es technológiával előállított processzort. A multimédiás platformok már most is sokprocesszoros SoC rendszerek, amelyek különböző típusú programozható processzorokat (mikroprocesszor, DSP, stb.) tartalmaznak. Látható, hogy a beágyazott rendszerek területén a hosszú távú irányvonal a sokprocesszoros SoC rendszerek alkalmazása, ahol akár több száz, egymással konkurens feladatokat futtató processzort, komplex funkcionális egységet integrálnak egyetlen lapkára. Az ilyen beágyazott rendszerek fejlesztése mind a rendszer-, mind a félvezető fejlesztők számára nagy kihívásokat jelentenek [33, 26]. Ugyanakkor a tervezők rendelkezésére állnak készen kapható, komplex funkcionális egységek, mint építőelemek (IP 3 ), amelyek többnyire viselkedési szinten specifikáltak. Az ilyen komponensek adaptálhatósága, programozhatósága és újrakonfigurálhatósága kedvező lehetőséget nyújt azonos típusok ismételt felhasználására (reusing) [35, 28, 7, 22, 65, ]. A komplex funkcionális egységek között teljesen programozható cél- és általános processzorok is megjelennek. Ezen építőelemek használata csökkentheti a tesztelésre és a gyors prototípus készítésére fordított időt. A hagyományos tervezési eljárás során a megvalósítandó struktúra kiválasztása gyakran az intuíción és a mérnöki tapasztalaton alapul. Ez tervezési hibákhoz vezethet, növekedhet a tervezéshez szükséges és a piacra kerülési idő, valamint a rendszerelemek nem optimális felhasználását eredményezheti. A gyors és megbízható fejlesztés, tervezés és gyártás nagyon fontos szempont. Olyan új eljárásokra van szükség, amelyek a hatékony, bonyolult funkcionális egységeket építőelemként képesek felhasználni a tervezés menete során, mindamellett megpróbálják automatizálni a tervezési folyamatot amennyire csak lehetséges. Jóval magasabb absztrakciós szintről kell kezdeni a tervezési folyamatot, amelyet emiatt rendszer-szintű szintézisnek (SLS 4 ) neveznek. A tervezés automatizálása döntő jelentőségű a rendszerszintű szintézisben, mert a legtöbb lépés NP-teljes jellegű [45], így nem mindig kerülhetők el a közelítő optimumkereső eljárások. A rendszer-szintű szintézis viszonylag új kutatási terület [5, 36, 5, 35, 28, 23, 38, 48, 27], amely teljesen új szempontból közelíti meg a tervezési folyamatot. Ezt a megközelítést mutatja az.. ábra. Az egyik legnagyobb előnye ennek a módszernek, hogy egyidőben több globális optimalizációs tényezőt (pl. ár, sebesség, szilícium felület, költségek, stb.) is figyelembe tud venni. Így System on Chip 2 Application Specific Integrated Circuit 3 Intellectual Property 4 System-Level Synthesis

13 BEVEZETÉS 2 felülről lefelé haladó (top-down) metodika szerint az SLS a globális optimalizációt helyezi előtérbe a hagyományos, felfelé (bottom-up) haladó, lokális optimalizációt megvalósító módszertannal szemben. Rendszer-szintű szintézis, SLS SW modul specifikáció Beágyazott szoftver tervezés Rendszer specifikáció A felhasználandó HW és SW modulok kiválasztása HW/SW interfész elméleti model - API könyvtár SW modulokhoz - elméleti interfész HW modulokhoz HW/SW particionálás HW/ SW együttes tervezés - CPU tervezés - HW függő SW tervezés - SW függő HW tervezés Prototípus HW modul specifikáció Hardver modul tervezés Magasszintű logikai szintézis, HLS RTL szintézis (Elemi) műveletek eladat Adatfolyam Ütemezés Allokáció Struktúrális leírás Áramkör Vezérlés Kódgenerálás Implementáció.. ábra. Rendszer-szintű szintézis folyamata A megoldandó feladat specifikációját viselkedési szinten adjuk meg, amely fiktív viselkedési összetevők együttműködésének leírása [2, 49]. A VHDL 5 [46, 73], Verilog [62] vagy egyéb más, eredetileg hardver leírására kifejlesztett nyelvek nem használhatók ezen a szinten, mivel nem eléggé magas szinten írják le a rendszer viselkedését. Ma már mindkét nyelvnek létezik rendszer leírásra alkalmas kiterjesztése is (VHDL-AMS, SystemVerilog). Ezzel szemben inkább magas szintű programozási nyelveket használnak a feladat viselkedési leírására (például C++, SystemC [74]), de annak is fennáll a lehetősége, hogy újabb leíró nyelvet kell kifejleszteni [8, 7, 72]. A következő lépésben olyan dekompozíciós algoritmusokra van szükség, amelyek különböző részfeladatokra bontják fel a problémát. Ez a felbontás olyan felépítést is eredményezhet a feladat optimális megoldása érdekében, amely hardver és szoftver összetevőket egyaránt tartalmaz. Így az úgynevezett hardver-szoftver együttes tervezés (HSCD 6 ) része a rendszer-szintű szintézisnek. Ezen a területen a kutatás az 99-es évek elejétől indult [4, 34, 39, 44, 4, 52, 6, 76, 79, 3, 3]. A HSCD legfőbb célja, hogy kiaknázza a hardver és szoftver összetevők egymást kiegészítő előnyeit és biztosítsa ezek optimális együttműködését oly módon, hogy automatikusan megtalálja a tervezendő rendszer legjobb felbontását különböző fő paraméterek (például költség és teljesítmény) által támasztott követelmények figyelembevételével. Ezért a sok kihívást jelentő feladat közül a legfontosabb a particionálás, azaz annak eldöntése, hogy mely összetevők kerüljenek hardveres, illetve szoftveres megvalósításra. A particionálás folyamán nemcsak a hardveres és szoftveres megvalósítás egymásnak ellentmondó előnyeit és hátrányait kell figyelembe venni, hanem a közöttük lévő kommunikációs többletterhelést is. A viselkedési szintről kiinduló szisztematikus tervezési lépéseket elsőként az úgynevezett magas szintű szintézishez (HLS 7 ) kezdték alkalmazni az 98-as évek közepétől [69, 58, 9, 2, 37, 47, 4, 5, 2]. A HLS algoritmusok főként a nagysebességű célhardverként megvalósított eszközök struktúrájának optimalizálását támogatták. A valóságos hardver erőforrások, mint összetevők ekkor már elég komplexek voltak ahhoz, hogy leírásukat már viselkedési szinten legyen célszerű kezelni fiktív elemi műveletekből összeállítva. Ennek ellenére korántsem érték el azt a bonyolultságot, mint a napjainkban használt, illetve a jövőben használandó komplex funkcionális egységek. A legtöbb alkalmazási területen a sebességi követelmények igénylik az úgynevezett pipeline feldolgozás megvalósítását. Ezért nagy előny, ha a HLS 5 VHSIC Hardware Description Language, Very High Speed Integrated Circuit 6 Hardware-Software Co-Design 7 High Level Synthesis

14 BEVEZETÉS 3 algoritmusok támogatni tudják a pipeline üzemmódban is működtethető struktúrák optimalizálását [67]. Természetesen a sebesség növelését más módszerekkel is lehet érni, például párhuzamos architektúra, vagy elosztott rendszerek alkalmazásával többnyire többprocesszoros rendszerekben. A HLS eredményeként olyan strukturális leírás (strukturális VHDL, vagy RTL 8 ) létrehozása a cél, amely alapján a kereskedelemben kapható, úgynevezett szintézis tervezőrendszerek segítségével a feladat könnyen megvalósítható PA 9, ASIC vagy full-custom integrált áramkörökkel. Az implementációnak ezt a formáját RTL szintézisnek nevezzük [3, 32, 6, 8]. Természetesen a szimuláció a legmagasabb absztrakciós szinten is nagyon fontos, azonban a cél, hogy minden egyes szinten szimuláció futtatásával ellenőrizzük az egyes lépések helyességét. Léteznek olyan eszközök, amelyek képesek a magas szintű programozási nyelven írt szoftver összetevő és a hardver leíró nyelven megadott hardver komponensek együttes szimulációjára [77, 6]... Az értekezés célkitűzése A szakirodalomban található, ismertetett tervezőrendszerekkel és azok algoritmusaival szemben már a magas szintű szintézis (HLS) területén is az alábbi nehézségek és problémák merültek fel, annak ellenére, hogy a viselkedési leírásból történő közvetlen tervezés és optimalizáció jelentős egyszerűsítést eredményezett.. A HLS során használt közelítő eljárások eredményeként a kialakuló struktúrában az építőelemek között lévő konkrét adatkapcsolatot nagy számú multiplexer és demultiplexer egység alkalmazásával valósítjuk meg, amely nagyon bonyolult struktúra lehet. A multiplexerek és demultiplexerek nagy száma jelentős hátrány, amely kihat a magas szintű szintézis módszerek hatékonyságára, használhatóságára [37]. 2. A hagyományos tervező eljárások primitív, azaz elemi műveletek alkalmazását feltételezik. Az elemi műveletek és a közöttük lévő adatkapcsolatok alkotják az elemi műveleti gráfot, amely a megoldandó feladat adatfolyam-szerű viselkedési leírása. A komplex funkcionális egységeket azok bonyolultsága és az elemi műveletektől eltérő viselkedése miatt a HLS algoritmusok nem tudják kezelni. 3. Döntő jelentőségű a pipeline üzemmód kialakítása. A szakirodalmi konkrét eljárások a tervezés végső fázisában végzik a pipeline üzemmód kialakítását. Magát a kiadódó struktúrát alakítják át úgy, hogy az képes legyen pipeline üzemmódban működni (strukturális pipeline). Ez a kialakítási mód nem előnyös, ha magasabb, viselkedési szintről indítjuk a tervezési folyamatot. Már ezen a szinten kezelni kell tudni a pipeline üzemmódot (funkcionális pipeline [2]). 4. Az RTL leírás előállítására a szakirodalomban olyan eljárások ismertek, amelyek vagy csak bizonyos feladat típusokat, vagy előre definiált, kötött struktúrákra történő leképezést támogatják [66]. Ezzel szemben az értekezésben nem feltételezünk speciális struktúrát, valamint a komplex funkcionális egységeket oly módon képezzük, hogy azok felhasználhatóak legyenek a hierarchikus tervezés során. Jelen értekezés célja, hogy a fentiekben felsorolt nehézségek kiküszöbölésére mutasson be kidolgozott algoritmusokat, egységes módszertant. A tervezési eljárásokat, algoritmusokat ki kell terjeszteni oly módon, hogy azok képesek legyenek kezelni a szokásos elemi műveletek felhasználásán felül a bonyolult funkcionális egységeket is. Ily módon ez a kiterjesztés egyszerűsíti, és gyorsabbá teszi a komplex rendszerek tervezését az új algoritmusok hierarchikus alkalmazásának köszönhetően. A magas szintű 8 Register Transfer Level 9 ield-programmable ate-array

15 BEVEZETÉS 4 szintézis algoritmusai többsége kiterjeszthető és alkalmazható a rendszer-szintű szintézis céljaira, ezen belül a HLS algoritmusok továbbra is előnyösen alkalmazhatók például a komplex funkcionális egységek elemi műveletekből történő tervezéséhez..2. Az értekezés felépítése A dolgozat következő 4 fejezete (2. 5. fejezet) a saját tudományos eredmények, tézisek kifejtését, kidolgozását tartalmazza. Mindegyik fejezet egy rövid bevezetővel indul, a kidolgozott módszerek, algoritmusok ismertetésével folytatódik, majd az algoritmusokra és alkalmazhatóságukra mutat be példákat. A 2. fejezet a hagyományos HLS algoritmusok kiterjesztésével foglalkozik, bemutatja a komplex funkcionális elemekkel történő hierarchikus tervezés módszertanát [4, 9, 8]. A 3. fejezet egy olyan új eljárást ismertet, amely a kiadódó komplex funkcionális elemek ismételt felhasználását (reuse) is szem előtt tartva építi fel a megvalósítandó rendszert. Ugyanakkor jól alkalmazható a rendszer felépítéséhez szükséges komplex funkcionális elemkészlet meghatározására is [6, ]. A 4. fejezet a tervezés során kiadódó bonyolult adatkapcsolatok optimális, sínszerű megvalósításával foglalkozik, miközben az alkalmazandó multiplexerek számát is próbálja a minimálisra csökkenteni [8, 4, 27]. Az 5. fejezet a megoldandó feladat VHDL leírásának előállítására mutat be szisztematikus módszert, amely nagymértékben támogatja a komplex funkcionális elemek használatát, a hierarchikus megvalósítást és a pipeline üzemmódot is [7, 55]. Az értekezés utolsó fejezete az egységes módszertanra mutat be egy példaalkalmazást [53, 54, 56].

16 2. fejezet Hierarchikus tervezés komplex pipeline műveletekkel 2.. Bevezetés és szakirodalmi eredmények áttekintése A rendszer-szintű szintézis területén végzett legutóbbi kutatások alapján olyan új eljárásokra van szükség, amelyek a hatékony, bonyolult funkcionális egységeket építőelemként képesek felhasználni a tervezés menete során. A legtöbb alkalmazási területen a sebességi követelmények igénylik a pipeline feldolgozás megvalósítását, ezért nagy előny, ha az algoritmusok támogatni tudják a pipeline üzemmódban is működtethető komplex funkcionális egységek kezelését, optimalizálását a szilícium felület és költség tényezők figyelembevétele mellett. Jelenleg az ismert szakirodalomban nem található olyan eredmény, amely szisztematikusan, hierarchikus megközelítésben az eredeti elemi műveletekkel együtt, alapműveletként tudná kezelni a pipeline módon is működtethető, bonyolult (nem elemi) funkcionális elemeket. Jó kiindulási alapnak tekinthetők a [2] könyvben kidolgozott szinkronizációs, ütemezési és allokációs algoritmusok. Ezek az algoritmusok az alábbi szempontokból tekinthetők kedvezőbbeknek a szakirodalomból addig ismert releváns megközelítésekhez képest:. A viselkedési modell olyan speciális szinkron adatfolyam-szerű elemi műveleti gráf (EO ), a- melynek alapján egyszerűen elkerülhetők az időzítési- és hazárd problémák a HLS-t követő tervezési lépések során. A hazárd problémák nem a viselkedési szinten lépnek fel, hanem a konkrét megvalósítási technológia során. Azonban célszerű már a viselkedési szinten is óvintézkedéseket tenni, hogy a későbbiek során elkerüljük a problémákat. Ezért viselkedési szinten azt feltételezzük, hogy minden időbeni lejátszódó esemény órajelhez szinkronizáltan történik. Az optimalizálandó algoritmusokat ezzel az elemi műveleti gráffal írjuk le, ahol a gráf csomópontjai jelképezik az elemi műveleteket, az élek pedig az adatutakat. Minden elemi műveletnek van egy végrehajtási ideje, amelyet órajel periódus számban adunk meg. Az elemi műveleti gráf lappangási ideje (L) az az idő, amennyi ahhoz kell, hogy egy adat a gráf bemenetétől eljusson a kimenetéig. Az újraindítási idő (R) pedig a gráf bemenetén két egymást követő adat között eltelt időt jelenti. Az időt mindig órajel periódusban mérjük. 2. A [2]-ben közölt algoritmusok mindig pipeline működést tételeznek fel (a nem-pipeline esetet a pipeline speciális eseteként kezelik, amikor az újraindítási idő egyenlő a lappangási idővel), továbbá a kívánt újraindítási idő előre megadható. Elementary Operation raph 5

17 HIERARCHIKUS TERVEZÉS 6 Amennyiben az újraindítási idő rövidebb, mint a lappangás, akkor érvényesül a futószalag elv, azaz az adatok pipeline szervezéséről beszélhetünk. Minél kisebb az újraindítási idő, annál több adatot tudunk feldolgozni adott idő alatt. Így tudjuk növelni a rendszer áteresztőképességét is. 3. Az előre megadható kívánt pipeline újraindítási idő a minimális számú pótlólagos puffer regiszter beépítésével és/vagy a minimális számú elemi műveletnek a lehető legkisebb példányszámú többszörözésével valósítható meg. A minimális újraindítási időt a legnagyobb foglaltsági idővel rendelkező elemi művelet határozza meg. Egy elemi művelet foglaltsági idején azt az időt értjük, amíg nem fogadhat új adatot a bemenetén. Ez két részből tevődik össze, az elemi művelet végrehajtási idejéből, és az őt követő művelet végrehajtási idejéből. Ugyanis a következő művelet számára biztosítani kell az eredményt mindaddig, amíg az végrehajtódik. Ezek alapján kétféleképpen csökkenthetjük az újraindítási időt. Az egyik módszer, hogy csökkentjük azt az időt, amíg tartani kell a kimeneten az adatot. Ez úgy lehetséges, hogy puffert illesztünk be az elemi műveleti egység után. A pufferek végrehajtási ideje, így a művelet foglaltsági ideje -gyel lesz nagyobb a végrehajtási idejénél. Vigyázni kell arra, hogy ez a módszer megnöveli a lappangást, ami bizonyos esetekben nem megengedhető, például rekurzív hurkok belsejében. A másik lehetőség, hogy magát a végrehajtási időt csökkentjük az elemi műveleti egység többszörözésével. Ez esetben a példányok felváltva fogadják az adatokat. Ezt - valamint, hogy mindig az érvényes adat legyen a kimeneten - a vezérlésnek kell megoldania. 4. A [2]-ben ismertetett adatszinkronizáló algoritmus közvetlenül szolgáltatja az ASAP 2 (minden elemi művelet a lehető legkorábban indul) és az ALAP 3 (minden művelet a lehető legkésőbben indul) ütemezést. Az elemi művelet mobilitási tartományát ez a két szélső indíthatósági időpont határozza meg. E két szélső eset közötti bármely ütemezés egyszerűen képezhető a szinkronizáló késleltető hatásoknak, mint fiktív, egymás után kapcsolt puffer regisztereknek az adatutak mentén történő mozgatása révén. Szinkronizációs probléma mindig fennállhat, ha az elemi műveleti egységnek egynél több bemenete van. Egy elemi műveleti egység csak akkor kezdheti el működését, ha minden bemenetén érvényes adat jelent meg. Továbbá minden adatnak a teljes végrehajtási idő alatt rendelkezésre kell állni a művelet-végrehajtó egység bemenetén. A kimenet a működés során változhat, de utána az eredmény a következő működésig rendelkezésre áll. A megoldás szinkronizációs puffer helyezése azokra a bemenetekre, ahol az adatok túl korán érkeznek. Ezek alapján minden műveletre megadható egy minimális és egy maximális indítási idő, amit ASAP illetve ALAP indítási időnek is nevezhetünk. Az ütemezés igen fontos része a HLS-nek. Több ütemezési eljárást is kidolgoztak, amelyek közül a három legfontosabbat említenénk: egész értékű lineáris programozáson (ILP 4 [2]) alapuló ütemezés, listás ütemezés, erő-vezérelt (force-directed [68]) ütemezés. 5. A [2]-ben bemutatott allokációs algoritmus a páronként nem konkurens elemi műveletek közötti kompatibilitási reláción alapulva a maximális kompatibilitási osztályokból képezhető fedőrendszer meghatározásán alapul. Az egyes elemi műveleteket a valóságban létező műveletvégző egységekkel kell realizálni. Az allokáció feladata, hogy meghatározza, mely elemi műveleteket lehet közös processzorba összevonni. Kétféle eljárás ismert: a topológiai lefedés és a konkurencián alapuló allokáció. A Budapesti Műszaki és azdaságtudományi Egyetem Irányítástechnika és Informatika Tanszékén fejlesztették ki a PIPE tervezőrendszert [2], amely a fenti HLS algoritmusokat használja fel az elemi 2 As Soon As Possible 3 As Late As Possible 4 Integer Linear Programming

18 HIERARCHIKUS TERVEZÉS 7 műveleti gráf ütemezésére és allokációjára adott újraindítási idő mellett. A PIPE az ütemezésre egy kiterjesztett force-directed ütemezőt használ, ahol az elemi műveletek végrehajtási ideje helyett azok foglaltsági idejét veszi figyelembe az erőforrás kiosztás optimalizációjához. Allokációs algoritmusként gráfszínező eljárást használ. A fentiekben összefoglalt tulajdonságok miatt célszerű megvizsgálni, hogyan használhatók a hagyományos szinkronizációs, ütemezési és allokációs algoritmusok a rendszer-szintű szintézis (SLS) folyamata során, valamint hogyan terjeszthetők ki ezek az algoritmusok komplex pipeline (hierarchikus) műveletek kezelésére A probléma megfogalmazása és kiindulási definíciók A megoldandó problémát megközelíthetjük úgy, hogy az nem más, mint a bemeneti és kimeneti adatok között végrehajtandó pipeline és nem pipeline (elemi) műveletek sorozata. Az így értelmezett adatkapcsolatok és a műveletek összességükben a megoldandó feladat által meghatározott adatfolyamot valósítanak meg. A legtöbb alkalmazási területen a sebességi és adott esetben a gazdaságossági követelmények igénylik a pipeline feldolgozás megvalósítását. Ezért a rendszer-szintű szintézis algoritmusainak lehetőséget kell biztosítani arra, hogy támogatni tudják a pipeline üzemmódban is működő komplex műveletek kezelését. Ahhoz, hogy meg tudjuk különböztetni a komplex pipeline műveleteket az elemi műveletektől, a következő jelöléseket vezetjük be. e i, egy elemi művelet nem képes a bemenetén új adatot fogadni mindaddig, amíg az aktuális bemeneti adatokkal műveletet végez, azaz a saját foglaltsági idején belül [2]. p i, egy komplex pipeline művelet képes a bemenetén új adatot fogadni akkor is, ha az aktuális bemeneti adatokkal műveletet végez. o i, egy művelet egy közös, általános elnevezése az elemi és a komplex pipeline műveletnek is. Az elemi műveletek esetében definiáltuk a végrehajtási időt (t j ) és a foglaltsági időt (q j ). A végrehajtási idő az elemi művelet működésének indítása és befejezése közötti időtartam órajel periódus számban. Egy elemi művelet foglaltsági ideje az az időtartam órajel periódusban, amíg nem fogadhat új adatot a bemenetén. Ez két részből tevődik össze, az elemi művelet végrehajtási idejéből, és az őt követő művelet végrehajtási idejéből. Ugyanis a következő művelet számára biztosítani kell az eredményt mindaddig, amíg az végrehajtódik. Ugyanezen fogalmakat bevezethetjük komplex pipeline művelet esetében is. A 2.. ábrán feltüntetett komplex pipeline műveletnek két fontos tulajdonsága van, ezek a pipeline újraindítási idő (R i ) és a lappangás (L i ). A pipeline művelet lappangása azt az időtartamot jelöli órajel periódusban, amely az első bemeneti adat feldolgozásához szükséges idő. A pipeline újraindítási idő az az időtartam órajel periódus számban, amilyen gyakran p i képes adatot fogadni a bemenetén. Eszerint egy pipeline művelet az L i által meghatározott időnél sokkal gyakrabban képes új adatokat fogadni a bemenetén. A pipeline üzemmód azt jelenti, hogy a pipeline újraindítási idő kisebb, mint a lappangás. Ha R i = L i teljesül, akkor a pipeline művelet elemi műveletként kezelhető. Az előbb említett fogalmak megfeleltethetők az elemi műveletek foglaltsági és végrehajtási időinek a következő módon: t j L i, q j R i. (2.) Amíg elemi műveletek esetén a foglaltsági idő függött a végrehajtási időtől (q j = max(t j + t k ), e j e k ), addig komplex pipeline művelet esetén nem, hiszen R i előre adott érték. Ezért ez a megfeleltetés csak formális.

19 HIERARCHIKUS TERVEZÉS 8 p i e j R i i L i q j j t j 2.. ábra. Műveletek jelölése, a) komplex pipeline művelet b) elemi művelet ontos kiemelni továbbá, hogy ez a megfeleltetés nem azonosságot, vagy ekvivalenciát jelent, hanem egyszerű megfeleltetést, helyettesítést. A hagyományos szinkronizációs, ütemezési és allokációs algoritmusok kiterjesztésének vizsgálata folyamán azt kell ellenőriznünk, hogy ennek a formális megfeleltetésnek a hatására az algoritmusok továbbra is helyes eredményt szolgáltatnak-e. Ha igen, akkor ez a helyettesítés helyes volt és ebben az esetben a kiterjesztett, új algoritmusok képesek kezelni a komplex pipeline műveleteket is a tervezési eljárás során. Ennek bizonyítását a következő fejezet tartalmazza. Az egyszerűség kedvéért egy komplex pipeline művelet formálisan többszörözött elemi műveletként kezelhető. A többszörözött elemi műveletek a végrehajtási idejüknél gyorsabban fogadhatnak adatokat a bemeneteiken. A 2.2. ábrának megfelelően v i,h az első példány első adatának megérkezési idejét jelöli. Az első példány következő adata v i,h + c i R i időpontban érkezik meg. Minden egyes példányra igaz, hogy a két egymást követő bemeneti adata között lévő időintervallum c i R i. Ennek az időtartamnak legalább a példányok bemeneti puffereinek foglaltsági idejével ( + L i ) kell megegyeznie. Ez a feltétel a következőképpen fejezhető ki: c i R i + L i +, (2.2) ahol a + egy többlet órajel periódust jelent a megfelelő működés biztosítása, tranziensek és hazárdjelenségek elkerülése érdekében. h t h R i v i,h+ v i,h v i,h + R i (c i )R i i i 2 i ci L i L i L i 2.2. ábra. Komplex pipeline művelet, mint többszörözött elemi művelet Azaz, egy pipeline művelet viselkedése Li + 2 c i = R i (2.3) példányban többszörözött elemi művelet viselkedésének feleltethető meg. A bemenetén R i gyakorisággal képes adatokat fogadni, míg egy bemeneti adat feldolgozásához szükséges idő L i. A kidolgozott modell minden, tetszőleges bonyolultságú pipeline művelet leírására képes, hiszen éppen a hierarchikus tervezés jellegéből következően bármely komplex pipeline művelet elemi viselkedési gráffal leírható, megtervezhető és ezután már komponensnek tekinthető a következő hierarchikus szinten.

20 HIERARCHIKUS TERVEZÉS Komplex pipeline műveletek alkalmazása Az újraindítási idő csökkentése Nyilvánvaló, hogy a rendszer újraindítási idejének (R) csökkentésére korlátot szabnak a végrehajtási idők és a feladat által előírt adatkapcsolatok. Az egyes műveletek foglaltsági ideje egyértelműen meghatározza az elérhető legkisebb újraindítási időt. Meg kell vizsgálni annak lehetőségét, hogy milyen módszerekkel lehet a kívánt R értéket elérni, és milyen változtatások szükségesek akkor, ha komplex pipeline műveleteket is használunk. Mint az ismeretes, a legkisebb újraindítási időt a legnagyobb foglaltsági idő határozza meg. Abban az esetben, ha az EO csak elemi műveleteket (e j ) tartalmaz, akkor a legkisebb újraindítási idő (min R) értéke [2]: min R = maxq j +. (2.4) Ahhoz, hogy a legkisebb újraindítási idő értékét csökkenteni tudjuk, azoknak az elemi műveleteknek a foglaltsági idejét kell csökkenteni, amelyek hatással vannak min R értékére. Két eljárás létezik min R csökkentésére: puffer regiszterek beiktatása, műveletek többszörözése. Továbbiakban megvizsgáljuk azt, milyen feltételeknek kell teljesülnie az újraindítási idő csökkentéséhez, hogyan kell kiegészíteni a már ismert algoritmusokat akkor, ha komplex pipeline műveleteket is használunk. Mindenképpen hasznos egy puffer beiktatása a komplex pipeline művelet be- és kimenetére egyaránt, mivel ezzel a módszerrel növelhető az ütemező és allokációs algoritmusok hatékonysága. Sajnos ezzel a rendszer lappangását kismértékben növeljük, azonban természetesen az újraindítási idő nem növekszik. Egy komplex pipeline művelet foglaltsági ideje nem csökkenthető puffer beiktatással, hiszen ez előre megadott, rögzített érték (R i ). Komplex pipeline művelet használata esetén a legnagyobb foglaltsági idővel rendelkező komplex pipeline műveletet kell figyelembe venni a rendszer legkisebb újraindítási idejének meghatározásakor, tehát a legnagyobb foglaltsági idővel (azaz, maxr i ) rendelkező komplex pipeline művelet a lényeges min R szempontjából: min R maxr i (2.5) Ha csökkenti akarjuk maxr i értékét (azaz, min R alsó korlátját), akkor a megfelelő komplex pipeline művelete(ke)t többszörözni kell. Ezt a szerkezetet szemlélteti a 2.3. ábra. Az előírt R eléréséhez, az adott komplex pipeline művelet esetén, a szükséges minimális példányszám (c) értékét a következőképpen számíthatjuk ki: c = Ri R. (2.6)

21 HIERARCHIKUS TERVEZÉS h t h v i,h i L i v i,h+ R i i,2 L i v i,h+ (c i )R i i ci, L i R R i, v i,h+ R i,2 L i v i,h+ v i,h+ R i + R (c i )R i + R i 2,2 i ci,2 L i L i R i,2 R i,c v i,h+ v i,h+ (c )R (c i )R i + (c )R i,c L i i ci,c L i 2.3. ábra. Többszörözött komplex pipeline művelet A fenti megfontolások figyelembe vételével a RESTART [2, 7. o.] algoritmust a következő módosításokkal kell alkalmazni: for (i=; i==n; i++) { if ((o i pipeline művelet) és (R i > R) { c = ceil((r i + 2)/R); /* A c kiszámítása és o i kicserélése c példányszámú művelettel, valamint minden egyes példány elé és után egy puffer beillesztése */ } j = succ(o i ); if (j pipeline művelet) { ins_buff(j); /* Puffer beillesztése j után */ if (o i elemi művelet) ins_buff(e i ); /* Puffer beillesztése e i után */ } /* A RESTART algoritmus alkalmazása */ }

22 HIERARCHIKUS TERVEZÉS Szinkronizáció Az adatfolyam reprezentációnál megköveteljük, hogy egy művelet csak akkor kezdheti el a működését, ha az összes bemenetén megérkeztek az adatok. Másik feltétel, hogy a műveletvégzés ideje alatt az összes bemeneti adat változatlan maradjon. Ezek a feltételek azonban nem teljesülnek automatikusan a kiindulási EO-ra és a RESTART algoritmus módosító hatásai szintén okozhatnak problémákat ebből a szempontból. A szinkronizáció problémája minden olyan esetben felléphet, ha egy műveletnek egynél több bemenete van. Annak érdekében, hogy az adat stabilitási kényszereket biztosítani lehessen, késleltető elemként szinkronizációs puffer beépítésére lehet szükség [2]. Jelölje az o i művelet első bemeneti adatainak megérkezési idejét v i,h,v i,r,..., ahogy azt a 2.4. ábra mutatja. Az o i művelet lehető legkorábbi indítási ideje az első adatokkal nem más, mint b i = max(v i,h,v i,r,... ). (2.7) eltételezzük, hogy b i = v i,r. R h h r h r h L t R h h t r h t r L h r t r v i,h i t i v i,r v i,h R i i L i v i,r v i,h R i i L i v i,r 2.4. ábra. Szinkronizációs probléma A legnagyobb megengedhető késleltető hatás értéke o i és o h között értelemszerűen: max p i,h = z i,h = b i v i,h. (2.8) Ezt az értéket növelve a rendszer lappangása nő és ez új szinkronizációs problémához vezethet. A minimális késleltető hatás értéke a következőképpen számítható: min p i,h = z i,h + t h + t i R. (2.9) Összegezve az előzőeket, a szinkronizációs késleltető hatás megengedhető intervalluma: min p i,h p i,h maxp i,h. (2.) A fent ismertetett számítási eljárás abban az esetben ad helyes eredményt, ha csak elemi műveleteket használunk a tervezéskor [2]. Ezek után meg kell vizsgálni, hogyan változik a minimális késleltető hatás értékének számítása azokban az esetekben, amikor szinkronizációs probléma áll fent o i és o h között, és o i vagy o h komplex pipeline művelet, nevezetesen p i vagy p h. A megfelelő helyzeteket a 2.4. ábra szemlélteti.. Ha o h komplex pipeline művelet (p h, 2.4.a. ábra), akkor o i mindkét bemenete az R z i,h időtartományban stabil, mert p h és o i műveletek között a módosított RESTART algoritmus által beiktatott puffer található. Így a minimális késleltető hatás értéke, amelyet be kell iktatni, a következő egyenlettel fejezhető ki: minp i,h = z i,h + + t i R. (2.)

23 HIERARCHIKUS TERVEZÉS 2 2. Ha o i komplex pipeline művelet (p i, 2.4.b. ábra), akkor minp i,h = z i,h + + L i c i R, (2.2) mivel t h =. Behelyettesítve c i -t (2.3)-ból, Li + 2 minp i,h = z i,h + + L i R. (2.3) képlethez juthatunk. R i Megjegyezzük, hogy p i viselkedését c i példányban többszörözött elemi műveletként kezeljük a felállított modellnek megfelelően. Természetesen a rendszer újraindítási ideje és p i pipeline újraindítási ideje között az R R i feltételnek teljesülnie kell. 3. Ha mindkét művelet komplex pipeline (2.4.c. ábra), akkor az előző számítás használható. A fenti megfontolások figyelembe vételével a SNC [2, 28. o.] algoritmust a következő módosításokkal kell alkalmazni: for (i=; i==n; i++) { if (in(o i ) >= 2) { } } /* Az o i művelet legalább két bemenettel rendelkezik */ h = prev(o i ); b i = calc_bi(); /* b i kiszámítása */ while (h > ) { z i,h = calc_zih(); /* z i,h kiszámítása */ max_pih = z i,h ; if (o i pipeline művelet) { /* min p i,h kiszámítása */ min_pih = z i,h + L i + ceil((l i + 2)/R i ) R; ins_all_buff(); /* Az összes szükséges puffer beillesztése */ } else if (o h pipeline művelet) { /* min p i,h kiszámítása */ min_pih = z i,h + t i + R; ins_all_buff(); /* Az összes szükséges puffer beillesztése */ } /* A SNC algoritmus alkalmazása */ h = h-; } Ütemezés Az ütemezés feladata az egyes műveletek indítási idejének lerögzítése a mobilitási tartományukon (az ASAP és ALAP indítási időn) belül. Az eljárás egyidőben próbálja minimalizálni az erőforrások (processzorok) számát és maximalizálni az áteresztőképességet. Számos algoritmus létezik ennek a problémának a megoldására, amelyek közül a három legfontosabb az egész értékű lineáris programozáson

24 HIERARCHIKUS TERVEZÉS 3 (ILP 5 ) alapuló ütemezés, a listás ütemezés és az erő-vezérelt (force-directed) ütemezés. ontos megemlíteni, hogy az ütemezés NP-teljes feladat. A feladat formális megfogalmazása, és a feladat NPteljességének bizonyítása megtalálható a [63] doktori értekezésben. Ugyanakkor egy új genetikus algoritmus is bemutatásra kerül, amelyben igazolják, hogy az algoritmus hatékonysága szempontjából a populációban érdemes megengedni nem érvényes ütemezést reprezentáló egyedeket is. Jelen értekezésben az egyik legismertebb ütemezési eljárást, az erő-vezérelt ütemezést (force-directed scheduling) [68] vizsgáljuk. Ez az algoritmus a processzorok kihasználtságától függő, erő-szerű függvényt minimalizál, amely kiegészíthető oly módon, hogy kezelni tudja a komplex pipeline műveleteket is. Az erő függvény a műveletek okozta terheltségtől függ. Egy nem nulla mobilitással rendelkező művelet terheltsége a saját mobilitása és az őt követő műveletek időzítése alapján becsülhető. Az algoritmus hatékonysága nagymértékben az előző becsléstől függ. Annak a valószínűsége, egy művelet a t órajel periódusban indul, s V i,t = i t l i l i s i +, (2.4) egyébként ahol s i és l i a művelet ASAP és ALAP indítási ideje. Egy művelet által okozott aktuális terheltség a következő terheltségi függvénnyel jellemezhető: { k t k + qi i,t k =, (2.5) egyébként ahol feltételezzük azt, hogy a művelet a k-dik órajel ciklusban indul. Egy művelet terheltségi függvénye csak elemi műveletek használata esetén egyszerűen, az ismert módon történik [2]. Most megvizsgáljuk, milyen módosításokat kell bevezetni ahhoz, hogy az ütemező algoritmus komplex pipeline műveleteket is tudjon kezelni. A i,t k -ban szereplő q i foglaltsági idő függ a művelethez közvetlen kapcsolódó műveletek időzítésétől. A q i helyes becslése nagyon kritikus pontja az algoritmusnak, és a komplex pipeline műveletek használata q i becslését módosítja. A becslés szempontjából fontos eseteket a következőkben összegezzük.. Minden egyes rögzített, közvetlen utód egy alsó korlátot határoz meg q i -re. Három különböző esetet vizsgálhatunk meg. (a) Ha o i elemi művelet (e i ) és minden egyes közvetlen utódja is elemi művelet, akkor minq i = max j:e i e j (t i + t j ). (2.6) (b) Ha e i -nek legalább egy komplex pipeline művelet a közvetlen utódja, akkor a RESTART által beiktatott puffer miatt a min q i kifejezésben t j helyett -et lehet írni: minq i = max j:e i p j (t i + ). (2.7) (c) Ha o i komplex pipeline művelet, akkor a közvetlen utódoktól függetlenül az ő foglaltsági ideje a következőképpen számítható: minq i = max j:p i o j (L i + ). (2.8) A számításnál L i -t kell figyelembe venni, mivel az első adat feldolgozásához mindig szükség van erre az időre. A közvetlen utódnak nincsen hatása, mert p i kimenetén mindig egy puffert feltételezünk. 5 Integer Linear Programming

25 HIERARCHIKUS TERVEZÉS 4 2. Minden olyan közvetlen utód bemenetére szinkronizációs puffert kell beilleszteni, amely nem indul közvetlen o i működésének befejezése után. Ezért t j nem jelenik meg min q i kiszámításánál: minq i = { ti + ha az i-dik művelet elemi L i + ha az i-dik művelet komplex pipeline (2.9) 3. Ha a közvetlen utód indítási ideje még nem rögzített, és legalább egy közvetlen utódja komplex pipeline művelet, akkor minq i = L i +. (2.2) A további számítások a hagyományos módon történnek, azzal a kiegészítéssel, hogy komplex pipeline műveletek esetén q i -re a fenti új becslést kell alkalmazni. A j típusú művelet pipeline terheltségi függvénye C j,t [2]. Ez nem más, mint a t-edik ciklusban működő j típusú processzorok száma a rendszer pipeline működését feltételezve. A hardveres megvalósításban felhasznált processzorok száma nem lehet kevesebb max C j,t -nél. C j,t = ( L ) i,k m V i,m ( t < R, k < L,s i m l i ) (2.2) l t[r] j i =j k= Két ütemezési terv értékszerű összehasonlítására a következő erő függvény vezethető be: ( J R ) C, C = w j C,j,t (C j,t C,j,t ) j= t= (2.22) ahol C j,t az új ütemezési terv átlapolt terheltségét jelenti, míg C,j,t a kiindulási ütemezési tervé. A j típusú processzorok relatív költsége w j. Az C, C alacsonyabb értéke jobb ütemezési tervet jelent, azaz az új ütemezés kedvezőbb, mint a kiindulási ütemezés. Az erő-vezérelt ütemezés végignézi az összes, nem nulla mobilitással rendelkező műveletet és megkeresi az összes lehetséges indítási idejük közül a minimális -et eredményezőket. Amikor a legjobbat megtalálja, akkor az adott műveletet rögzíti ott, és tovább folytatja az ütemezést a következő elemmel Allokáció Az allokáció határozza meg, hogy mely műveletek kerülhetnek közös processzorba. Ha két művelet időben konkurens, akkor nem valósíthatók meg közös processzorban. Az időbeni átfedés négy lehetséges helyzetét mutatja a 2.5. ábra. Az ábrán u i, u j, és f i, f j jelöli az o i és o j műveletek indítási és befejezési idejét. Tegyük fel, hogy c i = c j = és b j > b i.. Ebben az esetben, két művelet összevonhatóságának első szükséges feltétele [2, 47. o., 7.3. egyenlet] a következő: q i + q j < R. (2.23) Vizsgáljuk meg azt az esetet, ha valamelyik vagy mindkét művelet komplex pipeline művelet. Ekkor az első adat kiszámításának időtartama miatt a foglaltsági idő helyett a lappangás írható (2.23)-ba, hiszen komplex pipeline művelet esetén L i R i. Ha az egyik művelet komplex pipeline, akkor az első feltétel az alábbiaknak megfelelően módosul. q i + L j < R vagy L i + q j < R (2.24)

26 HIERARCHIKUS TERVEZÉS 5 u i u j u j u j idő f j u j f j f i fj f j 2.5. ábra. Konkurens szituáció két művelet között Ha mindkét művelet komplex pipeline, akkor a feltétel a következő: L i + L j < R. (2.25) 2. A második szükséges feltétel [2, 48. o., 7.4. egyenlet] a következő: b j > b i + q i. (2.26) Ha o i komplex pipeline művelet, akkor b j > b i + L i. (2.27) 3. A harmadik [2, 48. o., 7.5. egyenlet] feltétel abból adódik, hogy a második feltétel sérülhet, ha a műveletek már a második bemeneti adatot dolgozzák fel. [ ] b i b j + q i bi b j q j < (2.28) R R Ha o i vagy o j komplex pipeline művelet, akkor [ ] b i b j + L i bi b j q j < vagy R R b i b j + q i R [ ] bi b j L j < R (2.29) Ha mindkét művelet komplex pipeline, akkor a harmadik feltétel a következőképpen írható: [ ] b i b j + L i bi b j L j <. (2.3) R R Ha az előző három feltétel egyszerre teljesül, akkor két művelet nem konkurens, tehát megvalósítható egyetlen közös processzorral. Tételezzük fel, hogy c i, c j, vagy mindkettő -től különböző, azaz o i, o j, vagy mindkettő többszörözött művelet. Ebben az esetben a műveletek konkurensek, ha q i + q j R c j >, átrendezve q i + q j R > c j (2.3) fennáll [2, 49. o.].

27 HIERARCHIKUS TERVEZÉS 6 Ha o j komplex pipeline művelet és többszörözött, akkor a módosított RESTART algoritmus által meghatározott példányszám (2.6)-nak megfelelően: c j = R j R. Behelyettesítve c j kifejezését (2.3)-ba: (2.32) Mivel q i + q j R > R j R, vagy átírva q i + q j > R j. (2.33) q i > és L j R j (2.34) mindig teljesül, ezért p i többszörözött példányai mindig konkurensek, azaz időben átfedők. A feltételes elágazások kezelése további vizsgálatot igényel, amelyre nem térünk ki. Ezen a területen elért legújabb eredmények megtalálhatók a [63] doktori értekezésben, ahol a feltételes elágazások tetszőleges mélységű kezelésére alkalmas eljárás kerül bemutatásra. Az értekezés tartalmazza a CONCHECK algoritmus továbbfejlesztését is. Itt jegyeznénk meg, ha a módosított CONCHECK algoritmusban is kicseréljük az elemi műveletek esetén használt t j és q j jellemzőket a komplex pipeline műveletek esetében használt R i és L i jellemzőkre a 2. definíciónak megfelelően, akkor az algoritmus továbbra is helyes eredményt szolgáltat. A fenti megfontolások figyelembe vételével a CONCHECK [2, 52. o.] algoritmust a következő módosításokkal kell alkalmazni: if (o i pipeline művelet) { busy i = L i ; c i = ceil((l i + 2)/R); } else { busy i = q i ; c i = ceil((t i + 2)/R); } if (o j pipeline művelet) { busy j = L j ; c j = ceil((l j + 2)/R); } else { busy j = q j ; c j = ceil((t j + 2)/R); } if (sep_branch(o i, o j )) { if ( ( ((c i == ) && (c j == )) (!((c i == ) && (c j == )) &&!(c i + c j > 3)) ) && ((b j + busy j < b i + R) && (b i + busy i < b j + R)) ) { concurrence = ; /* o i és o j nem konkurens */ } else { concurrence = ; /* o i és o j konkurens */ }

28 HIERARCHIKUS TERVEZÉS 7 } else { if ((c i == ) && (c j == ) && (busy i + busy j < R) && (b j b i > busy i ) && ((b i b j + busy i )/R < int((b i b j busy j )/R))) { concurrence = ; /* o i és o j nem konkurens */ } else { concurrence = ; /* o i és o j konkurens */ } } 2.4. Alkalmazási példák Az előbbiekben ismertetett tervezési módszer jobb megértésére két, rövid alkalmazást mutatunk be. A koszinusz tétel kiszámítása Az első példa a koszinusz tétel kiszámítása, amely a következő formában adott: c 2 = a 2 + b 2 2 a b cos x. (2.35) Ebben a példában feltételezzük, hogy a cos függvény komplex pipeline művelet. A cosx érték kiszámítása a Taylor-soros közelítésen alapul. cos x 2! x2 + 4! x4 6! x6 + 8! x8 (2.36) Először a Taylor-soros közelítés kiszámítását kell megtervezni, majd az így adódott komplex pipeline műveletet felhasználva a koszinusz tétel kiszámítását valósítjuk meg. A Taylor-soros közelítés elemi műveleti gráfja adott. Tételezzük fel, hogy az elemi műveletek végrehajtási ideje a 2.. táblázat szerintiek. 2.. táblázat. Végrehajtási idők a közelítés esetén Művelet Végrehajtási idő Szorzó (m... m) 4 Összeadó (a3, a5) Kivonó (s2,s4) A hagyományos magas szintű szintézis algoritmusait alkalmazzuk. Az eredményt a PIPE tervezőrendszer szolgáltatja, amelyet a rendszer újraindítási idejének függvényében költségfüggvény formájában ábrázolunk 3 és a rendszer lappangása (L) között. Az allokáció során csak az azonos típusú műveletek kerülhettek közös processzorba. Az egyszerűség kedvéért a költséget úgy számoljuk, hogy a processzorok számát szorozzuk az ő végrehajtási idejükkel. Ezt a költségfüggvényt ábrázolja a 2.6. ábra. Természetesen sokkal pontosabb kiértékelést lehetne elvégezni, ha az implementációhoz jóval közelebb álló költségfüggvényt használnánk. Például a processzor végrehajtási ideje helyett a megvalósításához szükséges kapuszámot, vagy az általa elfoglalt szilícium felület nagyságát használhatjuk, mint a processzor bonyolultságát jellemző mennyiséget. Ugyanakkor az egyszerűség kedvéért jó közelítésnek

29 HIERARCHIKUS TERVEZÉS Költség Újraindítási idő ábra. A Taylor-soros közelítés költségfüggvénye 2.2. táblázat. Taylor-soros közelítés eredménye R Processzorok add mul sub Pufferek Költség L tekinthető a processzorszám végrehajtási idővel való súlyozása, mivel minél nagyobb a végrehajtási idő, annál bonyolultabb működésűnek tekinthetjük az adott processzort. A 2.2. táblázat foglalja össze a tervezés eredményét (processzorok száma, pufferek száma, lappangás és a költség R függvényében). A pufferek száma nem tartalmazza a közvetlenül a bemeneteken található szinkronizációs pufferek számát. A módosított gráf és az idődiagram a 2.7. ábrán figyelhető meg. Mivel a kiválasztott újraindítási idő (R = 2) kisebb, mint a lappangás, ezért a koszinusz közelítésének számítása pipeline módon történik. Miután befejeztük a cosx komplex pipeline művelet tervezését, elvégezhetjük a koszinusz tétel kiszámítását. Egy lehetséges, a c 4 komplex pipeline műveletet tartalmazó gráfot a 2.8. ábra bal oldala szemlélteti. A komplex pipeline művelet. A c 4 komplex pipeline művelet viselkedése megfeleltethető egy L c 4 = = = 2 (2.37) 2 R 4 példányban többszörözött elemi művelet viselkedésének. A bemenetén R 4 = 2 gyakorisággal fogadhat adatokat, és az adatok feldolgozásához szükséges idő L 4 = 33.

30 HIERARCHIKUS TERVEZÉS 9 x x B 8 m8 2 4 A s2 6 m 4 C m a3 x m2 4 x 8 m3 4 x 2 m4 4 x 6 m5 4 D 2 m 4 7 x 2 m6 4 x 24 m7 4 m m3 m9 m2 m4 m m5 m8 m6 s2 3 3 s4 E m7 28 m 4 32 a5 32 m a3 a5 s ábra. A Taylor-soros közelítés egy lehetséges megvalósítása, valamint az ütemezési és allokációs információk R = 2-nél Az újraindítási idő csökkentése. Módosítások nélkül a feladat gráfja által engedélyezett legkisebb újraindítási idő min R = 2. Ha R további csökkentése nem szükséges, akkor a RESTART algoritmus nem módosítja az EO-t, kivéve a komplex pipeline művelet bemeneti- és kimeneti puffereinek beillesztését. Ezért két órajel periódus adódik hozzá a lappangáshoz. Ha csak az elemi műveleteket vesszük figyelembe, akkor min R = 6 elérhető lenne: min e j R = max q j + = 5 + = 6. (2.38) A komplex pipeline művelet alkalmazása miatt egy pótlólagos feltétel is fennáll a legkisebb újraindítási idő kiszámítására: min p i R max R i = R 4 = 2. (2.39) Ezek a feltételek min R = 2 eredményeznek a rendszer újraindítási idejére. Szinkronizáció. A szinkronizációs késleltető hatásokat csak m 7 -re és s 8 -ra kell kiszámítani. Alkalmazva a SNC algoritmust: maxp 7,6 = 35 5 = 3, min p 7,6 = = 4 maxp 8,5 = 39 5 = 34, min p 8,5 = = 5 adódik. Az eredmény a 2.8. ábra jobb oldalán látható.

31 HIERARCHIKUS TERVEZÉS 2 a a b b a b x a a b b a b x m m2 m3 m m2 m c4 c a5 4 4 a6 4 a5 4 4 a m7 5 m s s ábra. Az eredeti feladat és a módosított EO a koszinusz tétel kiszámítására a a b b a b x 9 m 9 3 m a m a6 6 c4 33 m3 35 m c4 39 s x a b a 6 a b b cos m mux mux mul 2 a6 5 mux 4 mux m2 add sub m7 cos mul s8 sub a5 add 2.9. ábra. A koszinusz függvény ütemezése és allokációja R = 2-nél

32 HIERARCHIKUS TERVEZÉS 2 Ütemezés. A c 4, m 7, s 8 műveletek alkotta adatút mobilitása nulla, azonban az m, m 2, m 3, a 5 és a 6 műveletek nem rögzítettek, mobilitásuk nem nulla. A fent leírt ütemezési algoritmust alkalmazzuk, mialatt a nem nulla mobilitású műveletek indítási ideje rögzítésre kerül. Az ütemezett EO-t a 2.9. ábra jobb oldala mutatja. Allokáció. Például vizsgáljuk meg a c 4, s 8 művelet párt. Ha a fejezetben említett mindhárom feltétel fennáll, akkor ez a két művelet megvalósítható egy közös processzorral. Az első feltétel a következő: L 4 + q 8 < R, 33 + = 34 2 (2.4) Tehát már az első feltétel nem igaz, amely kizárja az összevonhatóságot. Azért vizsgáljuk meg a többi feltételt is. A második feltétel: b 8 > b 4 + L 4, 39 > + 33 = 34 (2.4) Ez teljesül, igaz. A harmadik feltétel [ b 4 b 8 + L 4 b4 b 8 q 4 < R 2 [ < 2 2 ], (2.42) ], 5 [ 2 39 ] = 2 nem teljesül. Tehát az első és a harmadik feltétel egyaránt sérti az összevonhatóság szükséges feltétel-rendszerét, így c 4, s 8 műveletek nem allokálhatók egy közös processzorba. Az tervezés eredményét a 2.9. ábra jobb oldala szemlélteti. Természetesen a Taylor-soros közelítés esetében más EO-ból is indíthattuk volna a tervezést. Ezt szemlélteti a 2.. ábra bal oldala. Annak eldöntése, meghatározása, hogy az adott feladat szempontjából melyik kiindulási gráf szolgáltatja majd az optimális megoldást, nagyon nehéz. Ez a gondolatmenet elvezet a gráfrajzolás, gráfgenerálás témaköréhez, amelyet nem érintünk. Azonban általában kijelenthetjük, hogy minél kisebb mértékben kell rögzíteni a kiindulási struktúrát a későbbi optimalizálási hatékonyság érdekében. Szeretnénk az algoritmusokra bízni annak eldöntését, hogy melyik műveletet melyik funkcionális egység fogja végrehajtani. Emiatt a kezdetben nem párhuzamosított, soros feldolgozású, bonyolultabbnak tűnő gráf csak akkor hátrány, ha egy hosszú kritikus útban magas végrehajtási idejű (költségű) elemek vannak. Az első Taylor-soros közelítés esetében sajnos ez a megállapítás helyes, így a második esetben kicsit kedvezőbb eredményeket kapunk. A 2.3. táblázat foglalja össze a tervezés eredményét. A módosított gráf és az idődiagram a 2.. ábrán figyelhető meg táblázat. Taylor-soros közelítés eredménye párhuzamos szervezésű EO-ból R Processzorok add mul sub Pufferek Költség L Jelen értekezésben az elsődleges cél a hierarchikus tervezés lépéseinek bemutatása komplex pipeline műveletek felhasználásával, ezért kisebb hangsúlyt fektettünk a kiindulási gráfok optimalizálására. Ezért minden esetben az értekezés során, ahol a koszinusz tételre hivatkozunk, mindig az első Taylor-soros közelítéssel megvalósított koszinusz tételre gondolunk.

33 HIERARCHIKUS TERVEZÉS 22 x x m 4 m B A 4 m m3 4 4 m3 m8 4 s2 C m a3 D 8 m m5 m m7 m m9 a3 a5 s2 s4 2 m 4 8 m s4 6 E 3 m 4 7 a ábra. A Taylor-soros közelítés egy másik lehetséges megvalósítása, valamint az ütemezési és allokációs információk R = 6-nál Komplex pipeline műveletek felhasználásának hatása A második feladatban egy, a digitális jelfeldolgozásban, elsősorban az audió kódolásban széleskörben elterjedt transzformációt, az MDCT-t (Modified Discrete Cosine Transformation) vizsgáljuk meg. Az MPE audió (3. réteg) kódolásnál használt MDCT 2 vagy 36 pontos. A 36 bemeneti adat a többfázisú szűrőtől érkezik (sávonként) és az MDCT 8 kimeneti értéket állít elő (x i ). Az eredeti algoritmus körülbelül 3 szorzóval és 65 összeadóval valósítható meg (feltéve, hogy a koszinusz értékeket konstansként kezeljük, tehát nem kell őket számítani). Az MDCT analitikus kifejezése: n ( π ( x i = z k cos 2k + + n ) ) (2i + ) 2n 2 k= i =... n 2 (2.43) A bejövő adatokat először egy, az aktuális sáv típusától függő függvény ablakozza. Ennek eredménye kerül z i -be. A start, stop és normal sávtípusokra n = 36, azaz 36 pontos MDCT-t alkalmazunk. A továbbiakban csak az első kimeneti érték (i = ) kiszámítását vizsgáljuk, ami a következőképpen néz ki: x = 35 k= ( π ) z k cos 72 (2k + 9),

34 HIERARCHIKUS TERVEZÉS 23 x = 35 k= z k cos y k, y k = π (2k + 9). (2.44) 72 Ezt a feladatot két különböző módon közelítjük meg és oldjuk meg. A hagyományos megközelítés esetén (nem hierarchikus tervezés), a 2.44 kifejezésben szereplő cos műveletet az ő Taylor-soros közelítésével helyettesítjük (lásd előző példa). Ebben az esetben a feladat megoldásához 432 szorzó, 7 összeadó és 72 kivonó műveletre lenne szükség. A feladathoz tartozó gráf lappangási ideje L = 72. Hierarchikus tervezésnél a cos műveletet komplex pipeline műveletként kezeljük, amelyre R cos = 2 és L cos = 33. Ekkor a feladat megoldásához eredetileg 36 szorzó, 35 összeadó és 36 cos művelet szükséges. A kétféle tervezési módszer esetén a megvalósításhoz szükséges tényleges processzor számot a 2.4. táblázat mutatja a kiválasztott újraindítási időpontokban, feltüntetve a processzor típusokat is táblázat. Processzorszám összehasonlítás a hagyományos és hierarchikus tervezési eljárás esetén Hagyományos Hierarchikus R add mul sub add cos mul A feladat megvalósításához szükséges processzorok számát mind a hagyományos, mind a hierarchikus tervezési eljárás esetében a 2.. ábra szemlélteti az újraindítási idő függvényében. A hierarchikus esetben a processzorszám számításnál a cos típusú processzorokat komplex hierarchikus építőelemként kezeljük, nem vesszük figyelembe, hogy ez az építőelem eredetileg hány processzorral lett megvalósítva. Ennek az a magyarázata, hogy a komplex építőelemet egy dobozként kezeljük, aminek csak az újraindítási idejét, lappangását, valamint a költségét ismerjük, a belső felépítését nem. A megvalósítási költség vizsgálatánál természetesen figyelembe vesszük az adott komplex pipeline építőelem költségét. Másik lényeges szempont a megvalósítási költség vizsgálata. A költséget most is úgy számoljuk, hogy a processzorok számát szorozzuk az ő végrehajtási idejükkel. Ez a hagyományos tervezési eljárás esetén a következőképpen néz ki: C = i P i t i, (2.45) ahol P i az i típusú processzorok száma, P i nem hierarchikus építőelem. Ezzel szemben a hierarchikus eljárás esetén a fenti képlet módosul, hiszen ismerjük a komplex építőelem költségét, így az ő végrehajtási ideje (L i ) helyett a költségét vesszük figyelembe a megvalósítandó rendszer összköltségének számításakor. C = i P i t i + j P j C j, (2.46) ahol P j a j típusú processzorok száma, P j hierarchikus építőelem, C j pedig a j típusú processzor költsége. A 2.2. és a 2.4. táblázat alapján R = 5 esetén a rendszer költsége (a táblázat nem tartalmazza a pufferek költségét, amit természetesen szintén számításba kell venni), hagyományos tervezési eljárás esetén: C = = 3544

35 HIERARCHIKUS TERVEZÉS hagyományos hierarchikus 2 Processzorok száma Újraindítási idő 2.. ábra. Processzorok száma az újraindítási idő függvényében hagyományos hierarchikus 34 Költség Újraindítási idő 2.2. ábra. A megvalósítás költsége az újraindítási idő függvényében Hierarchikus tervezési eljárás esetén: C = = 2853 A rendszer megvalósításának a fenti módszerrel számított költségét mind a hagyományos, mind a hierarchikus tervezési eljárás esetében a 2.2. ábra szemlélteti az újraindítási idő függvényében. Természetesen az előzőleg már említett módon tetszőleges költségfüggvényt lehet használni a különböző megvalósítások összehasonlítására. Az implementációhoz közelebb álló jellemzők például a komplex funkcionális egységek megvalósításához szükséges kapuszám, vagy az általuk elfoglalt szilícium felület nagysága.

36 HIERARCHIKUS TERVEZÉS 25 A következő, lényeges összehasonlítási szempont a tervezésre fordított idő. A futtatási idő 6 értékeket a 2.5. táblázat tartalmazza a kiválasztott újraindítási időpontokban táblázat. A futtatási idők összehasonlítása Újraindítási idő Hagyományos [s] Hierarchikus [s] Arány [%] A 2.3. ábra a futtatási idő alakulását mutatja mind a hagyományos, mind a hierarchikus tervezési eljárás esetében az újraindítási idő függvényében. Az ábrán látható, hogy a hierarchikus tervezési eljárás nagyon hatékony a tervezési idő tekintetében. Ez azt jelenti, hogy a módszer kiválóan alkalmas prototípus tervezésre, több koncepciót nagyon gyorsan ki lehet próbálni, meg lehet valósítani. Ezek közül a legjobbakat pedig részletesen ki lehet dolgozni, és tovább lehet optimalizálni a hagyományos eljárással, ha szükséges. hagyományos hierarchikus uttatási idő [s] Újraindítási idő 2.3. ábra. A tervezéshez szükséges idő (futtatási idő) 6 A futtatási idő a PIPE tervezőrendszer futási ideje az adott újraindítási időre. A teszteléshez használt számítógép konfigurációja a következő: Intel Pentium4 2.4Hz CPU, 52MB RAM, WindowsP operációs rendszer, cygwin környezet

37 HIERARCHIKUS TERVEZÉS Első tézis Az előzőek alapján a következő kijelentéseket tehetjük.. Tézis. Hierarchikus tervezés komplex pipeline műveletekkel Új modellt és tervezési módszert fejlesztettem ki, amely a magas szintű szintézis során az ismert eljárásokhoz illeszkedő módon lehetővé teszi a tetszőleges bonyolultságú komplex pipeline működésű műveletek kezelését az elemi műveletekhez hasonlóan [8, 6, 4, 9, 27]... A tetszőleges bonyolultságú pipeline működésű művelet lappangási idejét (L i ) és újraindítási idejét (R i ) a modell az alábbiak szerint értelmezi. L i t j, R i q j ahol t j és q j rendre megfelel az elemi műveletek végrehajtási és foglaltsági idejének..2. A kidolgozott modell a tetszőleges bonyolultságú pipeline működésű műveleteket többszörözött elemi műveleteknek felelteti meg a példányszám alábbi értelmezésével. Li + 2 c i = R i.3. Az új módszer az újraindítási idő beállítását végző (RESTART [2, 7. oldal]), a szinkronizációt biztosító (SNC [2, 28. oldal]), az ütemező [2, -3. oldal] és allokációs (CONCHECK [2, 28. oldal]) algoritmusokat azzal a céllal egészíti ki, hogy a tetszőleges bonyolultságú pipeline működésű műveletek alkalmazhatóak legyenek a tervezési eljárás során.

38 3. fejezet Szisztematikus dekompozícó és erőforrás kiosztás 3.. Bevezetés és szakirodalmi áttekintés A rendszer-szintű szintézis további lépéseiben olyan dekompozíciós algoritmusra van szükség, amely a teljes rendszert felbontja előre megadott és kiadódó komplex funkcionális egységekre. Ennek során sokszor egymásnak ellentmondó peremfeltételek mellett (a komplex funkcionális egységek közötti kommunikáció sebessége, a vezérlési struktúra egyszerűsége, az ismételt felhasználás mértéke, a különböző költségtényezők egymáshoz képesti aránya, pipeline működés biztosítása, stb.) kell a lehető legkedvezőbb megoldásokat megtalálni. Az allokáció eredményeként rendelkezésre áll a műveleteknek olyan fedőrendszere, amelynek minden blokkja olyan műveleteket tartalmaz, amelyek páronként nem-konkurensek, vagyis végrehajthatók közös processzorral. Ha közös processzorokként készen kapható, adaptálható és újrakonfigurálható egységek, vagy az előző fejezetben leírtak alapján kiadódó komplex funkcionális egységek alkalmazása a cél, akkor szükség van olyan szisztematikus eljárásra, amely a rendelkezésre álló, vagy kiadódó processzor készletéből való kiválasztást és az ismételt felhasználást (reuse) kísérli meg optimalizálni. Mivel a feladat NP-teljes [6], a továbbiakban ismertetendő COMPALL (COMPositive ALLocator) algoritmus csak egyszerű és gyors közelítő optimumkeresést tűzhet ki célul []. A variációk száma, így a COMPALL gyorsasága erősen függ a kiindulási fedőrendszer blokkjainak számától. Ha nagyfokú az átfedés a kiindulási fedőrendszer blokkjai között, akkor ez meredeken növelheti a variációk számát a komplex funkcionális egységek kiválasztásakor. Ez a nehézség csökkenthető a fedőrendszer redukálását végző REDIN (REDucing the INital cover) algoritmus segítségével. Már kisméretű feladat esetén is gondot jelenthet a kiindulási fedőrendszer megtalálása. Ezt a problémát már tapasztalhattuk a nem teljesen specifikált sorrendi hálózatok állapot-összevonási eljárása során is. Ehhez nyújt segítséget a MACOMP (MAimal COMpatibility classes Provider) iteratív algoritmus. A téma aktualitását mutatja, hogy a [75]-ben egy olyan tervezési módszertant mutatnak be, amely képes nem időzített szinkron adatfolyam gráfból kiindulva a legkisebb költségű pipeline üzemű PA implementáció kiválasztására oly módon, hogy az erőforrás kiosztást egyesítik a modul kiválasztással pipeline ütemező felhasználásával. Ezt a technikát használják fel arra, hogy egyidőben biztosítsák a legkisebb szilícium felület igényű implementáció kiválasztását úgy, hogy ez megfeleljen a felhasználó által megadott minimális átbocsátó képesség kritériumnak. Előnye ennek a felfogásnak, hogy a felhasználónak csak a minimális átbocsátó képességet, szükséges számítási kapacitást kell megadnia, az órajel frekvencia és az újraindítási idő (azaz a pipeline mélysége) a tervezési eljárás végén kiadódó paramé- Egy tetszőleges Ω halmaz egy lefedésén egy olyan θ halmazrendszert értünk, amelynek tagjai (ha külön-külön nem is, de összességükben) tartalmazzák az Ω bármely elemét, vagyis amelynek unióhalmaza részként tartalmazza Ω-t, Ω Ë θ. 27

39 SZISZTEMATIKUS DEKOMPOZíCÓ 28 ter. Ugyanakkor hátránya az, hogy iteratív eljárást mutat be a probléma megoldására, amely a teljes keresési teret vizsgálja, ily módon az algoritmusok futási ideje exponenciális robban a feladat bonyolultsága függvényében. A [75]-ben a modul kiválasztásra egy heurisztikus módszer is bemutatásra kerül, amely nagyban csökkenti a keresési tér nagyságát, ezáltal csökken az algoritmus futtatásához szükséges idő, azonban az optimum megtalálása nem garantált. Azt hangsúlyozzák, hogy ez az első ilyen kutatási eredmény ezen a területen, amely az előbb említett három technikát együtt alkalmazza, azonban a [2] könyvben ismertetett eredmények és az általam kidolgozott és publikált eljárások is korábbi kutatási eredmények. Itt említeném meg, hogy a [2]-ben kidolgozott algoritmusok esetén az újraindítási időt kell megadni bemenő paraméterként, amiből a maximális órajel frekvencia és így az áteresztőképesség is kiadódik Dekompozíció komplex funkcionális egységekre A COMPALL algoritmus Jelölje M a műveletek O halmazán képzett fedőrendszert. Ilyen fedőrendszernek tekinthető például a nem-konkurens műveletek maximális kompatibilitási osztályainak halmaza, amelyet az ütemezés és az allokáció szolgáltat a magas szintű szintézis során [47], [2], [6]. A fedőrendszerből kiindulva minden műveletet hozzá kell rendelni végrehajtásra a felhasználható komplex funkcionális egységeknek az I halmazából választott valamelyik, de csak egyetlen eleméhez. Meg kell tehát határozni a műveletek O halmazán egy T teljes partíciót az M fedőrendszerből kiindulva. Ennek a T partíciónak minden egyes blokkját egy végrehajtó komplex funkcionális elem definiálja, hiszen a blokkban szereplő műveleteket éppen ennek az erőforrásnak kell végrehajtania. A végrehajtó processzorok kiválasztásakor, vagyis T blokkjainak meghatározásakor a következő feltételezéseket és peremfeltételeket kell figyelembe venni.. Minden egyes komplex funkcionális egységet (processzort) azok a művelet típusok definiálják, amelyek végrehajtása lehetséges és preferált az adott egységgel. 2. Az adott komplex funkcionális egység készletből a lehető legkevesebb egységet kell felhasználni. 3. A lehető legkevesebb komplex funkcionális egység típust kell felhasználni (törekedni kell az ismételt felhasználásra). 4. A komplex funkcionális egységek különböző kiválasztási szempontjai megfelelő súlytényezők alkalmazásával egyszerűen lehessenek súlyozhatók és kombinálhatók.

40 SZISZTEMATIKUS DEKOMPOZíCÓ 29 Az algoritmus leírásában alkalmazott jelölések O : (o,...,o i,...,o N ) M : (M,...,M r,...,m k ) c(m r ) I : (I,...,I s,...,i j ) c(i s ) U : (U,...,U s,...,u j ) S : (...,I h,...,i v,...,i q,... ) n(i s ) U s,z T W Cost W γ W Sort w s A műveletek halmaza Az O halmaz teljes fedőrendszere (pl. az allokáció során keletkező maximális kompatibilitási osztályok halmaza) M r relatív költsége Az alkalmazható összes komplex funkcionális egységek halmaza, blokkjait azok a művelet típusok definiálják, amelyek végrehajtása lehetséges az adott egységgel. I s relatív költsége Az O halmazbeli műveletek azon nem szükségszerűen diszjunkt részhalmazai, amelyek végrehajtása lehetséges és preferált rendre az I,...,I s,...,i j egységekkel A kiválasztott végrehajtó komplex funkcionális egységek halmaza Az I s jelű komplex funkcionális egységnek a kiválasztás során kiadódó példányszáma U s diszjunkt részhalmazai, amelyek azokat a műveleteket tartalmazzák, amelyek végrehajtására az I s jelű egység z-dik példánya lett kiválasztva (( s j),( z n(i s ))) Az O halmaz végrehajtó partíciója (blokkjait az összes U s,z ) részhalmaz képezi) c(i s ) relatív súlytényezője γ s relatív súlytényezője, ahol γ s = M r U s : (M r,u s ) M U r N s relatív { súlytényezője, ahol, if n(is ) > N s =, if n(i s ) = Az I s jelű komplex funkcionális egységre vonatkozó súlyfüggvény érték Az algoritmus leírása A cél tehát az M fedőrendszerből kiindulva egy T teljes partíció meghatározása mindvégig szem előtt tartva, hogy az adott komplex funkcionális egység készletből a lehető legkevesebb számú és típusú egységet használjunk fel. ontos továbbá, hogy a kiválasztás mechanizmusa könnyen változtatható, hangolható legyen. Ahhoz, hogy a lehető legkevesebb számú egységet válasszuk ki az előre adott komplex funkcionális egységek halmazából, két új mennyiséget is bevezetünk. Az α-val jelölt mennyiség az M r, U s halmazok páronkénti közös részének a legnagyobb elemszámát fejezi ki. α = max{ M r U s : (M r,u s ) M U} (3.) Törekedni kell arra, hogy a komplex funkcionális egységek (azaz U s -ek) kiválasztásakor azt az egységet válasszuk ki, amelyhez az α érték tartozik. Ekkor tudjuk lefedni legjobban U s -sel az α-hoz tartozó M r halmazt.

41 SZISZTEMATIKUS DEKOMPOZíCÓ 3 A második mennyiség arra jellemző, hogy egy adott U s mennyire képes lefedni, megvalósítani egyszerre az összes M r halmazt. Ehhez összegeznünk kell az M r, U s halmazok páronkénti közös részének elemszámát. Jelölje ezt a mennyiséget γ s. γ s = r M r U s : (M r,u s ) M U, U s -re (3.2) A kiválasztás során szintén törekedni kell arra, az ismételt felhasználás követelménye miatt, hogy olyan U s -t válasszunk ki, ahol γ s érték a legnagyobb. γ max = max γ s (3.3) Ahhoz, hogy a kiválasztás mechanizmusa könnyen hangolható legyen, valamint az ismételt felhasználás mellett a megvalósítás költségét is figyelembe tudjuk venni, bevezetjük a w s súlyfüggvényt (minden U s -re), amelyben szereplő súlytényezők segítségével könnyen változtatható a kiválasztás célja. c(i s ) w s = W Cost max{c(i k ),I k I} + W γ s γ + W Sort N s, U s -re (3.4) γ max A súlyfüggvényben lévő tagok normáltak, így csak a súlyok határozzák meg a hatásuk arányát. Az első tag a megvalósítás költségét tartalmazza, amelyet negatív előjellel veszünk figyelembe, hiszen a legkisebb költségű megvalósításra törekszünk. A második tagban közvetett módon γ s hatása érvényesül, míg a harmadik tagban is az ismételt felhasználást díjazzuk a következőképpen: { ha n(is ) N s = ha n(i s ) =, U s-re. (3.5) Azaz, ha az adott U s -hez tartozó komplex funkcionális egység (I s ) már ki lett választva, akkor N s értéke, egyébként. Az ismételt felhasználás és a költség mellett figyelembe kell venni, hogy minden egyes lépésben a kiválasztás során a lehető legkevesebb szabadsági fokot vesszük el. Ehhez bevezetjük δ r mennyiséget. δ r = M r, M r -re (3.6) Az előző megfontolások alapján a COMPALL algoritmus leírása a következőképpen néz ki. START n(i s := ) S := while M do { α = max{ M r U s : (M r,u s ) M U} U s -re: γ s = M r U s : (M r,u s ) M U r γ max meghatározása (legnagyobb γ s érték) c(i s ) U s -re: w s = W Cost max{c(i k ),I k I} + W γ s γ + W Sort N s γ max M r -re: δ r = M r δ min meghatározása (legkisebb δ r érték) Egy U s kiválasztása, amelyre: M r : M r U s = α és w s = w max és δ r = δ min

42 SZISZTEMATIKUS DEKOMPOZíCÓ 3 S := S I s n(i s ) := n(i s ) + U s,n(is) := M r U s o i elhagyása M-ből, ha o i U s,n(is) } STOP Minden lépésben kiszámítjuk α értékét. Hasonlóan minden U s -re meghatározzuk γ s értékét és w s súlyfüggvényt. Minden M r -re kiszámítjuk δ r -t, és meghatározzuk γ max és δ min értékeket. A kiválasztás a következő lépésekből áll. Először kiválasztjuk azon U s halmaz(oka)t, amely(ek)re igaz, hogy M r : M r U s = α. Ezek után tovább szűkítjük a kiválasztott U s halmaz(oka)t a w s = w max feltétel alapján. Végül, ha még mindig több U s van kiválasztva, közülük egy kerül kiválasztásra a δ r = δ min feltétel szerint. Ha több legkisebb δ r létezik, akkor közülük az elsőre megtalált δ r lesz δ min. Mindezek után a kiválasztott U s -hez tartozó komplex funkcionális elemet hozzávesszük S-hez és a példányszámát -gyel növeljük. Végezetül minden olyan műveletet (o i -t) elhagyunk M-ből (az összes M r -ből), amelyet az éppen kiválasztott I s komplex funkcionális elem végre tud hajtani. A COMPALL algoritmus konvergenciája nyilvánvaló, hiszen M mérete minden ciklusban csökken, így a befejeződéskor üres halmaz adódik. A konvergencia sebességét alapvetően a kritériumok (α, w max, δ min ) szerinti heurisztikus U s választás határozza meg. A w s értékek változtathatók a súlytényezők (W Cost, W γ, W Sort ) hangolása révén. Ezáltal U s kiválasztási stratégiája befolyásolható és hatékonysága ellenőrizhető, kikísérletezhető. A variációk száma erősen függ a kiindulási M halmaz blokkjainak számától ( M ). Nagy M érték várhatóan nagyfokú átfedéssel jár együtt a kiindulási fedőrendszer blokkjai között, ami meredeken növelheti a variációk számát U s kiválasztásakor. Ez a nehézség csökkenthető a kiindulási M fedőrendszer redukálását végző algoritmus segítségével, amely a következő fejezetben kerül bemutatásra. Ha a COMPALL algoritmus komplexitását vizsgáljuk, akkor a következő megállapításra juthatunk. Jelöljük n-nel a műveletek számát, azaz n = O. A legpesszimistább eset az a kiválasztási lépések sorozatában, ha olyan U s -t választunk ki minden egyes lépésben, amelynek hatására csak egy művelet hagyható el M blokkjaiból. Minden egyes lépésben új műveleteket kell elhagyni M-ből, de az előzőleg elhagyott műveletek már nem szerepelnek M-ben. Ezért legfeljebb n lépés után M. Így megállapítható, hogy a COMPALL algoritmus komplexitása O(n). Ebből is látható az algoritmus mohó volta. Természetesen az egyes lépések során az U s kiválasztásához szükséges jellemzők kiszámításához szükséges idő nagy is lehet M U nagysága miatt, azonban a lépésszám tekintetében gyors algoritmusról van szó. Alkalmazási példa a COMPALL algoritmusra Tegyük fel, hogy adott az O = {o,o 2,... o 8 } műveletek halmaza és ezen műveletek teljes fedőrendszere M = {M,M 2,...,M 9 } = = {{o 3,o 6,o 8 }, {o 3,o 5,o 6 }, {o 2,o 6,o 8 }, {o 2,o 6,o 7 }, {o,o 2,o 8 }, {o 3,o 6,o 7 }, {o 2,o 5,o 6 }, {o 4,o 8 }, {o,o 3,o 8 }}.

43 SZISZTEMATIKUS DEKOMPOZíCÓ 32 Továbbá adott a következő komplex funkcionális elemkészlet, ill. az általuk végrehajtható műveletek halmaza, azaz U = {U,U 2,...,U 5 } = {{o,o 2,o 3,o 7 }, {o 4 }, {o 5,o 6 }, {o 8 }, {o,o 2,o 3,o 7,o 4 } {o,o 2,o 3,o 7,o 5,o 6 }, {o,o 2,o 3,o 7,o 8 }, {o 4,o 5,o 6 }{o 4,o 8 }, {o 5,o 6,o 8 }, {o,o 2,o 3,o 7,o 4,o 5,o 6 }, {o,o 2,o 3,o 7,o 4,o 8 }, {o,o 2,o 3,o 7,o 5,o 6,o 8 }, {o 4,o 5,o 6,o 8 }}. A komplex funkcionális egységek relatív költségei rendre a következők, továbbá c(i s ) = {4,8,2,2,2,6,6,,,4, 4,4,8,2}, c(m r ) = {8,6,8,6,6,6,6,, 6} is adott. Ebben a példában a súlyfüggvény kifejezésében lévő mindhárom súlytényező értékét azonosra választottuk, értékük,. Mivel a súlyoknak csak az egymáshoz képesti aránya számít, ezért praktikusan és közötti értékeket adunk nekik. A következő táblázat tartalmazza γ s és δ r értékeket, a félkövér számok az α-t, a dőlt γ s érték pedig γ max -ot jelölik. A w s súlyfüggvény értékek csak ott vannak feltüntetve, ahol M r U s = α, hiszen a kiválasztás során ennek a feltételnek kell először teljesülnie. Az algoritmusban leírtak alapján az első lépésben U 3 (és a hozzá tartozó I 3 komplex funkcionális egység) került kiválasztásra, mivel a hozzá tartozó súlyfüggvény érték a legnagyobb. M U M M 2 M 3 M 4 M 5 M 6 M 7 M 8 M 9 γ s w s U U 2 U U 4 5 U U ,37 U ,25 U U U U U ,28 U ,43 U δ r Így az első lépés után U 3, = {o 3,o 6,o 8 }. A megfelelő műveletek elhagyása után az M halmaz a következőképpen alakul: M = {{}, {o 5 }, {o 2 }, {o 2,o 7 }, {o,o 2 }, {o 7 }, {o 2,o 5 }, {o 4 }, {o }}. A következő táblázat már az aktuális M halmaz alapján számított új értékeket tartalmazza. A második lépésben ismét U 3 került kiválasztásra. Ennek megfelelően U 3,4 = {o 2,o 7 }. Az I 3 példányszáma -gyel nő, n(i 3 ) = 2. Az o 2,o 7 műveletek elhagyása után: M = {{}, {o 5 }, {}, {}, {o }, {}, {o 5 }, {o 4 }, {o }}.

44 SZISZTEMATIKUS DEKOMPOZíCÓ 33 M U M M 2 M 3 M 4 M 5 M 6 M 7 M 8 M 9 γ s w s U 2 2 8,44 U 2 U 3 2 U 4 U ,4 U ,48 U ,3 U 8 3 U 9 U 2 U U ,8 U ,34 U 4 3 δ r Tovább folytatva a kiválasztást, U s,z, n(i s ) és M lépésről-lépésre a következő értékeket veszik fel. U 3,2 = {o 5 } n(i 3 ) = 3 M = {{}, {}, {}, {}, {o }, {}, {}, {o 4 }, {o }} U 3,5 = {o } n(i 3 ) = 4 M = {{}, {}, {}, {}, {}, {}, {}, {o 4 }, {}} U 2,8 = {o 4 } n(i 2 ) = M = Végül 2 féle komplex funkcionális egységgel valósítható meg a feladat, I 3 -ból 4, I 2 -ből pedig példányra van szükségünk. Megfigyelhető, hogy az algoritmus a lehető legkevesebb komplex funkcionális egység fajta és darabszámmal próbálta megoldani a feladatot, mindvégig törekedve arra, hogy a megvalósítás költségét is alacsonyan tartsa, ami 4 c(i 3 ) + c(i 2 ) = = 4. Mint azt már többször említettük, a kiválasztás menete változtatható, a súlyokkal könnyen hangolható. Ha azt szeretnénk, hogy az algoritmus olcsóbb megoldást találjon (ha ez egyáltalán lehetséges), akkor a megfelelő súlyt növelni kell a többi súlyhoz képest. Ha például W Cost értékét,5-re állítjuk, míg W γ és W Sort értékét változatlanul,-en hagyjuk, akkor a következő eredmény születik: n(i 2 ) = n(i 6 ) = 2 n(i 7 ) =. A példa alkalmazás megvalósításához ebben az esetben 3 fajta komplex funkcionális egységet kell felhasználni, tehát kismértékben nőtt az egységek száma. A rendszer költsége azonban csökkent, hiszen: n(i 2 ) c(i 2 ) + n(i 6 ) c(i 6 ) + n(i 7 ) c(i 7 ) = = A REDIN algoritmus Mivel a COMPALL algoritmus által vizsgált variációk száma erősen függ a kiindulási M halmaz blokkjainak számától, ezért szükség van egy olyan hatékony algoritmusra, ami a kiindulási M fedőrendszer redukálását végzi el. A redukció akkor hatékony, ha a keletkezett M(red) halmazra a COMPALL algoritmus által szolgáltatott eredmény azonos a kiindulási M halmazra szolgáltatott eredménnyel, vagy csak kis mértékben tér el tőle. Lényeges megemlíteni, hogy az algoritmus alapgondolata nagyon hasonló a logikai függvények prímimplikáns lefedésénél használt segédfüggvény alkalmazásának módszeréhez.

45 SZISZTEMATIKUS DEKOMPOZíCÓ 34 Az algoritmus leírásában alkalmazott jelölések z i m r g s(m) M(red) Az o i művelet előfordulásának száma az aktuális M halmazban A z i értékek súlyozott összege M r -ben és c(m r ) összege (a súlyokat az o i műveletek relatív költségei képezik) M kívánt redukciójának mértéke A legkisebb z i érték(ek)nek megfelelő o i művelete(ke)t tartalmazó, legnagyobb m r értékekkel rendelkező M r -ek halmaza A redukált M halmaz Az algoritmus leírása Az elsődleges cél az, hogy egy teljes fedőrendszert válasszunk ki M-ből. A kiválasztás során nem kell vizsgálni a lefedés zártságát, mivel a kiindulási M halmaz, amely a nem-konkurens műveletek maximális kompatibilitási osztályainak halmaza, nem tartalmaz feltételes kompatibilitást. A teljes fedőrendszer megtalálása után az M halmaz további blokkjait vehetjük hozzá M(red)-hez. Ezzel befolyásolhatjuk a COMPALL algoritmus által vizsgált variációk számát, így az algoritmus gyorsaságát is. igyelni kell azonban arra, hogy ezt még kezelhető szinten tartsuk. A redukció mértékét könnyen hangolhatjuk a g paraméterrel. Vizsgáljuk meg először, hogyan tudjuk kiválasztani M egy teljes fedőrendszerét. Ehhez lépésrőllépésre a következőket kell végrehajtani. Arra kell törekedni, hogy először olyan M r blokkokat kell kiválasztani, amelyek azokat a műveleteket tartalmazzák, amelyeket esetleg más M r blokk nem tartalmaz, így mindenképpen ki kell választani őket. Ezáltal nem csökkentjük jelentősen a szabadsági fokok számát. A cél, hogy minél későbbre hagyjuk az úgynevezett redundáns információt tartalmazó blokkokból történő választást. Ezért minden lépésben olyan M r blokkokat választunk ki, amely a lehető legkevesebb olyan műveleteket (o i -t) tartalmazzák, amelyek M halmaz legkevesebb blokkjában szerepelnek. Ezért vezettük be előzőleg z i fogalmát, ezen értékeket a kiválasztás során figyelembe vesszük. Első közelítésben tehát, a kiválasztott M r halmazok: s (M) = r M r : o j M r és z j = min z i. (3.7) Ezen kiválasztott M r blokkok közül azonban már azt a blokkot kell kiválasztani, amely bizonyos szempontból a legnagyobb számban előforduló o i műveleteket tartalmazza. Mivel az így kiválasztott blokk tudja a legtöbb műveletet lefedni, így a következő iterációban ezen műveletekhez tartozó z i érték lesz. Ehhez az adott M r blokkban szereplő o i -khez tartozó z i értékeket súlyozva összegezzük, és hozzáadjuk ezen blokk relatív súlyát. Így megkapjuk m r értékeket. Az utolsó tag azért szerepel m r kifejezésében, mert így a legtöbb műveletet megvalósító blokkok közül a legkisebb költséggel rendelkező M r blokkot részesítjük előnyben. m r = o i M r t i max i t i z i + ( ) c(m r) max c(m r ) r Végül a legnagyobb m r értékkel rendelkező M r blokkot választjuk ki. (3.8) s(m) = j M j : M j s (M) és m j = maxm r (3.9) Ha s(m) >, akkor s(m) elemei közülük már tetszőlegesen választunk egy M r blokkot. A kiválasztott blokk már az M(red) redukált halmaz egy eleme lesz. Az iteráció lezárásaként, az azon műveletekhez tartozó z i értéket, amelyeket a kiválasztott M r blokk tartalmazott, -ra állítjuk. rissítjük az m r értékeket, és tovább folytatjuk a kiválasztást egészen addig, amíg M(red) teljes fedőrendszert alkot.

46 SZISZTEMATIKUS DEKOMPOZíCÓ 35 A teljes lefedés megtalálása után tovább folytatjuk az M r blokkok kiválasztását az előre beállítható g limit eléréséig. A kiválasztás menete annyiban különbözik az előbb ismertetett eljárástól, hogy az egyes iterációkban a z i értékeket nem állítjuk -ra, hiszen a teljes lefedés megtalálása következtében már az összes műveletet kiválasztottuk és megvalósítottuk valamely M r blokk segítségével. Továbbra is az a cél, hogy a legnagyobb m r értékkel rendelkező M r blokkot válasszuk ki minden egyes iterációban az aktuális M-ből. Az előző megfontolások alapján a REDIN algoritmus leírása a következőképpen adható meg. START ha M < g akkor STOP M(red) := j := z i -k és m r -ek kiszámítása minden egyes o i -re és M r -re do { s(m) meghatározása egy M r kiválasztása s(m)-ből és elhagyása az aktuális M-ből M(red) := M(red) M r ha o i M r, akkor z i := m r -ek és s(m) újraszámítása az aktuális M-re j := j + } while M(red) nem teljes fedőrendszer while j g { egy M r kiválasztása s(m)-ből és elhagyása M-ből M(red) := M(red) M r z i -k, m r -ek és s(m) újraszámítása az aktuális M-re j := j + } g := j STOP Ha a REDIN algoritmus komplexitását vizsgáljuk, akkor a következő megállapításra juthatunk. Jelöljük ismét n-nel a műveletek számát, azaz n = O. Először az algoritmus első részét vizsgáljuk, amíg a teljes lefedést meg nem találja. Ebben az esetben minden lépésben a kiválasztott M r -ben szereplő o i -khez tartozó z i -k értéke lesz. Az eljárás akkor találja meg a teljes lefedést, ha az összes z i értéke. A legrosszabb eset, ha minden egyes M r kiválasztási lépésben csak egyetlen művelethez tartozó z i értéke lesz. Ekkor n lépésszám után találjuk meg a teljes lefedést. Így megállapítható, hogy a REDIN algoritmus komplexitása O(n) a teljes lefedés megtalálásáig. Másodszor azt az esetet vizsgáljuk, amikor folytatjuk további M r blokkok kiválasztását. Jelölje j c azt a lépésszámot, amikor a REDIN algoritmus megtalálta az M egy teljes fedőrendszerét. Ezek után már csak l = g j c állandó számú lépést kell az algoritmusnak végrehajtani. Természetesen az egyes lépések során az M r kiválasztásához szükséges jellemzők kiszámításához szükséges idő nagy is lehet M O nagysága miatt, azonban a lépésszám tekintetében gyors, mohó algoritmusról van szó. Alkalmazási példa a REDIN algoritmusra A COMPALL algoritmusnál már ismertetett példára mutatjuk be a REDIN algoritmus működését. Tehát O, M és c(m r ) adott, t i pedig: t i = {4,4,4,8,2,2,4,2}.

47 SZISZTEMATIKUS DEKOMPOZíCÓ 36 A g limitet 7-re állítjuk, azaz maximálisan M(red) = 6. A keresési eljárást befejezzük, ha a kiválasztott 6 blokk teljes lefedést valósít meg, egyébként folytatjuk a kiválasztást addig, amíg M(red) teljes fedőrendszert nem alkot M-en. A következő táblázat tartalmazza z i és m r értékeket az első ciklusban. M O M M 2 M 3 M 4 M 5 M 6 M 7 M 8 M 9 z i o 2 o 2 4 o 3 4 o 4 o 5 2 o 6 6 o 7 2 o 8 5 m r 4,95 4,4 4,95 4,9 4,65 4,9 4,4 2,25 4,65 Először a legkisebb z i -hez tartozó M r blokkokat válasszuk ki, tehát: s (M) = {M 8 }. Mivel s (M) egyelemű, ezért s(m) = s (M) = {M 8 }. Tehát az első ciklus végén M(red) = {M 8 } = {o 4,o 8 }. Az első lépés után az {o 4,o 8 } műveletek elhagyásával az M halmaz a következőképpen alakul: M = {{o 3,o 6,o 8 }, {o 3,o 5,o 6 }, {o 2,o 6,o 8 }, {o 2,o 6,o 7 }, {o,o 2,o 8 }, {o 3,o 6,o 7 }, {o 2,o 5,o 6 }, {}, {o,o 3,o 8 }}. A következő táblázat már az aktuális M halmaz és a kiválasztott {M 8 } blokk alapján újraszámított z i és m r értékeket tartalmazza. M O M M 2 M 3 M 4 M 5 M 6 M 7 M 8 M 9 z i o 2 o 2 4 o 3 4 o 4 o 5 2 o 6 6 o 7 2 o 8 m r 3,7 4,4 3,7 4,9 3,4 4,9 4,4 3,4 Látható, hogy három művelet, o,o 5 és o 7 is kétszer fordul elő az M halmazban. Ezen műveletek hat {M r } blokkban is szerepelnek, így s (M) a következő: s (M) = {M 2,M 4,M 5,M 6,M 7,M 9 }.

48 SZISZTEMATIKUS DEKOMPOZíCÓ 37 Mivel s (M) elemei közül két blokk is a legnagyobb m r értékkel rendelkezik (m 4 = m 6 = 4,9), ezért s(m) = {M 4,M 6 }. Válasszuk ki közülük M 6 -ot, így a második iteráció végén a redukált M halmaz a következőképpen néz ki: M(red) = {M 8,M 6 } = {{o 4,o 8 }, {o 3,o 6,o 7 }}. A harmadik iteráció kezdetekor az aktuális z i és m r értékeket a következő táblázat mutatja. M O M M 2 M 3 M 4 M 5 M 6 M 7 M 8 M 9 z i o 2 o 2 4 o 3 o 4 o 5 2 o 6 o 7 o 8 m r,9 2,2 2,4 3,4 2,9,4 Két művelet létezik (o, és o 5 ), amelyek kétszer fordulnak elő az M halmazban, ennek megfelelően s (M) = {M 2,M 5,M 7,M 9 }. Látható, hogy az aktuális s (M) elemei közül csak egyetlen olyan létezik, amely a legnagyobb m r értékkel rendelkezik. A legnagyobb m r érték 3,4, a hozzá tartozó blokk M 5. Tehát s(m) = M 5, a redukált M halmaz pedig: M(red) = {M 8,M 6,M 5 } = {{o 4,o 8 }, {o 3,o 6,o 7 }, {o,o 2,o 8 }}. A negyedik iteráció kezdetekor az aktuális z i és m r értékek a következőképpen alakulnak. M O M M 2 M 3 M 4 M 5 M 6 M 7 M 8 M 9 z i o o 2 o 3 o 4 o 5 2 o 6 o 7 o 8 m r,9,9 Az előzőek alapján, s (M) = {M 2,M 7 }, s(m) = {M 2,M 7 }. A redukált halmaz M 7 blokk kiválasztása után, M(red) = {M 8,M 6,M 5,M 7 } = = {{o 4,o 8 }, {o 3,o 6,o 7 }, {o,o 2,o 8 }, {o 2,o 5,o 6 }}. A negyedik iteráció végrehajtása után a keletkezett M(red) halmaz egy teljes fedőrendszert valósít meg M-en. Mivel még M(red) blokkjainak száma nem érte el az előre beállított limitet, ezért tovább folytatjuk M redukcióját. A következő iteráció kezdetekor az aktuális z i és m r értékek a következők.

49 SZISZTEMATIKUS DEKOMPOZíCÓ 38 M O M M 2 M 3 M 4 M 5 M 6 M 7 M 8 M 9 z i o o 2 2 o 3 3 o 4 o 5 o 6 4 o 7 o 8 3 m r 3,45 3,5 2,95 2,9 3,5 Három művelet is létezik (o, o 5 és o 7 ), amelyek a legkevesebbszer fordulnak elő az aktuális M halmazban, ennek megfelelően s (M) = {M 2,M 4,M 9 }. Mivel s (M) elemei közül két blokk is a legnagyobb m r értékkel rendelkezik (m 2 = m 9 = 3,5), ezért s(m) = {M 2,M 9 }. Válasszuk ki közülük M 2 -öt, így az ötödik iteráció végén a redukált M halmaz a következőképpen alakul: M(red) = {M 8,M 6,M 5,M 7,M 2 } = = {{o 4,o 8 }, {o 3,o 6,o 7 }, {o,o 2,o 8 }, {o 2,o 5,o 6 }, {o 3,o 5,o 6 }}. A hatodik iteráció kezdetekor az aktuális z i és m r értékeket a következő táblázat mutatja. Mivel a g limitet 7-re állítottuk, ezért sikeres kiválasztás esetén M(red) = 6 lesz, így az iteráció végeztével az algoritmus leáll. M O M M 2 M 3 M 4 M 5 M 6 M 7 M 8 M 9 z i o o 2 2 o 3 2 o 4 o 5 o 6 3 o 7 o 8 3 m r 2,7 2,7 2,65 2,65 Az előzőek alapján, s (M) = {M 4,M 9 }, s(m) = {M 4,M 9 }. A redukált halmaz M 4 blokk kiválasztása után, M(red) = {M 8,M 6,M 5,M 7,M 2,M 4 } = = {{o 4,o 8 }, {o 3,o 6,o 7 }, {o,o 2,o 8 }, {o 2,o 5,o 6 }, {o 3,o 5,o 6 }, {o 2,o 6,o 7 }}.

50 SZISZTEMATIKUS DEKOMPOZíCÓ A MACOMP algoritmus Mindeddig azt feltételeztük, hogy a kiindulási M fedőrendszer adott, amelyet az ütemezés és az allokáció szolgáltat a magas szintű szintézis során. Ha a COMPALL algoritmust allokátorként szeretnénk használni úgy, hogy jóval nagyobb szabadsági fokot biztosítunk számára, akkor a műveletek páronkénti időbeni konkurenciáját kell vizsgálnunk. Szükségünk van tehát egy olyan eljárásra, amely azon műveletek maximális halmazait (M blokkjait) szolgáltatja, amelyek megvalósíthatók lennének olyan komplex funkcionális egységekkel, amelyek éppen az adott blokkban szereplő műveletek végrehajtására képesek. Ez a probléma azonos a nem teljesen specifikált sorrendi hálózatok esetén alkalmazott állapotösszevonási eljárással [3]. A nem teljesen specifikált sorrendi hálózatok nem megkülönböztethető állapotait kompatibilis állapotoknak nevezzük. A kompatibilitás nem tranzitív, egy osztály csak akkor bővíthető újabb állapottal, ha az osztály valamennyi állapotával kompatibilis. Egy kompatibilitási osztály maximális, ha nem bővíthető egyetlen újabb állapottal sem. A maximális kompatibilitási osztály megkeresésére az ismert páronkénti kompatibilitásból kiinduló, úgynevezett lebontó módszert [3] alkalmaztuk. A továbbiakban párhuzamot vonhatunk tehát a nem teljesen specifikált sorrendi hálózatok páronkénti állapot kompatibilitása és az időben nem-konkurens műveletek páronkénti összevonhatósága (kompatibilitása) között. eladatunk tehát a nem-konkurens műveletek maximális kompatibilitási osztályának megtalálása, amely a COMPALL algoritmus kiinduló fedőrendszerének tekinthető. Az eredeti eljárással szemben könnyebbséget jelent, hogy nem kell a lefedés zártságát vizsgálni, hiszen a mi esetünkben nincs feltételes kompatibilitás. A probléma NP-nehéz, nem ismerünk olyan algoritmust, amely polinom időben szolgáltatja az eredményt. Már néhány tíz művelet esetén is exponenciálisan robban a probléma. A feladat nehézsége, komplexitása természetesen nem csak a műveletek számától, hanem a közöttük fennálló időbeni átfedésen alapuló kapcsolatoktól, azaz a topológiától is nagymértékben függ. Ezért a megoldásra egy iteratív eljárás kerül bemutatásra, amely ugyanúgy szolgáltatja a maximális kompatibilitási osztályokat, korlátozva a memória használatot és csökkentve a keresési időt. Az algoritmus leírásában alkalmazott jelölések O(o,...,o j,...,o N ) C(C,...,C j,...,c N ) C (C,...,C j,...,c N ) M(M,... ) Q(Q,... ) S(S,... ) A műveletek halmaza Ahol C j az o j művelettel kompatibilis műveletek halmaza Ahol C j mindazon o j művelettel kompatibilis műveletek halmaza, amelyre k > j fennáll Maximális kompatibiltási osztályok halmaza Segéd halmazok Az iteratív eljárás során már vizsgált halmazok Az algoritmus leírása Az alap gondolat az, hogy a [3]-ban bemutatott kifejtő eljárással ellentétben, ne az összes műveletet tartalmazó egyetlen osztályból induljunk ki, hanem az egyes műveletek által generált, a velük nemkonkurens műveletek alkotta osztályokból (C ). Vegyük az első művelet által generált osztályt (C ). A generáló műveletet (e ) nem kell vizsgálni, hiszen az osztályban szereplő összes művelettel kompatibilis. Ezzel szemben az osztályban szereplő összes többi művelet páronkénti kompatibilitását vizsgáljuk. Ha találunk olyan művelet párt (e j,e l ), amelyek nem kompatibilisek, akkor az osztályt kettébontjuk, az egyik alosztályba az egyik (e j ), a másik

51 SZISZTEMATIKUS DEKOMPOZíCÓ 4 alosztályba a másik műveletet (e l ) tesszük a többi művelet mellé. Ezek után folytatjuk a nem kompatibilis művelet párok keresését a keletkezett új alosztályokra egészen addig, amíg csak kompatibilis párokat találunk. Azok az alosztályok, amelyek csak páronként kompatibilis műveleteket tartalmaznak, a kompatibilitási osztályok. Az eljárás során folyamatosan feljegyezzük, hogy mely alosztályokat vizsgáltuk már (S). Ha ezek az alosztályok a további vizsgálatok alatt újra előállnának a fenti szabály szerint, akkor őket már nem vizsgáljuk, ezzel gyorsítva az algoritmust. Továbbá, ha olyan alosztály keletkezik, amely tartalmazza valamely korábban kiválasztott és M-hez hozzáadott kompatibilitási osztályt, akkor M ezen osztályait elhagyjuk M-ből hiszen azok nem maximálisak, és a keletkezett alosztályt vesszük hozzá M- hez. Hasonlóan, ha a vizsgálat során olyan alosztály adódna kompatibilitási osztálynak, amely egyszer már előállt, nem vesszük újra hozzá a maximális kompatibilitási osztályok halmazához. Ezek után következik a második művelet által generált osztály (C 2 ) és a fenti gondolatmenetet követve tovább keressük a kompatibilitási osztályokat egészen addig, amíg az összes művelet által generált kiindulási osztályt végig nem néztük. Az előző megfontolások alapján a MACOMP algoritmus leírása a következőképpen adható meg. START M := Q := S := i := while i < N if C i 2 M := M C i else create_class(c i ) i := i + STOP create_class(t) e j,e l T -re: j,l i if e l / C j Q := {e l } \ T k := if (Q S) k := else S := S Q create_class(q) M k elhagyása M-ből, amelyre M k Q if (k = ) és (Q / M) M := M Q Az biztos, hogy a kompatibilitási osztályokba csak olyan műveletek kerülnek, amelyek páronként nem konkurensek, ilyen értelemben az új algoritmus helyes eredményt ad. Ezt az algoritmus lebontó jellege, valamint a páronkénti művelet kompatibilitás vizsgálat együttesen garantálja. Most már csak azt kell megvizsgálnunk, hogy az új, iteratív, ritka osztályokból kiinduló eljárás ugyanazt az eredményt szolgáltatja-e, mint a [3]-ban leírt kifejtő eljárás. Ennek bizonyítását az alábbi gondolatmenettel vizsgáljuk. Az összehasonlítási alap értelemszerűen a lépcsős tábla kifejtés, ahol a minden elemet tartalmazó (N elemű) halmazból az elemeken (azaz állapotokon, esetünkben műveleteken) egyesével haladunk, és

52 SZISZTEMATIKUS DEKOMPOZíCÓ 4 minden azt tartalmazó halmazt két részre vágunk (vele kompatibilisek illetve a kiinduló halmaz mínusz az adott elem). A kiadódó részhalmazokat mindig elhagyjuk. A fő kérdés az, hogy a teljes halmazból indulva elérünk-e olyan, már nem redukálható kompatibilitási osztályhoz, amit nem kapunk meg akkor, ha egyetlen teljes halmaz helyett (N ) ritka halmazzal indítunk, és ugyanúgy elemenként fésüljük végig őket. A válasz nem, amit az alábbiak szerint láthatunk be. Mindkét módszernél ugyanazok a lépések követik egymást, külön-külön egymás után véve az állapotokat (esetünkben műveleteket), amelyek a mindenkori generáló állapotok (műveletek) az eljárásban. A következő megfontolásokat tehetjük:. kiindulásként rendelkezésre áll valahány kompatibilitási osztály, amelyekről azt tudjuk, hogy nincsenek egymással részhalmaz relációban 2. a generáló állapotot, műveletet nem tartalmazó osztályok változatlanul megmaradnak (A) 3. a generáló állapotot, műveletet tartalmazó osztályokból két osztály származik: (a) a kiinduló osztály (B) és a generáló állapottal, művelettel kompatibilis állapotok halmazának metszete (B ) (b) a kiinduló osztály mínusz a generáló állapot, művelet (B 2 ) A részhalmaz relációk a következők: - A és B nincsenek részhalmaz relációban, A B és B A. - B részhalmaza B-nek, B B. - B 2 részhalmaza B-nek, B 2 B. - B és B 2 nincsenek részhalmaz relációban, B B 2 és B 2 B. - A nem lehet B vagy B 2 részhalmaza (A B és B B-ből következik, hogy A B B, hasonlóan B 2 -re). - B és B 2 lehet A részhalmaza, hiszen A és B metszete nem feltétlen üreshalmaz. A maximális kompatibilitási osztályok azon A, B és B 2 típusú kompatibilitási osztályok összessége, amelyek nem esnek ki B A, vagy B 2 A reláció miatt. A részhalmaz relációk tranzitivitása miatt minden megmaradó kompatibilitási osztály részhalmaza kell legyen egy olyannak, ami a teljes halmaz (mínusz valahány első elem) és valamelyik állapottal kompatibilisek halmazának metszete (B típus). Amikor a keresést az elemenkénti kompatibilitási halmazokkal indítjuk, lényegében felsoroljuk a teljes halmaz összes B típusú leszármazottját. Egyetlen speciális esetet kihagytunk, a teljes halmazból megmaradó halmazt. Ez valamikor maga is részhalmazzá válik és megszűnik, tehát nem maradt ki semmi. Az új algoritmus esetén, általában lényegesen kevesebb lépés elég, ugyanis az iteráció több felesleges exponenciális részhalmaz-gyarapodást azonnal kikerül. Komplexitás tekintetében nem sikerült javulást elérni a az eredeti algoritmushoz képest, mivel továbbra is páronkénti kompatibilitást vizsgálunk. A feladat exponenciálisan robban, komplexitása O(n 2 ), ahol n a műveletek száma. A nyereség ott van, hogy a ritka, C i halmazokból indulunk ki. Ezt a nyereséget nagymértékben befolyásolja a megoldandó feladat topológiája, azaz a C i halmazok felépítése.

53 SZISZTEMATIKUS DEKOMPOZíCÓ 42 Alkalmazási példa a MACOMP algoritmusra Legyenek adottak a következő O és C halmazok. O = (o,o 2,o 3,o 7,o 4,o 5,o 6,o 8 ) C = ((o,o 2,o 3,o 8 ),(o 2,o,o 7,o 5,o 6,o 8 ),(o 3,o,o 7,o 5,o 6,o 8 ), (o 7,o 2,o 3,o 6 ),(o 4,o 8 ),(o 5,o 2,o 3,o 6 ), (o 6,o 2,o 3,o 7,o 5,o 8 ),(o 8,o,o 2,o 3,o 4,o 6 )) Továbbá adottak a 3.. ábrán látható lépcsős táblából származtatható C halmazok. C = ((o,o 2,o 3,o 8 ),(o 2,o 7,o 5,o 6,o 8 ),(o 3,o 7,o 5,o 6,o 8 ), (o 7,o 6 ),(o 4,o 8 ),(o 5,o 6 ),(o 6,o 8 )) Az algoritmus működését a 3.2. ábrán követhetjük nyomon. Az o művelet által generált C halmazból indulunk ki. Mivel C > 2, ezért meghívjuk a create_class(c ) szubrutint (4. oldal). Minden művelet pár kompatibilitását meg kell vizsgálni, először az o 2, o 3 művelet párok kompatibilitását vizsgáljuk. Mivel o 3 / C 2 -nek, azaz nem kompatibilisek egymással, ezért Q = {o 3 } \ C = (o,o 2,o 8 ). A keletkező Q halmazt hozzávesszük az eljárás során már vizsgált S halmazokhoz. Majd ismét alkalmazzuk a create_class(q) szubrutint. Most csak az o 2, o 8 művelet párok kompatibilitását vizsgáljuk. A két művelet kompatibilis (o 8 C 2 ), ezért visszatérünk a szubrutinból. Mivel (k = ) és (Q / M) feltétel teljesül, ezért Q-et hozzávesszük a maximális kompatibilitási osztályok halmazához. M = M = (o,o 2,o 8 ) Visszatérünk az o 2, o 3 művelet párok vizsgálatára, csak fordított sorrendben vizsgáljuk azok kompatibilitását. Ebben az esetben, mivel o 2 / C 3 -nak Q = {o 2 } \ C = (o,o 3,o 8 ). Az eljárás során már vizsgált halmazok: S = (S,S 2 ) = ((o,o 2,o 8 ),(o,o 3,o 8 )). Az előzőekhez hasonlóan most o 3, o 8 művelet párokat vizsgáljuk, mivel kompatibilisek, ezért Q-et ismételten hozzávesszük M-hez. M = (M,M 2 ) = ((o,o 2,o 8 ),(o,o 3,o 8 )) A C halmazból hátra van még o 2,o 8, valamint o 3,o 8 művelet párok konkurencia vizsgálata. Mivel mindkét esetben a műveletek kompatibilisek, ezért az o művelet által generált C halmaz vizsgálatát befejeztük, és folytatjuk tovább az eljárást az o 2 művelet által generált C 2 halmaz vizsgálatával. A maximális kompatibilitási osztályok keresését addig folytatjuk, amíg az összes C halmazt végig nem néztük. Az algoritmus végrehajtása után a maximális kompatibilitási osztályok halmaza a következőképpen alakul: M = ((o,o 2,o 8 ),(o,o 3,o 8 ),(o 2,o 7,o 6 ),(o 2,o 6,o 8 ),(o 2,o 5,o 6 ), = (o 3,o 7,o 6 ),(o 3,o 6,o 8 ),(o 3,o 5,o 6 ),(o 4,o 8 ))

54 SZISZTEMATIKUS DEKOMPOZíCÓ 43 o 2 o 3 o 7 o 4 o 5 o 6 o 8 (o,o 2,o 3,o 8 ) (o 2,o 7,o 5,o 6,o 8 ) (o 3,o 7,o 5,o 6,o 8 ) (o 7,o 6 ) (o 4,o 8 ) (o 5,o 6 ) (o 6,o 8 ) o o 2 o 3 o 7 o 4 o 5 o ábra. Lépcsős tábla, művelet kompatibilitások (o,o 2,o 3,o 8 ) o 2,o 3 x (o,o 2,o 8 ) (o,o 3,o 8 ) o 2,o 8 o 3,o 8 o 2,o 8 o 3,o 8 (o 2,o 7,o 5,o 6,o 8 ) o 7,o 5 x o 7,o 6 o 7,o 8 x o 5,o 6 o 5,o 8 x o 6,o 8 (o 2,o 7,o 6,o 8 ) (o 2,o 5,o 6,o 8 ) o 7,o 6 o 5,o 6 o 7,o 8 x o 5,o 8 x o 6,o 8 o 6,o 8 (o 2,o 7,o 6 ) (o 2,o 6,o 8 ) (o 2,o 5,o 6 ) (o 2,o 6,o 8 ) o 7,o 6 o 6,o 8 o 5,o 6 (o 2,o 5,o 6,o 8 ) (o 2,o 7,o 5,o 6 ) o 7,o 5 o 7,o 6 o 5,o 6 x (o 2,o 7,o 6 ) (o 2,o 5,o 6 ) (o 2,o 7,o 5,o 6 ) (o 2,o 7,o 6,o 8 ) (o 3,o 7,o 5,o 6,o 8 ) (o 7,o 6 ) (o 4,o 8 ) o 7,o 5 x o 7,o 6 o 7,o 8 x o 5,o 6 o 5,o 8 x o 6,o 8 (o 3,o 7,o 6,o 8 ) (o 3,o 5,o 6,o 8 ) o 7,o 6 o 5,o 6 o 7,o 8 x o 5,o 8 x o 6,o 8 o 6,o 8 (o 3,o 7,o 6 ) (o 3,o 6,o 8 ) (o 3,o 5,o 6 ) (o 3,o 6,o 8 ) (o 5,o 6 ) o 7,o 6 o 6,o 8 o 5,o 6 (o 6,o 8 ) (o 3,o 7,o 5,o 6 ) o 7,o 5 x o 7,o 6 o 5,o 6 (o 3,o 7,o 6 ) (o 3,o 7,o 5,o 6 ) (o 3,o 5,o 6,o 8 ) (o 3,o 5,o 6 ) (o 3,o 7,o 6,o 8 ) 3.2. ábra. Alkalmazási példa a MACOMP algoritmusra

55 SZISZTEMATIKUS DEKOMPOZíCÓ Alkalmazási lehetőségek A fejezetben először azt mutatjuk meg, hogy a szisztematikus dekompozíció és erőforrás kiosztás témakörében kidolgozott és előzőleg bemutatott algoritmusok hogyan illeszkednek a tervezési folyamatba. Ugyancsak megvizsgáljuk, hogyan alkalmazhatók az algoritmusok akkor, amikor különböző tervezési célokat szeretnénk megvalósítani. Például ezek lehetnek többek között az adott feladatra a lehető legjobb komplex funkcionális elemkészlet kiválasztása, vagy adott komplex funkcionális elemkészlet esetén a lehető legkisebb darabszámmal (reuse), illetve költséggel történő megoldás keresése, vagy a futtatási (tervezési) idő hosszának figyelembe vétele. A tervezés kezdeti fázisában, mikor még a koncepció is gyakran változik, szükség van arra, hogy sok megvalósítási lehetőséget vizsgáljunk meg különböző peremfeltételekből kiindulva viszonylag gyorsan, esetleg a megoldás minőségének romlása esetén is. Az így kiválasztott megvalósítási lehetőséget pedig már részletesen vizsgáljuk meg, dolgozzuk ki. A fejezet második részében a gyakorlatban is használt tesztfeladatok (benchmark feladatok) példáján szemléltetjük az előzőleg bemutatott algoritmusok alkalmazását és hatékonyságát Az algoritmusok alkalmazásának módszere A 3.3. ábra azt mutatja, hogyan épülnek be a kidolgozott algoritmusok a hierarchikus tervezési eljárásba. Az ábrán kék színnel jelöltük a három új algoritmust. A nyilak az alkalmazási, futtatási útvonalakat jelölik, amelyeket tetszőlegesen kombinálhatunk a tervezési cél függvényében. Három további kiegészítő lehetőség figyelhető meg az ábrán. Ezek az Uset, weightvar és impl modulok, feladatuk pedig a következő. alloc PIPE compatibility MCC MACOMP REDIN Uset impl weightvar COMPALL 3.3. ábra. A szisztematikus dekompozíció megvalósításához kidolgozott algoritmusok kapcsolódása a tervezési folyamatba Uset A modul alkalmazása esetén a komplex funkcionális elemkészletet nem tekintjük adottnak, hanem a megoldandó feladat műveleteiből állítjuk össze azokat úgy, hogy lehetőleg a legkedvezőbb tulajdonsággal rendelkező funkcionális elemkészlet alakuljon ki. Kiindulásként egy funkcionális elemkészletet tételezünk fel, amelynek elemeit a feladat műveleteinek különböző kombinációi alkotnak.

56 SZISZTEMATIKUS DEKOMPOZíCÓ 45 weightvar Mint azt a COPMALL algoritmus ismertetésénél láttuk, az algoritmus konvergencia sebességét alapvetően a kritériumok szerinti heurisztikus U s választás határozza meg, amely választási folyamat befolyásolható a súlytényezők (W Cost, W γ, W Sort ) változtatása, hangolása révén. Ezen súlytényezők variálását végzi az adott modul. Mivel ezek a tényezők csupán a különböző követelmények és közé eső mérőszámainak relatív súlyozását fejezik ki, ezért szintén lehetnek és közötti értékűek. A súlytényezők hatásának kísérleti meghatározásához értéküket, és,5 között változtattuk, nagyságú lépésekben. Ezáltal a relatív súlyok közötti arány -től 5-ig beállítható volt, így a súlytényezőknek 25 különböző variációja vizsgálható kísérletileg. Az egyes variációkkal számolva az eredmények alapján a COPMALL algoritmus kiválasztási lépései behangolhatók a megoldandó feladat természetének előnyös figyelembe vételére. Természetesen bármelyik súlytényező -ra is választható, így a hozzá tartozó optimalizációs tényezőt nem vesszük figyelembe a komplex funkcionális építőelemek kiválasztása során. impl eladata a REDIN által generált redukált fedőrendszerre az összes lehetséges teljes partíció, fedőrendszer előállítása. Erre akkor lehet szükség, ha a REDIN algoritmus a teljes fedőrendszer megtalálása után további M r blokkokat választott ki a g limit eléréséig. Most vizsgáljuk meg azt, hogyan alkalmazhatók együttesen a fejezetben ismertetett algoritmusok. A különböző futtatási, és egyben vizsgálódási lehetőségeket a 3.4. ábra szemlélteti. A következőkben részletezzük a különböző futtatási módok tulajdonságait, illetve alkalmazhatóságukat. alloc PIPE compatibility 2 4 MCC MACOMP REDIN Uset 6 weightvar impl 5 3 COMPALL 3.4. ábra. Különböző futtatási módok az eltérő tervezési célok megvalósításához Általánosságban kijelenthetjük, hogy két fő futtatási mód létezik annak függvényében, hogy a futtatási útvonalban szerepel-e az Uset modul, vagy nem. Abban a végrehajtási módban, ahol az Uset modul nem szerepel a futtatási útvonalban, a komplex funkcionális elemkészletet a felhasználó által adottnak tekintjük, és az ebből történő optimális választást kell megvalósítani. Minden egyes komplex funkcionális egységet azok a művelet típusok definiálják, amelyek végrehajtása lehetséges és preferált az adott egységgel. A másik végrehajtási módban, ahol az Uset modul szerepel a futtatási útvonalban, a cél a legkedvezőbb komplex funkcionális elemkészlet közelítő meghatározása az adott feladathoz. Ebben a végrehajtási módban az komplex funkcionális elemkészletet (I halmaz) nem tekintjük adottnak, hanem az Uset modul generálja azokat.

57 SZISZTEMATIKUS DEKOMPOZíCÓ 46 alloc COMPALL (weightvar) A 3.4. ábrán -gyel jelölt esetben a kiinduló fedőrendszert közvetlenül a PIPE tervezőrendszer generálja. Az allokáció során keletkező maximális kompatibilitási osztályok, azaz a kiinduló M fedőrendszer diszjunkt, mivel minden műveletet csak egy végrehajtó egységhez rendelünk hozzá. Az I komplex funkcionális elemkészlet a felhasználó által adott. Ebben az esetben a COMPALL algoritmus futása gyors, mivel az allokáció által szolgáltatott diszjunkt fedőrendszerből indultunk ki, nem pedig a műveletek kompatibilitásán alapuló generált fedőrendszerből. Ettől függ a keletkező T partíció minősége is, hiszen már a kiinduláskor nagymértékben csökkentettük a COMPALL algoritmus keresési terét, a rendszer szabadsági fokát. A weightvar modul használatával eldönthetjük, befolyásolhatjuk a kiválasztási mechanizmust a súlytényezők módosításával. Prioritást adhatunk a lehető legkisebb darabszámmal (reuse), illetve költséggel történő megoldás keresésére. Ezt a futtatási módot a tervezési fázis elején, és a koncepció kidolgozásakor használhatjuk, ha gyors eredményre van szükség, illetve adott komplex funkcionális elemkészlettel kell a feladatot megvalósítani. alloc Uset COMPALL (weightvar) A 3.4. ábrán 2-vel jelölt futtatási útvonalra ugyanaz igaz, mint az előző esetre, azzal a kiegészítéssel, hogy az általános részben megfogalmazottal összhangban az I komplex funkcionális elemkészletet az Uset modul segítségével hozzuk létre. Adott feladat esetén a COMPALL algoritmus futási ideje kicsit növekedhet az előző esetéhez képest, mivel az I komplex funkcionális elemkészlet számossága nagyobb, azonban a kiinduló M fedőrendszer nem változott. Ezt a futtatási módot akkor használhatjuk, ha gyors eredményre van szükség az előző esethez hasonlóan, és a komplex funkcionális elemkészletet is nekünk kell megtervezni. compatibility MACOMP COMPALL (weightvar) A 3.4. ábrán 3-mal jelölt esetben a kiinduló M fedőrendszert a MACOMP modul állítja elő a PIPE tervezőrendszer által szolgáltatott műveletek közötti kompatibilitási információ alapján. Az I komplex funkcionális elemkészlet a felhasználó által adott. Ebben az esetben a COMPALL algoritmus futási ideje nagymértékben növekedhet, hiszen a kiinduló M fedőrendszer számossága nagyságrendekkel nagyobb lehet, mint az előző esetekben. Az -es és 2-es esetben szereplő kiinduló halmaz egy speciális teljes lefedés, amit a PIPE tervezőrendszer allokátora választott ki. Ez részhalmaza a MACOMP által szolgáltatott jelenlegi kiinduló M fedőrendszernek. Az előző két esetben az volt a feladat, hogy a végrehajtó egységeket, amelyekhez a PIPE rendelte hozzá a műveleteket további bonyolult, komplex funkcionális egységekhez rendeljük hozzá. Ebben az esetben és a további esetekben a fejezetben kidolgozott algoritmusok alkalmazásával gyakorlatilag egy komplex allokátort valósítottunk meg, amely a műveleteket közvetlenül képes hatékonyan hozzárendelni a komplex funkcionális egységekhez. Ilyen alkalmazásban a COMPALL algoritmus allokációs algoritmusnak tekinthető. Ezt a futtatási módot akkor lehet használni, amikor már a feladat megvalósításának végső fázisában vagyunk, és a lehető legnagyobb keresési tér optimalizálási hatása fontos, valamint főleg nagyobb méretű feladatok esetén az ezáltal megnövekedett futtatási idő is elfogadható. Ebben az esetben a feladatot előre megadott komplex funkcionális elemkészlettel kell megvalósítani.

58 SZISZTEMATIKUS DEKOMPOZíCÓ 47 compatibility MACOMP Uset COMPALL (weightvar) A 3.4. ábrán 4-gyel jelölt esetben is az előző eset megállapítása érvényesek. Természetesen most a komplex funkcionális elemkészletet is nekünk kell megtervezni. Ezt a futtatási módot akkor használhatjuk, ha a végső megvalósítás fázisában vagyunk, és a komplex funkcionális elemkészletet is nekünk kell megtervezni. őleg a megnövekedett futtatási idő miatt a jelenlegi és az előző esetben nem célszerű a weightvar modul használata, hanem a tervezési folyamat során előzőleg (-es, 2-es, illetve 5-ös és 6-os útvonalon) kikísérletezett súlyfaktorokkal kell futtatni a COMPALL modult. compatibility MACOMP REDIN COMPALL (weightvar) A 3.4. ábrán 5-tel jelölt esetben először a MACOMP modul előállítja maximális kompatibilitási osztályokat, majd a kiinduló M fedőrendszert a REDIN algoritmus állítja elő. Az I komplex funkcionális elemkészlet a felhasználó által adott. Ebben az esetben a COMPALL algoritmus futási ideje függ a maximális kompatibilitási osztályok redukciójának mértékétől. Ezt a futtatási módot akkor használhatjuk, amikor a megvalósítás közbülső fázisában vagyunk, a keresési tér túl nagy, és ezt akarjuk csökkenteni a REDIN algoritmus felhasználásával. Ez okos kompromisszum lehet a teljes futtatási idő és az eredmény minősége között. Itt is érdemes lehet kísérletezni a súlyfaktorok változtatásával. Ebben az esetben a komplex funkcionális elemkészlet előre adott. compatibility MACOMP REDIN Uset COMPALL (weightvar) A 3.4. ábrán 6-tal jelölt esetben is az előzőleg bemutatott futtatási útvonal megállapításai érvényesek. A kiinduló M fedőrendszert a REDIN által csökkentett maximális kompatibilitási osztályok alkotják. Itt azonban a COMPALL algoritmust allokátornak használjuk, tehát maga az algoritmus választja ki a feladat megoldásához szükséges komplex funkcionális elemkészletet. A megoldás minősége, valamint a futtatási idő is nagymértékben függ a maximális kompatibilitási osztályok redukciójának mértékétől, valamint a fiktív I komplex funkcionális elemkészlet számosságától, amely elemkészletet ebben az esetben az Uset modul generál. A COMPALL algoritmus által szolgáltatott eredmény megmutatja, hogy a feladat optimális megoldásához milyen komplex funkcionális elemkészletre van szükség. Először a felhasználónak ezt az elemkészletet kell megterveznie Az algoritmusok alkalmazása tesztfeladatokra Ebben a fejezetben két alkalmazás kerül bemutatásra. Az első feladat egy konkrét alkalmazás bemutatása, a második esetben az előzőleg bemutatott futtatási, tervezési utak hatását szemléltetjük különböző feladatokra az eredmények minőségére és a futtatási, tervezési időre koncentrálva. A MARS rejtjelező algoritmus megvalósítása Először a MARS [7] nevű rejtjelező algoritmus példáján szemléltetjük a COMPALL algoritmus alkalmazását és hatékonyságát. A 3.4. ábrán -gyel és 2-vel jelölt útvonalon haladunk, tehát a kiindulási M fedőrendszert a PIPE tervezőrendszerrel képeztük. A MARS algoritmus megvalósítása során használt művelet típusokat és paramétereiket a 3.. táblázat foglalja össze. Az sbox, sbox, sbox műveletek a MARS rejtjelező algoritmusban használt memória típusú műveleteket jelölik (írás/olvasás), amelyek többnyire úgynevezett look-up táblák formájában alakíthatók ki előnyösen PA környezetben.

59 SZISZTEMATIKUS DEKOMPOZíCÓ táblázat. MARS algoritmushoz használt műveletek tulajdonságai Művelet neve unkcionalitás Előfordulás száma Végrehajtási idő mult szorzás 6 2 add összeadás 72 5 sub kivonás 24 5 xor xor 8 shr8 eltolás 24 shl eltolás 32 shl5 eltolás 32 shl8 eltolás 24 shl3 eltolás 32 sbox memória 6 sbox memória 32 sbox memória 32 Összesen táblázat. elhasználó által megadott komplex funkcionális elemkészlet Komplex Komplex Végrehajtható funkcionális funkcionális és preferált Költség, egység neve, egység műveletek, c(i s ) I specifikáció U s részhalmazok szorzó szorzás mult 84 összeadó összeadás add 32 kivonó kivonás sub 32 logikai xor xor 9 eltolás eltolás shr8, shl, shl5, shl8, shl3 32 AU összeadás, kivonás add, sub 72 AU2 összeadás, kivonás, szorzás add, sub, mul 89 memória memória sbox, sbox, sbox 528 Elsőként azt az esetet vizsgáljuk, amikor a funkcionális elemkészletet a felhasználónak kell előre megadnia (-es útvonal). Minden egyes komplex funkcionális elemet azok a műveletek specifikálnak a 29. oldalon szereplő definíciónak megfelelően, amelyek végrehajtása lehetséges és preferált az adott funkcionális elemmel. A 3.. táblázatban ezek a specifikáló műveletek (U halmaz elemei) szerepeltek. A továbbiakban tekintsük adottnak a 3.2. táblázatban szereplő komplex funkcionális elemkészletet. A komplex funkcionális elemek többi paramétereit a 3.2. táblázat tartalmazza. Ezzel a COMPALL algoritmus összes bemeneti paraméterét megadtuk. Ezek után már csak le kell futtatni az algoritmust. A súlytényezők értékét, és,5 között változtattuk, nagyságú lépésekben. Az eredmények alapján kiválaszthatjuk a számunkra megfelelő megoldást. Ez lehet a minimális költségű megoldás, vagy a legkevesebb típusszámú funkcionális elemkészlettel történő megvalósítás, ahol az újrafelhasználást részesítjük előnyben, vagy netalán a kettő közötti kompromisszumos megoldás. Ahhoz, hogy a különböző megoldásokat össze tudjuk hasonlítani, a következőkben több értékelési szempontnak megfelelő függvényt, illetve jelzőszámot vezetünk be. Definiáljuk a K i költségfüggvényt az alábbi módon:

60 SZISZTEMATIKUS DEKOMPOZíCÓ 49 K i = s c i (I s ) n i (I s ) i =...W, (3.) ahol W a súlytényezők variációinak száma. Definiáljunk továbbá két úgynevezett,i és 2,i hatékonysági jelzőszámot a következőképpen:,i = 2,i = K i + S i max i K i max i S i, i =...W, (3.) 2 K i min i K i + S i min i S i max i K i min i K i max i S i min i S i, i =... W. (3.2) 2 A költségértékek és a kiválasztott komplex funkcionális elemek száma ( S i ) mindkét esetben normalizáltak.,i esetében az egész tartományra véve, 2,i esetében pedig a legkisebb és legnagyobb értékek által meghatározott tartományra vetítve.,i és 2,i maximális értéke lehet. Az eredmények kiértékelését a 3.5. ábrán látható diagram szemlélteti. Az, illetve 2 értékének minimuma jó kompromisszumnak tekinthető a költség és az ismételt felhasználás között. Ahol a költség kicsi, ott n(i s ) nagy és fordítva. Ezért a hatékonysági jelzőszám görbéje általában nem mutat a középértékhez képesti nagy eltéréseket Költseg 8 7 unkcionális elemszám W Sort W γ W Cost,,2,3,4,5,,, ábra. A költség, S i értékek és a hatékonysági tényezők alakulása a felhasználó által előre megadott komplex funkcionális elemkészletből történő választás esetén

61 SZISZTEMATIKUS DEKOMPOZíCÓ 5 A 3.3. táblázat foglalja össze a kiválasztott komplex funkcionális elemeknek azt az S halmazát, amelynek minimális a költsége (a 3.5. ábrán a legkisebb K értékekhez tartozó megoldás egyike). Abban az esetben, ha az ismételt felhasználást részesítjük előnyben a költséggel szemben, akkor a 3.4. táblázatban bemutatott módon 5 típusra van szükség a felhasználó által előre megadott komplex funkcionális elemkészletből. Ilyenkor a költség nagyobb, vagyis ez a megoldás adott esetben többlet szilícium felületet igényel, viszont kevesebb típusú komplex funkcionális elemre van szükség táblázat. Eredmények minimális költség preferálása esetén, a komplex funkcionális elemkészlet a felhasználó által előre megadott Kiválasztott komplex Komplex funkcionális Költség funkcionális elemek elemek száma S halmaz n(i s ) K összeadás 4 28 logikai 5 35 eltolás 5 48 AU 2 44 AU2 9 8 memória Összesen táblázat. Eredmények ismételt felhasználás preferálása esetén, a komplex funkcionális elemkészlet a felhasználó által előre megadott Kiválasztott komplex Komplex funkcionális Költség funkcionális elemek elemek száma S halmaz n(i s ) K logikai 5 35 eltolás 5 48 AU AU2 9 8 memória Összesen 6977 Második esetként azt vizsgáljuk, amikor a funkcionális elemkészletet nem tekintjük adottnak, hanem a megoldandó feladat műveleteiből állítjuk össze azokat úgy, hogy lehetőleg a legkedvezőbb viselkedésű komplex funkcionális elemkészlet alakuljon ki. Tehát a COMPALL algoritmust használjuk arra, hogy megtalálja a feladat megoldásához a lehető legjobb funkcionális elemkészletet. Kiindulásként egy fiktív komplex funkcionális elemkészletet (I halmazt) tételezünk fel, amelynek elemeit a feladatban szereplő műveletek különböző kombinációi alkotnak. Az öt művelet (szorzás, osztás, kivonás, OR, eltolás) minden kombinációját generáltuk egy-egy funkcionális elemként, kivéve azt, amely mind az öt műveletet tartalmazza. Az így keletkezett komplex funkcionális elemkészlethez még hozzáadjuk a memória műveletet. Az így kapott I halmaz paramétereit a 3.5. táblázat tartalmazza. A minimális költséget és a legnagyobb mértékű ismételt felhasználást ezúttal is a 3.6. ábrán szereplő diagram megfelelő szélsőértékei adják meg. Itt is jól látható a különböző súlyfaktor tényezők hatása a végső eredményre. A különböző esetekben a COMPALL algoritmus által kiválasztott végrehajtó komplex funkcionális elemeket rendre a 3.6. és a 3.7. táblázat foglalja össze. Ha összehasonlítjuk a 3.6. és a 3.3. táblázat adatait, akkor azt láthatjuk, ha a COMPALL algoritmusra bízzuk a komplex funkcionális elemkészlet kiválasztását, akkor a megvalósításhoz használt elemek tí-

62 SZISZTEMATIKUS DEKOMPOZíCÓ táblázat. enerált, fiktív komplex funkcionális elemkészlet Komplex Komplex Végrehajtható funkcionális funkcionális és preferált Költség, egység neve, egység műveletek, c(i s ) I specifikáció U s részhalmazok fu összeadás add 32 fu xor xor 9 fu2 eltolás shr8, shl, shl5, shl8, shl3 32 fu3 szorzás mul 84 fu4 kivonás sub 32 fu5 összeadás, xor add, xor 4 fu6 összeadás, eltolás add, shr8, shl, shl5, shl8, shl3 64 fu7 szorzás, összeadás mul, add 872 fu8 összeadás, kivonás add, sub 64 fu9 xor, eltolás xor, shr8, shl, shl5, shl8, shl3 4 fu szorzás, xor mul, xor 849 fu kivonás, xor sub, xor 4 fu2 szorzás, eltolás mul, shr8, shl, shl5, shl8, shl3 872 fu3 kivonás, eltolás sub, shr8, shl, shl5, shl8, shl3 64 fu4 szorzás, kivonás mul, sub 872 fu5 összeadás, xor, eltolás add, xor, shr8, shl, shl5, shl8, shl3 73 fu6 szorzás, összeadás, xor mul, add, xor 88 fu7 összeadás, kivonás, xor add, sub, xor 73 fu8 szorzás, összeadás, eltolás mul, add, shr8, shl, shl5, shl8, shl3 94 fu9 összeadás, kivonás, eltolás add, sub, shr8, shl, shl5, shl8, shl3 96 fu2 szorzás, összeadás, kivonás mul, add, sub 94 fu2 szorzás, xor, eltolás mul, xor, shr8, shl, shl5, shl8, shl3 88 fu22 kivonás, xor, eltolás sub, xor, shr8, shl, shl5, shl8, shl3 73 fu23 szorzás, kivonás, xor mul, sub, xor 88 fu24 szorzás, kivonás,eltolás mul, sub, shr8, shl, shl5, shl8, shl3 94 fu25 szorzás, összeadás, xor, eltolás mul, add, xor, shr8, shl, shl5, shl8, shl3 93 fu26 összeadás, eltolás, kivonás, xor add, sub, xor, shr8, shl, shl5, shl8, shl3 5 fu27 szorzás, xor, összeadás, kivonás mul, add, sub, xor 93 fu28 szorzás, összeadás, kivonás, eltolás mul, add, sub, shr8, shl, shl5, shl8, shl3 936 fu29 szorzás, eltolás, kivonás, xor mul, sub, xor, shr8, shl, shl5, shl8, shl3 93 fu3 tárolás sbox, sbox, sbox 528 pusszáma jóval kisebb. A megvalósítás költsége csak azért nagyobb, mert a második esetben a komplex funkcionális egységek költségei nagyobbak voltak, mint az első esetben, amikor a felhasználó állította össze a kiinduló készletet. Ez a megoldás azt mutatja, ha rendelkezésre állnak a tervezés során az fu5, fu25, fu26 és fu3 komplex funkcionális egységek, akkor optimális lefedést tudunk biztosítani úgy, hogy a költségeket a lehető legalacsonyabb szinten tartsuk. A 3.7. táblázatból látszik, hogy a felhasznált komplex funkcionális egységek típusszáma 3, ennél kevesebb egységgel nem lehet megoldani a feladatot, hiszen nem létezett olyan funkcionális elem, amely a tárolás műveletet kivéve mind az öt műveletet tartalmazza.

63 SZISZTEMATIKUS DEKOMPOZíCÓ Költseg 8 7 unkcionális elemszám ,5 2,5 W Sort W γ W Cost,,2,3,4,5,,, ábra. A költség, S i értékek és a hatékonysági tényezők alakulása fiktív komplex funkcionális elemkészletből kiindulva 3.6. táblázat. Eredmények minimális költség preferálása esetén, fiktív komplex funkcionális elemkészletből kiindulva Kiválasztott komplex Komplex funkcionális Költség funkcionális elemek elemek száma S halmaz n(i s ) K fu fu fu fu Összesen táblázat. Eredmények ismételt felhasználás preferálása esetén, fiktív komplex funkcionális elemkészletből kiindulva Kiválasztott komplex Komplex funkcionális Költség funkcionális elemek elemek száma S halmaz n(i s ) K fu fu26 55 fu Összesen 7292

64 SZISZTEMATIKUS DEKOMPOZíCÓ 53 A különböző futtatási, tervezési útvonalak vizsgálata A 3.4. ábrán bemutatott tervezési útvonalak vizsgálatát egy 8-pontos T-t megvalósító egység tervezésén keresztül mutatjuk be. Ennek egyik lehetséges realizációját az 5.4. ábra mutatja (5.3. fejezet, 79. oldal). A PIPE tervezőrendszer alkalmazása után rendelkezésre áll az -es és 2-es esetekben a kiinduló maximális kompatiblitási osztályok halmaza, M = 4; valamint a 3 6 esetekben a műveletek közötti kompatibiltási információ. Ebből az információból a MACOMP algoritmus futtatásával a 3-as és 4-es esetekre megkapjuk a kiinduló M halmazt, M = 32. Az 5-ös és 6-os esetekben a REDIN segítségével redukálhatjuk az M halmazt. Attól függően, hogy beállítunk-e határt a redukció mértékére, vagy nem, két különböző kiinduló M halmazt kapunk. Ha nem állítunk be, akkor M = 4 hasonlóan az -es és 2-es esethez, azzal a különbséggel, hogy az M halmaz elemei különbözőek. Ha a g paramétert 5-re állítjuk, akkor M = 49. Ezt foglalja össze a 3.8. táblázat táblázat. Kiinduló maximális kompatibilitási osztályok elemszáma 8-pontos T esetén Útvonal száma g paraméter M Útvonal száma g paraméter M a b a b 5 49 A 3.9. táblázatban a kiinduló komplex funkcionális elemkészlettel kapcsolatos információk figyelhetők meg. Ha fiktív elemkészletből indulunk ki (2-es, 4-es és 6-os eset), akkor mind a 6 funkcionális elemet tartalmazza I. A többi esetben a táblázatban szürkével jelölt funkcionális elemeket használjuk, azaz a kiinduló komplex funkcionális elemkészlet a felhasználó által definiált táblázat. Kiinduló komplex funkcionális elemkészlet 8-pontos T esetén Komplex Komplex Végrehajtható funkcionális funkcionális és preferált Költség, egység neve, egység műveletek, c(i s ) I specifikáció U s részhalmazok szorzó szorzás mult kivonó kivonás sub 3 összeadó összeadás add 3 AU kivonás, szorzás sub, mul 4 AU2 összeadás, szorzás add, mul 4 AU3 összeadás, kivonás add, sub 6 A COMPALL algoritmus futtatási eredményeit a weightvar modult felhasználva a 3.7 és a 3.8. ábrák mutatják. Az ábrákon a különböző futtatási útvonalakat eltérő színekkel jelöltünk, amit a jelmagyarázatban is feltüntettünk. A megvalósításhoz szükséges komplex funkcionális elemszám, a megvalósítási költség, a hatákonysági jelzőszám, valamint a futtatási idő továbbra is (a 3.5. ábrához hasonlóan) a súlyfaktorok variációinak függvényében vannak ábrázolva. A futtatási idő esetében most kumulált futtatási időről van szó, azaz a maximális érték a teljes weightvar modul futtatásához szükséges időt jelenti. A futtatási időt logaritmikus léptékben ábrázoltuk.

65 SZISZTEMATIKUS DEKOMPOZíCÓ 54 Először külön-külön vizsgáljuk meg az ábráknak megfelelően azt a két esetet, amikor fiktív komplex funkcionális elemkészletből indulunk ki (3.7. ábra), illetve amikor a kiindulási komplex funkcionális elemkészlet előre adott (3.8. ábra) a Költség 6.b unkcionális elemszám 6.a 6.b Hatékonysági jelzőszám, a 6.b uttatási idő a b ábra. Eredmények 8-pontos T esetén, fiktív komplex funkcionális elemkészletből kiindulva Az első esetben jól látható, hogy a súlyfaktorok függvényében hogyan befolyásolható a COMPALL algoritmus kiválasztási mechanizmusa. Minél nagyobb a kiinduló M halmaz, annál hatékonyabban tud választani az algoritmus, azonban a futási ideje is annál nagyobb. Általánosságban kijelenthető, hogy a hatékonyság szempontjából legjobb a 4-es útvonal, utána a 6.b és a 2-es útvonal következik, a legkevésbé hatékony a 6.a útvonal. Hiába egyezik meg az M halmaz számossága a 6.a és a 2-es esetben, a kiinduló halmaz minősége jobban számít. Az, hogy a 2-es esetben kicsivel jobb eredményeket kapunk annak köszönhető, hogy a PIPE tervezőrendszer allokátora igen hatékony, annak ellenére, hogy egy egyszerű gráfszínező eljárásról van szó. A futtatási idő természetesen ellenkező képet mutat, és nagysága erős korrelációt mutat az M halmaz nagyságával. A 2-es és a 6.a esetekben alig van különbség az idő tekintetében. A 6.b esetben fél nagyságrenddel, a 4-es útvonal esetén 2 nagyságrenddel több idő szükséges az algoritmus futtatásához, mint az elsőnek említett két esetben.

66 SZISZTEMATIKUS DEKOMPOZíCÓ a Költség 5.b unkcionális elemszám 5.a 5.b Hatékonysági jelzőszám,.4 5.a 5.b uttatási idő a b ábra. uttatási eredmények 8-pontos T esetén, a komplex funkcionális elemkészlet a felhasználó által előre megadott A második esetben mi adtuk meg a felhasználható komplex funkcionális elemek halmazát, ezzel nagyon leszűkítettük a COMPALL algoritmus mozgásterét. Itt nem figyelhetők meg olyan nagy eltérések az eredményekben az útvonal választásának függvényében, hiába nagyságrendben különbözőek a kiindulási M halmaz méretek. Ha a két különböző esetet hasonlítjuk össze, akkor az első esetben jobb minőségű eredményeket kapunk, azonban a második esetben kicsit gyorsabban futnak az algoritmusok. Természetesen ezt is vártuk, amely eredmények összhangban vannak a keresési tér nagyságával. Mindkét esetben kijelenthető az, hogy az eredmények alátámasztják a különböző tervezési útvonalak leírásánál említett felhasználási javaslatokat (3.3.. fejezet).

67 SZISZTEMATIKUS DEKOMPOZíCÓ Második tézis Az előzőek alapján a következő kijelentéseket tehetjük. 2. Tézis. Szisztematikus dekompozícó és erőforrás kiosztás Új szisztematikus eljárást fejlesztettem ki előre megadott és kiadódó komplex funkcionális egységekből történő rendszerfelépítésre, amely egyaránt lehetővé teszi az időbeli átfedésen alapuló allokáció optimális és közelítő végrehajtását a funkcionális egységek ismételt felhasználását (reuse) is szem előtt tartva [, 9, 48, ]. 2.. A funkcionális egységeket az általuk megvalósítható művelet típusok definiálják Az új algoritmus egyrészt használható előre megadott funkcionális egységekre történő allokációra, másrészt segíti az adott feladat szempontjából kedvező funkcionális egységek megtalálását figyelembe véve a költséget és a funkcionális egységek ismételt felhasználását (reuse) Az algoritmus az időbeli átfedést inkompatibilitási relációként kezeli. Ezáltal a maximális kompatibilitási osztályokból kiindulva az optimális megoldást szolgáltatja. Képes a maximális kompatibilitási osztályok célszerű redukciójára is, miáltal gyors közelítő megoldás is nyerhető.

68 4. fejezet Adatkapcsolatok optimális, sínszerű megvalósítása 4.. Bevezetés és szakirodalmi áttekintő A rendszer-szintű szintézis legkritikusabb lépései az ütemezés és az allokáció. Mint azt a korábbiakban láthattuk, az allokáció során az egyes műveleteket fizikai erőforrásokhoz, processzorokhoz rendeljük. Mivel egy közös processzorhoz, vagy komplex funkcionális egységhez több művelet is rendelhető, így a közöttük fennálló adatkapcsolatok megvalósítása is nagyon bonyolulttá válhat. A hagyományos megközelítés esetén ahhoz, hogy az építőelemek között lévő összes adatkapcsolatot meg tudjuk valósítani, nagy számú multiplexer és demultiplexer egység alkalmazására van szükség. Ez látható a 4.. ábrán. a b c x a b c x 6 6 mul cos c 4 8 m 4 a 5 2 m 2 4 a 6 2 m 3 4 c 4 8 m m sbff sbff mul m 3 m m 7 4 add a 5 2 a 6 2 s sbff2 8 2 sub s ábra. Adatkapcsolatok megvalósítása multiplexerek felhasználásával A multiplexerek és demultiplexerek nagy száma jelentős hátrány, ami kihat a magas szintű szintézis módszerek hatékonyságára, használhatóságára. A műveletek közös, komplex funkcionális elemekhez való hozzárendelésével ugyan jelentősen csökkenthető a megvalósításhoz szükséges szilícium felület 57

69 ADATKAPCSOLATOK OPTIMÁLIS MEVALÓSíTÁSA 58 nagysága, de az összevonásból adódó járulékos multiplexerek és demultiplexerek növelik a megoldás terület igényét. Ráadásul minél nagyobb az allokáció mértéke, várhatóan annál nagyobb számú multiplexer és demultiplexer egység alkalmazására van szükség. Tovább csökkenti a módszer hatékonyságát az, hogy ezen multiplexer és demultiplexer egységek vezérlését is biztosítani kell, ami szintén szilícium felület növekedést von maga után [35, 37]. Nagyon jó összefoglalást nyújt a komplex funkcionális egységek közötti összeköttetések megvalósításához használható lehetőségekről a [64]. Bemutatásra kerülnek az alap, egyszerű kommunikációs elvek, (például nem-szinkronizált, szinkronizált adatátvitel, IO, stb.), majd az aszinkron és szinkron hardver interfész szintézisének, valamint a kommunikáció ütemezésének lehetőségei. Ugyancsak helyet kap az IP-k, komplex funkcionális egységek közötti kommunikációs protokollok bemutatása. Ezekre jellemző, hogy általában bonyolult kommunikációs protokollokat használnak a különböző IP-ket előállító gyártók, amelyek egymással gyakran nem kompatibilisek. A cél, hogy egy szabványosított, lehetőleg egyszerű interfészt biztosítsunk a komplex funkcionális elemek közötti kommunikációhoz. A 2-es évek elején indult meg az OCP-IP által vezetett folyamat, amely azt tűzte ki célul, hogy kidolgozza és elterjessze az IP-k egy szabványosított interfészét, hogy elősegítsék a plug and play SoC tervezést. Ennek ellenére egy komplex funkcionális egységen belüli adat összeköttetések megvalósítására még mindig nincs egyszerű, ugyanakkor robosztus módszer. Ezért olyan új eljárásra van szükség, amely az előbb említett hátrányt nagymértékben csökkenti, adott esetben teljesen meg is szünteti. A továbbiakban olyan eljárásokat ismertetünk, amelyek a magas szintű szintézis eredményeként keletkező struktúrát olyan összeköttetés-rendszerrel valósítják meg, amely által jelentősen csökken a felhasználandó multiplexerek száma. Ez az összeköttetésrendszer nem más, mint a komplex funkcionális egységek közötti egyszerű, arbitrációmentes sínrendszer. A MURED algoritmus olyan sínrendszer létrehozásával próbálja meg a processzorok közötti összeköttetéseket megvalósítani, amely a multiplexerek számának drasztikus csökkenését, a legtöbb esetben a multiplexer egységek teljes elhagyását vonja maga után. A BUSRED algoritmus a lehető legkevesebb sín felhasználásával próbálja meg a komplex funkcionális egységek közötti adatkapcsolatokat megvalósítani, miközben jelentősen csökken a beépítendő multiplexer egységek száma és költsége is. Ha a [2, 5. o.]-on megfogalmazott feltételeket alkalmazzuk, akkor demultiplexer egységek alkalmazására nincsen szükség, hiszen egy funkcionális egység kimenete mindaddig stabil, amíg az őt közvetlen utódként követő funkcionális egység dolgozik vele A probléma megfogalmazása A cél tehát, hogy a komplex funkcionális építőelemek közötti adatkapcsolatokat olyan összeköttetésrendszerrel valósítsuk meg, hogy a felhasználásra kerülő multiplexer egységek száma minél kevesebb legyen. A hagyományos tervezési eljárás során azért van szükség nagy számú multiplexer egység alkalmazására, mert a komplex funkcionális építőelemek között minden adat átadása fizikailag külön adatutakon történik. Ha több adat átadását is meg tudjuk valósítani ugyanazon az adatúton, akkor kevesebb vezetéket kell a processzorok bemenetére kapcsolni, ezáltal csökken a multiplexer egységek száma, illetve mérete is, azaz a költsége. Ezeket a közös adatutakat síneknek nevezzük. Ez a sínrendszer nem igényel semmilyen arbitrációs mechanizmust, a sínen történő kommunikáció időosztásos protokollként értelmezhető. A komplex funkcionális egységek csak a kiadódó ütemezésnek megfelelően foglalják időben a síneket. A síneken fellépő konfliktusok az időbeni átfedés kizárásával kerülhetők el. A kidolgozott algoritmusok ezt a feltételt biztosítják. Először az algoritmusok által használt fogalmakat vezetjük be. Open Core Protocol International Partnership

70 ADATKAPCSOLATOK OPTIMÁLIS MEVALÓSíTÁSA Definíció. Az adatátadás (DT) komplex funkcionális építőelemek közötti, vagy rendszer be- és kimenet és komplex funkcionális egységek közötti adatfolyamot valósít meg. Minden egyes, az ütemezett és allokált gráfban megjelenő adatátadás egy forrással és egy vagy több nyelővel rendelkezik. A forrás vagy egy komplex funkcionális egység kimenete, vagy rendszerbemenet (gráf bemenet). A nyelő vagy egy másik komplex funkcionális építőelem bemenete, vagy rendszer kimenet (gráf kimenet). Meg kell különböztetni az adatátadás és az adatkapcsolat fogalmát Definíció. Az adatkapcsolat (DL) egyetlen forrás és egyetlen nyelő közötti egyedi adatátadást valósít meg. A 4.2. definícióból következik, ha egy komplex funkcionális egység több komplex funkcionális egységnek ad át adatot, akkor ez az adatátadás külön adatkapcsolatokat jelent. Ezt mutatja a 4.2. ábra. DT DL proc proc DL 3 DT 2 proc2 DL 2 proc2 proc DT 4 proc DL 5 DT 3 DL ábra. Adatkapcsolatok értelmezése 4.3. Definíció. Az sín olyan összeköttetés, amelyen egy vagy több adatátadás játszódik le Definíció. Minden egyes adatkapcsolat sínhez való hozzárendelését, azaz annak eldöntését, hogy az adott adatkapcsolatot melyik sín valósítsa meg, sínre történő allokációnak nevezzük. Ha egy komplex funkcionális egységnek, mint forrásnak, csak egyetlen nyelője van és ez a nyelő nem fogad más forrásból adatot, akkor nincs szükség multiplexer egység alkalmazására a nyelő processzor bemenetén. Ebben az esetben nem jelent előnyt az, ha az adat átadását sínnel valósítjuk meg. Ezért az ilyen adatkapcsolatokat érdemes megkülönböztetni Definíció. Két komplex funkcionális egység (p i és p j ) közti közvetlen adatkapcsolatról beszélünk akkor, ha p i és p j forrás-nyelő kapcsolatban állnak és p i egyetlen nyelője p j. Tehát közvetlen adatkapcsolat esetén nincs szükség sínre az adatok átadásához. Például a 4.2. ábra DL adatkapcsolata közvetlen adatkapcsolatot jelöl. A kidolgozott algoritmusok feladata a nem közvetlen adatkapcsolatok sínekre történő elhelyezése.

71 ADATKAPCSOLATOK OPTIMÁLIS MEVALÓSíTÁSA Kompatibilitás vizsgálata Következő lépésként azt vizsgáljuk meg, hogy milyen feltételek teljesülése mellett történhet két adatkapcsolat egy közös sínhez való rendelése. Az alábbi következtetések abból a feltételezésből indulnak ki, hogy egy adott időpillanatban nem állhat fenn két különböző adat egy sínen. Ehhez ismerni kell azt, hogy egy adatkapcsolat mikor válik aktívvá és meddig áll fent az általa szolgáltatott adat érvényessége Definíció. Azt az időpontot (órajel periódus), amikor egy adatkapcsolaton keresztül az adatátvitel indul, az adatkapcsolaton történő adatátadás kezdetének nevezzük. Ez megegyezik azzal az időponttal, amikor a forrás processzor befejezi működését Definíció. Az adatkapcsolat időbeni fennállása az az időtartam, ameddig az adatnak érvényesnek kell lennie az átadás során. Ez az időtartam megegyezik a nyelő processzor végrehajtási idejével. Ha egy adatkapcsolatot egy sínhez rendelünk, akkor az adatkapcsolat a sínt a 4.7.-ben definiált időtartam alatt foglalja, azaz ezen időtartam alatt más adatkapcsolat nem szolgáltathat adatot a sínre. Ha két adatkapcsolat időben nem átfedő, akkor ezek közös sínhez rendelhetők. Két adatkapcsolat időbeni átfedése a CONCHECK [2, 52. o.] algoritmus segítségével ellenőrizhető. Ha két adatkapcsolat időben átfedő, akkor ez még nem jelenti automatikusan azt, hogy mindkét adatkapcsolatot különböző sínekhez kell hozzárendelni. Ha mindkét adatkapcsolat forrása megegyezik, akkor az időbeli átfedés csak úgy lehetséges, ha a forrás komplex funkcionális egység egyidőben több nyelő egységnek adja át ugyanazt az adatot. Ez abból a tényből következik, hogy a magas szintű szintézis során csak az egymással időben nem konkurens műveletek allokálhatóak közös komplex funkcionális egységbe [2]. Vagyis ebben az esetben egy a forrás processzorhoz rendelt művelet befejezte a működését, és az eredményül kapott adatot több nyelő processzor is megkapja, ami nyilvánvalóan lehetővé teszi a közös sín alkalmazását az időbeni átfedés ellenére. Ha egy komplex funkcionális egység ugyanabban az időben több adatot kap, akkor ez csak úgy fordulhat elő, hogy az adatok a processzor különböző bemeneteire érkeznek. Ebben az esetben nyilvánvalóan nem használhatunk közös sínt, mert ezzel összekötnénk a processzor bemeneteit. Összefoglalva kijelenthetjük, hogy: 4.8. Definíció. Két adatkapcsolat akkor összevonható, azaz közös sínhez rendelhető, ha időben nem átfedőek, vagy időben átfedőek, de azonos a forrásuk és különböző a nyelőjük. Az alábbiakban megvizsgáljuk két adatkapcsolat összevonhatóságának, mint relációnak a tulajdonságait. Mivel egy adatkapcsolat önmagával közös sínhez rendelhető, ezért a reláció reflexív. Ha a DL i adatkapcsolat a DL j adatkapcsolattal együtt közös sínnel megvalósítható a fenti feltételek teljesülése esetén, akkor ez fordítva is igaz, tehát a DL j és a DL i adatkapcsolat is közös sínhez rendelhető. Azaz a reláció szimmetrikus. Ha azonban a DL i a DL j -vel és a DL j a DL k -val közös sínhez rendelhető, ebből nem következik az, hogy a DL i és a DL k adatkapcsolatok összevonhatóak. Mivel előfordulhat az, hogy a DL i és a DL j, valamint a DL j a DL k adatkapcsolatok időben nem átfedők, viszont ettől függetlenül a DL i és a DL k adatkapcsolatok időbeni fennállása átlapolódik. Így a DL i és a DL k adatkapcsolatok nem rendelhetők közös sínhez (feltéve persze, hogy különböző a forrásuk a 4.8. definíció értelmében). Ezt szemlélteti a 4.3 ábra. Tehát a reláció nem tranzitív. Azaz a reláció reflexív, szimmetrikus és nem tranzitív, ezért kompatibilitási relációról beszélhetünk.

72 ADATKAPCSOLATOK OPTIMÁLIS MEVALÓSíTÁSA 6 DL i DL k idő DL j fj 4.3. ábra. Adatkapcsolatok tranzitivitásának vizsgálata 4.4. Processzorok közötti sínszerű összeköttetésrendszer optimális megvalósítása Az alábbiakban két algoritmus kerül bemutatásra, amelyek az adatkapcsolatokból kiindulva meghatározzák a komplex funkcionális egységek közötti összeköttetésrendszert, azaz sínrendszert valamilyen optimalitási feltétel figyelembe vételével. Az algoritmusok leírásánál alkalmazott jelölések DL(DL,...,DL i,... ) n(dl) pred(dl i ) succ(dl i ) b(b,...,b r,...) B(B,...,B r,... ) Az adatkapcsolatok halmaza Az adatkapcsolatok száma Az i-dik adatkapcsolat forrása Az i-dik adatkapcsolat nyelője Sínek halmaza Sínenkénti adatkapcsolatok halmaza, a halmaz elemei az adott sínre allokált adatkapcsolatok, azaz B r DL A MURED algoritmus Az algoritmus célja, hogy redukálja a komplex funkcionális egységek bemenetén szükséges multiplexer egységek számát, illetve költségét. Mivel az adatkapcsolatokat hozzá kell rendelni a sínekhez, ezért az algoritmus arra törekszik, hogy a beépítendő multiplexerek száma is csökkenjen. Abból a feltételezésből indulunk ki, hogy minden egyes adatkapcsolat külön-külön sín is egyben. Az algoritmus úgy próbálja meg a síneket összevonni, vagyis csökkenteni a sínek számát, hogy eközben minél kevesebb multiplexer egység alkalmazására legyen szükség. A síneket úgy vonja össze az ütemezett és allokált gráf topológiáját figyelembe véve, hogy az nem sérti a sínre allokált adatkapcsolatok a 4.8. definíció szerinti összevonhatóságának feltételét. Így b s és b r sínek akkor vonhatók össze, ha B s B r halmaz minden elemére igaz, hogy összevonhatóak. A multiplexer egységek számának csökkentése érdekében minden egyes lépésben előnyben részesítjük a közös nyelővel rendelkező DL-ket. Abban az esetben, ha két sín összevonhatóságának vizsgálatakor több, azonos legnagyobb számú közös nyelővel rendelkező adatkapcsolat (DL) létezik, akkor a közös forrás processzorok száma alapján döntünk. Ezen megfontolások alapján a következő d i,j, optimailzációs jelzőszámot érdemes bevezetni.

73 ADATKAPCSOLATOK OPTIMÁLIS MEVALÓSíTÁSA 62 n(dl) ha succ(dl i ) = succ(dl j ) d i,j = ha pred(dl i ) = pred(dl j ) egyébként, ahol (DL i,dl j ) (B s B r ) (4.) Ha két sínt úgy akarunk összevonni, azaz a hozzájuk rendelt adatkapcsolatokat közös sínnel megvalósítani, hogy közben a multiplexer egységek száma csökkenjen, akkor a d i,j -re épülő, úgynevezett D s,r optimalizációs paramétert az alábbi módon célszerű bevezetni. B s B r d i,j D s,r = i= j= (4.2) Tehát a közös nyelővel rendelkező adatkapcsolatok esetén D s,r -t a d i,j -re bevezetett definíció értelmében egy akkora számmal növeljük, ami biztosan nagyobb a közös forrásokból származó maximális d i,j értéknél, például n(dl) értékkel, közös forrás processzor esetén pedig -gyel. Mindezt figyelembe véve, minden egyes lépésben az a két sín (b s és b r ) kerül összevonásra, amelyek a legnagyobb D s,r értékkel rendelkeznek, és természetesen nem sérül a két sín összevonhatóságának feltétele. Az előző megfontolások alapján a MURED algoritmus leírása a következőképpen néz ki. START while (létezik összevonható sínpár és létezik nem allokált DL i ) do { (B s,b r )-re: D s,r kiszámítása while (B s és B r összevonható) do { max{d s,r } meghatározása } max{d s,r } -nek megfelelő b s és b r kiválasztása B s = B s B r DL i B r megjelölése allokáltként } STOP Az algoritmus konvergens, hiszen addig történik a sínek redukciója, amíg létezik egymással összevonható két sín. Ha közelebbről vizsgáljuk meg az algoritmus komplexitását, akkor a következő megállapításokat tehetjük. Jelöljük n-nel az adatkapcsolatok számát. Minden lépésben az algoritmus kiválaszt egy b r sínt, amely legalább egy adatkapcsolatot tartalmaz és ezt megjelöli allokáltként. A legpesszimistább eset az, amikor minden lépésben csak egy adatkapcsolatot tudunk allokáltként megjelölni. Ezért a MURED algoritmus komplexitása O(n). Természetesen az egyes lépések során a b r kiválasztásához szükséges jellemzők kiszámításához szükséges idő nagy is lehet B s B r nagysága miatt, ami jelen esetben n 2. Azonban a MURED algoritmus a lépésszám tekintetében gyors, mohó algoritmus A BUSRED algoritmus Az algoritmus célja, hogy a komplex funkcionális egységek közötti összeköttetésrendszer megvalósításhoz szükséges sínek számát minimálisra csökkentse. Ezt úgy tudjuk elérni, ha csak akkor veszünk

74 ADATKAPCSOLATOK OPTIMÁLIS MEVALÓSíTÁSA 63 fel új sínt, ha ez mindenféleképpen szükséges. Ez azt jelenti, hogy az adott adatkapcsolat nem rendelhető hozzá egyik, már létező sínhez sem a 4.8. definíció alapján. Mivel egy adatkapcsolat csak akkor rendelhető hozzá egy sínhez, ha az adott sínre allokált valamennyi adatkapcsolattal kompatibilis. Természetesen a szükséges sínek számának csökkentése mellett a multiplexer egységek okozta költséget is csökkenteni szeretnénk. A multiplexerek számát illetve méretét úgy csökkenthetjük, ha csökkentjük azoknak a síneknek a számát, amelyektől egy adott komplex funkcionális építőelem adatot kap. Tehát, ha egy processzor a b i sínről már kap adatot akkor erre a b i sínre azon adatkapcsolatok hozzárendelését kell előnyben részesíteni, melyek szintén ennek a komplex funkcionális egységnek szolgáltatnak adatot. Ennek a kényszernek a figyelembevételéhez a MURED algoritmus esetében már megismerthez hasonlóan egy optimalizációs jelzőszámot vezetünk be az alábbi módon. { ha succ(dli ) = succ(dl d i,j = j ) egyébként, DL j B r -re (4.3) Annak eldöntéséhez, hogy az adott adatkapcsolatot melyik sínhez rendeljük hozzá, az alábbi összefüggést célszerű bevezetni, amely az adatkapcsolatok nyelői alapján megmutatja, hogy egy adatkapcsolat és egy már létező sín nyelői között mennyi azonos komplex funkcionális egység található. B r d i,j D i,r = j= (4.4) Az allokáció során azt a DL i, B r párost kell kiválasztani, ahol ez a szám maximális. Minden egyes lépésben az adott DL i adatkapcsolatot ahhoz a b r sínhez kell allokálni, amelyikhez a legnagyobb D i,r érték tarozik, feltéve, hogy létezik már olyan sín, amelyikkel egyáltalán összevonható. Ha nem létezik ilyen sín, akkor új sínt hozunk létre hozzárendelve az adott adatkapcsolatot. Az algoritmus abból a feltételezésből indul ki, hogy még nincs sín létrehozva. Az első vizsgálandó adatkapcsolat lesz az első sínre allokálva. Az algoritmus konvergens, hiszen addig történik az adatkapcsolatok sínekhez való hozzárendelése, illetve új sínek létrehozása, ameddig van még nem allokált adatkapcsolat. Az előző megfontolások alapján a BUSRED algoritmus leírása a következőképpen fogalmazható meg. START while (létezik nem allokált DL i ) do { (DL i,b r )-re: D i,r kiszámítása if (létezik olyan B r, amelyhez DL i hozzárendelhető) while (DL i és B r összevonható) do { max{d i,r } meghatározása } max{d i,r } -nek megfelelő DL i kiválasztása B r = B r DL i

75 ADATKAPCSOLATOK OPTIMÁLIS MEVALÓSíTÁSA 64 } STOP else max{d i,r } meghatározása új B n sín létrehozása B n = DL i endif DL i megjelölése allokáltként A BUSRED egymás után végignézi az összes adatkapcsolatot, és minden lépésben megvizsgálja, hogy az hozzárendelhető-e már létező sínhez. Ha igen, hozzárendeli, ha nem, akkor új sínt vesz fel. Az adatkapcsolatot mindenképpen megjelöli allokáltként. Ha az adatkapcsolatok számát n-nel jelöljük, akkor a legrosszabb esetben is n lépésszám után az algoritmus leáll, tehát konvergens. Az előbb leírtaknak megfelelően a BUSRED algoritmus komplexitása O(n) a lépésszám tekintetében Alkalmazási lehetőségek Az előbbiekben ismertetett két algoritmus alkalmazására először egy kisebb feladat kidolgozását mutatjuk meg a könnyebb érthetőség kedvéért, majd ezek után nagy feladatokra is alkalmazzuk a fent leírt módszert, és megmutatjuk az algoritmusok hatékonyságát mind minőségi, mind futási idő szempontjából. Ahhoz, hogy a PIPE tervezőrendszer által szolgáltatott eredményt fel tudjuk dolgozni, pár előkészítő lépésre van szükség. A legfontosabb, hogy olyan új gráfot kell építeni, amelynek csomópontjai komplex funkcionális egységek az eredeti műveletek helyett. Mivel mindkét algoritmus adatkapcsolatokkal dolgozik, ezért meg kell határoznunk a processzorok közötti, a definíció szerinti adatkapcsolatokat a PIPE által szolgáltatott információ alapján. Meg kell határozni az egyes adatkapcsolatok forrás és nyelő komplex funkcionális egységeit, valamint azt az idő-intervallumot, hogy az adott adatkapcsolatok mikor foglalják a síneket. Az intervallum kezdeti időpontja az az órajel periódus, amikor az adatkapcsolat forrás processzora befejezi működését, az időtartam hossza, azaz a foglaltság pedig a nyelő processzor működési ideje. Ki kell szűrni a közvetlen adatkapcsolatokat is, hiszen ezeket ki kell zárni a sínallokációból. Bemeneti puffereket kell elhelyezni a rendszerbemenetekhez kapcsolódó, nem nulla indítási idejű funkcionális elemekre. Az így behelyezett (ibff), valamint a PIPE tervezőrendszer által beillesztett szinkronizációs (sbff) puffereket az algoritmusok processzorokként kezelik. Először a már jól ismert koszinusz tétel kiszámítását bemutató feladatot elemezzük. A feladat gráfja az 57. oldalon lévő 4.. ábra bal oldalán látható. Az ábra jobb oldalán pedig az ütemezés és allokáció utáni, hagyományos módon, multiplexerek alkalmazásával megvalósított összeköttetésrendszer figyelhető meg. Jól látható, hogy 6 darab, 2 bemenetű multiplexer egységre van szükség a komplex funkcionális egységek közötti összes adatút biztosítására. A MURED algoritmus alkalmazása A MURED algoritmus alkalmazásától azt várjuk, hogy az adatkapcsolatokat olyan sínrendszerrel valósítsa meg, amelynek hatására jelentősen csökken az alkalmazandó multiplexerek száma, továbbá lehetőleg minimális számú sín keletkezzen. Az elérhető minimális sínszám 4, amely az adatkapcsolatok kompatibilitásából számítható. Számítását a következő fejezetben részletezzük. A MURED algoritmus azt feltételezi, hogy az összes adatkapcsolat egy-egy sín, és a sínek (azaz adatkapcsolatok) összevonásával próbálja meg csökkenteni a sínek számát.

76 ADATKAPCSOLATOK OPTIMÁLIS MEVALÓSíTÁSA 65 mul m m add a 5 a c ibff2 sbff sbff mul m 3 m sub s 8 2 a ibff b ibff x cos c 4 8 sbff2 idő 4.4. ábra. A MURED algoritmus alkalmazása után kiadódó sínszerű összeköttetésrendszer mul m m add a 5 a x c ibff2 mul cos sub m 3 m 7 sbff c 4 s a ibff sbff b sbff2 ibff idő 4.5. ábra. A BUSRED algoritmus alkalmazása után kiadódó sínszerű összeköttetésrendszer A 4.4. ábra mutatja a keletkezett sínrendszert. Az adatkapcsolatok megvalósításához összesen 6 sínre van szükség. Ugyancsak megfigyelhető az ábrán, hogy melyik komplex funkcionális egység melyik sínre kapcsolódik; azaz melyik sínről kap adatot és melyik sínre továbbítja az eredményét. A síneken látható szürke alakzatok a sín foglaltsági idejét mutatják. Jól látható az is, hogy nincs szükség multiplexer egységek alkalmazására, tehát teljesen sikerült eltávolítani a pótlólagos multiplexereket a sínrendszer, mint összeköttetésrendszer alkalmazásával.

77 ADATKAPCSOLATOK OPTIMÁLIS MEVALÓSíTÁSA 66 A BUSRED algoritmus alkalmazása A BUSRED algoritmus alkalmazásától azt várjuk, hogy az adatkapcsolatokat olyan, a minimálishoz közel álló számú sín alkalmazásával valósítsa meg, hogy az alkalmazandó multiplexerek száma lehetőség szerint jelentősen csökkenjen. A 4.5. ábra mutatja a BUSRED algoritmus alkalmazása után a keletkezett sínrendszert. Az adatkapcsolatok megvalósításához összesen 5 sínre van szükség. Ebben az esetben azonban a mul és add komplex funkcionális egységek egy-egy bementére be kell szúrni egy-egy két bemenetű multiplexer egységet a megfelelő működés biztosítása érdekében. Itt mérlegelni lehet, hogy melyik megoldást választjuk. A MURED algoritmus által szolgáltatott eredményt, ahol nincs szükség multiplexerek alkalmazására, és 6 sín kell a megvalósításhoz; vagy a BUS- RED algoritmus által szolgáltatott eredményt, ahol csak 5 sínt kell alkalmazni, de két darab két bemenetű multiplexer egységet kell pótlólagosan alkalmazni. Ezt mindig az adott feladatra kell megvizsgálni, hogy melyik megoldás kedvezőbb költség szempontjából. Ez nagyban függ például az adatutak bitszélességétől, azaz a huzalozás költségétől. Ezen kívül függ a multiplexerek vezérlését biztosító áramkör szilícium felület igényétől, költségétől is. A két algoritmus alkalmazása nagyobb feladatokra A kiválasztott nemzetközi benchmark feladatokat, illetve azok jellemzőit a 4.. táblázat tartalmazza. A feladatok között megtalálható egy 8-pontos T-t megvalósító feladat, valamint két titkosító algoritmus (IDEA [59], CAST6 []) is. A táblázatban feltüntettük a feladatokban eredetileg szereplő műveletek számát. Az újraindítási idő függvényében megfigyelhetjük az allokáció eredményét, hatékonyságát is. Az utolsó előtti oszlopban találjuk a komplex funkcionális építőelemek számát, amely egységekkel az adott R-nél megvalósítható a feladat. Érdemes megfigyelni a szükséges pufferek számát is, ezeket, mint műveleteket a PIPE tervezőrendszer az adott futtatási paraméterekkel nem allokálja. Minél nagyobb méretű a feladat, annál több szinkronizációs puffer alkalmazására van szükség, amelyeket a sínallokáció során processzorokként kezelünk, tehát a puffereket is hozzárendeljük a sínekhez. Az utolsó oszlop mutatja a sínekhez rendelendő adatkapcsolatok számát. eladat R L 4.. táblázat. Nemzetközi benchmark feladatok Komplex Adat- Pufferek Műveletek funkcionális kapcsolatok száma száma egységek száma száma cos cos fft fft fft idea idea idea cast cast Először vizsgáljuk meg a MURED algoritmus által szolgáltatott eredményeket, amelyeket a 4.2. táblázat mutat. A táblázatban minden egyes feladatnál megadtuk az adatkapcsolatok időbeni átfedésén

78 ADATKAPCSOLATOK OPTIMÁLIS MEVALÓSíTÁSA 67 alapuló, elméletileg szükséges minimális sínszámot (min). Ez az érték úgy számolható, hogy minden egyes órajel periódusban összegezzük a nem-kompatibilis adatkapcsolatok számát, és ezek közül vesszük a maximumot. Megadtuk továbbá az algoritmus alkalmazása után kiadódó sínszámot is. Hasonlóan jártunk el a multiplexer egységek számát tekintve is, azzal a kiegészítéssel, hogy ebben az esetben a költséget is feltüntettük. A multiplexerek költséget az egyszerűség kedvéért úgy számíthatjuk, hogy a multiplexer egységek számát súlyozzuk a bemeneteik számával. Végül az utolsó oszlopban megfigyelhető az algoritmus futási ideje. A példák alapján kijelenthető, hogy ezekben az esetekben a MURED algoritmus alkalmazása olyan sínrendszert, mint összeköttetésrendszert eredményezett a komplex funkcionális elemek között, amelyeknél nincs szükség multiplexer egységek alkalmazására. Azaz a beépítendő multiplexerek számát -ra, így nyilvánvaló a költségüket is -ra csökkentette. Mindeközben az algoritmus az adatkapcsolatok számát is jelentős mértékben redukálta, és az elméletileg elérhető sín számot is megközelítette táblázat. A MURED algoritmus által szolgáltatott eredmények eladat R Sínek Multiplexerek száma száma költsége eredelőttelőtte ered- eredmény mény min mény Idő [mp] cos , cos ,2 fft ,88 fft ,9 fft ,3 idea ,75 idea ,45 idea ,58 cast ,73 cast ,4 Ha az algoritmus futási idejét vizsgáljuk, akkor azt tapasztaljuk, hogy viszonylag nagy méretű feladatoknál is nagyon rövid idő alatt szolgáltatja az összeköttetésrendszert, mint például a CAST6 titkosító algoritmus fő része esetén, amelynél 3423 pufferrel, 23 funkcionális egységgel és 936 adatkapcsolattal kellett foglalkoznia az algoritmusnak. Következik a BUSRED algoritmus által szolgáltatott eredmények vizsgálata, amelyeket az előbbihez hasonló módon a 4.3. táblázat mutat. Ebben az esetben elsősorban a sínek számának alakulására figyelünk, hiszen az algoritmus az alkalmazandó sínek számát hivatott csökkenteni. A példák alapján kijelenthető, hogy ezekben az esetekben a BUSRED algoritmus alkalmazása olyan sínrendszert hozott létre a komplex funkcionális elemek összekötése céljából, ahol az alkalmazandó sínek száma az elméletileg elérhető minimális sín számot jelentősen megközelítette, sőt nagyon sok esetben el is érte azt. Mindeközben az algoritmus az alkalmazandó multiplexer egységek számát kisebb mértékben, míg költségüket jelentős mértékben csökkentette. Ez úgy lehetséges, hogy a multiplexerek bemeneteinek száma maximálisan a sínek számával lehet egyenlő, így a költségszámításnál a súlyok száma jelentősen csökkent, hiszen a sínek számát minimális szinten tartottuk. A BUSRED algoritmus futási ideje rövidebb, mint a MURED algoritmusé, hiszen egyszerűbb az optimalizációs feltétel, és kevesebb vizsgálatot is kell végezni az algoritmus futása során. Összességében kijelenthetjük, hogy mindkét bemutatott algoritmus alkalmazása esetén kevesebb szilícium felületre van szükségünk a feladat megoldásához, egyszerűbb vezérlést kell alkalmaznunk, hiszen

79 ADATKAPCSOLATOK OPTIMÁLIS MEVALÓSíTÁSA 68 eladat 4.3. táblázat. A BUSRED algoritmus által szolgáltatott eredmények R Sínek Multiplexerek száma száma költsége eredelőttelőtte ered- eredmény mény min mény Idő [mp] cos , cos ,2 fft ,2 fft ,28 fft ,36 idea ,73 idea ,97 idea ,9 cast ,5 cast ,3 vagy egyáltalán nincs, vagy jóval kevesebb vezérlő jelre van szükségünk a multiplexer egységek vezérléséhez, mint a hagyományos összeköttetésrendszer alkalmazása esetén. Továbbá nincs szükség sín arbitrációra sem és jóval kevesebb az összekötő vezetékek száma. Tehát a topológia és a vezérlés is nagymértékben egyszerűsödik a hagyományos eljáráshoz képest. Itt említjük meg, hogy szükség lehet a funkcionális egységek, processzorok kimenetén speciális demultiplexer egységek alkalmazására, amely többlet szilícium felületet jelent, azonban ez a többlet elenyésző a fent említett nyereséghez képest. Speciális demultiplexer alkalmazása abban az esetben lehet szükséges, ha az adott processzor kimenete több sínre csatlakozik és egy adott időpontban több sínre is szolgáltat adatot, viszont egy másik időpontban többek között ezen sínek egy részéhez is van hozzáférése (részletesebben később az 5.3. fejezetben). Ugyanakkor figyelembe kell venni annak a hatását is, hogy gyakorlati alkalmazásokban a sínszerű összeköttetésrendszer megvalósításához felhasznált háromállapotú meghajtók költsége ronthatja a kidolgozott módszer hatékonyságát. A redukció mértéke (multiplexerek számának és főleg költségének csökkentése) azonban olyan jelentős főleg bonyolult topológia esetén, hogy a technológiától függő költségesebb háromállapotú elemek alkalmazása mellett is jelentős a nyereség. Emellett nagy előny, hogy az automatikusan kialakuló arbitrációmentes sínrendszer semmiféle külön vezérlést nem igényel. Ezek hatása megfigyelhető a későbbiekben (5.3. fejezet). Természetesen ez az újfajta, sínrendszeren alapuló processzorok közötti összeköttetést megvalósító eljárás alkalmazható a 2. fejezetben ismertetett hierarchikus tervezési eljárással együtt is, továbbá szintén felhasználható a 3. fejezetben bemutatott szisztematikus dekompozíciót és erőforrás kiosztást végrehajtó eljárás eredményeként kiadódó építőelemek összekötésére is. Ebben az esetben hierarchikus sínrendszerről, mint komplex funkcionális elemek közötti adatkapcsolatokat megvalósító összeköttetésrendszerről beszélhetünk. A komplex funkcionális egységeken belül is, illetve azok összekötésére is használhatunk sínszerű, vagy hagyományos összeköttetésrendszert. Egy ilyen lehetséges, kevert struktúrát mutat be a 4.6. ábra.

80 ADATKAPCSOLATOK OPTIMÁLIS MEVALÓSíTÁSA ábra. Hierarchikus sínrendszer megvalósítása komplex funkcionális elemekkel

81 ADATKAPCSOLATOK OPTIMÁLIS MEVALÓSíTÁSA Harmadik tézis Az előzőek alapján a következő kijelentéseket tehetjük. 3. Tézis. Adatkapcsolatok optimális, sínszerű megvalósítása Új szisztematikus eljárást dolgoztam ki a magas szintű szintézis során az elemi műveleti gráf ütemezése és az allokáció eredményeként kiadódó processzorok közötti sínszerű, arbitrációt nem igénylő összeköttetések kompatibilitási reláción alapuló optimalizálására. Az algoritmus olyan összeköttetésrendszert, sínrendszert eredményez, amelyben a multiplexerek és a sínek száma is jelentősen csökken [8, 4, 27]. 3.. Az algoritmus a sín fogalmát a következőképpen értelmezi. A műveleti gráfban minden egyes adatátadásnak egyetlen forrása és egy vagy több nyelője van. Egy sín egy vagy több adatátadás lebonyolítására alkalmas összeköttetés. Az algoritmus külön kezeli az adatkapcsolatokat, amelyek egyetlen forrás és egyetlen nyelő közötti egyedi adatátadások Az összevonhatóságot az eljárás az alábbiak szerint értelmezi. Két adatkapcsolat akkor összevonható, vagyis akkor valósítható meg közös sínnel, ha időben nem átfedőek, vagy időben átfedőek, de azonos a forrásuk és különböző a nyelőjük. Két sín akkor vonható össze, ha a hozzájuk rendelt adatkapcsolatok páronként összevonhatóak Olyan optimalizációs paramétereket vezettem be, amelyek segítségével a kidolgozott algoritmusok különböző minőségi követelményeket és a gyors konvergenciát egyszerűen és tömören kezelhetővé teszik.

82 5. fejezet VHDL leírás szisztematikus előállítása komplex, pipeline funkcionális elemek alkalmazása esetén 5.. Bevezetés és szakirodalmi áttekintés Ahogy azt az előző fejezetekben is láthattuk, a rendszer-szintű szintézis területén a legutóbbi fejlesztések azt eredményezték, hogy a feladatok megoldása során egyre bonyolultabb, komplex hierarchikus funkcionális elemeket alkalmaznak építőelemként [5]. A gyakorlatban nagyon hasznos, ha feltételezzük, hogy a hierarchikus építőelemek pipeline működésre is képesek. Ezeknek a komplex, pipeline egységeknek a vezérlése jóval bonyolultabb, mint egy hagyományos elemi művelet vezérlése. Ezért az egyik fő cél az lehet, hogy olyan VHDL [78] [29] [46] kódot állítsunk elő, amely nagymértékben támogatja ezeknek a komplex, pipeline működésű egységeknek a tervezését és használatát a hierarchikus tervezési eljárás során. Nagy előnyt jelent, ha a viselkedési szintről indított tervezési eljárás olyan leírás előállításával fejeződik be, amelyből könnyen előállítható az RTL leírás. A szakirodalomban olyan eljárások ismertek, amelyek vagy csak bizonyos feladat típusokat, vagy előre definiált, kötött struktúrákra történő leképezést támogatnak [66]. Mivel kötött a struktúra, ezért ezek az eljárások nem tekinthetők általánosan használható eljárásoknak. Nagyon fontos, hogy minden egyes tervezési szinten szimuláció futtatásával ellenőrizzük az egyes lépések helyességét. Léteznek olyan eszközök, amelyek képesek a magas szintű programozási nyelven írt szoftver összetevő és a hardver leíró nyelven megadott hardver komponensek együttes szimulációjára [77] [6]. A feladat tehát olyan új, szisztematikus eljárás kidolgozása, amely a hierarchikus tervezési eljárást támogató PIPE tervezőrendszer által előállított, az allokációt és vezérlési információt tartalmazó feladatleírásból olyan VHDL leírást állít elő, amely alapján a kereskedelemben kapható, úgynevezett szintézis tervezőprogramok segítségével a feladat egyszerűen megvalósítható PA, ASIC vagy full-custom integrált áramkörökkel. A funkcionális elemek közötti összeköttetés létrehozását hagyományos módon kezeli az eljárás, tehát multiplexer és demultiplexer egységek beépítésével valósítja meg az adatkapcsolatokat. A leírt módszer nem kezeli a 4. fejezetben leírt redukciós eljárások eredményét, azonban a bemutatott VHDL generátor könnyen kiterjeszthető a komplex funkcionális egységek közötti sínszerű összeköttetésrendszer kezelésére is. Erre láthatunk egy rövid példaalkalmazást a későbbiekben. A multiplexer egységek és a komplex, pipeline funkcionális egységek vezérlését az egyszerűség kedvéért központi vezérléssel oldjuk meg. Természetesen más vezérlési stratégia, például az elosztott vezérlés is könnyen integrálható a szisztematikus VHDL leírás előállításának folyamatába. Először az eljárás bemutatására kerül sor, majd két rövid példára alkalmazzuk is az eljárást. 7

83 VHDL LEíRÁS SZISZTEMATIKUS ELŐÁLLíTÁSA Szisztematikus kódgenerálás Első lépésként számos módosítást kell végeznünk a PIPE által szolgáltatott adatfolyam leíráson ahhoz, hogy az automatikus kódgenerálás sikeres legyen. Ezek után következhet az adatfolyam leírásának előállítása, végül pedig a vezérlést valósítjuk meg, amely a multiplexer egységek és a komplex funkcionális egységek indítását végzi Előkészítő lépések Először egy olyan új adatfolyam gráfot kell létrehozni, ahol a műveletek helyett már a komplex funkcionális építőelemek szerepelnek a gráf csomópontjaiban. A következő feladatokat kell ehhez végrehajtani. Bemeneti pufferek beillesztése Bemeneti puffereket kell elhelyezni a rendszerbemenetekre csatlakozó, nem indítási idejű funkcionális egységekre, mivel a PIPE tervezőrendszer ezt nem végzi el. Erre a szinkronizációs problémák elkerülése érdekében van szükség. Multiplexer egységek beillesztése Mivel több művelet is hozzárendelhető egy közös processzorhoz, ezért a komplex funkcionális egységek közötti összeköttetés nagyon bonyolulttá válhat. Ahogy azt láttuk korábban, a hagyományos tervezési eljárás esetén az összeköttetésrendszer megvalósításánál nagy számú multiplexer (esetleg demultiplexer) egység beépítésére van szükség. A következő kijelentést tehetjük. 5.. Definíció. Egy komplex funkcionális egység bemenetére mindenképpen multiplexer egységet kell helyezni, ha az adott bemenethez kapcsolódó műveletek közvetlen elődei különböző funkcionális egységekhez lettek rendelve. Például o (o 22 elődje) és o 33 (o 32 elődje) különböző komplex funkcionális egységekhez vannak rendelve (sub2 és sub3) az 5.. ábra szerint. A multiplexer egység bemeneteinek a száma megegyezik az adott processzor közvetlen elődjeinek számával. o 5 o o 26 o 23 o 22 o 32 mul6 mul9 sub2 sub6 o 5 o 26 o 9 o o 23 o 33 mux add5 mux o 22 o ábra. Multiplexer egységek beillesztése komplex funkcionális egységek közé

84 VHDL LEíRÁS SZISZTEMATIKUS ELŐÁLLíTÁSA 73 Demultiplexer egységek beillesztése Demultiplexer egység beillesztésére akkor van szükség, ha egy funkcionális egység kimenete egyben rendszerkimenet is. Ebben az esetben az adott processzor kimenetére demultiplexer egységet kell beilleszteni. Ez elsősorban abban az esetben fontos, ha a megvalósított komplex funkcionális egységet a későbbiekben hierarchikus építőelemként és használni szeretnénk. Azért van rá szükség, hogy teljesítsük azt a feltételt, hogy a komplex funkcionális egység a saját végrehajtási idő eltelte utáni kimenetét csak egy következő indítás hatására változtathatja meg. Ez azt jelenti, hogy a komplex funkcionális egységen belül azt a funkcionális egységet, amely a kimenetet előállító műveletet is végrehajtja le kell választani a belső működésről egy demultiplexer egység beillesztésével. Így biztosítható a fejezetben leírt módon a komplex funkcionális egység kimenetére beillesztett pufferrel együtt a szinkronizáció és az adatkonzisztencia Adatfolyam létrehozása Az előkészítő lépések után rendelkezésre áll a módosított adatfolyam gráf a feldolgozásra. Legelőször az alkalmazni kívánt entitásokat kell specifikálni. Ezeket az entitásokat fogjuk felhasználni az adatfolyam felépítése közben. Számos entitás típus létezik, amelyek minden feladatban alkalmazhatók, ezek az entitások teljes mértékben automatikusan generálhatók. Ez azt jelenti, hogy nemcsak az interfészük definiálható, hanem maga a működésük is megadható. Ilyen egységek a puffer (sbff ), multiplexer (mux) és demultiplexer (demux) egységek. A funkcionális egységek esetében csak az interfész, illetve az egységek indításához szükséges általános működési leírás generálható. A művelet-specifikus részt a tervezőnek kell megadnia, létrehoznia. Az entitások bemenetén azt feltételezzük, hogy kétfázisú órajel áll rendelkezésre, mivel sokkal könnyebb a szinkronizációs feltételeket teljesíteni és bizonyos esetekben sokkal nagyobb szabadságunk van a vezérlés tervezésekor is. Minden entitás leírása viselkedési leírás. Pufferek Pufferek beillesztésére a szinkronizációs problémák elkerülése miatt van szükség. Ezeket az építőelemeket egyrészt a PIPE tervezőrendszer generálja, másrészt az előkészítő lépések során, mint bemeneti pufferek kerülnek az adatfolyamba. A puffer egységnek egy engedélyező bemenete (en_sbff ), két trigger bemenete (trg_in_sbff, trg_out_sbff ), egy adat bemenete (sbff_in) és egy adat kimenete (sbff_out) van. Az adatszélességet a tervezőnek kell megadnia. ENTIT sbff IS PORT ( en_sbff : IN STD_LOIC; trg_in_sbff : IN STD_LOIC; trg_out_sbff : IN STD_LOIC; sbff_in : IN STD_LOIC_VECTOR(7 DOWNTO ); sbff_out : OUT STD_LOIC_VECTOR(7 DOWNTO ) ); END sbff; Az egység működése a következő, ha a puffer működése engedélyezve van, akkor a bemeneti adat tárolását vezérlő trigger jel (trg_in_sbff ) felfutó élére a bemeneti adat a pufferbe íródik. A kimenetet vezérlő trigger jel felfutó élének hatására íródik át az adat a pufferből a kimenetre, és ott addig marad aktív, amíg trg_out_sbff aktív. A trg_out_sbff jel fennállásának időtartama megegyezik a következő egység végrehajtási idejével. A következő VHDL leírás egy puffer egység megvalósítását mutatja.

85 VHDL LEíRÁS SZISZTEMATIKUS ELŐÁLLíTÁSA 74 ARCHITECTURE behaviour O sbff IS SINAL sbff_out_tmp : STD_LOIC_VECTOR(7 DOWNTO ); BEIN sbff : PROCESS(trg_in_sbff, trg_out_sbff, en_sbff) BEIN I trg_in_sbff EVENT AND trg_in_sbff = THEN I en_sbff = THEN sbff_out_tmp <= sbff_in; END I; END I; END PROCESS; sbff_out <= sbff_out_tmp WHEN trg_out_sbff = ELSE (OTHERS => Z ); END behaviour; Multiplexer egységek A multiplexer egységek esetén fontos tudnunk a bemenetek számát, hiszen ekkor tudjuk pontosan létrehozni az egység viselkedési leírását. Ezért a multiplexer egység bemeneteinek száma meghatározza magát az entitást is. Annyi féle multiplexer egységet, (mint entitást) hozunk létre, ahány különböző bemenetszámú multiplexer egységet illesztettünk be az előkészítő lépések során. A multiplexer egység bemeneteinek a száma megegyezik az adott processzor közvetlen elődjeinek számával. Tehát akkor hozzuk létre például a mux3 entitást, ha a beillesztett multiplexer egység 3 bemenettel rendelkezik (mux3_in_, mux3_in_, mux3_in_2). A bemenetek kiválasztását a sel_in_mux3 kiválasztó bemenet végzi, aminek az adatszélességét egyértelműen meghatározza a bemenetek száma. Ez szintén automatikusan számolódik. ENTIT mux3 IS PORT ( trg_in_mux3 : IN STD_LOIC; sel_in_mux3 : IN STD_LOIC_VECTOR( DOWNTO ); mux3_in_ : IN STD_LOIC_VECTOR(7 DOWNTO ); mux3_in_ : IN STD_LOIC_VECTOR(7 DOWNTO ); mux3_in_2 : IN STD_LOIC_VECTOR(7 DOWNTO ); mux3_out : OUT STD_LOIC_VECTOR(7 DOWNTO ) ); END mux3; A következő VHDL kódrészlet segítségével követhető nyomon a multiplexer egység működése. A trigger bemeneten (trg_in_mux3) megjelenő jel felfutó élére a sel_in_mux3 bemenet által kiválasztott bemeneti adat a kimenetre (mux3_out) íródik. Tehát a vezérlés tervezésénél figyelembe kell venni azt a tényt, hogy a kiválasztó bemenetre az előtt kell megérkezni az érvényes adatnak, mielőtt a trigger bemenetet aktiválnánk. ARCHITECTURE behaviour O mux3 IS BEIN mux3 : PROCESS(trg_in_mux3) BEIN I trg_in_mux3 EVENT AND trg_in_mux3 = THEN CASE sel_in_mux3 IS WHEN "" => mux3_out <= mux3_in_; WHEN "" => mux3_out <= mux3_in_; WHEN "" => mux3_out <= mux3_in_2; WHEN OTHERS => NULL; END CASE; END I; END PROCESS; END behaviour;

86 VHDL LEíRÁS SZISZTEMATIKUS ELŐÁLLíTÁSA 75 Demultiplexer egységek Ezeknek az egységeknek a működése hasonló a multiplexer egységek működéséhez, azzal a különbséggel, hogy a trigger jel (trg_in_demux2) felfutó élére a bemeneti adat a sel_out_demux2 kiválasztó bemenet által aktivált kimenetre íródik. ENTIT demux2 IS PORT ( trg_in_demux2 : IN STD_LOIC; sel_out_demux2 : IN STD_LOIC; demux2_in : IN STD_LOIC_VECTOR(7 DOWNTO ); demux2_out_ : OUT STD_LOIC_VECTOR(7 DOWNTO ); demux2_out_ : OUT STD_LOIC_VECTOR(7 DOWNTO ) ); END demux2; ARCHITECTURE behaviour O demux2 IS BEIN demux2 : PROCESS(trg_in_demux2) BEIN I trg_in_demux2 EVENT AND trg_in_demux2 = THEN CASE sel_out_demux2 IS WHEN => demux2_out_ <= demux2_in; WHEN => demux2_out_ <= demux2_in; WHEN OTHERS => NULL; END CASE; END I; END PROCESS; END behaviour; Komplex funkcionális egységek, processzorok A komplex funkcionális egységeknél csak az entitás vázát tudjuk létrehozni, magát a működést a tervezőnek kell definiálnia. Abból a célból viszont, hogy az egész adatfolyamot automatikusan tudjuk generálni, mindenképpen szükség van a processzorok egységes interfészének létrehozására is. Minden processzor rendelkezik a bemenetén a kétfázisú órajellel (clk, clk2), két trigger bemenettel a bemeneti operandusokkal, valamint a kimenettel. A clk és clk2 órajelek szerepeltetése fontos, mivel a funkciót a felhasználónak kell definiálnia, amihez szüksége lehet az órajelek felhasználására is. A szintézis tervezőrendszerek a feleslegesnek bizonyult jeleket automatikusan eltávolítják. A következő VHDL leírás egy összeadó egység interfészét mutatja. ENTIT add IS PORT ( clk : IN STD_LOIC; clk2 : IN STD_LOIC; en_add : IN STD_LOIC; trg_in_add : IN STD_LOIC; trg_out_add : IN STD_LOIC; add_in_ : IN STD_LOIC_VECTOR(7 DOWNTO ); add_in_ : IN STD_LOIC_VECTOR(7 DOWNTO ); add_out : OUT STD_LOIC_VECTOR(7 DOWNTO ) ); END add; A komplex funkcionális egységek esetén külön kell választani a végrehajtási idő alatt történő bemeneti adatok feldolgozását, valamint a kimenet aktivizálását. Ennek megfelelően két process-t definiáltunk a megvalósításhoz. A következő példa egy összeadó egység funkcionális leírását mutatja. A bemeneti adat

87 VHDL LEíRÁS SZISZTEMATIKUS ELŐÁLLíTÁSA 76 tárolását vezérlő és a műveletet indító trigger (trg_in_add) jel felfutó élére ha a funkcionális egység működése engedélyezve van (en_add) a tervező által specifikált működésnek megfelelően a bemeneti adatokat (add_in_ és add_in_) felhasználva elkezdődik a számítás és az eredmény egy átmeneti pufferbe íródik. A trg_in_add jel fennállásának időtartama megegyezik az egység végrehajtási idejével. A kimenetet vezérlő trigger (trg_out_add) jel felfutó élének hatására íródik át az adat az átmeneti pufferből a kimenetre, és ott addig marad érvényes, amíg trg_out_add aktív. A trg_out_add jel fennállásának időtartama megegyezik a következő egység végrehajtási idejével. ARCHITECTURE behaviour O add IS SINAL add_out_tmp : STD_LOIC_VECTOR(7 DOWNTO ); BEIN add_in_proc : PROCESS(trg_in_add, en_add) BEIN I trg_in_add EVENT AND trg_in_add = THEN I en_add = THEN -- Put your code here -- add_out_tmp <= add_in_ + add_in_; END I; END I; END PROCESS; add_out_proc : PROCESS(trg_out_add, en_add, add_out_tmp) BEIN I trg_out_add = THEN I en_add = THEN -- Put your code here -- add_out <= add_out_tmp; ELSE add_out <= (OTHERS => Z ); END I; ELSE add_out <= (OTHERS => Z ); END I; END PROCESS; END behaviour; Adatfolyam Az adatfolyam leírás generálásához az alkalmazandó komplex funkcionális egységeket, puffereket, multiplexer egységeket, stb. komponensként deklarálni kell az interfészük megadásával, amit a következő példa mutat. Ez a deklaráció a már létrehozott entitások leírásából automatikusan keletkezik. COMPONENT add PORT ( clk : IN STD_LOIC; clk2 : IN STD_LOIC; en_add : IN STD_LOIC; trg_in_add : IN STD_LOIC; trg_out_add : IN STD_LOIC; add_in_ : IN STD_LOIC_VECTOR(7 DOWNTO ); add_in_ : IN STD_LOIC_VECTOR(7 DOWNTO ); add_out : OUT STD_LOIC_VECTOR(7 DOWNTO ) ); END COMPONENT;

88 VHDL LEíRÁS SZISZTEMATIKUS ELŐÁLLíTÁSA 77 Ezután a komponensekből felépítjük a módosított gráfnak megfelelő adatfolyamot. A komplex funkcionális egységek, mint komponensek közötti összeköttetéseket úgy oldjuk meg, hogy a különböző komponensek megfelelő adakapcsolatait (signal) egymáshoz rendeljük az architektúra törzs részében. Az adatfolyam leírás strukturális leírás, ami természetesen automatikusan előállítható a már létrehozott entitásokból, valamint a közöttük lévő adatkapcsolatokból, amit a módosított gráf leírás tartalmaz. A következő példa egy szorzó egység, és a két bemenetén lévő 3-bemenetű multiplexer egység összekapcsolását mutatja. comp_mul : mul PORT MAP ( clk => clk, clk2 => clk2, en_mul => en_mul, trg_in_mul => trg_in_mul, trg_out_mul => trg_out_mul, mul_in_ => mux_mul_, mul_in_ => mux_mul_, mul_out => mul ); comp_mux_mul_ : mux3 PORT MAP ( trg_in_mux3 => trg_in_mux_mul_, sel_in_mux3 => arg_sel_mux_mul_, mux3_in_ => sbff3, mux3_in_ => sbff33, mux3_in_2 => sbff48, mux3_out => mux_mul_ ); comp_mux_mul_ : mux3 PORT MAP ( trg_in_mux3 => trg_in_mux_mul_, sel_in_mux3 => arg_sel_mux_mul_, mux3_in_ => sbff38, mux3_in_ => sbff4, mux3_in_2 => add2, mux3_out => mux_mul_ ); Vezérlés tervezése Nagyon fontos a megfelelő vezérlés megtervezése, hiszen a vezérlés biztosítja azt, hogy az adatfolyamba épített különböző építőelemek (komplex funkcionális egységek, multiplexerek, pufferek, stb.) a megfelelő időpontban kezdjék el a működésüket és a bemeneteiken az éppen szükséges adatok álljanak a rendelkezésre. A vezérlést központosított módon valósítjuk meg, ami nem más, mint egy véges automata, jelen esetben egy számláló. A legnagyobb előnye a központi vezérlésnek, hogy nagyon könnyen lehet implementálni. Hátránya viszont, hogy nagyobb szilícium felületet foglal, valamint a vezérlő jeleket megvalósító vezetékek hosszúak lehetnek, így a jelterjedési idők növekedése miatt csökkenhet a rendszer maximális működési frekvenciája. Természetesen a pipeline működésű komplex funkcionális elemek kezelése többlet követelményt jelent. Mivel modulo-r számlálót használunk, ezért ezen építőelemek indítása után figyelni kell arra, hogy mindaddig engedélyezni kell a működésüket, amíg az utolsó bemeneti adatcsomagra is megjelenik az érvényes kimeneti adat. Ezt a többlet időtartamot az R/L arány határozza meg.

89 VHDL LEíRÁS SZISZTEMATIKUS ELŐÁLLíTÁSA 78 Természetesen másfajta vezérlési elvet is lehet használni. Elosztott vezérlés esetén maga az elemi vezérlő cella egyszerűbb, de ugyanazt a topológiát meg kell valósítani közöttük, mint az adatfolyam esetében. Egy másik megoldás lehet az integrált adatfolyam-vezérlés megközelítés, amikor is maguk a funkcionális egységek tartalmazzák az elosztott vezérlés elemi celláját, de ebben az esetben a puffer, multiplexer és demultiplexer áramkörök leírásán is módosítani kell. A központi elven működő vezérlés megvalósítása viselkedési leírással történik. Az építőelemek indítási időpontját a PIPE tervezőrendszer szolgáltatja. Ez az információ R-ben átlapolva tartalmazza az indítási információkat, így a pipeline működést könnyen biztosítani lehet. A vezérlés működésének elvét az 5.2. ábra felső részén követhetjük nyomon. Az ábra alsó felén ennek megfelelő szimulációs eredmény látható. multiplexerek kiválasztó bemenetének állítása multiplexerek trigger jelének előállítása processzorok és pufferek működésének tiltása processzorok és pufferek működésének engedélyezése processzorok és pufferek indítójelének generálása processzorok és pufferek kimenetének engedélyezése processzorok és pufferek kimenetének tiltása clk clk2 counter clk_2 counter_r mul en_mul trg_in_mul trg_out_mul trg_in_mux_mul_ trg_in_mux_mul_ arg_sel_mux_mul_ arg_sel_mux_mul_ mul3 en_mul3 trg_in_mul3 trg_out_mul3 trg_in_mux_mul3_ trg_in_mux_mul3_ arg_sel_mux_mul3_ arg_sel_mux_mul3_ 5.2. ábra. Az adatfolyam vezérlése A vezérlési periódust ami a tervezési módszertanban egy órajel periódusnak felel meg nyolc fázisra bontjuk, ahogy azt az ábra is szemlélteti. Így egy perióduson belül az órajel nyolc felfutó éléhez tudjuk szinkronizálni a különböző eseményeket. A funkcionális egységek (processzorok) működésének engedélyezése (en_xx) az ő foglaltsági idejük alatt aktív. A funkcionális egységek bemenetének (trg_in_xx) indítójelei a végrehajtási idejük alatt aktívak. A funkcionális egységek kimenetének (trg_out_xx) indítójele az őt követő egységek végrehajtási idejei alatt aktívak. Így együttesen az adott funkcionális egység foglaltságát reprezentálják Teszt-környezet Végső lépésként a létrehozott adatfolyam és vezérlés modulokat automatikusan össze kell kötni egymással, így kapjuk meg a megoldandó feladat VHDL leírással megvalósított realizációját. Ahhoz, hogy

90 VHDL LEíRÁS SZISZTEMATIKUS ELŐÁLLíTÁSA 79 könnyen tesztelhessük, és szimulációval ellenőrizzük a feladatot megvalósító, szisztematikus módon, automatikusan generált VHDL leírást, illetve az általa leírt működést, egy teszt-környezetet definiálunk. Ennek a teszt-környezetnek a felépítését figyelhetjük meg az 5.3. ábrán, amelyet strukturális leírással valósítunk meg. teszt-környezet feladat adatfolyam órajel vezérlés 5.3. ábra. Teszt-környezet létrehozása funkció ellenőrzés céljából Az alkalmazási lehetőségeknél bemutatott feladatokhoz is használtuk különböző szinteken létrehozott teszt-környezeteket a működés helyességének vizsgálatához Alkalmazási lehetőségek Két rövid példán mutatjuk be az automatikus VHDL leírás előállításának folyamatát. Az első példa esetében nem használunk hierarchikus tervezési eljárást, míg a második példában egy olyan feladat megoldását mutatjuk be, ahol komplex, hierarchikus funkcionális elemet is használunk a tervezés során, így közben alkalmaznunk kell a 2. fejezetben bemutatott módszertant is. Megmutatjuk, hogyan használható a VHDL kódgenerálás a második esetben. 8-pontos T műveletvégző megvalósítása A 8-pontos T funkciót megvalósító egység szorzó, összeadó és kivonó műveletekkel történő, egyik lehetséges realizációját mutatja az 5.4. ábra. Az ábra felső részén az T DSP lepkeszerű jelfolyam ábrázolása figyelhető meg, az ábra alsó részén az ebből származtatott EO. A W bemenetek konstans értékek, amelyeket az ábra alsó részén sorszámozva jelöltünk. Tételezzük fel továbbá, hogy az elemi műveletek végrehajtási idejei az 5.. táblázat szerintiek. A végrehajtási időket órajel-periódusok számában tüntettük fel. 5.. táblázat. 8-pontos T művelet végrehajtási idők Művelet Végrehajtási idő Szorzó (m...m 28 ) 5 Összeadó (a 6...a 36 ) 2 Kivonó (s 5...s 35 ) 2 A hagyományos magas szintű szintézis algoritmusait alkalmazzuk a feladat megoldására. Az eredményt a PIPE tervezőrendszer szolgáltatja, amelyet az 5.2. táblázat mutat. Tételezzük fel, hogy nem

91 VHDL LEíRÁS SZISZTEMATIKUS ELŐÁLLíTÁSA 8 x y x 4 W 8 - y x 2 - y 2 x 6 W 8 - W y 3 x W 8 - y 4 x 5 W 8 - W 8 - y 5 x 3 W 8 - W y 6 x 7 W 8 - W8 2 - W8 3 - y 7 x 6 W x 4 W 3 x 5 x 7 W W 2 m 3 m 4 m 2 m x 2 x x x 3 x 2 x x x 3 s 9 s s 7 s 5 a a 2 a 8 a 6 W 6 W 4 W 7 W 5 m 5 m 3 m 6 m 4 s 2 a 22 s 7 a 8 s 23 a 24 s 9 a 2 W 8 W 9 W W m 25 m 27 m 26 m 28 s 29 a 3 a 34 s 33 s 3 a 32 a 36 s 35 y 7 y 3 y y 5 y 6 y 2 y y ábra. 8-pontos T DSP jelfolyam ábrája és az ennek megfelelő elemi műveleti gráf pipeline működést valósítunk meg, tehát az R értékét 23-ra választjuk, ami megegyezik a lappangás értékével. Azért adódott 6 szorzó egység az T jól elkülöníthető végrehajtási fázisaiból várható 4 szorzó egység helyett, mert a konkrét alkalmazásnál a be- és kimenetekre beiktatott pufferek meggátolták a PIPE tervezőrendszert abban, hogy kedvezőbb megoldást találjon. Ennek következménye az is, hogy a lappangás értéke 23, nem pedig 2. Ha nem szerepelnek a be- és kimenetre beillesztett pufferek, akkor 4 szorzó egységgel megvalósítható a feladat. Ebben az esetben is jelentős, közel 6%-os processzorszám csökkenést értünk el, ami az allokációnak köszönhető. Most már rendelkezésre állnak azok az információk, amelyekre alkalmazhatjuk a szisztematikus VHDL kódgenerálás kezdeti, előkészítő lépéseit. Tehát beépítésre kerülnek a bemeneti 5.2. táblázat. A PIPE tervezőrendszer által szolgáltatott eredmények különböző újraindítási időknél R Processzorok add mul sub Pufferek Költség L

92 VHDL LEíRÁS SZISZTEMATIKUS ELŐÁLLíTÁSA 8 pufferek azokra a rendszerbemenetekre, amelyekre nem indítási idejű processzorok csatlakoznak. Valamint az 5.. definíció szerint elhelyezzük a multiplexer egységeket az adatfolyamba. Mivel minden egyes komplex funkcionális egységhez több művelet is hozzá lett rendelve, ezért az összes építőelem bemeneteire multiplexer egységek kerültek. A módosított gráfot az 5.5. ábra mutatja, amelyre már alkalmazható az előző fejezetben ismertetett, szisztematikus VHDL kódgeneráló eljárás. Jól megfigyelhetők az ábrán a tervezés, valamint az előkészítő eljárás során beillesztett szinkronizációs és bemeneti puffer egységek is. A konkrét megvalósítás esetén a műveletvégzők egységek nem komplex számábrázolásúak. x2 x7 x4 W W W3 x6 W7 W x5 W6 W2 x x W4 W8 W5 W9 W x3 mul mul mul4 mul2 add mul5 sub mul3 add2 sub2 sub3 add3 sub add y2 y6 y y7 y5 y3 y y ábra. Allokáció eredményeként az adatkapcsolatok megvalósítása multiplexerek felhasználásával, 8-pontos T esetén Az entitások, az adatfolyam, a vezérlés és a teszt környezet létrehozása után meg kell vizsgálni, hogy ténylegesen helyes eredményt szolgáltat az eljárás. Ehhez először a generált kódot felhasználva funkcionális szimulációt hajtunk végre. A teszt környezetet felhasználva gerjesztjük a rendszer bemeneteit különböző teszt vektorokkal és figyeljük a keletkező eredményt a rendszer kimenetén. A funkcionális szimulációt a Mentor raphics által készített ModelSim E III 6.d program segítségével végeztük. Azt is ellenőrizzük, hogy a generált VHDL kód valóban leképezhető PA áramkörre. Ezért a feladatot a ilinx ISE WebPACK 8.i tervezőrendszer segítségével leképeztük az C2S2 PA áramkörre, amely a Spartan-II család 2. logikai cellát tartalmazó áramköre. A VHDL szintézis eredményeit az 5.3. és az 5.4. táblázatok 2 részletezik. A PIPE tervezőrendszer által szolgáltatott eredmények összhangban vannak a megvalósításhoz szükséges funkcionális elemek és a pufferek számával is. Az 5.3. táblázatból látható, hogy 4-4 összeadó és kivonó egység, valamint 6 szorzó egység került beépítésre (az 5.2 táblázat utolsó sorának megfelelően). A felhasznált pufferek száma is megegyezik a generált háromállapotú (tristate) pufferek számával, hiszen ha összeadjuk az 5.2 táblázatban szereplő értéket a funkcionális egységek kimenetén szereplő pufferek számával (a funkcionális elemek viselkedési leírásából következik, hogy a kimeneteikre pufferek kerülnek beépítésre), akkor megkapjuk a tristate pufferek számát, azaz = 68. Szintén megfigyelhetők a hagyományos összeköttetés-rendszer alkalmazása miatt az adatfolyamba került multiplexer egységek 2 A hardver szintézis eredményeit bemutató táblázatok angol nyelvűek, mivel a tervezőrendszer által közvetlenül szolgáltatott eredményeket tartalmazzák.

93 VHDL LEíRÁS SZISZTEMATIKUS ELŐÁLLíTÁSA 82 is. A központi vezérlés megvalósítása egy számláló, egy komparátor, valamint a ROM-ba került, vezérlést leíró igazságtáblázat megvalósítását végző egység segítségével történt automatikusan táblázat. A generált VHDL kódból történő hardver szintézis eredménye 8-pontos T esetén Pieces Pieces of units of units ROMs Registers x27-bit ROM 8-bit register 94 Multipliers 6 Comparators 8x8-bit multiplier 6 8-bit comparator less Adders/Subtractors 8 Multiplexers 4 8-bit adder 4 8-bit 4-to- multiplexer 4 8-bit subtractor 4 Tristates 68 Counters 8-bit tristate buffer 68 8-bit up counter ors -bit xor2 Az 5.4. táblázat számszerűen mutatja a megvalósított feladat felületi kihasználtságát a céláramkörön. A későbbi összehasonlítás szempontjából mindenképpen hasznos információt hordoz az ekvivalens kapu szám, ami esetünkben Szemléletesebb összehasonlítást tesz lehetővé az 5.6. ábrán bemutatott felületi térkép. Az eddig leírt feladatban az 5.2. fejezetben ismertetett elmélet alapján generált VHDL leírást felhasználva a hardver szintézis folyamatát és a kapott eredményeket részleteztük. Az ismertetett eljárás eredményeként teljesen automatikus módon keletkezett a feladat VHDL leírása. A funkcionális egységek összekötése multiplexerek segítségével történt. A multiplexer egységek nagy száma jelentős hátrány, amely kihat a magas szintű szintézis módszerek hatékonyságára, használhatóságára. A járulékos multiplexerek növelik a megoldás terület igényét, valamint a vezérlés is bonyolultabbá válhat. Ahhoz, hogy számszerűleg is megvizsgáljuk a 4. fejezetben ismertetett módszerek hatékonyságát, illetve a megvalósítás minőségét, ezért az előző feladatra alkalmaztuk a MURED algoritmust és a komplex funkcionális elemek közötti összeköttetéseket sínrendszerrel 5.4. táblázat. Az C2S2 PA áramkör felületi kihasználtságának alakulása hagyományos tervezési eljárás alkalmazása esetén Logic Utilization Used Available Utilization Number of Slice lip lops 558 4,74 % Number of 4 input LUTs 983 4,74 2% Logic Distribution Number of occupied Slices 678 2,352 28% Total Number 4 input LUTs 99 4,74 2% Number used as logic 983 Number used as a route-thru 7 Number of Tbufs 48 2,464 9% Number of CLKs 4 4 % Total equivalent gate count for design 5,67

94 VHDL LEíRÁS SZISZTEMATIKUS ELŐÁLLíTÁSA 83 valósítottuk meg. Ezt a megoldást szemlélteti a 86. oldalon látható 5.8. ábra. Az algoritmus által szolgáltatott eredmény alapján elkészítettük félig automatikusan a feladat VHDL leírását, ugyanazon komplex funkcionális elemeket felhasználva, amelyeket a hagyományos tervezési megközelítés esetén is használtunk. A félig automatizált eljárás annyit jelent, hogy csak a a komplex funkcionális elemek közötti összeköttetéseket valósítottuk meg kézi módszerrel, minden más leírást, beleértve a vezérlés leírását is automatikusan állítottunk elő. A feladat megoldásához szükség volt a 4.5. fejezet végén már említett, speciális demultiplexer egységek alkalmazására. Erre akkor lehet szükség, ha egy adott processzor kimenete több sínre csatlakozik és ugyanazon időpontban több sínre is szolgáltat adatot. A következő VHDL kódrészlet egy ilyen két kimenetű demultiplexer egységet mutat. A működési különbség annyi a klasszikus értelemben vett demultiplexer egységhez képest, hogy ebben az esetben egyszerre több kimenet is lehet aktív, ezt a vezérlő bemenettel döntjük el, amelynek bitszélessége ennek megfelelően megegyezik a kimenetek számával. ENTIT demux2 IS PORT ( trg_in_demux2 : IN STD_LOIC; sel_out_demux2 : IN STD_LOIC_VECTOR( DOWNTO ); demux2_in : IN STD_LOIC_VECTOR(7 DOWNTO ); demux2_out_ : OUT STD_LOIC_VECTOR(7 DOWNTO ); demux2_out_ : OUT STD_LOIC_VECTOR(7 DOWNTO ) ); END demux2; ARCHITECTURE behaviour O demux2 IS BEIN demux2: PROCESS(trg_in_demux2, sel_out_demux2, demux2_in) BEIN I trg_in_demux2 = THEN CASE sel_out_demux2 IS WHEN "" => demux2_out_ <= (OTHERS => Z ); demux2_out_ <= (OTHERS => Z ); WHEN "" => demux2_out_ <= demux2_in; demux2_out_ <= (OTHERS => Z ); WHEN "" => demux2_out_ <= (OTHERS => Z ); demux2_out_ <= demux2_in; WHEN "" => demux2_out_ <= demux2_in; demux2_out_ <= demux2_in; WHEN OTHERS => demux2_out_ <= (OTHERS => Z ); demux2_out_ <= (OTHERS => Z ); END CASE; ELSE demux2_out_ <= (OTHERS => Z ); demux2_out_ <= (OTHERS => Z ); END I; END PROCESS; END behaviour; A MURED algoritmus által szolgáltatott eredmény alapján elkészített VHDL leírásból kiinduló hardver szintézis eredményeit az 5.5. és az 5.6. táblázatok foglalják össze. Ebben az esetben a komplex funkcionális egységek közötti összeköttetéseket sínrendszerrel valósítottuk meg. Az eredményekből kiolvasható, hogy teljesen eltűntek a megvalósításból a multiplexer egységek. Az

95 VHDL LEíRÁS SZISZTEMATIKUS ELŐÁLLíTÁSA táblázat. A sínszerű összeköttetést megvalósító VHDL kódból történő hardver szintézis eredménye 8-pontos T esetén Pieces Pieces of units of units ROMs Registers x229-bit ROM 8-bit register 69 Multipliers 6 Comparators 8x8-bit multiplier 6 8-bit comparator less Adders/Subtractors 8 Tristates 87 8-bit adder 4 8-bit tristate buffer 87 8-bit subtractor 4 ors Counters -bit xor2 8-bit up counter összeadó, kivonó és szorzó komplex funkcionális egységek száma nem változott. A felhasznált regiszterek száma csökkent, csökkent továbbá a központi vezérlés megvalósításához szükséges ROM mérete is. Természetesen növekedett a háromállapotú puffer egységek száma a sínrendszer alkalmazása miatt. A tesztfeladat esetén az összeköttetésrendszer sínekkel történő megvalósításával a kapott eredmények megfelelnek az elvártaknak. Mindezek hatása jól megfigyelhető az áramkör felületi kihasználtságának alakulásában is. Ha összehasonlítjuk az ekvivalens kapu számot, amely jelen esetben 2.37, akkor a csökkenés 28,59%-os. rafikusan ábrázolva az áramkör felületi kihasználtságát is szembetűnő a csökkenés mértéke a sínrendszerrel történő megvalósítás javára. Ezt mutatják együttesen az 5.6. és az 5.7. ábrák táblázat. Az C2S2 PA áramkör felületi kihasználtságának alakulása sínrendszer alkalmazása esetén Logic Utilization Used Available Utilization Number of Slice lip lops 37 4,74 7% Number of 4 input LUTs 653 4,74 3% Logic Distribution Number of occupied Slices 526 2,352 22% Total Number 4 input LUTs 66 4,74 4% Number used as logic 653 Number used as a route-thru 8 Number of Tbufs 632 2,464 25% Number of CLKs 4 4 % Total equivalent gate count for design 2,37

96 VHDL LEíRÁS SZISZTEMATIKUS ELŐÁLLíTÁSA 85 l l l l 5.6. ábra. Áramköri elrendezési rajz hagyományos összeköttetésrendszer használata esetén l l l l 5.7. ábra. Áramköri elrendezési rajz sínszerű összeköttetésrendszer használata esetén

97 VHDL LEíRÁS SZISZTEMATIKUS ELŐÁLLíTÁSA 86 W4 mul5 m28 5 mul4 m4 m m 5 mul m27 5 m4 5 W8 W a 2 add2 a34 2 a8 2 W3 sub3 mul2 mul3 s23 2 s29 2 m3 m6 m3 m x add3 a3 a mul m5 m2 5 5 y7 x sub s5 s9 2 2 s35 2 sub2 s9 s7 2 2 s33 2 y3 add a6 a2 2 2 a36 2 y W2 y4 W W sub s7 s 2 2 s2 s3 2 2 add a8 a2 2 2 a22 a y x5 y5 W6 y6 x6 W7 y2 x2 W5 W9 x3 x7 x4 W 5.8. ábra. A MURED algoritmus alkalmazása után kiadódó sínszerű összeköttetésrendszer, 8-pontos T

98 VHDL LEíRÁS SZISZTEMATIKUS ELŐÁLLíTÁSA 87 A koszinusz tétel megvalósítása A második példában bemutatjuk, hogy a hagyományos, csak egyszerű műveleteket tartalmazó tervezési eljárás segítségével létrehozott komplex funkcionális egység hogyan használható fel a 2. fejezetben ismertetett hierarchikus tervezési eljárás során, valamint a keletkező hierarchikus komplex funkcionális elem hardveres megvalósításához hogyan használható az automatikus VHDL leírás generálás eszköztára. Ehhez a 2.4. fejezetben bemutatott példának, a koszinusz tétel kiszámításának eredményeit használjuk fel. Emlékeztetőül, a kifejezésben szereplő cos építőelemet a Taylor-soros közelítésével (2.36) valósítjuk meg. Először a Taylor-soros közelítést végző komplex pipeline funkcionális elem VHDL leírását kell előállítani. Ezek után a koszinusz tétel kiszámításához is elkészítjük a VHDL leírást, és a két kódgenerálás során keletkezett VHDL kódokat közös könyvtárba másoljuk és elvégezhető a két részfeladat együttes, illetve külön-külön történő szimulálása és hardveres megvalósítása is. A két részfeladatot ismét a ilinx ISE WebPACK 8.i tervezőrendszer segítségével leképeztük az C2S2 PA áramkörre. A végső feladat, azaz a koszinusz tétel kiszámítását megvalósító egység VHDL szintézisének eredményeit az 5.7. és az 5.8. táblázatok részletezik a már ismert módon táblázat. A VHDL kódból történő hardver szintézis eredménye a koszinusz tétel megvalósítása esetén Pieces Pieces of units of units Multipliers 5 Registers 2 6x6-bit multiplier 5 lip-lops 2 Counters 2 Comparators 2 32-bit up counter 2 32-bit comparator less 2 Adders/Subtractors 4 Latches 75 6-bit adder 2 -bit latch 7 6-bit subtractor 2 2-bit latch 4 ors 2 Multiplexers 8 -bit xor2 2 6-bit 4-to- multiplexer táblázat. Az C2S2 PA áramkör felületi kihasználtságának alakulása a koszinusz tétel megvalósítása esetén Logic Utilization Used Available Utilization Number of Slice lip lops 695 4,74 4% Number of 4 input LUTs 4 4,74 29% Logic Distribution Number of occupied Slices 854 2,352 36% Total Number 4 input LUTs 428 4,74 3% Number used as logic 4 Number used as a route-thru 27 Number of Tbufs 34 2,464 2% Number of CLKs 4 4 % Total equivalent gate count for design 9,986

99 VHDL LEíRÁS SZISZTEMATIKUS ELŐÁLLíTÁSA 88 A generált VHDL kódon alapuló szimuláció eredményét szemlélteti az 5.9. ábra, amely a koszinusz tétel kiszámításának ütemezését mutatja. Jól látható az ábrán a hierarchikus tervezési eljárás hatása. A beágyazott komplex funkcionális egység (Taylor-soros közelítés) indítása az en_cos engedélyező jel megjelenése után történik. A kiszámított eredmény a cos művelet lappangási idejének eltelte után meg is jelenik a művelet kimenetén. Ezt az eredményt használja fel továbbiakban a koszinusz tétel kiszámítását végző blokk és a végeredmény a 4-dik órajel ciklusban keletkezik, ami a teljes rendszer lappangási ideje. Ez a működés és ütemezés teljesen összhangban van a 2.4. fejezetben bemutatott eredményekkel, valamint a 2.9. ábrán látható ütemezéssel. clk clk2 clk_2 counter rst_cos_equ A koszinusz tétel kiszámítása, processzorok kimenete és vezérlőjeleik en_cos_equ add/add_in_ add/add_in_ add/add_out 2 2 mul/mul_in_ 2 mul/mul_in_ mul/mul_out 2 sub/sub_in_ 2 2 sub/sub_in_ 2 sub/sub_out en_add en_cos en_mul en_sub A koszinusz tétel számításának eredménye Újraindítási idő, koszinusz tétel Lappangás, koszinusz tétel 5 us us 5 us A Taylor-soros közelítés kiszámítása, processzorok kimenete és vezérlőjeleik clk_2 counter 27 add/add_out mul/mul_out mul/mul_out mul2/mul_out mul3/mul_out sub/sub_out en_add en_mul en_mul en_mul2 en_mul3 /en_sub A Taylor-soros közelítés eredménye Újraindítási idő, Taylor-soros közelítés Lappangás, Taylor-soros közelítés 5 us us 5 us 5.9. ábra. A koszinusz tétel kiszámításának idődiagramja R = 2-nél Összegzésül elmondhatjuk, hogy egy olyan módszert mutattunk be, amely a magas szintű szintézis eredményeiből kiindulva automatikusan generálja számunkra a feladat szintetizálható VHDL leírását, továbbá támogatja a hierarchikus tervezési eljárást is. Ezáltal sokkal komplexebb funkcionális egységek, építőelemek is használhatók bonyolultabb rendszerek fejlesztésére. Ezen építőelemek újrahasznosítása további távlatokat nyit a rendszer-szintű szintézis felé, valamint az IP-k szisztematikus tervezésének és felhasználásának irányába.

100 VHDL LEíRÁS SZISZTEMATIKUS ELŐÁLLíTÁSA Negyedik tézis Az előzőek alapján a következő kijelentéseket tehetjük. 4. Tézis. VHDL leírás szisztematikus előállítása komplex, pipeline funkcionális elemek alkalmazása esetén Új szisztematikus eljárást dolgoztam ki, amely automatikusan előállítja a magas szintű szintézis során kiadódó tetszőleges bonyolultságú pipeline működésű funkcionális egységek és a közöttük lévő adatkapcsolatok VHDL nyelven történő olyan leírását, amelynek alapján a szintézis közvetlenül elvégezhető PA áramkörökre vagy VLSI építőelemekre szintézis tervezőrendszerekkel [7, 55, 54]. 4.. A puffer, multiplexer és demultiplexer egységeket megvalósító entitások automatikusan keletkeznek, a funkcionális egységeket leíró entitások váza generálódik, a funkcionalitást a tervezőnek kell definiálnia Az adatfolyam specifikációja strukturális leírással, a központi elven működő vezérlésé pedig viselkedési leírással történik Az így kapott egység a hierarchikus szintézis folyamatában egy komplex műveleteként értelmezhető.

101 6. fejezet Alkalmazás, MRI agyfelvételek feldolgozása 6.. Bevezetés A BME IIT és az Akita Industrial Technology Center - Japan (továbbiakban AITC) közös együttműködésében olyan képfeldolgozó algoritmusok kifejlesztése volt a cél, amelyek orvosi képalkotó eljárások során keletkezett képek diagnosztizálását segítik. A másik cél az volt, hogy ezeket a gyors képfeldolgozó algoritmusokat közvetlen a páciens személyi egészségügyi kártyáján (amit az EHR rendszer tud kezelni) valósítsák meg, így a tárolt képek és a feldolgozó algoritmusok ugyanarra az adathordozóra kerülnek. A képeket DICOM 2 formátumban tárolják a kártyán. A DICOM abban különbözik a többi adatformátumtól, hogy az információt adathalmazokba csoportosítja. Például egy páciens röntgenfelvétele egy fájlban helyezkedik el a páciens azonosítójával, elválaszthatatlanul tőle, így a kép nem keverhető el véletlenül az adatoktól. A DICOM szabványok célja, hogy biztosítsa a kompatibilitást és a hatékony adatáramlást az orvosi képalkotó rendszerek és egyéb egészségügyi alkalmazások között világszerte. A megvalósítandó feladat az volt, hogy a kidolgozott képalkotó eljárásokat közvetlen egy PA áramkörre valósítsuk meg, így a feldolgozott (diagnosztizált) kép közvetlenül kinyerhető, nem kell hozzá speciális szoftver, alkalmazás. Ezek, az automatikusan diagnosztizált felvételek nagymértékben segítik az orvosok munkáját. Lerövidíti a hagyományos diagnosztizálás idejét és ráirányítja az orvos figyelmét a fontos, lényeges részekre. Az MRI 3 mágneses magrezonancia vizsgálat egyike a manapság széles körben alkalmazott orvosi diagnosztikai képalkotó eljárásoknak. Egyebek közt képes arra, hogy anatómiai, pszichológiai és működési információt szolgáltasson az emberi agyról. A feladat az, hogy az MRI szeletkép-sorozatok képeit úgy szegmentáljuk, hogy könnyen elkülöníthető legyen az öt fő terület, az agyfolyadék, a fehérállomány, a szürkeállomány, a koponya és a fejbőr, valamint a képek háttere. Ezért a szegmentálást végző algoritmusok a T2-súlyozású, szürkeárnyalatos agyfelvételek minden egyes képpontját hozzárendelik a fenti öt osztály valamelyikéhez. (Az MR kép kontrasztját a protonok három alapvető tulajdonsága befolyásolja: a protonok sűrűsége, a T és T2 relaxációs idő. A T2-súlyozású felvételeken a szürkeállomány világosabb a fehérállománynál.) Az különbözteti meg az eljárásokat, hogy ezt a hozzárendelést milyen módszer, algoritmus alkalmazásával valósítják meg. Két algoritmus kerül bemutatásra, mindkét eljárás a neurális számítástechnika (neurocomputing [24, 2, 42, 25]) módszereit alkalmazva valósítja meg a szegmentálás feladatát. Az eredeti algoritmus, amelyet az AITC kutatói dolgoztak ki, a Kohonen [57] által kifejlesztett algoritmuson alapul. A Kohonen háló Electronic Health Record 2 Digital Imaging and Communications in Medicine 3 Magnetic Resonance Imaging 9

102 ALKALMAZÁS 9 egy nem ellenőrzött tanulású hálózat. A Kohonen hálót Kohonen térképnek nevezzük, ha a bemeneti minták topológiai kapcsolatait megőrzi. Ehhez úgy kell módosítani a tanulási folyamatot (módosított Hebb [43] szabály), hogy nemcsak a győztes processzáló elem súlyait módosítjuk, hanem a győztes adott környezetében lévőkét is. A fuzzy logikát [82, 83, 8] számos műszaki probléma megoldására használják, többek között létezik néhány alkalmazás a képfeldolgozás, osztályozás területén is. A második algoritmus azon a megfigyelésen alapul, hogy a világ nem egyszerűen fekete és fehér. Logikus az, hogy egy adott dolog egy bizonyos osztályhoz tartozik, egy másik dolog viszont nem. Ez megfeleltethető a hagyományos Boole algebra szabályainak is. Ezzel szemben a fuzzy világában egy elem csak bizonyos mértékben tartozhat egy osztályhoz, amelyet a fuzzy tagsági érték jellemez. A tagsági érték értéke jelenti, hogy az adott elem teljes mértékben az adott osztályhoz tartozik. A azt jelenti, hogy az adott elem nem tagja az adott osztálynak, a köztes értékek pedig részleges hozzátartozást reprezentálnak. Ennek az elvnek megfelelően először az öt osztálynak megfelelő tagsági értékeken alapuló képeket határozzuk meg, majd elvégezzük az eredeti agyfelvétel szegmentálását a tagsági képek alapján. Mindkét megközelítés leírásának célja, hogy bemutassuk a hierarchikus tervezés módszertanának és a szisztematikus VHDL leírás generálásának együttes alkalmazhatóságát. A hierarchikus tervezés során a COMPALL algoritmust is alkalmaztuk az általunk definiált funkcionális elemkészletre történő allokáció céljára Kohonen hálózat tervezése Az általunk használt Kohonen hálózat eléggé sajátos. Általában a neuronok egy mátrixban, egy sík rácspontjaiban helyezkednek el, esetünkben az öt processzáló elemet egydimenziós tömbben (egy vonal mentén) helyeztük el. A háló jellemzője, hogy nincs különálló kimeneti réteg, hanem minden egyes neuron egyben kimeneti csomópont is. (Ezért tudjuk az egyes neuronokat egyszerűen az egyes osztályokhoz rendelni a későbbiekben.) A tanulási folyamat elején a súlymódosítást a győztes neuronra is, valamint az ő közvetlen bal- és jobboldali szomszédjára is elvégezzük, míg a tanulási folyamat második szakaszában csak a győztes neuron súlyait módosítjuk. A hálózat tanítása a véletlenszerűen kiválasztott képpontokhoz rendelt, négy jellemző tulajdonság alapján történik. Az adott képponthoz, mint az őt körülvevő szomszéd rácspontokból képzett 3x3-as ablak középpontjához rendelt jelleg-vektor meghatározásához a következőket vesszük figyelembe: az adott képpont fényessége, az átlagos fényesség a 3x3-as ablakban, a legkisebb eltérés az adott képpont és az ablakban szereplő többi képpont között, a legnagyobb eltérés az adott képpont és az ablakban szereplő többi képpont között. Az a neuron lesz a nyertes, amelyik jelleg-vektora a legközelebb esik a tanító pont jelleg-vektorához. A neuronok súlyainak módosítása a fent leírtak szerint történik, ügyelve arra, hogy a győztes neuron jelleg-vektora közeledjen az adott tanító pont jelleg-vektorához. A tanulási folyamat után, az osztályozási fázisban minden egyes processzáló elemet, azaz neuront hozzárendelünk egy-egy osztályhoz, amely az agy öt fő területét reprezentálja. A T2 súlyozású MRI agyfelvételek karakterisztikájának megfelelően a legfényesebb tulajdonsággal rendelkező neuron lesz hozzárendelve az agyfolyadék osztályhoz. A fényesség csökkenésének sorrendjében az osztályok a következők, szürkeállomány, fehérállomány, koponya és fejbőr, valamint háttér. Tehát megjelöljük a neuronokat, hogy melyik osztályhoz rendeljük. Ezek után a kiértékelési fázisban minden egyes képpontot hozzárendelünk valamelyik osztályhoz. Ez úgy történik, hogy minden képpontnak meghatározzuk a jelleg-vektorát és a hozzá legközelebb álló neuron által reprezentált osztályba soroljuk.

103 ALKALMAZÁS 92 Az eredeti algoritmust az AITC munkatársai fejlesztették, ezt az eljárást módosítottuk és fejlesztettük tovább [56, 54, 53] VHDL leírás generálása Kohonen hálózatból Első lépésként a feladatot felbontottuk három részfeladatra, ezek a tanulás (learning), az osztályozás (clustering), és a kiértékelés (eval). Külön-külön állítjuk elő az egyes részfeladatok VHDL leírását, majd összefűzve ezeket eljutunk a képfeldolgozó algoritmus megoldásához. Mivel a teljes algoritmust C nyelven valósítottuk meg, ezért ebből kiindulva a C fordító (gcc) adta lehetőségeket kihasználva automatikus módon elkészítettük mindhárom részfeladat műveleti gráfját. Így minden adott volt ahhoz, hogy a PIPE tervezőrendszer és a COMPALL algoritmus segítségével előállítsuk a bemenetet a VHDL leírás elkészítéséhez. A részfeladatokban található műveletek számát és ezen feladatokat reprezentáló műveleti gráf lappangási idejét a 6.. táblázat mutatja. 6.. táblázat. Műveletek száma és a lappangási idő Részfeladat Műveletek száma Lappangás Tanulás Osztályozás Kiértékelés 3 58 Ezek után a részfeladatokra a hagyományos magas szintű szintézis algoritmusait alkalmaztuk. Az eredményt a PIPE tervezőrendszer szolgáltatta. A COMPALL algoritmus futtatásával az általunk megadott funkcionális elemkészlethez rendeltük hozzá a PIPE által létrehozott processzorokat. A 6.2. táblázat foglalja össze a megvalósításhoz szükséges processzor számot mindhárom részfeladat esetén. Például, a learning részfeladat estén 74 funkcionális elem szükséges a 439 művelet helyett a feladat realizációjához. A VHDL leírás létrehozásához a bemenetet a három részfeladat ütemezett és a funkcionális elemekhez allokált gráfja szolgáltatja. Az fejezetben ismertetett lépések (bemeneti pufferek és multiplexer egységek beillesztése) alkalmazása után előállt az új adatfolyam leírás, ahol a csomópontok a funkcionális egységek. Az adatfolyam felépítése után készítettük el a központi vezérlést az fejezet szerint. Az itt leírt lépések természetesen automatikusan hajtódnak végre. Mindhárom részfeladat teljes megvalósítására nem tárgyaljuk részletesen, azonban pár érdekes részletet kiemelünk. Az első probléma a tanulási folyamat során szükséges ál-véletlenszám (PRN 4 ) előállítása. Használhattuk volna ugyanazt az álvéletlenszám generátort, amit a C implementáció során, azonban a C beépített véletlenszám generátora fordító és géptípus függő is lehet. Az ANSI C esetében is csak ajánlás van a konkrét megvalósításra. Ennek ellenére lehetett volna garantálni az azonos álvéletlenszám sorozatot, azaz a tanulópontok azonosságát, azonban az eredmények bitszintű összehasonlítása ebben az esetben sem lett volna lehetséges, mivel a C implementáció esetében lebegőpontos, a VHDL esetben pedig fixpontos számábrázolást használtunk. Ezért a C-től eltérő megvalósítást választottunk. Egy lehetséges megoldás az LSR 5, azaz lineárisan visszacsatolt léptető regiszter alkalmazása, amit kétféle módon valósíthatunk meg. A ibonacci megvalósítás egy léptető regisztert tartalmaz, ahol a regiszter megcsapolásainak binárisan súlyozott modulo-2 összege vissza van kötve a léptető regiszter bemenetére. A modulo-2 összeadás hardverben történő megvalósítás esetén nem más, mint egy OR kapu. A alois megközelítés szintén egy léptető regiszter, amelynek tartalmát minden egyes lépésben a kimenet 4 Pseudorandom Number enerator 5 Linear eedback Shift Register

104 ALKALMAZÁS táblázat. unkcionális elemek száma részfeladatok szerint bontva unkcionális elemek Tanulás Osztályozás Kiértékelés add_double 6 6 add_int cast_double gt_bool int_random le_bool lt_bool 9 9 max 2 2 min 2 2 mul_double 8 8 mul_int 5 4 rdiv_double read_big_array_cluster read_big_array_iarray 2 2 read_big_array_neuron sub_double 2 sub_int trunc_div_int truth_andif_bool 6 6 write_big_array_cluster write_big_array_neuron write_big_array_segmented_array Összesen Tanulás Osztályozás Kiértékelés binárisan súlyozott értékével módosítjuk. A alois formula gyorsabb hardverben megvalósítva, mivel kevesebb kapu van a visszacsatoló ágban. Az LSR generátor úgynevezett lineáris ismétlődő sorozatot (LRS 6 ) hoz létre, mivel minden művelet lineáris. Általánosságban mondva, az ismétlődő sorozat hossza két dologtól függ, a visszacsatoló megcsapolásoktól és a kiindulási állapottól (hogy milyen kiindulási érték van töltve a léptető regiszterbe). Egy m számú regiszterből álló LSR képes előállítani az összes állapotot az N = 2 m periódusidő alatt, de csak akkor, ha a megfelelően helyezzük el a visszacsatoló megcsapolásokat. Az ilyenfajta sorozatot legnagyobb, vagy maximális hosszúságú sorozatnak nevezzük. Röviden csak m-sorozatnak hívják. Bizonyos ipari alkalmazásban csak ál-zajként (PN 7 ) vagy ál-véletlen sorozatként emlegetik az ő zajszerű jellegének megfelelően. A bemutatott alkalmazásban egy 32 állapotú (32 bites), 4 megcsapolással rendelkező LSR-t választottunk, ahol a visszacsatolásokat a [32, 27, 26, 4] sorszámú regiszterek kimenetére helyeztük. Tehát 9 darab 32 állapotú LSR-t használtunk a tanulás során szükséges 9 bites ál-véletlenszám sorozat előállítására. A szimuláció eredményét a 6.. ábra szemlélteti. Az ábra felső részén látható a 9 darab LSR tartalma. Ezen regiszterek legalacsonyabb helyiértékén szereplő bitekből összeállított érték a PRN egység kimenete, azaz maga az ál-véletlenszám, amelyet az ábra legalsó jelformája mutat. Egy másik érdekes részfeladat volt annak kezelése, hogyan modellezzük a különböző részfeladatok által használt közös memória modulokat. Ehhez szükség volt egy úgynevezett memória olvasás/írás menedzserre, amely a memóriarekesz hozzáférést engedélyezte az összes részegység, a tanulás (learning), az osztályozás (clustering) és a kiértékelés (eval) számára egyaránt. Minden egyes közös memória mo- 6 Linear Recursive Sequences 7 PseudoNoise

105 ALKALMAZÁS 94 /prng_32/clk comp_prng_32 8/prreg comp_prng_32 7/prreg comp_prng_32 6/prreg comp_prng_32 5/prreg comp_prng_32 4/prreg comp_prng_32 3/prreg comp_prng_32 2/prreg comp_prng_32 /prreg comp_prng_32 /prreg comp_prng_32 8/prng_out comp_prng_32 7/prng_out comp_prng_32 6/prng_out comp_prng_32 5/prng_out comp_prng_32 4/prng_out comp_prng_32 3/prng_out comp_prng_32 2/prng_out comp_prng_32 /prng_out comp_prng_32 /prng_out /prng_32/prng_32_out us us 6.. ábra. Az ál-véletlenszám generátor működésének idődiagramja dul (iarray, neuron, cluster és segmented_array) rendelkezett ilyen menedzser egységgel. Ez tette lehetővé, hogy ugyanazt a memória olvasó/író műveletet (read_big_array_iarray, read_big_array_neuron, write_big_array_neuron, stb.) lehetett alkalmazni minden egyes részfeladat esetén. A memória menedzser egységek teremtették meg a kapcsolatot az író/olvasó műveletek és a közös memória modulok között. A 6.2. ábrán figyelhető meg a memória olvasás folyamata. Miután engedélyezzük az olvasás műveletet (read_big_array_neuron) és egyben a bemenetre helyezzük a megfelelő memória címeket (read_big_ array_neuron_in_ és read_big_array_neuron_in_), majd aktiváljuk a művelet indítójelét (trg_read_ big_array_neuron). Ennek hatására a memória címet átmásoljuk a művelet kimenetére és egy indítójelet /mri/comp_mri_ctr/clk /mri/comp_mri_ctr/clk2 read_big_array_neuron en_read_big_array_neuron read_big_array_neuron_in_ read_big_array_neuron_in_ 2 read_big_array_neuron_in_2 trg_read_big_array_neuron trg_read_big_array_neuron_out read_big_array_neuron_in out read_big_array_neuron_in out 2 2 read_big_array_neuron_in read_big_array_neuron_out neuron trg_read_neuron trg_write_neuron neuron_in_ neuron_in_ 2 2 neuron_out us 6.2. ábra. A neuron memória egység olvasásának folyamata

106 ALKALMAZÁS 95 generálunk, amely aktiválja az olvasás folyamatát a neuron nevű memória egységben. Majd a neuron egység kimenetén megjelenik a címek által meghatározott adat, amely egyben bemenete (read_big_ array_neuron_in) az olvasás műveletnek. Végül az olvasás művelet ezt az értéket átmásolja a saját kimenetére (read_big_array_neuron_out), így befejeződik az olvasás folyamata. Mindhárom részfeladatra elvégeztük a funkcionális szimulációt és az eredmények az elvártnak megfelelően alakultak. Ezeket az eredményeket azonban nem részletezzük. Inkább a három részegység, az olvasás (learning), az osztályozás (clustering), és a kiértékelés (eval) egy egységbe történő összeépítésére koncentrálunk. Az így összeépített MRI egység struktúráját a 6.3. ábra szemlélteti. Ez az egység tartalmazza a három részegységet, valamint a részegységek által használt közös memória tömböket (iarray, neuron, cluster és segmented_array). Az ábrán az adatfolyam kapcsolatokat, valamint a részegységek és a memória egységek közötti sín vezérlő jeleket nyilakkal jelöltük. A szürkeárnyalatos vonalak a központi vezérlés vezérlő jeleit mutatják. iarray neuron cluster segmented_array learning eval control datapath control datapath clustering control control datapath MRI 6.3. ábra. Az MRI modul szerkezeti felépítése Az osztályozás folyamata a következő. Először is a szürkeárnyalatos MRI agyfelvétel képét konvertáljuk az általunk használt formátumra és letároljuk az iarray memóriába. A learning részegység bemenetként az iarray és neuron tömböket használja és a módosított súlyokat visszaírja a neuron tömbbe. A tanulás folyamatának lépésszáma esetünkben... Ezek után a neuronoknak az öt osztályhoz való hozzárendelését a clustering egység végzi, a neuron tömbön alapuló eredmény a cluster tömbbe kerül. Végül, az eval részegység generálja az osztályozott képet és a segmented_array memóriába (tömbbe) tárolja le azt Szimulációs eredmények Az eredeti algoritmus C nyelven, lebegőpontos számábrázolás alkalmazásával került megvalósításra. A VHDL implementáció esetén pedig fixpontos számábrázolást használtunk bit széles törtrész alkalmazásával. Tehát a második esetben a számábrázolás pontossága körülbelül ezred (/24). Ahhoz, hogy

107 ALKALMAZÁS 96 az eredeti algoritmus által előállított szegmentált képet, valamint a VHDL szimuláció során keletkezett osztályozott képet összehasonlítsuk, mindkét esetben ugyanazokat a kiindulási értékeket (jelleg-vektor értékeket, súlyokat), és ugyanazt a tanulási lépésszámot alkalmaztuk. Természetesen a két implementáció esetén a tanulási folyamat során a véletlenszám generátorok által szolgáltatott értékek eltérők a fentebb említettek okok miatt. A nagy lépésszám következtében azonban ez a hatás elhanyagolható. Ezek után megvizsgáljuk a tanulási folyamat végén a neuronok jelleg-vektor értékeit, valamint a keletkezett osztályozott képeket is összehasonlítjuk. A következő táblázat az öt neuron jelleg-vektor értékeit mutatja a C nyelven írt algoritmus futtatása esetén a tanulási folyamat végén. Az első oszlop a keletkezett öt osztály képpont értékek középértékét reprezentálja. neuron = 54, , 547 3, 92 4, 398 8, 428 8, 82 4, 387 2, 958 2, 876 2, 889 6, 786 8, 34 4, 36 39, 484 5, 8, 63 24, 33 2, , 8 2, 454 Az előállított VHDL kód funkcionális szimulációját a már ismertetett, a Mentor raphics által készített ModelSim E III 6.d program segítségével végeztük. A tanulási folyamat (learning) végén a neuron memória rekesz tartalma a következő: neuron = A fixpontos számábrázolás és a bit széles törtrész használata miatt: 53, , 9 4, 993 3, , 65 78, 945 3, 28 2, 6 neuron = 3, 2 2, 833 7, 93 7, 878 4, 2 38, 3 4, 675, , , , 49 2, 87 Ha összehasonlítjuk a tanulás eredményét a kétfajta megvalósítás esetén, akkor azt tapasztaljuk, hogy az eltérés minimális. Ez a kismértékű eltérés a véletlenszám generátorok és a számábrázolás különbözőségére vezethető vissza. Így nem meglepő, hogy mindkét implementáció esetén az osztályozó részfeladat a következő kimenetet állítja elő: cluster = [ ]. Ez azt jelenti, ha a kiértékelés folyamán az első neuron lesz aktív, akkor az adott képpontot háttérként jelöljük meg. Ha a második neuron, akkor a képpont a koponya és fejbőr osztályba tartozik, ha a harmadik, akkor a fehérállományba, negyedik esetén a szürkeállomány csoporthoz, és legvégül, az ötödik neuron győzelme esetén az adott képpont az agyfolyadék osztályhoz tartozik. Ezek után hasonlítsuk össze a kiértékelés végén keletkezett osztályozott képeket. Az eredeti, T2 súlyozású MRI agyfelvétel a 6.4. ábrán figyelhető meg. A hardveres (VHDL) és szoftveres (C) megvalósítás estén is a kiértékelő egység (eval) az osztályozott képet a segmented_array memória tömbbe tárolja. Az ebből visszaállított képeket a 6.5(a). és a 6.5(b). ábra mutatja. Az osztályozott képeken az öt fő területet a következő színek jelölik, kék agyfolyadék, lila szürkeállomány, fehér fehérállomány, sötét zöld koponya és fejbőr, valamint világos zöld háttér. A vizuális összehasonlítás során is megfigyelhető, hogy a két megvalósítás által létrehozott osztályozott kép közötti eltérés minimális..

108 ALKALMAZÁS ábra. Eredeti T2 súlyozású MRI agyfelvétel (a) C szimuláció (b) VHDL szimuláció (c) Különbségi kép 6.5. ábra. A Kohonen hálózattal osztályozott kép A különbségi kép a 6.5(c). ábrán figyelhető meg. A háttérben halványan látható az összehasonlítás alapjául szolgáló szoftveres megvalósítás eredményeként keletkezett kép. A piros képpontok mutatják azokat a helyeket, ahol a két megvalósítás által létrehozott kép különbözik. Ezeknek a képpontoknak a száma Ez azt jelenti, hogy az összes képpont számához viszonyítva 8,85% az eltérés. A két megvalósítás közötti különbségek, mint ahogy azt korábban is említettük, többnyire a kerekítési hibáknak köszönhetők. Ha tovább szeretnénk növelni a hardveres megvalósítás pontosságát, akkor ez a számábrázolás felbontásának növelésével érhető el. Természetesen ez megnöveli az elfoglalt szilícium felület nagyságát is.

109 ALKALMAZÁS A 2D fuzzy algoritmus leképezése Ebben a fejezetben azt mutatjuk be, hogyan illeszthető az előbb bemutatott agyfelvétel osztályozó eljárásba a fuzzy megközelítés. A tanulási folyamat (learning) és az osztályozás részfeladatok (clustering) változatlanok maradnak. Így alkalmazhatóak a hierarchikus tervezés módszerei, hiszen ezen feladatok korábban előállított VHDL leírása változtatás nélkül felhasználható. Csak a kiértékelés változik ebben a megközelítésben, ezért az eval részfeladat VHDL leírását kell csak automatikusan előállítani. Ezt a részfeladatot két részre bontottuk, amit a 6.6. ábra mutat. iarray neuron cluster membership segmented_array learning control datapath control datapath calculate_membership clustering segment_picture control control datapath control datapath MRI 6.6. ábra. Az MRI modul szerkezeti felépítésének módosítása fuzzy algoritmus esetén Az ábrán zöld szín jelöli a kettébontott eval részfeladatot, az új modulok a calculate_membership és a segment_picture modulok. A kék színnel jelzett memória modul tárolja az eljárás során keletkező tagsági képeket. Először a calculate_membership modul meghatározza minden egyes képpontra a fuzzy tagsági értékeket, amely azt mutatja, hogy az adott képpont milyen mértékben tartozik az öt osztály valamelyikéhez. Ez a tagsági függvény, amely fordítottan arányos az adott képpont jelleg-vektorának és az aktuális osztály jelleg-vektorának a távolságával, a következőképpen néz ki: ( µ c (x p ) = pos d(w ) c,x p ) b max (6.) ahol x p a p képpont jelleg-vektora, µ c a c osztály tagsági értéke, w c a c osztály jelleg-vektora (osztály közép), megegyezik az osztálynak megfelelő neuron jelleg-vektorával, d(.) az euklideszi távolságot jelöli, b max a lehetséges legnagyobb fényességű pont az eredeti képen, és pos(.) a pozitív függvény, azaz pos(x) = x ha x =, és pos(x) = ha x <. Világos, hogy az előző a fejezetben bemutatott eredeti algoritmus (szigorú osztályozás) azonos azzal, ha ebben az esetben az egyes képpontokhoz ahhoz az osztályhoz rendeljük, ahol a fuzzy tagsági

110 ALKALMAZÁS 99 érték a legnagyobb. Tehát ez a fuzzy megközelítés képes előállítani ugyanazt az osztályozott képet, mint az eredeti algoritmus. Ezt az eljárást használva azonban láthatóvá tehetjük azt, hogy az egyes képpontok milyen mértékben tartoznak az egyes osztályokhoz. Ezek az úgynevezett tagsági képek jóval több információt hordoznak az emberi agyról, mint a szigorú osztályozással, az eredeti eljárás által előállított szegmentált kép. Ezeken a képeken a fehér szín jelenti az tagsági értéket, azaz a képpont csak az adott osztályhoz tartozik, a fekete szín pedig a tagsági értéket, tehát a képpont nem tartozik az adott osztályhoz. A képpont fényessége a tagság mértékével arányos. A 6.7. ábrán láthatóak az öt osztálynak megfelelő tagsági képek. Ha összehasonlítjuk az eredeti algoritmussal, akkor ezekből a képekből jóval részletesebb információkat nyerhetünk az agy anatómiai felépítésére vonatkozóan. Továbbá ezek a tagsági képek alapul szolgálhatnak jóval bonyolultabb osztályozó algoritmusok kidolgozására és alkalmazására. (a) Háttér (b) Koponya és fejbőr (c) ehérállomány (d) Szürkeállomány (e) Agyfolyadék 6.7. ábra. Az öt osztálynak megfelelő tagsági képek Ezt fogjuk most bemutatni, amely egyben a kiértékelő rész második modulja (segment_picture). A kiértékelés során nem csak az adott képpont fuzzy tagsági értékeit vesszük figyelembe, hanem a szomszédos képpontokét is. Az adott képpont átlagos fuzzy tagsági értékét a képpontot körülvevő 3x3-as ablakban lévő képpontok fuzzy tagsági értékeit is figyelembe véve a következő módon definiálhatjuk: µ c (x p ) = 9 µ c (x i p ) i= 9 ahol µ c az új, 2D tagsági függvény és x i p az i-edik képpont a p képpontot körülvevő 3x3-as ablakban. Ezt a definíciót használva a kiértékelés második fázisában minden egyes képpontot ahhoz a c-edik osztályhoz (6.2)