3. Az illesztett szűrés párhuzamosítása
3.7. Teljesítménynövekedések becslése
3.7.2. A Gustafson-törvény alkalmazása
Gustafson-törvényével relatív sebességnövekedést becsülhetünk, vagyis rögzített méretű probléma megoldásának gyorsulása helyett azt becsülhetjük meg, hogy rögzített idő alatt mennyivel nagyobb problémát tudunk megoldani P számú processzor bevezetésével. Amdahl-törvényének alkalmazásához hasonlóan ismernünk kell a szekvenciális kód futási idejének azon hányadát, amely végrehajtása párhuzamosan végezhető.
Erre felhasználhatjuk egy szekvenciális és egy párhuzamos (például 2 szálon futó) program futásának idejét és becsülhetünk úgy, mint az Amdahl-törvénynél, azaz esetünkben
(4.3) Ennek ismeretében a korábban bemutatott formulák felhasználásával a sebességnövekedés P processzor esetén
(4.4)
azaz P=3 processzor esetén például
(4.5) Ez a becslés nem egyezik az Amdahl-törvénnyel kapott becsléssel, ahol azt kaptuk, hogy három processzor esetén a futási idő várhatóan 2,49-ed részére csökken. A Gustafson-törvénynél kapott teljesítmény növekedési faktor azt jelenti, hogy a szekvenciálissal megegyező futási idő alatt Ŝ(P)-szer több számítást fogunk tudni elvégezni P processzor használatával, azaz Ŝ(P)-szer nagyobb problémát tudunk megoldani. Példaként vizsgáljuk meg, hogy ha három processzort használnánk, mennyivel nagyobb szögfelbontással tudnánk elvégezni az illesztett szűrést (ez egy valós probléma, minél nagyobb szögfelbontást alkalmazunk, a Gábor-szűrők annál pontosabban emelik ki az egyenes struktúrákat; egy valós idejű képfeldolgozási alkalmazásban a rendelkezésre álló időt például a kívánt FPS (Frame-Per-Second) érték határozhatja meg, például sok ipari alkalmazásban, biztonsági kamerák képének feldolgozásakor az 1FPS körüli érték elfogadható).
Eredményeinkből azt kaptuk, hogy T1(nθ=10)=2,00s számítási idő szükséges az σ=3,0, nθ=5 és γ=0,06 probléma megoldásához egy processzoron (a T felső indexével jelöljük a végrehajtáshoz használt processzorok számát), s ez jól jellemzi a probléma számításigényét is. Tekintsük a szekvenciális futásidő és nθ paraméter függését demonstráló grafikont. A Gustafson-törvény értelmében, 3 processzor használata esetén azon mθ méretű problémát tudjuk hasonló T3(mθ) ≃ T1(nθ) idő alatt megoldani, amelyhez tartozó szekvenciális futási idő T1(mθ)=
Ŝ(3)T1(nθ)= S(3)· 2,00s= 5,59s. Kikereshetjük most a szekvenciális futási időket tartalmazó grafikonból azt az mθ értéket, amelyre a futási idő megközelítőleg 5,59s. Ez a becsült mθ ≃ 13. Azt várhatjuk tehát, hogy 3 szálon történő futtatás esetén a mθ= 13 értéknél kell az nθ=5 szekvenciális futási idejéhez hasonló időt kapnunk.
Végezzünk futtatásokat és ellenőrizzük a feltételezést a képpont szintű párhuzamosítást felhasználva. A futási eredményeket a 4.4. ábrán demonstráljuk.
4.4. ábra - Gustafson törvényének alkalmazása - Piros szaggatott vonallal jelöljük azt a
futási időt, amely a 3 szálon párhuzamosan futó program szekvenciális végrehajtásának
becsült ideje a vizsgált paraméterek esetén. A szekvenciális futtatáshoz tartozó fekete
görbét ez kb. n
θ=13-as értéknél metszi. A Gustafson-törvény alkalmazása azt jelenti,
hogy ha elvégezzük a futtatásokat 3 szálon, akkor az n
θ=13 értéknél kell kb. 2s futásidőt kapnunk. Hogy erről meggyőződjünk, elvégeztük 3 szálon a teszteket és jól látható, hogy a 2s-hoz tartozó zöld szaggatott vonal a kék görbét kb. n
θ=13 értéknél metszi.
Megjegyezzük, hogy Gustafson-törvényét is használhatjuk arra, hogy a programunk szekvenciálisan futó hányadát megbecsüljük. Ehhez azonban figyelembe kell vennünk, hogy a teljesítmény növekedés értelmezése nem ugyanaz, mint az Amdahl-törvény esetén. Használhatjuk tehát a
(4.6)
összefüggést, azonban ügyelnünk kell arra, hogy Ŝ(P) ebben az esetben azt jelenti, hogy mennyi a szekvenciális futás idejének aránya ahhoz a P processzoron történő futtatás idejéhez, amelynek számítás igénye nagyságrendileg P-szerese a szekvenciális futásénak. Ki kell tehát jelölnünk egy tetszőleges nθ paramétert a szekvenciális futási időket összefoglaló grafikonokról, meg kell keresnünk azt a mθ értéket, amely esetén a futásidő éppen P-szerese T1(nθ)-nak, és a nθ paraméterrel történő szekvenciális futtatás idejének valamint a mθ paraméterrel P szálon történő futtatás idejének aránya adja Ŝ(P)-t.
4. Összefoglalás
A pragmák egyszerű használatának köszönhetően az OpenMP napjaink egyik legszéleskörűbben használt párhuzamos programozási technológiája. Előnye, hogy a párhuzamos konstrukciók konkrét megvalósítását a fordítóprogram végzi, ezáltal nagyon hatékony megoldások jelennek meg a kódban. Hátrányaként talán azt nevezhetjük meg, hogy kezdő programozók számára a pragmák használata idegen és szokatlan lehet, az kód imperatív jellege csökken. Az illesztett szűrés párhuzamosításának vizsgálata során láthattuk, hogy az OpenMP gyakorlati használata sok esetben nagyon egyszerű, azonban ügyelnünk kell rá, hogy a célnak leginkább megfelelő pragmákat és konstrukciókat használjuk, mert a versenyhelyzetek nem megfelelő kezelése akár teljesítmény visszaeséshez is vezethet. A fejezet végén az Amdahl- és Gustafson-törvények gyakorlati alkalmazását demonstráltuk. A hátralévő technológiákat hasonló felépítéssel mutatjuk be, azonban az Amdahl- és Gustafson-törvények használata már csak a feladatokban fog megjelenni.
Ha felkeltettük az olvasó érdeklődését az OpenMP technológia iránt, ajánljuk az OpenMP hivatalos weboldalán4 található anyagokat, az OpenMP specifikációt, valamint a [4] és [3] könyveket.
5. Feladatok
1. (★★★) A π értéke pontosan becsülhető un. Monte Carlo integrálás segítségével. A megközelítés alapja, hogy az egység sugarú kör területe éppen Tk=π, míg a két egység oldalhosszúságú négyzet területe Tn=4, a kettő aránya . A arányt úgy becsülhetjük, hogy egyenletes eloszlású N darab véletlen számpárt generálunk a [-1,1]×[-1,1] intervallumban, és megszámoljuk, hogy ezek közül hány darab esik az egységkörbe, azaz hány (x,y) pontpárra teljesül, hogy x2 + y2 ≤ 1. Legyen a körbe eső pontok száma K.
4http://openmp.org/wp/
Ekkor π értéke módon közelíthető. Készítsen programot, amely π értékének közelítésére használható, egyenletes eloszlású pontpárok generálásához használja a GSL5 csomag gsl_rng_uniform függvényét!
A végrehajtás során használt P darab szál mindegyike generáljon N véletlen számpárt, regisztrálják az egységkörbe eső koordináta párok számát saját K változójukba, majd összegezzék a K értékeket a szálak által közösen elérhető memóriaterületen, úgy, hogy az a szálak befejeződése utána főprogram által elérhető legyen. Az összegzett K értékből a főprogram számítja ki π közelítő értékét a formula alapján.
A következő párhuzamos implementációkat készítse el:
• A versenyhelyzetek kezelésére használjon atomi műveleteket!
• A versenyhelyzetek kezelésére használja a critical pragmát!
• Használjon redukciós operátort!
2. (★) Implementálja az illesztett szűrés jelen fejezetben bemutatott párhuzamosítási megoldásait, végezzen futási teszteket saját hardverkörnyezetében és értelmezze az eredményeket!
3. (★) Vizsgálja meg, a megfelelő kódrészlet és a teljes program futási idejének mérésével, hogy az illesztett szűrést három szálon megvalósító programunk sebességnövekedése mennyire tér el az Amdahl-törvény alapján jósolt értéktől!
4. (★★) Végezzen futási teszteket az illesztett szűrés képpont szintű párhuzamosításával úgy, hogy a for-ciklus ciklusváltozója által befutott tartományt különböző stratégiák szerint bontsa fel független részekre!
Hasonlítsa össze és értelmezze az eredményeket!
5. (★★) Módosítsa az illesztett szűrés képpont szintű párhuzamosítását úgy, hogy két szintű párhuzamosítást alkalmaz: az első szinten a képpontok feldolgozását párhuzamosítsa, a második szinten szűrőhalmaz szintű párhuzamosítást valósítson meg! Ügyeljen rá, hogy a több szintű párhuzamos végrehajtás engedélyezve legyen! Végezzen futási teszteket és értelmezze az eredményeket!
6. (★★★) Módosítsa az illesztett szűrés képpont szintű párhuzamosítási megoldását úgy, hogy OpenMP taszkokat használjon! Végezzen futási teszteket, hasonlítsa össze és értelmezze a parallel for és task konstrukciók használata esetén kapott eredményeket!
7. (★) Egészítse ki a kNN-osztályozás kódját OpenMP alapú időméréssel!
8. (★★) Párhuzamosítsa a kNN-osztályozás algoritmusát úgy, hogy az egyes szálak párhuzamosan számolják a vektorok távolságait!
9. (★★★) Párhuzamosítsa a kNN-osztályozás algoritmusát úgy, hogy az osztályozandó vektorhoz legközelebbi (k) vektor keresése történjen párhuzamosan!
10. (★★) Vizsgálja meg, hogy a kNN-osztályozás ciklusainak OpenMP alapú párhuzamosítása esetén a ciklustartomány felosztásának mely stratégiája vezet a legjobb eredményekhez! Ábrázolja és értelmezze az eredményeket!
11. (★★) Készítsen a kNN-osztályozáshoz a feldolgozás állapotát kijelző szálat! Ügyeljen rá, hogy a feldolgozási műveletek most több ciklus munkájából tevődnek össze!
12. (★★) Becsülje meg Amdahl-törvényének segítségével, hogy egy rögzített méretű kNN-osztályozás esetén 10 processzor használatával hogyan csökkenne a számítási idő!
13. (★★) Becsülje meg Gustafson-törvényének, hogy egy rögzített méretű kNN-osztályozásból kiindulva 10 processzor használata esetén mekkora problémák (mintaszám, vektor dimenzió, k) válnának megoldhatóvá rögzített számítási idő alatt!
5GNU Scientific Library - http://www.gnu.org/software/gsl/
14. (★★★) Módosítsa a kNN-osztályozás párhuzamosítási megoldását úgy, hogy OpenMP taszkokat használjon! Végezzen futási teszteket, hasonlítsa össze és értelmezze a parallel for és task konstrukciók használata esetén kapott eredményeket!
15. (★★) Párhuzamosítsa a részecskeszimulációs alkalmazást minden lehetséges párhuzamosítási ponton OpenMP technológiával! Végezzen sebességteszteket, vizualizálja és értelmezze az eredményeket!
16. (★) Egészítse ki a részecskeszimulációs alkalmazást a számítások állapotát és a megjelenítés aktuális FPS értékét monitorozó szállal!
17. (★★) Határozza meg Amdahl-törvényének segítségével, hogy 4000 részecske szimulációja esetén hány FPS-re növekedne a szimuláció megjelenítése 10 processzor használata esetén!
18. (★★) Becsülje meg Gustafson-törvényének segítségével, hogy 10 processzor bevezetésével hány részecske szimulációjával érhető el a 40 FPS megjelenítési sebesség!
19. (★★) Módosítsa a részecskeszimulációs alkalmazást úgy, hogy parancssori argumentumokkal tudjuk szabályozni a szálak számát és a ciklustartományok felosztásának stratégiáját! Végezzen teszteket és határozza meg, melyik stratégia vezet a legjobb időeredményekhez!
20. (★★★) Módosítsa a részecskeszimulációs alkalmazás párhuzamosítási megoldását úgy, hogy OpenMP taszkokat használjon! Végezzen futási teszteket, hasonlítsa össze és értelmezze a parallel for és task konstrukciók használata esetén kapott eredményeket!