Bevezetés az MPI programozásba példákon keresztül január 16. DRAFT

DR AF T Bevezetés az MPI programozásba példákon keresztül Várady Géza

Zaválnij Bogdán

2014. január 16.

DR AF T

Sorozatoldal

www.tankonyvtar.hu

c Várady Géza, Zaválnij Bogdán, PTE

Copyright 2013 (C) Szerz®k : Géza Várady, Bogdán Zaválnij Lektorálta : Juhász Zoltán Kulcsszavak : párhuzamos programozás, MPI, bevezetés, példa, elmélet, mérnöki, programok A könyv célja az olvasó bevezetése a párhuzamos programozásba, MPI környezetben. Manapság a nagy számítási igényt a párhuzamosításban rejl® er®vel szolgáljuk ki. Már nem csak a szuperszámítógépeknek van több processzora, de a mindennapi eszközeinkben (tabletek, telefonok) is legalább kett® vagy négy mag dolgozik. A párhuzamos logika, ezzel kapcsolatos újszer¶ problémák és megoldásaik szerepelnek a könyvben, több C++

DR AF T

példaprogrammal demonstrálva.

Egyes fejezeteket BSc szint¶, további fejezeteket MSc szint¶ és az egész m¶vet akár

PhD szint¶ oktatási anyagként ajánljuk.


www.tankonyvtar.hu

Bevezetés az MPI programozásba példákon keresztül

DR AF T

iv

www.tankonyvtar.hu


Tartalomjegyzék Bevezetés

1

DR AF T

I.

1. Bevezetés

3

1.1.

Kinek ajánljuk a fejezeteket

. . . . . . . . . . . . . . . . . . . . . . . . . .

3

1.2.

A párhuzamos számítás szükségessége . . . . . . . . . . . . . . . . . . . . .

4

1.3.

Párhuzamos architektúrák

. . . . . . . . . . . . . . . . . . . . . . . . . . .

4

1.4.

Az elosztás problémája . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5

1.5.

A párhuzamosítás problémája

5

. . . . . . . . . . . . . . . . . . . . . . . . .

1.5.1.

Amdahl törvénye és Gustavson törvénye

. . . . . . . . . . . . . . .

6

1.5.2.

Szuper-lineáris gyorsulás . . . . . . . . . . . . . . . . . . . . . . . .

7

2. Alapvet® számításigényes feladatok

9

2.1.

Alapvet® nehéz feladatok számításigényes feladatok

. . . . . . . . . . . .

9

2.2.

Mérnöki, matematikai, gazdasági és zikai számítások . . . . . . . . . . . .

10

2.3.

Komplex modellek

12

2.4.

Számítások valós id®ben

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . .

3. Az MPI környezet logikája

13

15

3.1.

Az MPI a programozó szemszögéb®l . . . . . . . . . . . . . . . . . . . . . .

16

3.2.

Küldés (send) és fogadás (recieve) . . . . . . . . . . . . . . . . . . . . . . .

20

3.2.1.

Halálos ölelés (deadlock) . . . . . . . . . . . . . . . . . . . . . . . .

21

Üzenetszórás (broadcast) . . . . . . . . . . . . . . . . . . . . . . . . . . . .

23

3.3.

4. Els® MPI programok

25

4.1.

Elemek összegzése . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

25

4.2.

π

. . . . . . . . . . . . . . . . . . . . . . . . . . . .

27

. . . . . . . . . . . . . . . . . . . . . . . . . . . .

28

4.3.

értékének kiszámítása

4.2.1.

A soros program

4.2.2.

A párhuzamos program . . . . . . . . . . . . . . . . . . . . . . . . .

29

4.2.3.

Redukciós m¶veletek

31

4.2.4.

π számítása Monte Carlo módszerrel redukciós függvények segítségével

Gyakorló feladatok

. . . . . . . . . . . . . . . . . . . . . . . . . .

32

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

35

4.3.1.

Mátrix-vektor szorzás . . . . . . . . . . . . . . . . . . . . . . . . . .

35

4.3.2.

Mátrix-mátrix szorzás

. . . . . . . . . . . . . . . . . . . . . . . . .

35

4.3.3.

Numerikus integrálás . . . . . . . . . . . . . . . . . . . . . . . . . .

36


www.tankonyvtar.hu

vi


5. Alapvet® párhuzamosítási technikák

39

5.1.

Lehetséges feladatfelosztási módszerek

5.2.

Ciklusbontás (loop-splitting) . . . . . . . . . . . . . . . . . . . . . . . . . .

42

5.3.

Blokkos ütemezés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

43

5.4.

Önütemezés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

45

5.5.

A dinamikus terheléselosztás más eszközei

53

. . . . . . . . . . . . . . . . . .

40

Számítási hálók . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

53

5.6.1.

A Delaunay-háromszögelés rövid leírása . . . . . . . . . . . . . . . .

56

5.6.2.

Az Advancing Front módszer rövid leírása

56

5.6.3.

Párhuzamos hálógenerálás

. . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

56

DR AF T

5.6.

. . . . . . . . . . . . . . . . . . . .

5.7.

Monte Carlo és Las Vegas módszerek

5.7.1.

5.8.

II.

π

. . . . . . . . . . . . . . . . . . . . .

számítása Monte Carlo módszerrel

Feladatok

56

. . . . . . . . . . . . . . . . .

57

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

57

Gyakorlati példák

59

6. Legrövidebb út keresése gráfokban

63

6.1.

Dijkstra algoritmusa

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

63

6.2.

Párhuzamos változat

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

65

6.3.

Az eredmények értékelése . . . . . . . . . . . . . . . . . . . . . . . . . . . .

68

6.4.

A program kód

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

68

6.5.

Variáns más MPI függvényekkel . . . . . . . . . . . . . . . . . . . . . . . .

72

6.6.

A program kód

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

73

6.7.

Különböz® adatstruktúrák használata . . . . . . . . . . . . . . . . . . . . .

74

7. Gráfszínezés

77

7.1.

A probléma leírása

7.2.

Daniel Brélaz DSATUR algoritmusa . . . . . . . . . . . . . . . . . . . . . .

78

7.3.

Párhuzamosítás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

88

7.4.

A program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

89

7.4.1.

97

7.5.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

A teljes párhuzamos program

. . . . . . . . . . . . . . . . . . . . .

77

Felhasználás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

8. Lineáris egyenletrendszerek megoldása

109

8.1.

A probléma

8.2.

Az elimináció

8.3.

Visszahelyettesítés

8.4.

A program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

8.5.

Párhuzamosítás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

8.6.

A párhuzamos program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123

8.7.

Futásid®k

8.8.

A pivotálás szerepe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

www.tankonyvtar.hu

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133


Tartalomjegyzék

vii

9. Laphevítés

137

9.1.

Szekvenciális implementáció

. . . . . . . . . . . . . . . . . . . . . . . . . . 138

9.2.

Párhuzamos eljárás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

9.3.

A munka felosztása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

9.4.

A peremadatok kicserélése . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

9.5.

Példa program szekvenciális megoldás . . . . . . . . . . . . . . . . . . . . 139

9.6.

Párhuzamos megoldás példaprogramja

9.7.

Egyszer¶bb adatcsere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

. . . . . . . . . . . . . . . . . . . . 145

161

DR AF T

10.Gyors Fourier-transzformáció (FFT) 10.1. Fourier-transzformáció

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

10.2. Diszkrét Fourier-transzformáció (DFT) . . . . . . . . . . . . . . . . . . . . 161 10.3. Gyors Fourier-transzformáció (FFT)

. . . . . . . . . . . . . . . . . . . . . 162

10.3.1. Szekvenciális FFT példaprogram

. . . . . . . . . . . . . . . . . . . 165

10.3.2. Párhuzamos FFT példaprogram . . . . . . . . . . . . . . . . . . . . 177

11.Mandelbrot

191

11.1. Mandelbrot halmaz, szekvenciális példa . . . . . . . . . . . . . . . . . . . . 193 11.2. Mandelbrot halmaz, párhuzamos példa

. . . . . . . . . . . . . . . . . . . . 198

11.2.1. Mester-szolga, egy els® megközelítés . . . . . . . . . . . . . . . . . . 199 11.2.2. Mester-szolga, egy jobb megoldás

. . . . . . . . . . . . . . . . . . . 207

11.2.3. Loop splitting ciklusbontás . . . . . . . . . . . . . . . . . . . . . 214 11.2.4. Loop splitting variáció

. . . . . . . . . . . . . . . . . . . . . . . . 220

11.2.5. Block scheduling tömbös ütemezés

. . . . . . . . . . . . . . . . 226

11.2.6. Block scheduling variáció . . . . . . . . . . . . . . . . . . . . . . . 233

11.2.7. Gondolatok a munkamegosztásról . . . . . . . . . . . . . . . . . . . 239

12.Sugárkövetés Raytracing

243

12.1. Képi megjelenítés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243 12.2. Sugárkövetéses példa

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244

12.2.1. Soros sugárkövetés

. . . . . . . . . . . . . . . . . . . . . . . . . . . 244

12.2.2. Párhuzamos sugárkövetés . . . . . . . . . . . . . . . . . . . . . . . . 262

13.Projekt munkák 13.1. Rendezések

273

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273

13.1.1. Összefésül® rendezés

. . . . . . . . . . . . . . . . . . . . . . . . . . 275

13.1.2. Gyorsrendezés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275

13.1.3. Mintavételez® rendezés . . . . . . . . . . . . . . . . . . . . . . . . . 276 13.2. K-átlagú csoportosítás

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277

13.3. A Gauss elimináció jobb párhuzamosítása . . . . . . . . . . . . . . . . . . . 278 13.4. FFT további párhuzamosítási lehet®ségek . . . . . . . . . . . . . . . . . . . 278 13.5. Akusztikai példa

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279


www.tankonyvtar.hu

viii


III.

Függelék

281

14.Az MPI keretrendszer installálása

283

14.1. Kommunikáció ssh segítségével . . . . . . . . . . . . . . . . . . . . . . . . . 284 14.2. A programok futtatása egy gépen

. . . . . . . . . . . . . . . . . . . . . . . 285

14.3. A programok futtatása több gépen 14.4. Szuperszámítógépes használat

. . . . . . . . . . . . . . . . . . . . . . 285

. . . . . . . . . . . . . . . . . . . . . . . . . 286

15.MPI függvények

287 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287

DR AF T

15.1. Kommunikáció

15.1.1. Blokkoló és nem blokkoló . . . . . . . . . . . . . . . . . . . . . . . . 287 15.1.2. Küldés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287 15.1.3. Fogadás

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292

15.1.4. KüldésFogadás SendReceive . . . . . . . . . . . . . . . . . . . . . 293 15.1.5. Többesküldés Broadcast

15.2. Redukció Reduction

. . . . . . . . . . . . . . . . . . . . . . . 294

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294

15.2.1. Csökkentés Reduce . . . . . . . . . . . . . . . . . . . . . . . . . . 295 15.2.2. Teljes redukció All-reduce

. . . . . . . . . . . . . . . . . . . . . 295

15.2.3. Scan redukció Scan reduce . . . . . . . . . . . . . . . . . . . . . 296 15.2.4. Operátorok

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296

15.3. A kommunikációs topológia dinamikus változtatása

. . . . . . . . . . . . . 298

15.3.1. Egy kommunikátorhoz rendelt csoport lekérdezése . . . . . . . . . . 299 15.3.2. Új csoport létrehozása kizárással

. . . . . . . . . . . . . . . . . . . 299

15.3.3. Kommunikátor létrehozása csoportból . . . . . . . . . . . . . . . . . 299

15.4. Vegyes függvények

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300

15.4.1. Inicializálás

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300

15.4.2. Rang lekérdezése

. . . . . . . . . . . . . . . . . . . . . . . . . . . . 300

15.4.3. Méret lekérdezése . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300 15.4.4. Lezárás

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301

15.4.5. Megszakítás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301 15.4.6. Korlát

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301

15.4.7. Eltelt id® Wall time

. . . . . . . . . . . . . . . . . . . . . . . . . 302

15.5. Adattípusok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302

www.tankonyvtar.hu


DR AF T Els® rész

Bevezetés


www.tankonyvtar.hu

DR AF T

1. fejezet

DR AF T

Bevezetés

Könyvünk napjaink szabvány üzenetküldési paradigmájával foglalkozik, az MPI-al (Message Passing Interface). Az MPI a nagyteljesítmény¶ számításokhoz (high performance

computing HPC) használt Fortran, C és C++ nyelvekkel használható. A példaprogramjaink C++-ban íródtak, mivel ez a legsokoldalúbb nyelv a háromból, de igyekeztünk

a feladatokhoz feltétlenül szükséges mennyiségét használni, hogy az esetleges C-beli MPI

programozáshoz is hasznos legyen. Bár van az MPI-nak C++ jelölése is, mi a C-szer¶

használatát fogjuk alkalmazni, mert ezt hasznosabbnak tartjuk. A C++ programokban ezt megtehetjük, ami fordítva viszont nem menne.

Mivel a szuperszámítógépeken valamilyen Linux vagy Unix rendszerek futnak, mi is

Linux rendszer alatt mutatjuk be a programjainkat és az OpenMPI-t használtuk. A pél-

dafuttatásokat különböz® szuperszámítógépes rendszereken végezzük el. Az MPI jelenleg

Windows alatt kevésbé támogatott, azoknak, akik csak Windows környezetben dolgoznak,

egy Linux rendszer kipróbálását ajánljuk, legalább virtualizált környezetben. A Cygwin környezet is használható, ami alatt az OpenMPI elérhet®.

1.1. Kinek ajánljuk a fejezeteket

A könyvet párhuzamossággal kapcsolatos, különböz® szint¶ el®adásokhoz lehet használni.

Az 1-4, 14 fejezetek és az 5-ös fejezet egyes részei BSc szint¶ kurzusokhoz ajánlott. A II. részben gyakorlati példák vannak, amihez különböz® szint¶ programozási és mérnöki tudás szükséges. A legtöbb fejezet itt MSc szint¶ kurzusokhoz ajánlott (pl. a Raytrace program,

az FFT vagy a gráfszínezési példa), de PhD kurzusoknál is hasznosnak bizonyulhat. Az utóbbihoz a projektmunkákat is ajánljuk, amik a kész példákra alapulva újabb példákat és ötleteket vetnek fel. Mindegyik egyszer¶, közepesen bonyolult és nehezebb példa a mérnöki és tudományos területekr®l mutat példákat. A könyv, bár tesz releváns hivatkozásokat, önmagában is jó kezd® anyag.


www.tankonyvtar.hu

4


1.2. A párhuzamos számítás szükségessége A számítási kapacitás igénye folytonosan n®. Egy maggal ezt az igényt több mint egy évtizede már nem lehet kielégíteni. Az egy mag sebessége limitált. A mai gépek a maximum 3-5GHz-es sebességet érnek el, ez az utóbbi 10 évben nem sokat változott. Például

http://ark.intel. com/products/27475/Intel−Pentium−4−Processor−570J−supporting−HT−Technology− −1M−Cache−3_80−GHz−800−MHz−FSB az Intel a 3.8GHz Pentium 4 processzorát pont 10 éve mutatta be.

A többprocesszoros rendszerekben viszont szükség van a párhuzamos programozásra.

DR AF T

Az utóbbi id®ben többmagos processzorokat és elosztott rendszereket használunk, így ma-

napság számítási magok millióit használjuk a szó szoros értelmében (www.top500.org). Láthatjuk, hogy exponenciálisan növekv® számítási kapacitásunk is lehet ezen a módon.

A legújabb problémánk a szuperszámítógépek h® disszipációja és energia költsége. Az

üzemeltetéshez szükséges energia ára 3-5 év távlatában meghaladja a rendszerek bekerülési költségét.

Egy másik akkut probléma a túl sok mag. Ugyanis sok algoritmus nem skálázódik

rendesen több-százezer mag felett.

1.3. Párhuzamos architektúrák

A mai számítógép architektúrák sok szempontból különböznek. Miután láttuk milyen szük-

ség van a számítási kapacitásra nagy feladatok esetén, át kell tekintenünk a mai gépek osztályozását.

A PC-k, az otthoni vagy irodai egyszer¶ gépek többmagos gépek. Ezekben egy pro-

cesszor van, több maggal, tipikusan 2 vagy 4-el, de vannak 10-12 magos gépek is.

A következ® méret már nagyobb számítógépeket jelent. Ezek általában multiprocesszo-

ros rendszerek, azaz zikailag több processzorral (többnyire 2 vagy 4) szerelik ®ket. (Ezek a rendszerek természetesen szintén többmagosak, így akár 48 maggal is m¶ködhet egy ilyen rendszer.)

A HPC-hez sokkal-sokkal nagyobb gépeket és rendszereket használnak. Ezek a gépek

több ezer vagy millió magot tesznek elérhet®vé a felhasználók részére. Az SMP (Symmetric

Multiprocessor) rendszerek közös memóriás rendszerek, ahol a programok az egész memóriát elérik. Ezek a rendszerek manapság úgynevezett ccNUMA rendszerek, amikben csak a memória egy része van közel az egyes processzorokhoz, és a további, nagyobb memóriate-

rületek messzebb helyezkednek el. Ez nagyobb memória-késleltetést (latency) jelent, amit a cache használatával lehet kiegyenlíteni, ezért is hívják a rendszert cc -nek, azaz cache

koherensnek (cache coherent). Az ilyen rendszerek programozása általában openMP-ben történik, de nagyobb rendszereken az MPI is használatos.

Napjaink legnagyobb szuperszámítógépei elosztott vagy fürtözött (cluster ) számítógépek. Ezek gyors összeköttetéssel rendelkez® külön számítógépek. Ezeket a gépeket MPI segítségével programozzák. Ebben a könyvben az olvasót az MPI C++ alatti használatába vezetjük be.

www.tankonyvtar.hu


1. fejezet. Bevezetés

5

A mai további párhuzamos architektúrák a videokártyák, melyeket különböz® feladatokra lehet programozni és még szuperszámítógépekben is használni lehet ®ket. Ezt a paradigmát GPGPU-nak (General Programming GPU általánosan programozható GPU) nevezik és ezeket a rendszereket CUDA vagy OpenCL nyelven programozzák.

1.4. Az elosztás problémája Amikor egy párhuzamos algoritmust kell létrehoznunk, általában le kell osztanunk a prob-

DR AF T

lémát al-problémákra. Egyes esetekben ez könny¶, mert maga a probléma is különálló feladatokból áll össze, vagy az algoritmus olyan adatokon dolgozik, amiket fel lehet osztani és külön kezelni. jó példa erre a Mandelbrot halmaz párhuzamosítása a 11. fejezetben,

ami rámutat egy további problémára. Ugyanis ezeket a részfeladatokat hozzá kell rendelnünk a folyamatainkhoz, és ez sem egy triviális kérdés.

A jó elosztás viszont nem mindig lehetséges. Jó pár probléma esetén a problémát nem

tudjuk független részproblémákra osztani, többnyire azért, mert nem függetlenek. Sok diszkrét algoritmus ebbe a kategóriába esik.

Egy kis szerencsével ezeket az eseteket is kezelni tudjuk, ha a részproblémákat párhu-

zamos feladatokra bontjuk, majd a részfeladatok megoldásait egy soros szál egyesíti. Egy

egyértelm¶ példa a rendezés problémája. A számok részsorozatait az egyes processzusok-

nak osztjuk ki, majd a részeredményeket re-kombinálva kapjuk meg a végs® eredményt. Ezt összefésüléssel (merge) oldhatjuk meg, így ezt a rendezést összefésül® rendezésnek -

nek hívjuk. Egy másik megközelítés az lehet, ha az egyes processzusoknak úgy adunk ki elemeket, hogy azok a csoportokban mind kisebbek mint egy következ® csoportban. Más szóval, nagyjából kiválogatva az elemeket különböz® csoportokba, majd ezeket csoportonként rendezve, és az eredményeket visszaküldve a mester processzusnak, rendezett

csoportokat, így ezeket egybetéve, rendezett listát kapunk. Ezt a sémát párhuzamos gyors

rendezésnek (quicksort) hívhatjuk. Látni fogjuk, hogy a részhalmazokra való bontás egy speciális problémát vet fel, ami miatt egy nomhangolt rész-leosztást kell végezni. Ezt a módszert mintavétel alapú rendezésnek (samplesort) hívják.

1.5. A párhuzamosítás problémája

Amikor párhuzamos programot írunk, természetesen gyorsabb futást szeretnénk elérni. A

szimpla gyors helyett érdekes lenne tudni milyen gyors ?. A párhuzamosítás jóságát szeretnénk mérni. Természetesen különböz® feladatokhoz különböz® mértékeket vizsgál-

hatunk. Egyes esetekben a legkisebb futási id® csökkenés is fontos lehet, mert a problémát

pl. adott id®n belül kell megoldani. Gazdasági szempontból is nézhetjük a dolgot és a

gyorsabb futást a befektetett pénz (és talán id®) arányában is értelmezhetjük. Egyetlenegy általános és tökéletes mérték talán nem meghatározható, de létezik egy, ami elég széles körben elfogadott. Ez a gyorsulás (speed-up), amit a következ®képp számolunk. Az adott problémára lefuttatjuk a legjobb szekvenciális programot, majd a párhuzamos implementációt. A két futási id® hányadosa adja ki a gyorsulást. Ez persze a felhasznált processzorok


www.tankonyvtar.hu

6


és számítógépek számától függ. A cél az, hogy olyan párhuzamos programot írjunk, mely

n

processzor használatával

n-szeres

gyorsulást mutat, azaz kétszer annyi processzor fele

annyi id® alatt végez. Legtöbbször a problémát nem lehet független részproblémákra osztani, így alternatív algoritmusokat kell találnunk, melyek sokszor bonyolultabbak mint a szekvenciális. Ez utóbbi egy szálon lassabban fut le, mint a szekvenciális párja. Amikor további processzorokat vonunk be a számításba, ezt a lassabb algoritmust gyorsítjuk, így messze nem maradunk arányban a felhasznált processzorokkal. Ez azt jelenti, hogy a lineáris gyorsulást nem érhetjük el. Még így is hasznát vesszük az ilyen algoritmusoknak, mivel még a

DR AF T

lineáris alatti gyorsulással, több gép használatával (vagy épp szuperszámítógép haszná-

latával) sokkal nagyobb problémákat oldhatunk meg, mint a szekvenciális eljárással. Azt mondhatjuk, hogy az

1,5-szeres

gyorsulás kétszer annyi processzorral kielégít® eredmény.

1.5.1. Amdahl törvénye és Gustavson törvénye

Ezen a ponton meg kell említenünk két jól ismert felismerést a gyorsulás problémájáról és határáról. Ezek a felismerések Amdahl és Gustavson törvényei. Gene Amdahl törvénye,

mely a kései '60-as években fogalmazódott meg, azt mondja ki, hogy minden párhuzamos programnak van egy határa, a felhasznált processzorok számától függetlenül is. Ezt a jelen-

séget az a tény gerjeszti, hogy minden párhuzamos programnak van olyan része, mely nem párhuzamosítható. Ezek tipikusan a program kezdete, ahol a kezd®értékeket vesszük fel,

a párhuzamosítás megkezdése, a f® szállal végzett adatgy¶jtés és a párhuzamosítás vége.

Ezeket a részeket nem tudjuk párhuzamosan végezni, így nem számít, hány processzort

használunk és gyorsítunk a párhuzamos részen, ez a rész mindig ugyanolyan gyors marad.

1%-a ilyen, és végtelen számú processzorral dolgozunk, hogy gyor99%-ot, amely így azonnal lefut, az egész program futási ideje 1/100-ad

Ha például a program sítsuk a maradék

része lesz az eredeti program futási idejének, azaz a nem párhuzamos rész futási ideje. Így 100 lesz a gyorsulásunk. Ennél jobbat semmiképpen sem tudunk elérni ebben az esetben.

Azt is meg kell jegyeznünk, hogy a valós problémákban kommunikálnia kell az egyes

szálaknak és processzusoknak. Ennek a kommunikációnak az ára nem független a fürt vagy a szuperszámítógép nagyságától. Azaz, egyre több és több processzor esetén a kommunikáció egyre több és több id®be telik. Az is el®fordulhat, hogy a különböz® processzorok

terhelése nem lesz egyenletes, így az egyiken hosszabb futási id®k jelentkezhetnek, míg a másik egy ideig nincs terhelve. A valóságban a probléma tehát hangsúlyosabb : egyre több

processzorral az elméleti gyorsulás egyre kevésbé elérhet®, a kommunikációs id®k növe-

kedésével kell számolnunk és a kiegyensúlyozatlanságok is egyre nagyobbak lesznek. A

Mandelbrot halmaz párhuzamosítási részében, a 11. fejezetben, valódi futtatási példákat fogunk mutatni erre az esetre.

Amdahl törvényét ugyan nem tagadva, de John L. Gustavson és Edwin H. Barsis kimondta, hogy a nem párhuzamosítható rész aránya a probléma nagyságának növelésével csökken. Mivel a f® szempont mindig adott problémák megoldása lesz, nem pedig az elméleti gyorsulás határainak a megadása, a nagyobb számítógépek és számítógép fürtök egyre nagyobb problémákat tudnak majd megoldani, így érve el egyre nagyobb gyorsulásokat.

www.tankonyvtar.hu


1. fejezet. Bevezetés

7

A kommunikációs többletre és kiegyensúlyozatlanságra vonatkozóan nagyjából ugyanezt feltételezhetjük.

1.5.2. Szuper-lineáris gyorsulás Egy párhuzamos program elméleti elvárt gyorsulása a felhasznált processzorok számával azonos. Van azonban olyan kivétel, amikor nagyobb gyorsulást kapunk mint amennyit ez a hozzáadott processzorok számából adódna. Ezt a ritka, de nem túl ritka jelenséget szuperlineáris gyorsulásnak" nevezik. Két oka lehet egy ilyen gyorsulásnak. Egyik a rendszerben

DR AF T

felhalmozott cache vagy memória hatása. Ha a teljes probléma nem fér be a memóriába (vagy cache-be), a futás lelassul. Viszont ha annyi processzort használunk, hogy az extra cache-be vagy memóriába így már befér a probléma egésze, extrém ugrást kaphatunk a

gyorsulásban. Ebben az esetben a lineáris feletti (szuper-lineáris) gyorsulást kapunk. Az

olvasó egy ilyen viselkedésre a gráfokban való legrövidebb utak problémájának fejezetében kap példát, a 6. fejezetben.

A szuper-lineáris gyorsulás másik lehetséges forrása a visszaléptetéses (backtracking)

algoritmusok, ahol az egyik ág eredménye információt adhat a másik ág futtatásának megszakításához, így csökkentve le a futásid®t.


www.tankonyvtar.hu


DR AF T

8

www.tankonyvtar.hu


2. fejezet

DR AF T

Alapvet® számításigényes feladatok

2.1. Alapvet® nehéz feladatok számításigényes feladatok

A számítási problémáinkat alapvet®en két csoportba oszthatjuk. A számítógéppel nem

megoldható és a számítógéppel megoldható problémákra. Az els® csoportba tartoznak tipikusan azok a problémák, melyek érzelmekt®l, szubjektív paraméterekt®l illetve minden,

jelenleg még nem modellezhet® vagy leírható dolgoktól függenek. A második csoportba pedig azok a problémák tartoznak, melyeket le lehet írni olyan módon, hogy azokat számítógépek megértsék és megoldják. Ez tipikusan azt jelenti, hogy az informális leírást

algoritmusokkal le lehet írni. Az algoritmus egy véges lépések sorozatából álló eljárás,

mely lépésr®l lépésre halad a megoldásig, bemenetei és kimenetei jól deniáltak. Ha egy probléma algoritmizálható, azt mondjuk, hogy számítógéppel megoldható. Egy algoritmussal szemben persze nem csak az az elvárásunk, hogy megadja az eredményt, hanem az

is, hogy lehet®leg minél el®bb adja azt meg. Mivel a futási id® er®sen függ a bemeneti adat mennyiségét®l, jó ötletnek t¶nik, hogy az algoritmusokat az alapján osztályozzuk, hogy

hogyan reagálnak a bemenet változására. Ezt az osztályozást a Landau-tól származó ordó

f (x) és g(x) f (x) = O(g(x)) akkor és csak akkor, ha létezik olyan pozitív egész M szám és egy valós x0 szám, melyekre igaz, hogy |f (x)| ≤ M |g(x)| minden x > x0 . Azaz, egy bizonyos x0 -tól az f (x) nem n® jobban mint g(x). Legyen c egy konstans. Ha, például g(x) egyenl® cx-el, azt mondjuk, hogy az algoritmus futási ideje lineáris. Ha g(x) egyenl® xc , azt mondjuk, hogy az algoritmus bonyolultsága polinomiális. Ez utóbbi x bonyolultságig a lépésszám még általában elfogadható. Ha g(x) egyenl® c akkor az algorit-

(nagy O) jelöléssel írjuk le, amely az algoritmus kategóriáját jelenti. Adott függvények esetén azt mondjuk, hogy

mus lépésszáma exponenciálisan n® a bemenetek számával. Ez már nagy adatok esetében elfogadhatatlanul id®igényes, így azt mondjuk, hogy az exponenciális algoritmusok rossz algoritmusok.

Természetesen a bemeneti adatok mennyisége önmagában is meghatározhatja a feladat nagyságát. Ennek megfelel®en két faktorral kell számolnunk :


www.tankonyvtar.hu

10

Bevezetés az MPI programozásba példákon keresztül I. Hatalmas mennyiség¶ adat (big data probléma), II. A megoldáshoz exponenciális id® szükséges. Ezek problémák együtt, de akár külön-külön is nehezen megoldhatóak. A big data

problémakör a párhuzamosság lineáris növelésével kezelhet®. Minél több adatunk van, annál több számítási kapacitást kell igénybe venni. Az exponenciális id®igényt viszont csak exponenciálisan növeked® számítási kapacitással lehetne kezelni, ami a valóságban

DR AF T

kezelhetetlen.

2.2. Mérnöki, matematikai, gazdasági és zikai számítások

A mérnöki, nagy számításigény¶ feladatok általában szimulációs feladatok. A repül®mér-

nökök szimulációkkal vizsgálják az ¶rhajó és repül® tervezésnél az egyes alkatrészek, a környezet, a mozgó leveg® és a motor dinamikájának kapcsolatát. Ezt egyéb közleked®eszközökre kiterjesztve, közlekedéstervezésr®l beszélhetünk.

Az épület és szerkezettervezés hasonló problémákkal foglalkozik, csak más anyagokat,

er®ket, más céllal vizsgál. Az épületeket a funkciójuk alapján osztályozhatjuk, attól függ®-

en, hogy magasra és kecsesre vagy robusztusra és biztonságosra tervezik ®ket. A különböz® szerkezetek, mint a hidak, alagutak és tartószerkezetek megint más követelmények alapján kerülnek tervezésre.

A fenti legtöbb probléma modellezési kérdés, ahol a szimuláció és a vizualizáció nagy

szerepet játszik. Látni akarjuk, hogy egy struktúra elbír-e adott súlyt, vagy ellenáll-e föld-

rengéseknek és szeleknek. Rengeteg számítás árán, rengeteg paraméter bevonásával kell az eredményeket megjeleníteni, majd ha úgy látjuk jónak, bizonyos paraméterek állítgatásá-

val annak hatását akarjuk meggyelni. A számításra egy bizonyos id®n belül tudunk várni, de az igazán eektív megoldás az, ha azonnal látjuk mi az eredménye a változtatásainknak, azonnal visszajelzést kapva a beállításainkról.

Az említett zika számítása numerikus módszereken alapul, úgy mint nem lineáris

egyenletrendszerek megoldása, görbe illesztések, interpolálás, dierenciálás, integrálás és egyéb számításigényes feladatok.

A matematikai problémákat nehéz a maguk teljességében kezelni. Bevett szokás, hogy a

problémát lineáris és kevésbé komplex feladatokra bontva oldjuk meg. A numerikus mód-

szereinket közelítéses módszernek is nevezhetjük, mivel általában az ilyen számításoknál az adja az egyszer¶sítést, hogy egy elfogadható közelítést keresünk, elfogadható id® alatt.

Az ilyen eljárások gyakran iteratívak, így a megoldáshoz szükséges id®t a kívánt pontosság fogja befolyásolni. Tekintsük az egyszer¶ példát, ahol a

sin(x)−x2 = 0

többtagú függvény

gyökeit keressük. A grakus megoldás az lenne, hogy ábrázoljuk a függvényt és megnézzük, hol metszi az

x-tengelyt.

Ez is egy közelítés lenne, hiszen a metszéspont nem feltétlenül egy egész

értéknél lenne.

www.tankonyvtar.hu


11

DR AF T

2. fejezet. Alapvet® számításigényes feladatok

2.1. ábra. Példa egyenlet :

sin(x) − x2 = 0

(fooplot.com)

A numerikus megoldásra egy egyszer¶ példa lehetne, ha egy adott tartományon belül

keresnénk. A várható megoldás ebben a tartományban kell, hogy legyen. Ez persze némi el®-analízist kíván, mivel az intervallum elejét és végét meg kell határozni. Tekintsük az ábrát és tegyük fel, hogy

0

és

1

között keressük a megoldást. A nulla triviális megoldása

az egyenletnek. Egy egyszer¶, de nem túl eektív megoldás lehetne, ha egy bizonyos fel-

0,1. Mivel a 0,1-r®l indulhatunk. Az x-et 0,1-el helyettesítve megmegoldása-e ? Ha nem, akkor lépjünk a 0,2-re és így

bontással végigmennénk ezen az intervallumon. Legyen a felbontás például nulla egy triviális megoldás volt, így vizsgáljuk, hogy az egyenletnek ez

tovább. Ha az eredmény el®jelet vált, átfutottunk a megoldáson. Ekkor vissza kell lépnünk egy lépést és nomítani a lépésközt, pl.

0,01-re.

Ezt nagyon hosszú ideig ismételhetjük,

sokszor gyakorlatilag örökké, a megoldást pedig nagyon lassan közelítenénk. Egy közelít® megoldást viszont véges id®n belül találhatunk, és ha a pontosság megfelel a céljainkra,

már egy m¶köd® módszerünk van. A pontosság egy kulcsmomentum, hiszen a numerikus módszereknél pont olyan megoldás közelítéseket keresünk, amik már elég közel vannak az

egzakt megoldáshoz. Ez a módszer rengeteg id®t spórolhat meg. Most már csak az elég közel-t kell deniálni. Egy lehet®ség lenne az iteratív lépések számát maximálni. Ez garantált lépésszámon belül adna megoldást, illetve nem kerülnénk végtelen iterációba. A másik lehet®ség az lenne, ha a hibára mondanánk egy mértéket, mennyire kell megközelítenünk

a valós megoldást. De hogy deniálhatjuk ezt, ha nem ismerjük a valós megoldást ? Egy lehet®ségünk az, hogy az iteráció lépései között lév® változásból következtetünk arra, hogy milyen közel járunk az eredményhez. Ha a változás adott értéken belüli, azt mondhatjuk kell®en közel járunk a megoldáshoz.

Több megoldás is létezik a közelítési eljárás felgyorsítására. A felezéses vagy bináris keresés módszere. Ha a polinom kifejezésünk folytonos és az induló valamint záró értékek el®jele más, élhetünk a felezéses módszerrel. Az ötlet egyszer¶ : a teljes intervallumot mindig elfelezzük, és azt a felet vizsgáljuk tovább, ahol a kezd® és végértékek el®jelet váltanak. Ezt újra ketté bontjuk és így lépegetünk tovább. Ezt addig


www.tankonyvtar.hu

12


ismételjük, amíg a kezd® és végérték egy megadott távolságon belül lesznek egymástól. A Newton módszer (Newton-Raphson módszer vagy Newton-Fourier módszer). Ha az el®z® feltételek teljesülnek, a módszert fel lehet gyorsítani. Az ötlet az, hogy ha nem vagyunk túl messze a megoldástól, akkor a következ®

xn+1

pozíciót a függvény

xn

helyen

vett deriváltjával választhatjuk ki. Jó ötlet el®ször a felezéses módszerrel közel kerülni, majd onnan a Newton-Raphson módszerrel nomítani. A módszer azt használja ki, hogy egy függvény deriváltja egy bizonyos ponton egyenl® 0 a függvény érint®jével. Ez alapján f (xn )=f (xn )/(xn −xn+1 ). Ez átrendezhet® a következ® 0 formába : xn+1 = xn −f (xn )/f (xn ). Az érint® és az x-tengely új metszéspontját kiszámítva

f ()

értéket kapunk az új érint® kiszámításához. Addig iterálva, amíg a

DR AF T

(xn+1 ), egy újabb

hiba egy adott érték alá csökken megkapjuk a megfelel® közelítést.

A matematikában egy további gyakori számítási feladat adott függvény integráljának

a kiszámítása. Egyes esetekben ez analitikus módon meg lehet tenni, de nagyon sokszor ez nem lehetséges vagy túlzottan id®igényes feladat lenne.

Kézenfekv®, hogy numerikus módszerrel oldjuk meg ezt a feladatot is, azaz egy integrál

közelítést végezzünk.

Az alapvet® problémát a következ®képpen fogalmazhatjuk meg. A függvény, adott in-

tervallumon vett területét szeretnénk kiszámolni. Egy lehetséges megoldás lehet, hogy az

intervallumot kis részintervallumokra osztjuk és az egyes darabok helyén a függvényt egy konstans értékkel helyettesítjük. Ez a konstans a függvény részintervallumon felvett érté-

keinek a középértéke lehet. Ezzel a módszerrel a területet vékony téglalapokkal közelítjük,

azaz a közelít® integrál ezen területek összegéb®l adódik. Minél keskenyebb sávokra bontjuk az intervallumot, az integrálközelít® összeg annál pontosabb lesz. Ezt a módszert az alap kvadratúra problémának hívjuk.

Egy bonyolultabb közelítés lenne, ha a téglalapok helyett trapézokat használnánk.

A fenti megoldások pontosságának növelése érdekében a felbontást növelhetjük, ez azonban számítási kapacitás igény növekedést is jelent egyben.

Egy kinomultabb technika lenne a magasabb fokú polinomok interpolációján alapuló

megoldás. Ez a Newton-Cotes szabályok alapján történne, de az instabilitás és annak kezelése miatt célszer¶bb a robusztusabb Newton-Raphson módszernél maradni és a felbontást növelni.

2.3. Komplex modellek

A párhuzamosság alapötlete az, hogy a nagy mennyiség¶ munkát az egyes számítási egységek között elosztva, azokon egy id®ben, külön lehessen dolgozni. Így id®t takarítunk meg,

azaz hamarabb kész leszünk az adott feladattal. Mivel a számítási kapacitás egyre olcsóbb, a párhuzamosítás egyre költséghatékonyabb. A párhuzamosítás egyik triviális megvalósítása, amikor nagy, független adatokkal dolgozunk, ugyanis itt a szétosztás egyértelm¶. A munkamegosztás a feladattól függ®en egyszer¶ is lehet, bár a szimmetrikus elosztásra mindig gyelni kell. Erre lehet példa a prímszámok keresés intervallumokon belül. A pár-

www.tankonyvtar.hu


2. fejezet. Alapvet® számításigényes feladatok

13

huzamosítás a tudományos és mérnöki modellezés és megoldás jó eszköze lehet akkor is, amikor az adataink függ®ek és a munka közben több feltételt kell állandóan vizsgálni. A természetben több olyan esemény is van, amelyben függ®ségek vannak. Erre jó példa lehet a bolygók, üstökösök és holdak pályája. Ezeket Kepler törvényei alapján számíthatjuk és minden elem hatással van az összes többire. Ebben a komplex rendszerben a mesterséges objektumok, mint rakéták, m¶holdak mozgásának számítása egy további lépés a komplexitás felé, amely egyre nagyobb és nagyobb számítási kapacitást igényel. További jó példák lehetnek a klíma számítás, közlekedési modellezés, elektronikai rend-

DR AF T

szer modellezése, plazma dinamika.

2.4. Számítások valós id®ben

A sebességnövekedéssel a számításainkat rövidebb id® alatt végezhetjük el. Ez a rövidebb

id® olyan rövid is lehet, hogy a visszajelzéseket, eredményeket szinte azonnal látjuk. A sebességnövekedés egyik hatása, hogy valósidej¶ (real-time) rendszereket építhetünk. A valós id® deníciója nem az, hogy azonnal kapunk választ, hanem az, hogy a választ egy

adott id®n belül garantáltan megkapjuk. Ennek több hatása van. A rendszer így várhatóan

interaktív lesz, akadás és késlekedések nélkül, a felület reagálni fog a m¶veleteinkre, rövid id®n belül pedig lefutnak a kért feladatok. Ez azt is sejteti, hogy a vizualizáció jobb lehet,

a változások hatását azonnal látni is lehet. A valós idej¶ rendszerek egyéb el®nyei például, hogy valós id®ben tudnak folyamatokba beavatkozni, illetve jövendölés segítségével

el®re kikerülni bizonyos nem kívánt eseményeket. A valós idej¶ párhuzamosítás operációs rendszer ill. hardver szinten is megvalósulhat.

A párhuzamos m¶ködés egyik szabványa az MPI/RT (Message Passing Interface /

Real-Time). Ezzel a szabvánnyal megvalósul a platformfüggetlenség és jobb portolhatóság. A szabvány az MPI-hoz

QoS -t,

min®ségbiztosítást ad. Sok HPC (High-Perfomance

Computation) alkalmazás id®zítési garanciákat igényel a m¶ködéshez, amihez a fentiek szükségesek.

Az MPI/RT-r®l a vonatkozó irodalomban részletes leírások találhatók.[Kan1998].


www.tankonyvtar.hu


DR AF T

14

www.tankonyvtar.hu


3. fejezet

DR AF T

Az MPI környezet logikája

Els®nek el kell magyaráznunk, hogy fut egy MPI program, mivel ez alapvet®en különbözik a soros programok futásától. Magában a programkódban nem sok különbséget

mpi.h-t, és MPI_ MPI:: névtéren

találunk egy szokványos C++ programtól. A program elején include-oljuk az

csak néhány plusz függvényhívást helyezünk el a programkódban, melyek mind az el®taggal kezd®dnek. (Az MPI-nak van C++ szer¶ jelölése is, ebben az

belül találhatóak a függvények. Mivel a könyvünkben is használt C szer¶ jelölés amúgy is

használható a C++ programokban, így az MPI 3.0 szabványa a C++ jelölést kivezette, jelenleg obsolete státuszú.)

A programot le kell fordítanunk, ehhez egy külön felparaméterezett fordítót haszná-

lunk, ami a megfelel® paraméterekkel lefordítja, és linkeli a szükséges könyvtárakat, de amúgy a szabvány fordítót csomagolja be (wrapper). A C++ programokhoz tipikusan a

mpic++ vagy mpicxx program használandó, ez az adott telepített MPI programoktól függ,

ami meghívja a rendszerben telepített C++ fordítót mint a g++, vagy az icc illetve pgc++.

Értelemszer¶en ugyanazokat a kapcsolókat használhatjuk, mint amit a fordítónak is megadhatunk, például a

-O3 kapcsolót az er®teljesebb optimalizáláshoz illetve a -o kapcsolót,

hogy elnevezhessük a kimeneti, futtatható állományt. Példaként bemutatjuk a hamarosan bemutatandó nevezetes Helló Világ Hello World program fordítási parancsát.

$mpic++ -O3 hello.cpp -o hello

Miután sikeresen lefordítottuk a programot egy újabb programot kell meghívnunk, az

mpirun-t,

ami a program futtatásáért felel. A

-np

kapcsoló fogja meghatározni azt, hogy

hány példányban szeretnénk futtatni a lefordított programot. Az

mpirun feladata összesen

ez, több példányban elindítani ugyanazt a programot. Az olvasó ki is próbálhatja valami

szokványos linux rendszerprogrammal, mint a

kifejezetten hasznos az

mpirun

date vagy a hostname az utóbbi egyébként

tesztelése céljából amikor több számítógépet használunk

majd egyszerre. Az el®bbi példánál maradva a parancssor így nézne ki ha nyolc példányt szeretnénk indítani :

$mpirun -np 8 ./hello Ha több gépet használunk akkor be kell állítanunk közöttük az ssh kommunikációt, és a

-np

kapcsoló helyett a

-hostfile


kapcsolót kell használnunk ahhoz, hogy majd

www.tankonyvtar.hu

16


megmondjuk azoknak a gépeknek a nevét, amit használni szeretnénk. Ha viszont egy szuperszámítógépen akarjuk elindítani a programunkat, akkor azon egy külön ütemez® gondoskodik a programok futtatásáról. Így ott az

mpic++-vel

való fordítás után a futási

sorba kell beküldenünk a feladatot, melynek módjáról a konkrét rendszer dokumentációja ad felvilágosítást. A Függelékben a ezekr®l b®vebb példát is talál az olvasó. Ha az olvasó most ismerkedik az MPI környezettel, akkor valószín¶leg az otthoni gépén fogja kipróbálni, amihez néhány kisebb csomagot kell telepítenie a linuxára. Alapvet®en az olvasónak az ezek az

openmpi

openmpi-al kezd®d® csomagnevekre lesz szüksége (a szerz® rendszerén és az openmpi-dev csomagok voltak), majd az mpirun programot -np

DR AF T

kapcsolóval tudja lokálisan futtatni az MPI programokat amiket írt, annyi darabban, amit a

-np

kapcsolónak megad. A részletes leírást az olvasó a Függelékben találja.

3.1. Az MPI a programozó szemszögéb®l

Miután a fenti módon elindítottuk a programunkat több példányban MPI függvényhívások

segítségével kaphatunk információkat az MPI világról, illetve más függvények segítségével

végezhetünk kommunikációt a programok folyamatok között. Nézzünk meg egy MPI programpéldát, ami a híres Hello Világ ! Hello World ! program MPI változata.

01 : 02 : 03 : 04 : 05 : 06 : 07 : 08 : 09 : 10 : 11 : 12 : 13 : 14 : 15 : 16 : 17 : 18 : 19 :

//Hello World ! program

#include #include <mpi.h> using namespace std ; int main (int argc, char **argv) { int id, nproc ;

//

MPI inditasa

MPI_Init(&argc, &argv) ; // Rangunk lekerdezese

MPI_Comm_rank(MPI_COMM_WORLD, &id) ; // Osszes processzus szama ?

MPI_Comm_size(MPI_COMM_WORLD, &nproc) ; cout<<"Process

"<
// MPI leallitasa

MPI_Finalize() ;

}

Láthatjuk, hogy nincs olyan nagy különbség egy hagyományos soros programhoz képest. Természetesen a program elején include-olnunk kell az

www.tankonyvtar.hu

mpi.h

headert. Az

MPI_Init


3. fejezet. Az MPI környezet logikája illetve az

MPI_Finalize

17

függvényhívások jelzik a kooperatív rész elejét és végét. Alap-

main függvény) az MPI_Init paraméterei a

szabályként kimondhatjuk, hogy a programunk (egészen pontosan a els®vel fog gyakorlatilag kezd®dni és az utóbbival végz®dni. Az

main paramétereire mutató pointerek, így minden egyes folyamat meg tudja kapni az indító paraméterlistát. A függvény formális deníciója :

DR AF T

int MPI_Init( int *argc, char ***argv ) Az

MPI_Comm_rank

és az

MPI_Comm_size

függvények a futó programokról gy¶jtenek

információkat. A size, azaz méret, a futó programok számát adja meg. A rank, azaz rang egy nem-negatív egyedi szám, amit a rendszer minden egyes programhoz rendel, ami 0 és

size − 1

közé esik. A függvények formális deníciója :

int MPI_Comm_rank( MPI_Comm comm, //MPI kommunikátor int *rank //Az egyedi azonosító értéke, a folyamat rangja )

int MPI_Comm_size( MPI_Comm comm, //MPI kommunikátor int *size //Az MPI világ mérete )

Az MPI kommunikátor egy egyedi azonosító, amely gyakorlatilag az összes MPI függ-

vényben jelen van. Azt az egyedi azonosítót amit itt használunk az és a

MPI_COMM_WORLD

MPI_Init

hozza létre

a neve. Ez az kommunikátor teszi lehet®vé hogy megszólíthassuk a

többi futó programot. A program futása közben más kommunikátorokat is létrehozhatunk

azért, hogy lesz¶kítsük bizonyos kommunikációk körét bizonyos speciális algoritmusokban. Az FFT algoritmus elemzésében talál majd erre példát az olvasó.

Ezek a függvények alapvet®ek ahhoz, hogy információkat gy¶jtsünk össze a futó prog-

ramokról, mivel ezek az információk futásról futásra változhatnak, s®t az is befolyásolja ®ket, hogy a felhasználó miképpen indította el a programokat. Például ha a felhasználó az

mpirun -np 4 ./hello

paranccsal indítja el a példaprogramot, akkor a méret (az

változó értéke) 4 lesz, az

id

nproc

változó meg a 0, 1, 2 illetve 3 értékeket veszi fel a különbö-

z® futó programokban. Így tehát az egyik lehetséges kimenete a példaprogramunknak a következ® lehet :


www.tankonyvtar.hu

18


$ mpirun -np Process 0 of Process 1 of Process 3 of Process 2 of

4 ./hello 4: Hello World! 4: Hello World! 4: Hello World! 4: Hello World!

Az olvasó bizonyára észrevette a fenti sorrend felcserél®dést (a 3. folyamat megel®zi a 2-at). Fontos, hogy a párhuzamos programoknál gyelnünk kell arra, hogy a folyamatok sorrendjére semminem¶ el®feltételezéssel sem élhetünk. Úgy kell megírnunk az algoritmusa-

DR AF T

inkat, hogy eleve minden elképzelhet® sorrendre felkészülünk, és ha speciálisan szükségünk van valami szinkronizációra, akkor azt nekünk kell elhelyeznünk a programkódban.

Abból a célból, hogy egy picit összetettebb programot is bemutassunk az el®z® prog-

ramkód egy egyszer¶ változatát mutatjuk még meg.

01 : 02 : 03 : 04 : 05 : 06 : 07 : 08 : 09 : 10 : 11 : 12 : 13 : 14 : 15 : 16 : 17 : 18 : 19 : 20 : 21 : 22 : 23 : 24 : 25 :

//Hello World ! program minimais kommunikacioval

#include #include <mpi.h> using namespace std ; int main (int argc, char **argv) { int id, nproc, id_from ; MPI_Status status ;

//

MPI inditasa

MPI_Init(&argc, &argv) ; // Rangunk lekerese

MPI_Comm_rank(MPI_COMM_WORLD, &id) ; // Az osszes processzor szamanak lekerese

MPI_Comm_size(MPI_COMM_WORLD, &nproc) ; if(id

!= 0){

// a Szolga processzusok kuldest keszitenek elore cout<<"Process

id="<
MPI_Send(&id, 1, MPI_INT, 0, 1, MPI_COMM_WORLD) ;

}

else{

// a Mesterek fogadjak a koszontest. cout<<"Master

process (id=0) receiving greetings"<<endl ;

for(int i=1 ;i
1,

MPI_INT,

MPI_ANY_SOURCE,

1,

MPI_COMM_WORLD,

26 : 27 :

&status) ; cout<<"Greetings

www.tankonyvtar.hu

from process

"<
3. fejezet. Az MPI környezet logikája

19

28 : } 29 : } 30 : // MPI leallitasa 31 : MPI_Finalize() ; 32 : } 33 : Itt a futó programokat (folyamatokat) két csoportba osztottuk : egyfel®l lesz a mester

id

értéke 0 lesz), és lesznek a szolgák (az összes többi prog-

DR AF T

(az a program, amelynél az

ram). A futásbeli megkülönböztetés egy egyszer¶ if-else szerkezettel van megvalósítva a

programkódon belül. A szolgák üdvözletüket küldik a mesternek, amit a mester fogad. Az üzenet tartalma a küld® folyamat id-ja, melyet a mester az el. Az üzenetküld® függvény az

MPI_Send,

id_from

változóban tárol

míg a fogadást végz® függvény az

amiket részletesen elemzünk majd kés®bb. A mester összesen

nproc − 1

MPI_Recv,

üdvözletet kap,

hiszen önmagától nem kap üzenetet, amit egy ciklusban fogad. Egy lehetséges kimenete a programnak :

$ mpirun -np 4 ./hello2 Master process (id=0) receving greetings Process id=1 sending greetings! Process id=2 sending greetings! Greetings from process 2! Process id=3 sending greetings! Greetings from process 3! Greetings from process 1! De lehetséges más kimenet is, például :

$ mpirun -np 4 ./hello2 Master process (id=0) receving greetings Greetings from process 3! Greetings from process 1! Greetings from process 2! Process id=1 sending greetings! Process id=2 sending greetings! Process id=3 sending greetings!

Ismételten, az olvasó észreveheti mennyire furcsa a kimenet sorrendje. Valójában csak

abban lehetünk biztosak, hogy az üzenet küldése meg fogja el®zni annak a bizonyos üzenetnek a fogadását, de még az üzenet elküldése el®tti kimenet is lehet, hogy kés®bb fog megérkezni, mint maga az üzenet. Az egyedüli amiben biztosak lehetünk, hogy a Master process. . . sor el®bb fog megjelenni, mint a Greetings. . . sorok, mivel ezeket a mester írja ki, és a mester programja önmagában egy soros program. Azaz egy adott folyamat


www.tankonyvtar.hu

20


kimenetének sorai a szokványos módon fogják egymást követni, de a folyamatok között már sokszor nem állíthatunk fel sorrendet. A mester-szolga algoritmusok részletezésére a következ® fejezetekben kerül majd sor.

3.2. Küldés (send) és fogadás (recieve) Az

MPI_Send

és az

MPI_Recv

a két leggyakrabban használt MPI függvény. Az els® adatot

DR AF T

vagy adatokat küld, a második ezeket fogadja.

A küldés (send) formális deníciója:

int MPI_Send( void *buffer, //A küld® puffer címe int count, //A küldend® elemek száma MPI_Datatype datatype, //A küldend® elemek adattípisa int dest, //A címzett rangja int tag, //Az üzenet cimkéje MPI_Comm comm //MPI kommunikátor )

A küldend® adatot tároló változó pointerét adjuk át (egy változó vagy egy egész tömb

pointerét), az adatok számát és az adat típusát. Az utóbbi egy MPI beépített típus kell, hogy legyen kompatibilitási okokból, és tipikusan az

MPI_INT vagy az MPI_DOUBLE típuso-

kat használjuk. (A Függelékben részletezzük ezeket.) Meg kell adjuk a pontos címzettet, mivel ez egy pont-pont kommunikáció. Az üzenet címkéje azt a célt szolgálja, hogy a

hasonló üzenetek között különbséget tehessünk. A kommunikátor az MPI világot nevezi meg.

A leggyakrabban használt adattípusok a következ®ek :

MPI_CHAR MPI_INT MPI_LONG MPI_LONG_LONG_INT MPI_DOUBLE MPI_LONG_DOUBLE

www.tankonyvtar.hu

char signed int signed long int signed long long int double long double



21

A fogadás (recieve) formális deníciója:

DR AF T

int MPI_Recv( void *buffer, //A fogadó puffer címe int count, //A fogadott elemek száma MPI_Datatype datatype, //A fogadott elemek adattípusa int source, //A küld® rangja int tag, //Az üzenet cimkéje MPI_Comm comm, //MPI kommunikátor MPI_Status *status //Státusz objektum )

A pointer egy változóra vagy tömbre mutat, melybe a fogadott adat kerül eltárolásra.

Az adatok száma és típusa azonos, mint amit a küldésnél láthattunk. A source a küld®

pontos rangját (id-ját) adja meg, viszont a konkrétan megnevezett küld® helyett használhatjuk az általános

MPI_ANY_SOURCE

jelölést, amely bármelyik küld®t®l fogad adatot. A

címkének egyeznie kell a küld® üzenet címkéjével, vagy ismételten használhatjuk az általános

MPI_ANY_TAG cimkét de ez utóbbit nem ajánljuk, mert véleményünk szerint minden

egyes üzenet határozottan egyértelm¶ kell, hogy legyen. A kommunikátor ismételten az MPI világot jelöli. A státusz objektum egy struktúra, amely a következ® mez®kb®l áll :

MPI_SOURCE

MPI_TAG

MPI_ERROR

a küld® folyamat id-ja

az üzenet címkéje hiba státusz.

Az objektum egyéb információkat is tartalmaz, melyeket az illetve

MPI_Iprobe

MPI_Get_count, az MPI_Probe

függvényekkel tudunk lekérdezni.

3.2.1. Halálos ölelés (deadlock)

A leggyakrabban használt MPI függvények, az

MPI_Send()

illetve

MPI_Recv()

blokkoló

pont-pont kommunikációt valósítanak meg. Ez azt jelenti, hogy a küldést megvalósító függvény csak azután tér vissza a program további végrehajtásához, miután az összes adat elküldésre került ; illetve a fogadó függvény akkor tér vissza, ha a fogadás minden adatot megkapott. Ez bizonyos problémákat tud okozni ha nem vagyunk eléggé körültekint®ek a függvények használata során. Ez a probléma a halálos ölelés deadlock. Hadd mutassunk


www.tankonyvtar.hu

22


be egy egyszer¶ példaprogramot, ahol a két folyamat beállít egy-egy változót, majd átküldi annak értékét a másik folyamatnak.

//a kuldes/fogadas rossz sorrendje elakadast (deadlock) okozhat int a,b ;

if(id == 0){ a=1 ;

MPI_Send(&a, 1, MPI_INT, 1, 1, MPI_COMM_WORLD) ; MPI_Recv(&b, 1, MPI_INT, 1, 2, MPI_COMM_WORLD, &status) ; }else{ //id == 1

DR AF T

01 : 02 : 03 : 04 : 05 : 06 : 07 : 08 : 09 : 10 : 11 : 12 :

b=2 ;

MPI_Send(&b, 1, MPI_INT, 0, 2, MPI_COMM_WORLD) ; MPI_Recv(&a, 1, MPI_INT, 0, 1, MPI_COMM_WORLD, &status) ;

}

Habár a program els® ránézésre jónak t¶nik, mégis a futása során halálos ölelésbe

kerülhet a két folyamat. Mivel a küldés blokkoló m¶velet, így az

id = 0

folyamat amikor

a változót nem tér vissza addig, amíg az meg nem érkezik a másik folyamathoz. id = 1 a b változót küldi el, és vár arra, hogy a másik folyamat megkapja azt, de nem

elküldi az

Azaz nem kezdi meg a fogadást addig, amíg a küldésnek nincs vége. A másik,

folyamat

kezdi meg a fogadást. Egyértelm¶, hogy a két folyamat meg fog akadni ezen a ponton, így ezt az állapotot hívjuk halálos ölelésnek.

A küldések és fogadások sorrendjét úgy kell megírnunk, hogy az mindkét oldalon gye-

lembe veszi a sorrendet. A helyes program így kell, hogy kinézzen :

01 : 02 : 03 : 04 : 05 : 06 : 07 : 08 : 09 : 10 : 11 : 12 :

//a kuldes/fogadas jo sorendje nem okozhat elakadast int a,b ;

if(id == 0){ a=1 ;

MPI_Send(&a, 1, MPI_INT, 1, 1, MPI_COMM_WORLD) ; MPI_Recv(&b, 1, MPI_INT, 1, 2, MPI_COMM_WORLD, &status) ; }else{ //id == 1 b=2 ;

MPI_Recv(&a, 1, MPI_INT, 0, 1, MPI_COMM_WORLD, &status) ; MPI_Send(&b, 1, MPI_INT, 0, 2, MPI_COMM_WORLD) ;

}

Valójában sokféle küld® és fogadó függvény van az MPI keretrendszerben, melyekr®l az olvasó a Függelékben tájékozódhat. A szokásos

MPI_Send() és MPI_Recv() függvények

valójában vegyes módúak. Igyekeznek puerelni a küldést, így ilyen esetben a vezérlés

www.tankonyvtar.hu



23

visszatér még az el®tt, hogy a másik fél megkapja az üzenetet. Így tehát, ha az üzenet rövid, a fenti példa valójában nem feltétlenül fog halálos ölelésre vezetni. De ebben nem lehetünk biztosak, így tehát nyomatékosan arra kell, hogy gyelmeztessük az olvasót, hogy mindig gyeljen erre a problémára. A jó kódolási elvek alapja, hogy az ilyen eseteket úgy kezeljük, hogy biztosan elkerüljük a halálos ölelést még akkor is, ha a függvények valójában nem blokkolók, és olyan sorrendbe rendezzük a küldést és fogadást, hogy mindig biztosítsuk a halálos ölelés mentességet.

DR AF T

3.3. Üzenetszórás (broadcast)

Még egy speciális üzenetküldési eszközt kell, hogy megemlítsünk a fentieken kívül, ez az üzenetszórás (broadcast), Gyakori igény az, hogy egy bizonyos adatot eljuttassunk

minden egyes folyamathoz a mester folyamattól. Azaz más szavakkal megfogalmazva, azt szeretnénk, hogy mindenki ugyanazon az adathalmazon dolgozzon. A leggyakoribb helye az ilyen kommunikációnak az algoritmusok inicializáló része a program legelején. Erre a speciális feladatra használjuk az üzenetszórást az MPI-ban.

Az ózenetszórás (broadcast) formális deníciója : int MPI_Bcast( void *buffer, //A küld®-fogadó puffer címe int count, //A küldend® elemek száma MPI_Datatype datatype, //A küldend® elemek adattípusa int root, //A gyökér (root) id-ja/rangja MPI_Comm comm //MPI kommunikátor )

Az üzenetszórás egy szimmetrikus függvényhívás, ami azt jelenti, hogy minden egyes

folyamat, a küld® és az összes fogadó egyaránt, ugyanazt a függvényt, ugyanazzal a para-

méterlistával fogja meghívni. A gyökér (root, mester) rangja (id-ja) jelzi azt, hogy melyik

folyamat lesz a küld®. Az olvasó a könyv második részében találhat majd részletes példákat az üzenetszórásra.


www.tankonyvtar.hu


DR AF T

24

www.tankonyvtar.hu


4. fejezet

DR AF T

Els® MPI programok 4.1. Elemek összegzése

Egy egyszer¶ példaprogramot mutatunk be. Össze szeretnénk adni a számokat 1-t®l 10 000ig. A soros program, melyhez nem szükséges magyarázat a következ® :

01 : // az osszeg 1-tol 10000-ig 02 : 03 : #include 04 : using namespace std ; 05 : 06 : int main(int argc, char ** argv){ 07 : int sum ; 08 : sum = 0 ; // sum nullazasa 09 : for(int i=1 ;i<=10000 ;++i) 10 : sum = sum + i ; 11 : cout << "The sum from 1 to 10000 is : " 12 : } 13 :

<< sum << endl ;

Ha ezt az eljárást szeretnénk párhuzamosítani, akkor az egész folyamatot részfolyama-

tokra kell bontanunk, ebben az esetben a különböz® számokat különböz® folyamatokhoz fogjuk rendelni, melyek résszöszegeket fognak majd kiszámolni. A folyamatok egy TÓL-IG tartományban (startvalendval) összegeznek, majd elküldik a részösszeget a mesternek, aki összeadja azokat.

01 : 02 : 03 :

// az osszegzes parhuzamos szamitasa // 1-tol 10000-ig


www.tankonyvtar.hu

26


#include #include<mpi.h> using namespace std ; int

main(int argc, char ** argv){

int id, nproc ; int sum,startval,endval,accum ; MPI_Status status ;

MPI_Init(&argc,&argv) ;

DR AF T

04 : 05 : 06 : 07 : 08 : 09 : 10 : 11 : 12 : 13 : 14 : 15 : 16 : 17 : 18 : 19 : 20 : 21 : 22 : 23 : 24 : 25 : 26 : 27 : 28 : 29 : 30 : 31 : 32 : 33 : 34 : 35 : 36 :

// osszes csomopont szamanak lekerese

MPI_Comm_size(MPI_COMM_WORLD, &nproc) ; // sajat csomopontunk rangja

MPI_Comm_rank(MPI_COMM_WORLD, &id) ; sum = 0 ; // sum nullazasa

startval = 10000*id/nproc+1 ; endval =

10000*(id+1)/nproc ;

for(int i=startval ;i<=endval ;++i) sum = sum + i ;

cout<<"I cout<<

am the node "<< id ; " ; the partial sum is : "<<

sum<<endl ;

if(id !=0) //a szolgak kuldik vissza a reszeredmenyeket MPI_Send(&sum,1,MPI_INT,0,1,MPI_COMM_WORLD) ; else //id==0 ! a mester a reszosszegeket kapja for(int j=1 ;j
sum yet is : "<<sum<<endl ;

}

if(id == 0) cout <<

"The sum from 1 to 10000 is : "

MPI_Finalize() ;

<< sum << endl ;

}

10000*(id+1)/nproc kifejezés nem azonos a 10000/nproc*(id+1) nproc nem osztja maradék nélkül a 10 000-et, és így olyan esetre vezet, ahol az utolsó endvalue értéke kevesebb Vegyük észre, hogy a

kifejezéssel ! Az értékük különböz® lesz azokban az estekben, amikor lesz, mint 10 000, ami hibás eredményre fog vezetni. A program kimenete a következ® lesz, vagy valami hasonló :

$ mpirun -np 4 ./sum1 I am the node 0; the partial sum is: 3126250 www.tankonyvtar.hu


4. fejezet. Els® MPI programok

27

The sum yet is: 12502500 The sum yet is: 28128750 The sum yet is: 50005000 The sum from 1 to 10000 is: 50005000 I am the node 1; the partial sum is: 9376250 I am the node 2; the partial sum is: 15626250 I am the node 3; the partial sum is: 21876250

DR AF T

4.2. π értékének kiszámítása

Könyvünkben nem csak programozási példákat szeretnénk bemutatni, hanem néhány hasznos módszertani tanácsot is adni arra, hogy lehet bizonyos feladatokat hatékonyan algoritmizálni párhuzamos környezetben. A következ® példa is egy ilyen hasznos technika. Ez

egy véletlenen alapuló eszköz, nevezetesen a Monte Carlo módszer. Ott tudjuk használni, ahol valami közelít® eredménnyel is megelégszünk, és nem ragaszkodunk feltétlenül a

pontos megoldáshoz. A módszer felbontja a probléma terét sok-sok rész partícióra, és ezek közül néhány véletlenszer¶en választottat, de nem az összeset megmér. Az által, hogy egyre több és több ponton mérjük meg a problémát abban reménykedünk, hogy egyre

pontosabban tudunk válaszolni az egész kérdésre. Ez egy kifejezetten jól m¶köd® módszer számos probléma esetén beleértve sok m¶szaki illetve természettudományos feladatot.

Viszont meg kell említenünk, hogy habár egyre pontosabb választ várunk egyre több

pont felhasználásával, ez nem ennyire egyszer¶. A válasz ugyanis el®ször gyorsan konvergál, de ez a konvergencia hamar lelassul. Egészen pontosan ez egy

√ 1/ N

konvergencia, ami

azt jelenti, hogy megnégyszerezve a mintavételi pontok számát a hiba a felére csökken.

Ugyancsak, egy bizonyos határ után, nem fogunk pontosabb eredményt kapni újabb és újabb minták bevonásával egyszer¶en a gép által használt számábrázolási kerekítési hibák

miatt, és amiatt, hogy egy pszeudo randomszám generátort használunk valódi véletlen számok helyett.

A Monte Carlo módszert könnyedén tudjuk párhuzamosítani : a különböz® mintavé-

teli pontokat más és más folyamatokhoz tudjuk rendelni, majd a legvégén egy mester folyamattal összegy¶jthetjük az eredményeket.

A második példánk egy olyan program, ami a

π

értékét számolja ki. A Mote Carlo

módszer lényege ebben a feladatban a következ®. Képzeljünk el egy

1×1

méter méret¶

dart táblát, és egy kört rajta, melynek átmér®je 1 méter. Ezek után képzeljük el, hogy jó sok dart nyilat dobunk a táblába. Ezek után feltehetjük azt a kérdést, hogy mi annak

a valószín¶sége, hogy egy dart nyíl ha eltalálta a táblát a körön belül van. (Ez ugyanaz, mint 1 minusz annak a valószín¶sége, hogy egy dartnyíl eltalálta a táblát de nem találta

el a kört.) A válasz egyszer¶ : mivel a véletlenszer¶ dart dobások találati aránya arányos 2 a területtel, így el kell osztanunk egymással a darttábla területét (1m ) és a kör területét 2 2 (r × π = π/4m ). De ugyanezt a választ empirikus módon is megtehetjük, kísérlet útján. A két megközelítés egymáshoz közeli értékeket kell, hogy adjon. Ha megszámoljuk a kék és piros pontokat a 4.1 ábrán a kisebbik négyzeten belül, akkor


www.tankonyvtar.hu


DR AF T

28

4.1. ábra. Simulating a dart shot

a 140 és a 40 értékeket kapjuk saját számításunk szerint. Tehát összesen 180 dartnyíl találta el ezt a kisebbik négyzetet, melyb®l 140 találta el a negyedkört. A számított arány meglep®en közeli értéket fog adni

π -hez : π≈

Tehát a

π

140 × 4 = 3.11 180

számítását végz® Monte Carlo módszer dartnyíl dobások-at generál, és

kiszámolja a körön belüli találatok arányát az összes dobáshoz képest. A könnyebb programozás végett általában egy

2×2

tábla negyedét szokás használni, amin egy negyedkör

található 1 rádiusszal. A program két koordinátát generál (x és

y melynek értékei 0 és 1 p x2 + y 2 ). ha a távolság

között lesznek), amihez kiszámolja az origótól vett távolságát (

kisebb vagy egyenl® 1-el, akkor ez egy körön belüli találat. Ha a távolság nagyobb, akkor körön kívüli találatként számoljuk.

4.2.1. A soros program A program f® része egyértelm¶. Véletlen

x és y

értékeket generálunk nem szabad elfelej-

teni a double típusra kényszerítést, mivel az egészek között elvégzend® osztás különbözik a lebeg®pontos osztástól ! és kiszámoljuk az origótól vett távolságot (pontosabban a

www.tankonyvtar.hu



29

négyzetét), és megnézzük, hogy ez kisebb-e 1-nél. Nincs szükségünk gyökvonásra, mert egyszer¶bb a két oldal négyzetével számolni. Miután összeszámoltuk az 1-nél kisebb távolságú pontok számosságát ezt a számot elosztjuk az összes pár számosságával és megkapjuk

π/4

közelít® értékét.

const long long iternum=1000000000 ; long long sum=0 ;

srand((unsigned)time(0)) ; for(long long i=0 ;i
DR AF T

01 : 02 : 03 : 04 : 05 : 06 : 07 : 08 : 09 : 10 : 11 : 12 :

}

Pi=(4.0*sum)/iternum ;

4.2.2. A párhuzamos program

A program párhuzamosítása viszonylag egyszer¶. Mivel a véletlen számok generálása, és azok összeszámolása melyek a körre es® pointokat jelképeznek teljesen független felada-

tok, így ezeket megkötés nélkül más-más folyamatokhoz rendelhetjük. A program végén a szolgák a saját lokális összegüket a mester folyamatnak küldik el, aki fogadja és összegzi ezeket. Csak a végs®

π számításánál kell gyelnünk : az iternum helyett az iternum*nproc iternum számú pontpárt

értékkel kell számolnunk, hiszen minden egyes folyamat egyesével generált.

01 : 02 : 03 : 04 : 05 : 06 : 07 : 08 : 09 : 10 : 11 : 12 : 13 :

// A Pi konstans kiszamitasa Monte-Carlo modszerrel

#include #include #include #include <math.h> #include <mpi.h> using namespace std ;

int

main(int argc, char **argv){

int id, nproc ; MPI_Status status ; double x,y, Pi, error ;


www.tankonyvtar.hu

30

long long allsum ;

const long long iternum=1000000000 ; // MPI inditasa :

MPI_Init(&argc, &argv) ; // Sajat rangunk lekerdezese :

MPI_Comm_rank(MPI_COMM_WORLD, &id) ; // A processzorok osszletszamanak lekerdezese :

MPI_Comm_size(MPI_COMM_WORLD, &nproc) ;

DR AF T

14 : 15 : 16 : 17 : 18 : 19 : 20 : 21 : 22 : 23 : 24 : 25 : 26 : 27 : 28 : 29 : 30 : 31 : 32 : 33 : 34 : 35 : 36 : 37 : 38 : 39 : 40 : 41 : 42 : 43 :


srand((unsigned)time(0)) ; cout.precision(12) ; long long sum=0 ;

for(long long i=0 ;i
}

//Szolga :

if(id !=0){ MPI_Send(&sum, 1, MPI_LONG_LONG, 0, 1, MPI_COMM_WORLD) ; }

//Mester :

else{

allsum=sum ;

for(int i=1 ;i
MPI_LONG_LONG, MPI_ANY_SOURCE, 1,

MPI_COMM_WORLD,

44 : 45 : 46 : 47 : 48 : 49 : 50 : 51 : 52 : 53 :

&status) ;

allsum+=sum ;

}

//Pi kiszamitasa, math.h-s Pi-vel valo osszevetes Pi=(4.0*allsum)/(iternum*nproc) ; error =

fabs( Pi-M_PI ) ;

cout<<"Pi :

\t\t"<<M_PI<<endl ; by MC : \t"<
www.tankonyvtar.hu



31

DR AF T

54 : } 55 : 56 : // MPI leallitasa : 57 : MPI_Finalize() ; 58 : return 0 ; 59 : } 60 : 4.2.3. Redukciós m¶veletek

Mivel részlegesen el®készített adatok összegy¶jtése kifejezetten gyakori feladat a párhu-

zamos programozásban így speciális redukciós függvényeket használhatunk erre az MPI

programokban. A redukció azt jelenti, hogy összegy¶jtjük az adatokat és egy adott m¶veletet végzünk el rajta. Hasonlóan az üzenetszóráshoz (broadcast) megadjuk a gyökér folyamatot, amely összegy¶jti az adatokat, és megadjuk a m¶veletet, amelyet a gyökér végrehajt az adatokon.

A redukció formális deníciója:

int MPI_Reduce( void *sendbuf, //Küld® puffer címe void *recvbuf, //Fogadó puffer címe (csak a gyökérfolyamatnál érdekes) int count, //Elemek száma a küld® pufferben MPI_Datatype datatype, //A pufferben lév® elemek adattípusa MPI_Op op, //Redukció m¶velet int root, //A küld® processzus rangja MPI_Comm comm //Kommunikátor )

Mivel a gyökér folyamat ugyanúgy küld mint fogad, így az ® esetében szükségünk van a

küld® puert®l különböz® fogadó puerre. Bár csak ® használja a fogadó puert formálisan minden hívó megadja azt. A gyökér rangja, az küldend® adatok számossága, az MPI adattípus és a kommunikátor mind azonos a korábbiakban már bemutatott üzenetküld®, üzenetfogadó illetve üzenetszóró (broadcast) függvények használatához. Mivel redukciót hajtunk végre így a fogadó puer adatainak számossága mindig 1, így ezt nem kell külön


www.tankonyvtar.hu

32


megadnunk. Az egyetlen új paraméter a redukciós m¶velet. Ismételten, ahogyan azt az adattípusoknál már láthattuk, kompatibilitási okokból az MPI saját operátorokat határoz meg. A részletes lista : maximum minimum szumma szorzás logikai ÉS bináris ÉS logikai VAGY

DR AF T

MPI_MAX MPI_MIN MPI_SUM MPI_PROD MPI_LAND MPI_BAND MPI_LOR MPI_BOR MPI_LXOR MPI_BXOR MPI_MAXLOC MPI_MINLOC

bináris VAGY logikai XOR

bináris XOR

MAX érték és pozíció MIN érték és pozíció

Allreduce

A redukciós függvény egy változata az

MPI_Allreduce

amely a redukció után vissza-

küldi az eredményt az összes folyamatnak. A szintaxis megegyezik az

MPI_Reduce függvény

szintaxisával azzal az egy különbséggel, hogy nem kell megneveznünk a gyökér folyamatot. A függvény használatára kés®bb fogunk példát mutatni.

4.2.4.

π

számítása Monte Carlo módszerrel redukciós függvények

segítségével

Az el®bb bemutatott redukciós függvény segítségével egyszer¶síthetünk az el®z® példánkat. A

sum

összegy¶jtött összegek összege. Az MPI m¶velet amit használunk az

01 : 02 : 03 : 04 : 05 : 06 : 07 : 08 : 09 : 10 : 11 : 12 :

allsum MPI_SUM.

változó egy lokális összeg a körön belüli találatokra, az

változó az

//A Pi konstans kiszamitasa Monte-Carlo modszerrel

#include #include #include #include <math.h> #include <mpi.h> using namespace std ;

int


int id, nproc ; MPI_Status status ;

www.tankonyvtar.hu



double x,y, Pi, error ; long long allsum ;

const long long iternum=1000000000 ; // MPI inditasa :

MPI_Init(&argc, &argv) ; // Sajat rangunk lekerdezese :

MPI_Comm_rank(MPI_COMM_WORLD, &id) ; // A processzorok osszletszamanak lekerdezese :

DR AF T

13 : 14 : 15 : 16 : 17 : 18 : 19 : 20 : 21 : 22 : 23 : 24 : 25 : 26 : 27 : 28 : 29 : 30 : 31 : 32 : 33 : 34 : 35 :

33

MPI_Comm_size(MPI_COMM_WORLD, &nproc) ; srand((unsigned)time(0)) ; cout.precision(12) ; long long sum=0 ;

for(long long i=0 ;i
//adjuk ossze a lokalis osszegeket a mester \emph{allsum}-jaba

MPI_Reduce(&sum,

&allsum, 1, MPI_LONG_LONG, MPI_SUM, 0,

MPI_COMM_WORLD) ;

36 : 37 : //A mester ki irja a szamitott Pi-t. 38 : if(id==0){ 39 : //Pi szamitasa, osszehasonlitasa a math.h-belivel 40 : Pi=(4.0*allsum)/(iternum*nproc) ; 41 : error = fabs( Pi-M_PI ) ; 42 : cout<<"Pi : \t\t"<<M_PI<<endl ; 43 : cout<<"Pi by MC : \t"<

www.tankonyvtar.hu

34

Bevezetés az MPI programozásba példákon keresztül 4.1. táblázat. Dupla változó típusok

MPI_FLOAT_INT MPI_DOUBLE_INT MPI_LONG_INT MPI_2INT MPI_SHORT_INT MPI_LONG_DOUBLE_INT

float és int double és int long és int int pár short és int long double és int

DR AF T

Minimum és maximum pozíció

Létezik két speciális redukálási m¶velet ami dupla értékekkel dolgozik. A a

MPI_MINLOC.

MPI_MAXLOC

és

Az adatpár els® tagját kezeljük úgy, mint amit össze kell hasonlítani a

szétszórt többi adatokkal. A második érték pedig egy index, azaz ez mutatja majd az eredményadat pozícióját. A

MPI_MAXLOC

függvény deníciója :

u v w ? = , i j k

ahol

w = max(u, v),

és

  i min(i, j) k=  j

A

MPI_MINLOC

if

if

if

u>v u=v u

u v w ? = , i j k

ahol

w = min(u, v),

és

  i min(i, j) k=  j

if

if

if

uv

Speciális dupla adattípusok A fent leírt

MPI_MAXLOC

és

MPI_MINLOC

függvények dupla adattípusokat használnak. A

lenti táblázatban az MPI beépített dupla változó típusait láthatjuk. Ahhoz, hogy használni tudjuk ®ket, el®ször konstruálni kell egy struktúrát, mint a Dijkstra legrövidebb út algoritmusának példájában is tesszük majd. Az függvényben a küld® puer

www.tankonyvtar.hu

p

lesz, a fogadó puer

p_tmp

MPI_Allreduce

lesz.



01 : 02 : 03 : 04 : 05 : 06 : 07 :

35

struct{ int dd ; int xx ; } p, tmp_p ; p.dd=tmp ; p.xx=x ;

MPI_Allreduce(&p,

&tmp_p,

1,

MPI_2INT,

MPI_MINLOC,

MPI_COMM_WORLD) ;

DR AF T

08 : 09 : 10 : 11 :

x=tmp_p.xx ;

D[x]=tmp_p.dd ;

4.3. Gyakorló feladatok

A következ® részben néhány egyszer¶bb gyakorlófeladatot mutatunk be az olvasó számára.

Ezek bátran ajánlhatóak diákoknak, órai gyakorló feladatként és kisebb házi feladatként egyaránt. Els®ként próbálják meg a legkézenfekv®bb módon párhuzamosítani a problémákat, és ne is gondolkozzanak hatékonysági kérdéseken. Ajánljuk, hogy mindig hasonlítsák össze a párhuzamos program eredményeit és kimenetét a soros verzióval, hogy láthas-

sák, vajon nem hibázik-e a párhuzamos megoldás. Igen gyakori, hogy els®re nem sikerül

helyesen a párhuzamosítás még a legegyszer¶bb esetekben is, mivelhogy a párhuzamos programozás igencsak más gondolkodást igényel.

4.3.1. Mátrix-vektor szorzás

Els® feladatnak a mátrix-vektor szorzás párhuzamosítását ajánljuk. Els®nek egy soros program elkészítését javasoljuk, amivel kisebb mátrixokat és vektorokat szoroznak össze.

Ezek után próbálják meg párhuzamosítani a programot az elemek összegzése fejezetrész megoldásához hasonlóan.

A mátrix-vektor szorzás deníciója a következ® :



a11 a12 . . . a1n  a21 a22 . . . a2n  Ax =  .. . . . . . .  . . . . am1 am2 . . . amn



  x1 a11 x1 + a12 x2 + · · · + a1n xn   x2   a21 x1 + a22 x2 + · · · + a2n xn      ..  =  . .  .   . xn am1 x1 + am2 x2 + · · · + amn xn

    

4.3.2. Mátrix-mátrix szorzás A második feladat a mátrix-mátrix szorzás párhuzamosítása.


www.tankonyvtar.hu

36

Bevezetés az MPI programozásba példákon keresztül A mátrixok szorzásánál az els® mátrix sorainak elemeit szorozzuk a második mátrix

megfelel® oszlopainak elemeivel.

n×m és m×p mátrix, akkor azok szorzását a következ®képpen végezzük :     A11 A12 · · · A1m B11 B12 · · · B1p  A21 A22 · · · A2m   B21 B22 · · · B2p      A =  .. , B =   .. . . . . , .. .. . .  . .   .  . . . . . . . An1 An2 · · · Anm Bm1 Bm2 · · · Bmp

Ha adott két

ahol az A mátrix oszlopainak száma kötelez®en egyenl® kell, hogy legyen a B mátrix

DR AF T

m. Az AB mátrixszorzás eredménye egy n×p méret¶   (AB)11 (AB)12 · · · (AB)1p  (AB)21 (AB)22 · · · (AB)2p    AB =  .. , . . .. . .  .  . . . (AB)n1 (AB)n2 · · · (AB)np

sorainak számával, a fenti esetben ez mátrix :

ahol

AB

elemei a következ®ek :

(AB)ij =

m X

Aik Bkj .

k=1

4.3.3. Numerikus integrálás

Egy hasznos gyakorlat lehet néhány numerikus integrálási módszer párhuzamos megvalósítása. Ismételten azt ajánljuk, hogy egy soros programból induljanak ki, amit különféle

bemen® paraméterekre kipróbálnak. Figyeljenek oda, hogy a bemen® paraméterek minél szélesebb skálán mozogjanak, kezdve mondjuk egy konstans függvénnyel, például az

=1

f (x)=

függvénnyel, és utána bonyolultabb esetekre. Próbáljon ki különféle végpontokat, és

különböz® közbüls® pont-számosságot. Ha az eredmény jónak t¶nik, csak akkor próbál-

kozzon a párhuzamosítással. Maga a párhuzamosítás viszonylag egyszer¶, mivel mindegyik

módszer egymástól függetlenül számolható értékeket összegez, így tehát az egyedüli problémás pont a részfeladatok egyenletes elosztása lehet.

Az itt tárgyalt módszerek egydimenziós határozott integrál számításokra adnak meg-

oldást.

Téglalap módszer

Ebben a módszerben az integrálandó függvényt az intervallum tartományban

n

részre

osztjuk, és az eredeti függvényt olyan téglalapokkal helyettesítjük, melyeknek a magassága a részek kezd®értékének függvényértéke. A 4.2 ábra mutatja be ezt a módszert. Deníciószer¶en :

Z

b

f (x) dx ≈ h a ahol

h = (b − a)/N

www.tankonyvtar.hu

és

N −1 X

f (xn )

n=0

xn = a + nh. c Várady Géza, Zaválnij Bogdán, PTE

37

DR AF T


4.2. ábra. Téglalap módszer

A trapéz módszer

Ez a módszer hasonló az el®z®höz, de téglalapok helyett trapézokat használunk ahol a trapéz elejének a magassága a függvény azon pontjában vett értéke, és a trapéz végének

a magassága is az abban a pontban vett függvényérték. A 4.3 ábra mutatja be ezt a módszert.

A trapéz módszer deníciója egy trapézre :

Z

a

b

f (a) + f (b) . f (x) dx ≈ (b − a) 2

Ezeknek a trapézoknak a területét kell összeadnunk, hogy megkapjuk az integrál kö-

zelít® értékét.

4.3. ábra. Trapéz módszer


www.tankonyvtar.hu

38


Simpson szabály Ismételten részekre bontjuk a függvényt, de most a függvényt másodrend¶ polinomokkal helyettesítjük. A 4.4 ábra mutatja be ezt a módszert. A Simpson módszer deníciója egy szakaszra :

Z

b−a a+b f (a) + 4f + f (b) . f (x) dx ≈ 6 2

DR AF T

a

b

4.4. ábra. Simpson módszer

www.tankonyvtar.hu


5. fejezet

DR AF T

Alapvet® párhuzamosítási technikák

A párhuzamosítás alapvet® problémája nem is igazán maga az algoritmus, hanem a fel-

adat szétosztása rész-feladatokra. Sokféle módszer és eljárás ismert ebben a kérdésben, és a könyvünkben csak röviden tudjuk kifejteni ezt a kérdést. Els®dleges célunk ugyanis

bevezetés az MPI programozásba. Így tehát ennek az igencsak nagy kérdésnek a mélyebb

és részletesebb elemzése végett az olvasó számára könyvünk irodalomjegyzékében szerepl® m¶veket ajánljuk, f®képpen a [Gram2003] és a [Matt2005] könyveket. Sajnos ebben a kérdésben nincs királyi út, így alapvet®en minden egyes problémához különböz®képpen kell közelíteni, és végül magunknak kell megtalálnunk a megoldást.

A párhuzamosítás alapvet® célja az, hogy minél nagyobb gyorsulást érjünk el. Ahhoz,

hogy elérjük ezt a célt három különálló problémát kell kezelnünk.

Az els® probléma az, hogy miképpen tudjuk a részfeladatokat minél egyenletesebben el-

osztani a folyamatok között, melyek különböz® processzorokon futnak. Abban az esetben,

ha ez az elosztás nem egyenletes, egyes folyamatok jóval hosszabb ideig fognak futni, és a teljes futási id®t éppen ezeknek a folyamatoknak a futásideje fogja dominálni. Nézzünk

meg egy példát ! Vegyünk egy olyan feladatot, amit 100 részfeladatra tudtunk osztani, és a munkára 10 processzort, így 10 különálló folyamatot fogunk használni. Ha a részfeladatok ideje egyenletes és mindegyik folyamatnak 10 részfeladatot adunk, azaz az eredeti probléma egytizedét, akkor minden folyamat (nagyjából) egytized id® alatt fog befejez®dni, mint

az eredeti soros program. (Itt egyel®re nem foglalkozunk a párhuzamosítás egyéb kérdéseivel.) A gyorsulás tehát tízszeres (10) lesz. Ha az egyik folyamatnak 20 részfeladatot adunk, a többinek meg 9 illetve 8-at, akkor azok a folyamatok, akiknek kevesebb munkát adtunk

nagyjából fele annyi id® alatt fognak végezni mint az a folyamat, akinek 20 részfeladatot adtunk. Mivel az egész rendszer futási ideje a leghosszabb futási id®vel egyenl®, ezért a gyorsulás így ötszörös (5) lesz, ami egyértelm¶en rosszabb, mint az el®z® érték. Természe-

tesen ha tudjuk, hogy a részproblémák azonos súlyúak, akkor egyenletesen is fogjuk ®ket elosztani. De különböz® súlyú részproblémák eseten ezt nem tudjuk megtenni. Vagy el kell találnunk a problémák súlyának eloszlását el®re, vagy egyenletlen eloszlást kapunk. Ebben a részben ezzel a problémával fogunk foglalkozni. A második probléma az adatlokalitás problémája. Megosztott memóriájú rendszerek esetén (shared memory systems) ez egy alapvet®, problémás kérdés, mivel az a lehet®ség,


www.tankonyvtar.hu

40


hogy az adatokat bármikor könnyedén lehet olvasni és írni elrejti a probléma lényegét, miszerint vannak közelebb és távolabb lév® adatok. Ha a programozó nem veszi gyelembe ezt a sajátosságot könnyedén nagyságrendekkel lassabb programot kap, mint a soros verzió ! Ugyancsak ehhez a kérdéshez kapcsolódik a hatékony cache kezelés kérdésköre, hiszen a mai többprocesszoros rendszerek mind cache koherens rendszerek, azonban a koherencia fenntartása komoly lassulást is okozhat a számításokban. A cache koherencia kérdéskörében ajánljuk az olvasónak a [Sima1997] könyv idevágó fejezeteit. Az algoritmusok helyes tervezésének kérdésével a cache hatékony használatával a [Braw1989] könyv szolgál kifejezetten jó példákkal.

DR AF T

Az üzenetküldésen alapuló elosztott rendszerek (distributed systems) esetében a fen-

ti probléma egyszerre könnyebb és nehezebb. Könnyebb, mert nincs lehet®ség az adatok

közvetlen olvasására a másik számítógépr®l, így tehát az algoritmus mindig explicite -

gyelembe kell vegye ezt a sajátosságot. De ugyancsak nehezebb ugyanezen okból, hiszen nincs könny¶ lehet®ség az adatok olvasására. A programozónak minden esetben meg kell

terveznie az adatkommunikációt, kés®bb esetleg újragondolva és újratervezve. Ráadásul

talán a legnagyobb hátrány nem is a bonyolultabb programstruktúra megírása, hanem

a kommunikációs extra terhelés (overhead). Ha oda-vissza küldözgetjük folyamatosan az adatokat könnyen kapunk ismételten csak lassabb programot, mint a soros verzió. Végül mindig oda jut az ember, hogy egy pont után hiába von be még több processzort a fel-

adat megoldásába az eredmény nem hogy nem gyorsabb, hanem egyre lassabb program

lesz. Ezekben az esetekben a teljes program futásidejét már nem is a számítási sebesség,

hanem a kommunikáció határozza meg. Azaz minden esetben, amikor a feladatok szétosz-

tását tervezzük meg gyelembe kell vennünk az adatlokalitás kérdését, így minimalizálva a folyamatok közötti kommunikációt, úgy, hogy azok minél többet dolgozzanak lokális adatokon.

A harmadik probléma az algoritmikus többletmunka. Ide tartoznak azok a részek, me-

lyeket mindenképpen sorosan kell elvégeznünk és a párhuzamosítási költségek maguk. A soros részt semmiképpen sem tudjuk kikerülni. Mindig lesz a programnak olyan része

tipikusan a probléma felállításának, az adatok szétosztásának, eredmények összegy¶jtésének, a tesztek és ellen®rzések költsége melyeket nem lehetséges párhuzamosan elvégezni. Továbbá ide kell még számolnunk az MPI keretrendszer felállításának költségét is, hiszen

több száz folyamat elindítása egy elosztott rendszeren hosszú másodpercekig is letarthat.

Ha a probléma olyan, hogy egy PC-n néhány perc alatt megoldható, akkor valószín¶leg semmi okunk nincs rá, hogy egy szuperszámítógépet használjunk ugyanennek a problémának a megoldására, amely sokszor lassabb, nehézkesebb lesz, miközben maga a gép túlterheltebb.

5.1. Lehetséges feladatfelosztási módszerek

Ahogy azt láthattuk a párhuzamos algoritmusok tervezésének egyik kulcsmomentuma a feladat felosztása. Ekkor egy adott nagy problémát részfeladatokra osztunk fel, mely részfeladatokat hozzá tudjuk rendelni a különböz® számítási er®forrásokhoz. Ez semmiképpen

www.tankonyvtar.hu


5. fejezet. Alapvet® párhuzamosítási technikák

41

sem egyértelm¶ és könny¶ feladat, és ebben a fejezetben csak arra vállalkozunk, hogy nagy vonalakban bemutassunk néhány lehetséges eljárást. Els®ként látnunk kell, hogy az egyik központi kérdés az, hogy hány részre bontsuk fel magát feladatot. Mindezt úgy kell elvégeznünk, hogy az algoritmus tervezése közben nem tudhatjuk a folyamatok számát, hiszen az algoritmus különböz® esetekre kell, hogy m¶ködjön, és az aktuális szám csak futás közben d®l el. Els® megközelítésben úgy t¶nik, hogy a legjobb megközelítés éppen annyi részre szétszedni a feladatot, mint ahány folyamatunk van, de nem ez a megfelel® hozzáállás. Ha nem tudjuk biztosítani azt, hogy minden rész pontosan ugyanannyira számításigényes legyen, akkor ez a megközelítés biztosan egyen-

DR AF T

l®tlen elosztáshoz fog vezetni. Így valójában ha több részfeladatra bontjuk a problémát

jobban tudjuk kezelni az egyenl®tlenségeket. Értelemszer¶en sokkal-sokkal több részfel-

adat alkalmazása sem jó, hiszen azok nyilvántartása és ütemezése a hasznos számítási

feladattal összemérhet® er®forrást fog megkövetelni. Mindez azt jelenti, hogy általában a cél több, de nem sokkal több részfeladat megkonstruálása, mint ahány folyamatunk van.

Amikor felbontjuk a feladatot részfeladatokra néha a probléma maga önálló és különálló

feladatokból áll. Ezekben az esetekben beszélhetünk munkafolyamat párhuzamosításról.

Ebbe a kategóriába tartoznak például a sugárkövetéses (ray-trace) ábrázolási módszer vagy

a molekuladinamikai feladatok, ahol egy-egy sugárhoz vagy molekulához tartozó feladatok független feladatként értelmezhet®ek.

Másik esetben az algoritmus, amit használunk bontja fel a problémát kisebb felada-

tokra. Ilyenek az oszd-meg-és-uralkodj elv alapján dolgozó algoritmusok, mint például az összefésül®- vagy a gyorsrendezés. Ezekben az esetekben az így keletkez® feladatokat oszthatjuk ki különálló folyamatoknak.

Ismételten más esetekben a problémához tartozó adatok struktúrája olyan, ami a se-

gítségünkre van a feladat felosztásában. Sok tudományos-mérnöki számítás adatai a valós világ topológiai sajátosságait tükrözik, és ezekben az esetekben használhatjuk a geomet-

riai felbontás elvét. Ilyenkor általában az adott pontokhoz tartozó lokális számításokat a szomszédos pontokkal való adatcsere követ váltakozva. Ezek azok az esetek, ahol a beme-

n® adatok egy részén független számításokat végezhetünk legalábbis egy ideig , így itt

adatpárhuzamos módszerr®l beszélhetünk.

Megint csak más esetekben a felbontást nem térben, hanem id®ben végezhetjük el. Az-

az a bemen® adatokon el kell végeznünk egymás után több feladatot. Ilyenkor a különböz®

feladatokat rendeljük a különböz® folyamatokhoz és az adatokat mozgatjuk egyik folya-

mattól sorba a másikhoz ahogy a következ® feladatot el kell végezni rajta. Ez a cs®vezeték

(pipeline) struktúra. Jelfeldolgozási feladatok, vagy kötegelt grakai feldolgozás feladatai tartozhatnak ebbe a kategóriába.

Az olvasó különböz® példákat láthat majd könyvünk második részében. A legrövidebb

utak keresésének- illetve a gráfszínezés feladata, továbbá a sugárkövetés eset jó példái

a munkafolyamat párhuzamosításnak. A laphevítés egy geometriai felbontás, a lineáris egyenletrendszerek megoldása adatpárhuzamosításon alapuló eset. Miután elvi szinten eldöntöttük a felbontás módszerét még meg is kell valósítanunk azt. A következ® bekezdésekben néhány lehetséges módszert mutatunk erre. Ugyancsak el kell majd döntenünk, hogy a feladatok szétosztását statikus, el®re eldöntött, vagy dinamikus


www.tankonyvtar.hu

42


módon oldjuk majd meg, a program futása közben. Mindkét választásnak lehetnek ugyanis el®nyei.

5.2. Ciklusbontás (loop-splitting) Az egyik legegyszer¶bb módszere az adatok felbontásának a ciklusbontás. Ilyenkor az adatok egy tömbben vannak (vagy úgy tekintünk rájuk, mintha tömbben lennének), és minden egyes folyamat az összesen

nproc

folyamatból az

nproc-adik

adatot veszi sorra a

DR AF T

tömbb®l. Konkrétan :

1 : //N : elemek szama 2 : //id : processzus rangaj 3 : //nproc : az osszes processzus 4 : //a[] : munkaeirok tombje 5 : for(int i=id ;i
szama

Ebben az esetben minden egyes folyamat a tömb egy elemét veszi ki, kezdve a folyamat

rangjával, azaz az

id-val

megegyez® sorszámú elemmel, és utána

nproc

lépéseket végez.

A módszert az el®z® fejezet egyik példaprogramján, az elemek összegzése feladaton

mutatjuk be. Ciklusbontással a program így néz ki :

01 : 02 : 03 : 04 : 05 : 06 : 07 : 08 : 09 : 10 : 11 : 12 : 13 : 14 :

// parhuzamos osszeg szamitasa // 1-tol 10000-ig // loop splitting


szama

15 :


int id, nproc ;

int sum,accum,startval,endval ; MPI_Status status ;

MPI_Init(&argc,&argv) ; MPI_Comm_size(MPI_COMM_WORLD,

&nproc) ;

MPI_Comm_rank(MPI_COMM_WORLD,

&id) ;

// osszes csomopont // sajat azonositonk

(rangunk) lekerdezese

www.tankonyvtar.hu



43

DR AF T

16 : sum = 0 ; // sum lenullazasa 17 : //startval = 10000*id/nproc+1 ; 18 : //endval = 10000*(id+1)/nproc ; 19 : for(int i=1+id ;i<=10000 ;i+=nproc) // loop splitting 20 : sum = sum + i ; 21 : cout<<"I am the node "<
sa igen egyszer¶ feladat, így tehát igen kevés változtatással élve tudjuk párhuzamosítani a programunkat. Másodszor, amikor minden

nproc-ik

elemet veszünk sokszor egyenlete-

sebb terheléselosztást fog jelenteni a feladatok nehézsége szempontjából mint amit más módszerek eredményeznek. Ugyanis a részfeladatok a feladat különböz® részeiben gyakran más-más komplexitásúak lesznek. Mondjuk az elején vannak a könnyebb problémák, amik

egyre bonyolultabbak és nehezebbek lesznek a végére. Ebben az esetben a ciklusbontás igen jó terheléselosztást fog eredményezni. De vigyázzunk, lehetnek ellenpéldák is, mond-

juk amikor a páros sorszámú feladatok nehezebbek a páratlan sorszámúaknál és páros

számú processzorra használunk ciklusbontást. Ilyenkor igen egyenl®tlen lesz az elosztott feladatok nehézsége.

5.3. Blokkos ütemezés

A ciklusbontással áll szemben az a megoldás, ami a legtöbb programozó számára természetesebbnek t¶nik els® ránézésre, a blokkos felbontás. Ebben az esetben a feladathoz tartozó adatokat blokkokra bontjuk.


N

elem és

nproc

folyamat esetén az els®

N/nproc

www.tankonyvtar.hu

44


elemet rendeljük hozzá az els® folyamathoz, a második részt a másodikhoz, és így tovább. Ha ismételten ciklusba rendezzük a munkát, akkor els®ként a ciklus kezd® és végpontját, a

startvalue

és az

endvalue

értékét kell meghatároznunk. A módszert demonstráló

programrészlet :

DR AF T

1 : //N : elemek szama 2 : //id : processzus rangaj 3 : //nproc : az osszes processzus szama 4 : //a[] : munkaeirok tombje 5 : int startval = N*id/nproc ; 6 : int endval = N*(id+1)/nproc ; 7 : for(int i=startval ;i<endval ;++i) 8 : do_work(a[i]) ; 9:

A módszer alkalmazásához ismételten beidézzük a már bemutatott elemösszegzési fel-

adatot :

01 : 02 : 03 : 04 : 05 : 06 : 07 : 08 : 09 : 10 : 11 : 12 : 13 : 14 : 15 : 16 : 17 : 18 : 19 : 20 : 21 : 22 : 23 :

// az osszegzes parhuzamos szamitasa // 1-tol 10000-ig



int id, nproc ;

int sum,startval,endval,accum ; MPI_Status status ;

MPI_Init(&argc,&argv) ;

// osszes csomopont szamanak lekerese

MPI_Comm_size(MPI_COMM_WORLD, &nproc) ; // sajat csomopontunk rangja

MPI_Comm_rank(MPI_COMM_WORLD, &id) ; sum = 0 ; // sum nullazasa

startval = 10000*id/nproc+1 ; endval =

10000*(id+1)/nproc ;

for(int i=startval ;i<=endval ;++i) sum = sum + i ; cout<<"I cout<<

am the node "<< id ; " ; the partial sum is : "<<

www.tankonyvtar.hu

sum<<endl ;



if(id !=0) //a szolgak kuldik vissza a reszeredmenyeket MPI_Send(&sum,1,MPI_INT,0,1,MPI_COMM_WORLD) ; else //id==0 ! a mester a reszosszegeket kapja for(int j=1 ;j
sum yet is : "<<sum<<endl ;

}

if(id == 0)

DR AF T

24 : 25 : 26 : 27 : 28 : 29 : 30 : 31 : 32 : 33 : 34 : 35 : 36 :

45

cout <<

"The sum from 1 to 10000 is : "

MPI_Finalize() ;

<< sum << endl ;

}

A ciklusbontás és blokkos felbontás közötti különbség igen érdekes kérdés. Már említet-

tük, hogy a ciklusbontás sokszor egyenletesebb elosztást eredményezhet, másfel®l viszont

az a ciklus, ami egyesével lépked kevesebb számítást végez a léptetéshez, így lehet egy árnyalatnyival gyorsabb. Természetesen ez a különbség az esetek túlnyomó többségében elhanyagolható különbséget jelent.

Mégis, egyes esetekben nem kerülhetjük el a blokkos ütemezést. Ha a részfeladatok

kapcsolódnak egymáshoz és közöttük kötelez® kommunikáció zajlik ami az egymásutániságra épül, akkor nem alkalmazhatunk ciklusbontást, ami nagyságrendekkel megnövelné a folyamatok közötti kommunikációt. A mérnöki modellezés esetei, amik a geometriai de-

kompozíció elvére épülnek, kifejezetten ilyen típusú esetek. A kérdést részletesen elemezzük

majd a könyv második részében bemutatott példák közül a laphevítés példáján keresztül.

5.4. Önütemezés

Szemben az eddig bemutatott lehet®ségekkel, amikor a munkákat statikusan, el®re eldön-

tött módon rendeljük az egyes folyamatokhoz, lehetséges még a dinamikus hozzárendelés alkalmazása is.

Az egyik jól ismert módszer erre a mester-szolga munkamegosztás, vagy ahogy más

szakirodalomba nevezik a postaókelv.

Adott egyfel®l a mester folyamat, aki a munkák kiadásának és elvégzésének könyvelésé-

ért felel. A szolga folyamatok a mestert®l kérnek munkát, és neki jelzik, amikor végeztek vele. Miután visszaküldték az eredményt új munkát kérnek. Amikor munkák készlete kifogy, azaz nem maradt már több elvégezend® munka, a mester folyamat válaszként terminálásra szólítja fel a szolga folyamatot. A módszert szemléltet® hiányos alapprogram a következ® lehet :


www.tankonyvtar.hu

46


DR AF T

01 : //N : elemek szama 02 : //id : a processzus rangja 03 : //a[] : munkaleirok tombje 04 : 05 : if(id==0){//Mester processzus 06 : int id_from ; 07 : unit_result_t ANSWER ; 08 : for(int i=0 ;i
1,...) ;

Láthatjuk a program hiányosságait, hiszen nincs kezdés és befejezés ebben a kérdez-

válaszol beszélgetésben. Ezeket ezen felül kell megírni. Ugyancsak fontos észrevenni a szo-

ros kötöttséget a kérdések és válaszok sorrendjében. Ha más sorrend lenne, akkor felléphetne a halálos ölelés problémája, amit a harmadik fejezetben már tárgyaltunk.

Ugyancsak rendkívül fontos, hogy megkülönböztessük a különböz® üzeneteket. Ezt az

üzenetek címkézésével oldjuk meg, miszerint különböz® funkciójú üzenetekhez más-más címkét rendelünk. Ez is alapvet® fontosságú, hogy hibamentes programot tudjunk írni.

Abból a célból, hogy ezt a módszert teljességében bemutathassuk egy egyszer¶ de teljes keretprogramot amely a mester-szolga kommunikációt valósítja meg, habár konkrét munkák nélkül. A program fejlécében a kommunikációs címkéket deniáljuk, azaz a címkét ami a munkát jelzi illetve a címkét ami a terminálást jelzi a szolgáknak. Ugyancsak itt deklaráljuk a

www.tankonyvtar.hu



47

függvényeket, amiket használni fogunk.

// http ://www.lam-mpi.org/tutorials/one-step/ezstart.php

#include #include <mpi.h>

using namespace std ; const int WORKTAG=1 ; const int DIETAG=2 ; typedef double unit_result_t ; typedef double unit_of_work_t ;

DR AF T

001 : 002 : 003 : 004 : 005 : 006 : 007 : 008 : 009 : 010 : 011 : 012 : 013 : 014 : 015 : 016 : 017 : 018 : 019 : 020 : 021 :

/* Lokalis fuggvenyek

*/

master(void) ; slave(void) ; unit_of_work_t get_next_work_item(void) ; void process_results(unit_result_t result) ; unit_result_t do_work(unit_of_work_t work) ;

void void

int main(int argc, char **argv){

--- masterslave.cpp ---

A

main()

függvény lesz az, ami elkezdi és befejezi az MPI keretrendszert, és ami

megkülönbözteti egymástól a mester és a szolga folyamatok munkáját. A mester folyamat a

master()

függvényt fogja meghívni, a szolga folyamat a

slave()

függvényt.


018 : unit_result_t do_work(unit_of_work_t 019 : 020 : 021 : int main(int argc, char **argv){ 022 : int myrank ; 023 : 024 : /* MPI inicializalasa*/ 025 : 026 : MPI_Init(&argc, &argv) ; 027 :


work) ;

www.tankonyvtar.hu

48


/* sajat azonositonk lekerdezese az alapkommunikatorban */

MPI_Comm_rank(MPI_COMM_WORLD, &myrank) ; if (myrank == 0) { master() ; } else { slave() ; }

DR AF T

028 : 029 : 030 : 031 : 032 : 033 : 034 : 035 : 036 : 037 : 038 : 039 : 040 : 041 : 042 : 043 : 044 :

/* MPI leallitasa*/

MPI_Finalize() ; return 0 ;

}

void master(void){


A

master()

függvény kifejezetten hosszú, így három részben fogjuk bemutatni és ele-

mezni. Az els® részben a mester lekérdezni a

MPI_COMM_WORLD

világunk méretét, azaz

pontosan hány folyamat is fut összesen. Ezek után kiszámolja a következ® munkát, amit el kell végezni :

work=get_next_work_item();,

és elküldi az els® munkát minden egyes

szolga folyamatnak.


041 : } 042 : 043 : 044 : void master(void){ 045 : int ntasks, rank ; 046 : unit_of_work_t work ; 047 : unit_result_t result ; 048 : MPI_Status status ; 049 : 050 : /* Lekerdezzuk hany processzusunk van osszesen az 051 : alap kommunikatorban */ 052 : 053 : MPI_Comm_size(MPI_COMM_WORLD, &ntasks) ; 054 :

www.tankonyvtar.hu



49

DR AF T

055 : /* A szolgaknak kikuldjuk a feladat egy reszet */ 056 : 057 : for (rank = 1 ; rank < ntasks ; ++rank) { 058 : 059 : /* Keresseuk meg a kovetkezo adag munkat */ 060 : 061 : work = get_next_work_item() ; 062 : 063 : /* Minden rangu szolganak kuldjuk el */ 064 : 065 : MPI_Send(&work, /* uzenet puer */ 066 : 1, /* egy adat */ 067 : MPI_INT, /* az adat integer */ 068 : rank, /* celprocesszus rangja */ 069 : WORKTAG, /* felhasznaloi uzenet tag */ 070 : MPI_COMM_WORLD) ; /* alapertelmezett kommunikator 071 : } 072 : 073 : /* Ciklus fut amig nem lesz tobb elvegzendo 074 : feladat */

*/


A mester folyamat f® ciklusa abból áll, hogy el®ször fogadja a szolgáktól a választ

amikor azok végeztek a kit¶zött feladattal. Utána kiszámolja a soron következ® feladatot

(amíg van még elvégezend® feladat a feladatok készletében), és elküldi ezt a feladatot a szolgának, aki az el®bb választ küldött.


071 : } 072 : 073 : /* Ciklus fut amig nem lesz tobb elvegzendo 074 : feladat */ 075 : 076 : work = get_next_work_item() ; 077 : while (work != NULL) { 078 : 079 : /* Egy szolgatol eredmenyeket kapunk */ 080 : 081 : MPI_Recv(&result, /* uzenet puer 082 : 1, /* egy adat */


*/

www.tankonyvtar.hu

50


/* double real tipussal */

MPI_DOUBLE,

/* fogadunk valamely kuldotol

MPI_ANY_SOURCE,

/* barmilyen tipusu uzenet

MPI_ANY_TAG,

MPI_COMM_WORLD,

*/

*/

/* alapertelmezett kommunikator

*/

/* informacio a kapott uzenetrol */

&status) ;

/* A szolganak uj munkareszt kuldunk */

MPI_Send(&work,

/* uzenet puer */

DR AF T

083 : 084 : 085 : 086 : 087 : 088 : 089 : 090 : 091 : 092 : 093 : 094 : 095 : 096 : 097 : 098 : 099 : 100 : 101 : 102 : 103 : 104 :

1,

/* egy adat */

MPI_INT,

/* adat integer tipus

*/

status.MPI_SOURCE, /* annak, akitol epp kaptunk */ WORKTAG,

/* felhasznaloi uzenet tag

MPI_COMM_WORLD) ;

*/

/* alapertelmezett kommunikator

*/

/* megkapjuk a kovetkezo munkaegyseget */ work =

get_next_work_item() ;

}

/* Nincs tobb munka, igy meg kell kapjuk a maradek eredmenyeket a szolgaktol */


Ha már nem maradt több elvégezend® munka a feladatkészletben a mester az utolsó

válaszokat kapja a szolgáktól, és válaszként terminálási címkét küld, amely hatására a szolga befejezi majd a m¶ködését.


101 : } 102 : 103 : /* Nincs tobb munka, igy meg kell kapjuk a maradek 104 : eredmenyeket a szolgaktol */ 105 : 106 : for (rank = 1 ; rank < ntasks ; ++rank) { 107 : MPI_Recv(&result, 1, MPI_DOUBLE, MPI_ANY_SOURCE, 108 : MPI_ANY_TAG, MPI_COMM_WORLD, &status) ; 109 : } 110 : 111 : /* Minden szolgat kileptetunk ugy, hogy a DIETAg

www.tankonyvtar.hu



MPI_COMM_WORLD) ;

DR AF T

112 : uzenetet kuldjuk nekik */ 113 : 114 : for (rank = 1 ; rank < ntasks ; ++rank) { 115 : MPI_Send(0, 0, MPI_INT, rank, DIETAG, 116 : } 117 : } 118 : 119 : 120 : void slave(void){

51


A szolga függvény viszonylag egyszer¶. Egy végtelen ciklus, amiben a szolga folya-

mat megkapja a következ® munkát, kiszámolja azt, és visszaküldi az eredményt. Másfel®l viszont ha a szolga terminálási címkéj¶ üzenetet kap, akkor befejezi a m¶ködését, azaz visszatér az ®t hívó

main()-be.


117 : } 118 : 119 : 120 : void slave(void){ 121 : unit_of_work_t work ; 122 : unit_result_t result ; 123 : MPI_Status status ; 124 : 125 : while (1) { 126 : 127 : /* A mestertol kapunk egy uzenetet */ 128 : 129 : MPI_Recv(&work, 1, MPI_INT, 0, MPI_ANY_TAG, 130 : MPI_COMM_WORLD, &status) ; 131 : 132 : /* Megvizsgaljuk a kapott uzenet tag-jet */ 133 : 134 : if (status.MPI_TAG == DIETAG) { 135 : return ; 136 : } 137 : 138 : /* Elvegezzuk a munkat */ 139 :


www.tankonyvtar.hu

52


result =

do_work(work) ;

/* Visszakuldjuk az eredmenyt */

MPI_Send(&result, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD) ; } }

DR AF T

140 : 141 : 142 : 143 : 144 : 145 : 146 : 147 : 148 : 149 :

unit_of_work_t get_next_work_item(void){


get_next_work_item(), a process_results(unit_result_t result) és do_work(unit_of_work_t work) függvények üresek, mivel ez csak egy keretprogram A

a

a

mester-szolga kommunikáció bemutatásához. Az olvasó ezekbe a függvényekbe írhatja be

a megfelel® feldolgozási és számítási programrészeket, és így egy jól m¶köd® programot kaphat arra az esetre, amikor ezt a párhuzamosítást lehet használni.


146 : 147 : 148 : 149 : 150 : 151 : 152 : 153 : 154 : 155 : 156 : 157 : 158 : 159 : 160 : 161 : 162 : 163 : 164 : 165 : 166 :

}

unit_of_work_t

get_next_work_item(void){

/* Toltsuk ki barmivel ami megfeleo,

hogy kiadjuk feladatnak egy szolganak */

}

void

process_results(unit_result_t result){

/* Toltsuk ki valamivel, ami az eredmeny visszadashoz szukseges lehet */

}

unit_result_t

do_work(unit_of_work_t work){

/* Toltsuk ki barmivel, ami szukseges a munka elvegzesehez es eredmenyt general */

www.tankonyvtar.hu



53

5.5. A dinamikus terheléselosztás más eszközei Véleményünk szerint az önütemezésen alapuló terhelésmegosztás egy kifejezetten jó módszer. De más módszerek is ismertek a szakirodalomban. Az egyiket munkalopásnak (Work Stealing) hívják. Ez a megközelítés el®ször egy statikus munkamegosztást végez a feladatok között. Amikor egy folyamat kifogy a hozzá rendelt munkákból, akkor ellop egy másik, leterheltebb folyamattól egy olyan munkát, amibe az még nem kezdett bele. Miközben az, hogy a program elején egy statikus munkamegosztást alkalmazunk sok

DR AF T

el®nyt hordoz, a munkalopás jóval bonyolultabb programja igencsak megnehezíti ennek a módszernek a megírását. Így tanulási szempontból mindenképpen az önütemezést ajánljuk inkább.

5.6. Számítási hálók

Sok problémánál, a számítási feladat felosztása alapból adott (pl. mátrixok). Egyes feladatoknál, ez nem adott, az objektumainkat magunknak kell valamilyen struktúrába osztani. Az alap ötlet az, hogy a komplex felületeket, formákat és testeket kis darabokra bontsuk,

azaz komplex egyenletrendszereket kicsi, egyszer¶ egyenletekb®l építsük fel. A tudomány manapság elképzelhetetlen nagy számítások nélkül. Ezek a számítások gyakran támaszkodnak parciális dierenciálegyenletekre. A valóságban ezen egyenletek pontos, analitikus

megoldása legtöbbször nem kivitelezhet®. Elterjedtebb, hogy a megoldást valamilyen kö-

zelít® módszerrel, numerikus módon találjuk meg. A dierenciálegyenletek esetében a véges elemes módszer (Finite Element Method FEM) egy jó numerikus közelítési eljárás. A FEM hasznos a folyadékáramlás, h®terjedés, mechanikai er®hatások, akár elektromos

hullámterjedés szimulálására. A módszer egyik f® érdekessége önmagában is hatalmas tématerület : hogyan végezzük el a felosztást, dekompozíciót ? Az egyik módszer, amelyik

adja magát bár nem túl eektív, a pontonkénti felosztás, ahol egy hatalmas, n-dimenziós ponthalmaz reprezentálja a teljes jelenetet. Ebben az esetben több kérdés is felmerül : fel-

bontás, végtelen elemszám és a szükségesség. Ezzel a módszerrel hatalmas számításigény¶,

de vélhet®en felesleges munkát állítanánk magunknak. Egy jobb ötlet, ha az objektumunkat véges számú, valamilyen kiterjedéssel rendelkez® részobjektumra bontjuk. Ezt változó

méretekkel is kivitelezhetjük, így az érdekesebb részek kisebb elemekb®l, míg a kevésbé érdekes részek elnagyoltan szerepelhetnek.

A particionálást al-hálók (sub-mesh) generálásával végezhetjük el, melyek az eredeti

objektumunk formáját adják ki. A hálónk (mesh v. grid) 2D-ben háromszögekb®l vagy négyszögekb®l állhat, 3D-ben pedig tetrahedronokból, vagy négyzetalapú hasábokból. A továbbiakban maradjunk két dimenzióban. Az eredeti problémától függ®en, a háromszö-

geinknek speciális tulajdonsággal kell rendelkeznie, amit különböz® hálógeneráló algoritmusokkal érhetünk el. A hálózatgenerálás sokkal több id®be telhet, mint maga a FEM modellezés, így egyértelm¶, hogy a párhuzamosítás sokat segítene ebben.


www.tankonyvtar.hu


DR AF T

54

5.1. ábra. Egyenletesen elosztott háló és partíciók (Iványi P, Radó J[Ivanyi2013])

www.tankonyvtar.hu


55

DR AF T


5.2. ábra. Adaptív háló, particionálás és domének (Iványi P, Radó J[Ivanyi2013])

Több hálógeneráló stratégia létezik. A kezdeti állapot alapján két f® típust különböz-

tetünk meg. Az egyik féle hálógenerálás pontok halmazából indul ki, ahol ezeknek a pontoknak összekötöttnek kell lenniük, mégpedig egyenletes háromszögeket vagy négyszögeket

alkotva. Erre egy tipikus példa a Delanuay-háromszögelés. Egy másik féle hálógenerálás bels® pontok nélküli. A geometriánk egy sziluett, egy határoló forma, amit fel szeretnénk tölteni adott méret¶ és paraméter¶ háromszögekkel. Erre egy egyszer¶ hálózatgeneráló algoritmus az el®re növekv® (Advancing Front) módszer.


www.tankonyvtar.hu

56


5.6.1. A Delaunay-háromszögelés rövid leírása [Ivanyi2013] A módszer egy ponthalmazból indul. Ezeket a pontokat kell összekötnünk élekkel úgy, hogy az eredmény egy többé-kevésbé szabályos, nem átlapoló háromszögekb®l álló struktúra legyen. A pontos szabály az, hogy minden háromszögre igaz kell, hogy legyen, hogy egy másik pont sincs a háromszög körülíró körében. Ez a szabály maximálja a háromszögek szögeit, így adva egy számításhoz alkalmas szerkezetet.

DR AF T

5.6.2. Az Advancing Front módszer rövid leírása [Ivanyi2013]

A módszer csak egy határvonalból indul, amely pontokból és ezeket összeköt® élekb®l

áll. Ezt a formát hálózatot alkotó háromszögekb®l kell kitölteni. Az ötlet az, hogy a kezdeti

élek bels® oldalaira háromszögeket helyezünk el, majd ezek távoli csúcsait összekötjük. Az

így kapott újabb körvonalon ezt újra és újra megtesszük. Ez csíkokat generál a forma belsejében, és végül az utolsó csík már szinte összeér. Itt pár keresztbekötéssel befejezzük a lefedést.

5.6.3. Párhuzamos hálógenerálás

A FEM azt sugallja, hogy a párhuzamosítást itt hatékonyan tudnánk használni, mivel

nagy számú elemmel dolgozunk. A megfelel® elemeket az egyes munkásoknak kiosztva felgyorsíthatjuk az eljárásainkat. A hálózatgenerálás és FEM jó alanyai a párhuzamosí-

tásnak, de a probléma nem triviális. A hatékony munkához megfelel® particionálás kell. Ha az al-hálókat legeneráltuk, ezeket össze kell olvasztani. Itt helytelen háromszögek vagy sokszögek jöhetnek létre, melyeket utókezelni kell. Ez gyakran a környez® csomópontokra is kihat és komplikálja a javítást.

További részletekért a hálógenerálás, particionálás és párhuzamos hálógenerálás témá-

jában P. Iványi and J. Radó El®feldolgozás párhuzamos számításokhoz [Ivanyi2013] cím¶ könyvét ajánljuk.

5.7. Monte Carlo és Las Vegas módszerek

Sok probléma esetén nem tudjuk a feladatot zárt alakban felírni, illetve lehetséges, hogy egy determinisztikus algoritmus elkészítése lehetetlen vagy nem praktikus. Ezekben az

esetekben jó megközelítés lehet, ha többszörös mintavételt alkalmazva statisztikus alapon

numerikus közelítést végzünk. A módszer a megoldások halmazát állítja el®, amiket vélet-

len mintákból számít ki, amivel egy kaszinóbeli helyzetet szimulál innen az elnevezés, a Monte Carlo módszer. Feltételezhetjük, hogy ez az approximáció növekv® számú minta esetén egyre kisebb és kisebb hibát fog produkálni. Mivel az egyre pontosabb számításokhoz szinte exponenciálisan növekv® számítási kapacitásra van szükségünk a párhuzamosítás ismételten a segítségünkre lehet. A módszer nagy el®nye, hogy a minták egymástól

www.tankonyvtar.hu



57

függetlenek, így a párhuzamos programban a számítási folyamatok közötti kommunikáció minimális lehet. Diszkrét problémák esetén egyes esetekben a Las Vegas, véletlenen alapuló módszert alkalmazhatjuk. Ebben a módszerben mindig helyes választ kapunk, de nem tudhatjuk el®re a futásid®t. Az NP-nehéz feladatok megoldásához lehet ezt a módszert használni, de ez túlmutat könyvünk témáján.

5.7.1.

π

számítása Monte Carlo módszerrel

π értékének kiszámítása geometriai ala2×2 négyzetbe rajzolt 1 sugarú kör segítségével tehetjük meg. Képzeletbeli

DR AF T

A Monte Carlo módszer bemutatására jó példa a

pokon. Ezt egy

dartsnyilakat dobálunk ebbe a táblába feltételezve, hogy a találatok helye véletlenszer¶, megszámolhatjuk a körön belüli és a körön kívüli találatokat a táblán. A körön belüli

találatok és az egész táblát eltaláló találatok aránya közelít®leg azonos lesz a területük 2 arányával : 2 × 2 = 4 és 1 × π , így az arány π/4 lesz. A számítást elvégz® példaprogramot az el®z® fejezetben találja az olvasó.

5.8. Feladatok

Az olvasó számára azt ajánljuk, hogy nézze vissza az el®z® fejezet feladatait, és gondolja újra végig azokat, miszerint vajon hatékonyak lettek-e az elkészült megoldások. Mik a f® problémák az elkészült megoldásokkal ha vannak ilyenek, és hogy lehetne javítani rajtuk. Mi vajon a programok várt gyorsulása ?

Az olvasó ugyancsak megpróbálhatja lemérni a különböz® megvalósítások futásidejét

és összehasonlítani azokat a várt id®kkel.


www.tankonyvtar.hu


DR AF T

58

www.tankonyvtar.hu


DR AF T Második rész

Gyakorlati példák


www.tankonyvtar.hu

DR AF T

61

Bevezetés Ebben a részben néhány gyakorlati példát szeretnénk bemutatni. Általában olyan példákat igyekszünk hozni, melyek számításigényes példáknak számítanak, és kiszámításuk igen hosszú ideig tarthat még a mai legmodernebb számítógépeken is. Egyértelm¶ tehát, hogy ezekben az esetekben érdemes lehet párhuzamos számításokkal gyorsítani ezt a folyamatot. Értelemszer¶en az olvashatóság és értelmezhet®ség miatt igyekeztünk leegyszer¶síteni ezeket a példákat és a bemutatott programokat. Mindazonáltal a bemutatott megoldások jó példákkal szolgálhatnak arra, hogyan lehet hasznosítani a mai párhuzamos számítási

DR AF T

lehet®ségeket, és demonstrálhatják, milyen trükkökkel és megoldásokkal lehet párhuzamos programokat tervezni az MPI keretrendszerben.

Példáink, melyek a MPI párhuzamosítási lehet®ségeket mutatják be, felölelnek diszk-

rét matematikai feladatokat, mint a legrövidebb út keresése gráfokban, gráfok színezése és számok rendezése. Ugyancsak bemutatunk néhány mérnöki feladatot, mint például li-

neáris egyenletrendszerek megoldása, gyors Fourier transzformáció és egy gyakorlat közeli példát a h®terjedésr®l. Ugyancsak mutatunk néhány látványos feladatot, a Mandelbrot halmaz generálását illetve egy egyszer¶ Raytrace (sugárkövetés) programot, mindezeket értelemszer¶en párhuzamos megoldással és elemzéssel.

Tesztelés

A példák bemutatása során igyekeztünk minél jobban érdekl®dést felkelt® problémákra

koncentrálni. Ebbe beletartozik az is, hogy az elkészült programokat abból a szempontból is megvizsgáltuk, vajon mennyire hatékony lett a párhuzamosítás, milyen gyorsulást lehet elérni ezekkel az algoritmusokkal és implementációikkal. Így tehát egyes problémáknál

demonstrálni fogjuk a futásid®ket is különböz® bemenetekre és különböz® párhuzamos

rendszereken. Ehhez két magyarországi szuperszámítógépet használtunk, melyek a kutatók számára maximum 512 mag egyidej¶ használatát teszik lehet®vé, így lehet®ségünk nyílt

egészen eddig a pontig tesztelni a programjainkat. A második szuperszámítógép sajátos

architektúrája miatt a legkisebb párhuzamos futtatás 12 processzormagot használt, majd k ezt mindig 2-vel szoroztuk. Így tehát példáinkat 12×2 processzormagon, illetve 512 magon futtattuk, azaz a szekvenciális futtatással együtt 1, 12, 24, 48, 96, 192, 384 illetve 512 magon.

Az els® szuperszámítógép, melyre kés®bbiekben mint az A szuperszámítógépre fogunk

hivatkozni, egy SMP, azaz közös memóriás rendszer. Ez azt jelenti, hogy a folyamatközi

kommunikáció igen gyors és alacsony késleltetés¶. Ez a szuperszámítógép a magyar szuperszámítógépes infrastruktúra egyik gépe és a Pécsi Tudományegyetemen található. SGI UltraViolet 1000 típus, amely ccNUMA architektúrájú, 1152 mag található benne, és a peak teljesítménye 10 TFlops.

http://www.niif.hu/node/660

A második szuperszámítógép, melyre mint a B gép fogunk hivatkozni, egy klaszter alapú gép, fat tree topológiával, melyben több processzor található de a folyamatközi kommunikáció lassabb. A gép a Szegedi Tudományegyetemen található és 24 magos blade-


www.tankonyvtar.hu

62


ekb®l áll. A szuperszámítógép csúcsteljesítménye 14 TFlops és 2304 processzormag van összesen benne.

http://www.niif.hu/node/661

Az ok, ami miatt éppen ezt a két gépet választottuk az, hogy szeretnénk bemutatni az interkonnekt kapcsolat típusának hatását az algoritmusok futásidejére. Az A gép magjai gyorsabbak, mint a B gép magjai, viszont a B gépben jóval több mag van, így ha egy algoritmus képes jól skálázódni, akkor a B gép összességében gyorsabb tud lenni. Ugyancsak meg kell említenünk, hogy az A géphez hasonló SMP gépek építése rengeteg elméleti és gyakorlati problémával jár, így az A gép az SMP gépek közül a világon az egyik legnagyobbnak számít, sokkal nagyobbat építeni nem tudunk. Ezzel szemben klaszter felépítés¶

DR AF T

gépek mint a B szuperszámítógép jóval nagyobb méretig képesek skálázódni, így ez a

gép a kisebbek közé tartozik inkább. Ami összességében azt jelenti, hogy a jóval nagyobb számítási kapacitás tekintetében nem választhatjuk az SMP-t mint opciót.

A programok tesztfuttatása sok érdekes eredményt hozott, és a szerz®k rá kívánnak

mutatni arra, hogy ezek csak arra alkalmasak, hogy rámutassanak az érdekes és problémás részletre, illetve bemutassanak bizonyos trendeket a skálázódás tekintetében. El®ször is a

problémák tipikusan túl kicsik valódi tesztelésre. Másodszorra, a futásid®k igen nagy mértékben változtak egyik futásról a másikra, egyes ritka esetekben akár kétszeres id®különbséget is mutatva. Nem készítettünk részletes, több futás átlagát bemutató táblázatot. A

való életben sem szokás ugyanazt a problémát többször kiszámolni, így a futásid®k amiket bemutatunk kifejezetten valószer¶ek az esetleges apróbb ellentmondásokkal egyetemben.

Nagyobb problémák esetén a varianciák amúgy elt¶nnek. Mindazonáltal a futásid®k táblázatszer¶ összefoglalása kit¶n®en képes demonstrálni a trendeket, ami a szerz®k els®dleges célja volt.

www.tankonyvtar.hu


DR AF T

6. fejezet Legrövidebb út keresése gráfokban

Sok optimalizálási probléma vezethet® vissza arra, hogy megfelel® gráfban két csúcs között keressünk legrövidebb utat. Ezekben a feladatokban egy súlyozott gráfot szerkesztünk,

melyben két csúcs akkor van irányított éllel összekötve ha közvetlenül elérjük az els®b®l a

másodikat, és súlyt rendelünk hozzá, mely ezt az egy lépést jellemzi. A feladat, hogy adott

u

és

v

csúcs között találjuk meg a legrövidebb összsúlyú utat.

6.1. Dijkstra algoritmusa

Edsger W. Dijkstra egy egyszer¶ de hatékony algoritmust írt le a fenti probléma megoldá-

sához arra az esetre, amikor a súlyok nem negatívok.[Dijk1959] Ez egy mohó algoritmus, amely egy adott

s

csúcs és az összes többi csúcs közötti legrövidebb utat meghatározza

(algoritmikus bonyolultság tekintetében ez azonos nehézség¶ feladat). Az algoritmus egy

D

(távolság angolul distance) tömböt használ, amelyben elmenti a m¶ködés közben ta-

lált legrövidebb utakat minden csúcshoz csúcsok közül az

s-b®l.

Minden lépésben veszi a még nem kész

s-hez legközelebbit és kész-nek jelöli. Ezek után megvizsgálja, hogy ezen D tömbben.

csúcson keresztül nincs-e javító út más csúcsokhoz, és ha talál ilyet azt jelzi a Formálisan az 1 algoritmus írja le az eljárást.


www.tankonyvtar.hu

64


Algoritmus 1 Dijkstra algoritmusa a legrövidebb utak keresésére Require: N a gráf mérete 1: function dijkstra(s) 2: 3: 4:

igaz

D[i] ← (s, i)

loop x ← i ahol D[i] minimális és OK[i] hamis OK[x] ← igaz for all i ahol OK[i] hamis do if D[i] > D[x] + (x, i) then D[i] ← D[x] + (x, i) Jelezzük, hogy i-be x-b®l jöttünk

DR AF T

5: 6: 7: 8: 9: 10: 11:

OK[s] ←

for all i do

Ha implementáljuk a fenti algoritmust az egyik lényegi pont a

D

tömb-beli értékek

közül a minimális megkeresése. Különféle megoldások léteznek attól függ®en, hogy s¶r¶ vagy ritka gráfról beszélünk-e. Ritka gráfok esetén a kupac adatstruktúra a leginkább meg-

felel®bb (bináris, binomiális vagy Fibonacci kupac) ; s¶r¶ gráfok esetén egy egyszer¶ tömb és azon végigmen® ciklus is hatékonyan használható. Mivel a kés®bbiekben a párhuzamosításra koncentrálunk, így az utóbbi, egyszer¶bb megoldást fogjuk használni. Ugyancsak feltételezzük, hogy el®re adott a gráf szomszédsági mátrixa (G[N ][N ]), azaz két

(u, v)

pont közötti távolság közvetlenül kiolvasható bel®le. A Dijkstra algoritmusát megvalósító szekvenciális programfüggvény a következ®képpen néz ki :

01 : const int INFINITY=9999 ; 02 : // llegyen az INFINITY egy

nagyon nagy szam, tobb, mint barmelyik masik

hasznalt

03 : 04 : // G[][] az adjacencia matrix 05 : // D[] a tavolsag matrix 06 : // path[] mutatja honnan jottunk 07 : 08 : void dijkstra(int s){ 09 : int i,j ; 10 : int tmp, x ; 11 : 12 : //kezdo ertekek : 13 : for(i=0 ;i
www.tankonyvtar.hu

az adott csomoponthoz


6. fejezet. Legrövidebb út keresése gráfokban

65

DR AF T

17 : } 18 : OK[s]=true ; 19 : path[s]=-1 ; 20 : 21 : //a moho algoritmusban N-1 lepes van : 22 : for(j=1 ;jD[x]+G[x][i]){ 37 : D[i]=D[x]+G[x][i] ; 38 : path[i]=x ; 39 : } 40 : } 41 : } 42 : } 43 :

6.2. Párhuzamos változat

A probléma párhuzamosítását azzal kell, hogy kezdjük, hogy a problémateret valamilyen módon alterekre bontsuk ahhoz, hogy párhuzamosan végezhessünk rajtuk számításokat.

Sajnos ezt triviális módon nem tudjuk megtenni, mert nincsenek egyértelm¶ független részei az algoritmusnak. A feladatot így a csúcsok szerint fogjuk elosztani. Ez azt jelenti, hogy mindazon helyeken a programban, ahol egy ciklus az összes csúcsot sorra veszi

átírjuk úgy, hogy az adott ciklus csak a csúcsok egy részhalmazán menjen végig. Ehhez használhatunk ciklikus felbontást (loop scheduling) vagy tömbök szerinti felbontást (block scheduling) akár. Az el®bbit választottuk, így tehát programunkban minden ciklust a következ®képpen fogunk átírni :


www.tankonyvtar.hu

66


1 : for(i=id ;i
DR AF T

A globális minimumot párhuzamosan a következ®képpen tudjuk meghatározni. El®ször

minden folyamat a lokális minimumot fogja meghatározni azokon a csúcsokon, melyek hozzá vannak rendelve. Ezek után a mester folyamat összegy¶jti a lokális minimumokat és

kiválasztja közülük a legkisebbet ez lesz a globális minimum , majd ezt az információt visszaküldi a szolgáknak.

Azaz a lokális minimum

D[x] és helye x kiszámolása után a kett®b®l egy párt készítünk

(pair[2]). A szolgák elküldik a saját párjukat a mesternek. A mester fogadja a párokat, és minden fogadásnál összeveti az eddig talált és elmentett optimálissal, hogy nem kisebb-e annál a fogadott

D[x]

érték. Ha igen, akkor a mester kicseréli az eddig elmentett optimu-

mot a frissen fogadottra. A fogadás végén a mester visszaküldi az optimális értékeket és a szolgák frissítik az

01 : 02 : 03 : 04 : 05 : 06 : 07 : 08 : 09 : 10 : 11 : 12 : 13 : 14 : 15 : 16 : 17 : 18 :

x

és

D[x]

értékeiket a globális minimummal.

pair[0]=x ;

pair[1]=tmp ;

if(id !=0){ MPI_Send(pair,2,MPI_INT,0,1,MPI_COMM_WORLD) ; }else{ // id==0 for(i=1 ;i
}

}

}

MPI_Bcast(pair,2,MPI_INT,0,MPI_COMM_WORLD) ; x=pair[0] ;

D[x]=pair[1] ;

Használhattuk volna az

MPI_ANY_SOURCE

fogadást is, de ez nem gyorsítaná fel a prog-

ramot, hiszen mindenképpen be kell verjük az összes szolgát, és a broadcast visszaküldés amúgy is barrier-ként fog viselkedni.

www.tankonyvtar.hu



67

Vajon jó választás volt-e a loop splitting alkalmazása ? Mindenképpen lesznek egyenl®tlenségek a csúcsok szétosztásában, hiszen a kész csúcsok egymás után esnek ki a feldolgozandók közül, ami egyértelm¶en egyenl®tlen elosztásra fog vezetni el®bb-utóbb. Viszont azt el®re megjósolni, hogy mely csúcsok esnek ki, és melyek maradnak ugyancsak lehetetlen. Mindebb®l az következik, hogy teljesen mindegy, hogy osztjuk fel a csúcsokat, az egyenl®tlenségeket amúgy sem kerülhetjük el, így a legegyszer¶bb felosztást, a loop splitting-et érdemes választanunk. Azért, hogy lássuk egyszer¶ példánk párhuzamosításának er®sségét lefuttattuk a prog-

DR AF T

ramot két különböz® szuperszámítógépen. Az els® (A) egy SMP gép gyors folyamatközi

kommunikációval. A második (B) egy klaszter gép több processzorral, de lassabb kom-

munikációval. Két mesterséges gráfot készítettünk 30 000 illetve 300 000 csúccsal (ezeket a táblázatban a 30k és a 300k cinkével jelöljük), és ezekre a bemenetekre futtattuk a programot különböz® processzormagszámra. Az alábbi táblázatban a szekvenciális és a

párhuzamos futási id®ket egyaránt feltüntettük. Ugyancsak jelezzük a gyorsulás (speed up) értékeket is a szekvenciális programhoz képest.

nproc

A-30k

B-30k

A-300k

B-300k

1

80.0s

169s

9841s

20099s

12

10.8s

7.4x

49s

24

5.7s

14.0x

48

3.2s

25.0x

96

2.4s

33.0x

192

3.5s

384

11.0s

3.5x

2302s

4.3x

2896s

34s

5.0x

11s

15.6x

55s

3.0x

1320s

7.5x

1201s

16.8x

447s

22.0x

807s

24.9x

226s

43.5x

433s

46.4x

23.0x

151s

65.2x

360s

55.8x

7.3x

129s

76.3x

580s

34.7x

152s

64.7x

512

6.9x

Ahogy az olvasó láthatja a párhuzamosítás sikeres volt. Kifejezetten jó gyorsulási ér-

tékeket láthatunk, miközben a probléma triviálisan nem volt párhuzamosítható. Azáltal, hogy a csúcsok egy részhalmazát rendeltük hozzá a folyamatokhoz szét tudtuk osztani a

munkát is közöttük. A folyamatok a részleges lokális minimum számítását végzik, majd a globális maximum segítségével (amit a mester számol ki) a javítóutakat is ugyanarra a csúcsrészhalmazra számolják csak ki.

A megoldás kommunikációs szükségessége a minimum távolságok szinkronizációjára

korlátozódik. A mester begy¶jti a lokális minimumokat, kiszámolja a globális minimumot és az eredményt broadcast-al visszaküldi a szolgáknak. A gyorsulást (speed up) a lokális munka és a kommunikáció aránya korlátozza csak, azaz a kérdés az, hogy az elvégzend® munkához képest milyen gyakran van szükség üzenetküldésre.


www.tankonyvtar.hu

68


6.3. Az eredmények értékelése Ha alapos vizsgálatnak vetjük alá a táblázat adatait néhány meglep® meggyelést tehetünk, melyek segítségével fontos következtetésekre juthatunk és észrevehetünk bizonyos speciális jelenségeket. El®ször is, egyértelm¶, hogy a gyorsulást valami korlátozza. Amíg az elején minél több processzormagot allokálunk a feladatra, annál gyorsabban fut le a program. Kés®bb egyre több mag hatására csak kicsit gyorsul, majd egy bizonyos pont után a több és több mag nem gyorsít a program futásán, s®t, lelassítja azt.

DR AF T

Itt emlékeztetnénk az olvasót Amhdahl törvényére, amely kimondja, hogy minden pár-

huzamosítás gyorsulásának van egy határa. Amhdal rámutatott arra, hogy minden párhuzamos programnak kell lennie egy szekvenciális részének (ez legalább az inicializálási rész),

így tehát nem gyorsíthatjuk több processzor segítségével a futási sebességet ennek a rész-

nek a szekvenciális futása fölé. Ennél még többet is mondhatunk. A kommunikációs extra munka ugyancsak dominálhatja a gyorsulást, ha a kommunikációra több id® megy el, mint a lokális számolásokra. Azaz a gyorsulás lassulásba fog átbillenni egy pont után, amikor

olyan sok folyamatot adunk hozzá a rendszerhez, hogy a részfeladatok túl kicsik lesznek miközben a kommunikáció túl gyakori. Az olvasóra bízzuk, hogy ezt a pontot megtalálja a

táblázatban ! Vegyük észre, hogy ez a pont máskor következik be a különböz® gépek esetén,

hiszen a kommunikációs csatorna teljesítménybeli különbségei jelent®sen befolyásolják ezt. Másodszor is, meggyelhetjük, hogy különböz® problémaméretek esetén az Amhdal

törvénye más és más ponton kezdi el dominálni a futásid®ket. Ez a meggyelés elvezet

minket Gustavson törvényéhez. Ez a törvény azt mondja ki, hogy nagyobb problémák

esetén jobb gyorsulást tudunk elérni még akkor is, ha nem tagadjuk Amhdal törvényét. Megint az olvasóra bízzuk a táblázatbeli értékek megkeresését.

Harmadszorra, egy kifejezetten érdekes pontot is észrevehetünk, ahol kétszer annyi

processzormag hozzáadása után a gyorsulás több, mint kétszeresére n® ! Ismételten az olvasóra bízzuk, hogy ezt az érdekes pontot megtalálja a táblázatban. Ez nem egy hibás

mérési adat ezt a méréspárt többször is lefuttattuk, hogy elkerüljük a lehetséges hibákat. Ez a jelenség a lineárisnál nagyobb gyorsulás (superlinear speedup). Ez a jelenség éppen

azt mondja ki, hogy bizonyos esetekben lehetséges kétszeresnél nagyobb gyorsulás kétszeres

magszám esetén is. Meglátásunk szerint ez az adott architektúra miatt következett itt be. Esetünkben a probléma mérete, a szomszédsági mátrix adott része illetve a

D távolságtömb

már elfér a processzor cache memóriájában adott feldarabolás után. Ami azt eredményezi,

hogy a memóriam¶veletek sokkal gyorsabbak tudnak lenni, így a gyorsulás több mint kétszeres lehet.

6.4. A program kód

Végezetül szeretnénk bemutatni a párhuzamos változat teljes programkódját. Az els® felében a konstansok és a globális változók találhatóak. Két okból használtunk globális változókat. el®ször is azért, mert azok így elérhet®ek az összes függvényb®l. Másodszor is azért,

www.tankonyvtar.hu



69

mert így a szomszédsági mátrix a heap memórián foglal helyet (szemben a verem vagy más néven stack memóriával), így nagyon nagy mátrix esetén nem lesz memóriaproblémánk. (Természetesen a dinamikusan foglalt memória is elérné ugyanezt a célt.)

id illetve nproc változók ugyancsak globálisak, mivel az MPI inicializációt a main-ben végezzük el de maga a folyamatközi kommunikáció a void dijk(int) Figyeljük meg, hogy a

függvényben fog megvalósulni. A

int Read_G_Adjacency_Matrix()

függvényt csak deklaráció szintjén adtuk meg.

Az olvasónak az adott feladathoz igazított függvényt kell megírnia, amely beolvassa a szomszédsági mátrixot például a háttértárról. Egy másik lehet®ség az lehet, hogy a mát-

DR AF T

rix valójában nincs elmentve, hanem minden egyes élét akkor számoljuk csak ki, amikor szükségünk van más adatokból. A szerz®k valójában ezt a változatot használták a tesz-

teléshez. Akkor vagyunk kénytelenek ilyen megoldást használni, amikor a mátrix túl nagy ahhoz, hogy letároljuk, és ésszer¶bb kiszámolni lépésenként. Ilyenkor a

G[][]

helyeken a

konkrét memóriaolvasásokat egy függvényhívással helyettesítjük.

01 : #include 02 : #include <mpi.h> 03 : using namespace std ; 04 : 05 : const int SIZE=30000 ; //a graf maximum merete 06 : char G[SIZE][SIZE] ; //adjacenciamatrix 07 : bool OK[SIZE] ; //kesz csomopontok 08 : int D[SIZE] ; //tavolsag 09 : int path[SIZE] ; //honnan jottunk a csomopontba 10 : const int INFINITY=9999 ; //eleg nagy szam, nagyobb

mint barmilyen lehetseges

utvonal

11 : 12 : 13 : 14 : 15 : 16 : 17 : 18 : 19 : 20 : 21 : 22 :

int nproc, id ;

MPI_Status status ; int N ; int

Read_G_Adjacency_Matrix(){

//aktualis

beolvasott G[][] adjacencia matrix

}

void

dijk(int s){

int i,j ;

int tmp, x ;

---dijk-par.cpp---

A második rész az a függvény, amelyet párhuzamosítottunk és amelyik valójában kiszámolja a legrövidebb utakat. Ezt már korábban részleteztük, így most csak a függvényt


www.tankonyvtar.hu

70


magát mutatjuk egyben.

---dijk-par.cpp---

DR AF T

18 : } 19 : 20 : void dijk(int s){ 21 : int i,j ; 22 : int tmp, x ; 23 : int pair[2] ; 24 : int tmp_pair[2] ; 25 : for(i=id ;i
www.tankonyvtar.hu



71

DR AF T

57 : x=pair[0] ; 58 : D[x]=pair[1] ; 59 : OK[x]=true ; 60 : for(i=id ;iD[x]+G[x][i]){ 62 : D[i]=D[x]+G[x][i] ; 63 : path[i]=x ; 64 : } 65 : } 66 : } 67 : } 68 : 69 : main(int argc, char** argv){ 70 : double t1, t2 ; 71 : ---dijk-par.cpp---

A harmadik rész a

int main() függvény. Ez állítja el® a G[][] szomszédsági mátrixot,

inicializálja az MPI kommunikátort és méri a futásid®t.

---dijk-par.cpp---

67 : } 68 : 69 : main(int argc, char** argv){ 70 : double t1, t2 ; 71 : 72 : MPI_Init(&argc,&argv) ; 73 : MPI_Comm_size(MPI_COMM_WORLD, &nproc) ; //

osszes munkas sza-

ma

74 : MPI_Comm_rank(MPI_COMM_WORLD,

&id) ;

// sajat azonosito le-

kerese

75 : 76 : N=Read_G_Adjacency_Matrix() ; 77 : // G[][]-be valo beolvasas 78 : //aktualis meret beallitasa 79 : 80 : if(id==0){ 81 : t1=MPI_Wtime() ; 82 : } 83 :


www.tankonyvtar.hu

72


altal

DR AF T

84 : dijk(200) ; 85 : //meghivjuk az algoritmust a valasztott csomoponttal 86 : 87 : if(id==0){ 88 : t2=MPI_Wtime() ; 89 : 90 : //ellenorizzuk az eredmenyeket a G[][] es D[] kimenetei 91 : 92 : cout<<"time elapsed: "<<(t2-t1)<<endl ; 93 : } 94 : 95 : MPI_Finalize() ; 96 : } 97 :

6.5. Variáns más MPI függvényekkel

Láthattuk, hogy az MPI lehet®séget ad redukciós függvények használatára, és ebben az esetben is használhatunk egy megfelel®t. Konkrétan az

MPI_Reduce

és a variánsait hasz-

nálhatjuk itt. A globális minimumot keresünk, de nem csak a minimum értékét, hanem egyben azt a csúcsot is, melyhez ez a minimum tartozik. Hiszen majd ez a csúcs lesz kész

ebben a lépésben, és azokat a javítóutakat keressük, melyek ezen a csúcson keresztül mennek. Ezen célból a redukció

MPI_MINLOC

operátorát fogjuk használni, amely egyszerre

találja meg a legkisebb értéket és az indexét. (Az operátor részletes m¶ködését az olvasó

a Függelékben találja.) Ugyancsak célunk az is, hogy a redukció végeredményét minden egyes folyamathoz eljuttassuk, így az

MPI_Allreduce

függvényt fogjuk használni. A mó-

dosítás a következ®képpen fog kinézni, és jól látható, mennyivel könnyebben értelmezhet® így a kód.

01 : 02 : 03 : 04 : 05 : 06 : 07 :

struct{

int dd ; int xx ;

} p, tmp_p ;

p.dd=tmp ; p.xx=x ;

MPI_Allreduce(&p,

&tmp_p,

1,

MPI_2INT,

MPI_MINLOC,

MPI_COMM_WORLD) ;

08 : 09 :

x=tmp_p.xx ;

www.tankonyvtar.hu



10 : 11 :

73

D[x]=tmp_p.dd ;

Természetesen végeztünk futási id® méréseket a módosított kóddal is, de nem volt szignikáns különbség az eredeti programhoz képest. A redukciós függvények nagyban segítenek megírni, majd kés®bb értelmezni a programot, de az esetek többségében használatuk nem gyorsít önmagában a programon.

DR AF T

6.6. A program kód Csak a

void dijk(int) függvényt mutatjuk be, hiszen a program többi része változatlan.

---dijk-reduce.cpp---

18 : } 19 : 20 : void dijk(int s){ 21 : int i,j ; 22 : int tmp, x ; 23 : int pair[2] ; 24 : int tmp_pair[2] ; 25 : for(i=id ;i

www.tankonyvtar.hu

74


45 : 46 : 47 : 48 :

} p, tmp_p ; p.dd=tmp ; p.xx=x ;

MPI_Allreduce(&p,

&tmp_p,

1,

MPI_2INT,

MPI_MINLOC,

MPI_COMM_WORLD) ;

DR AF T

49 : 50 : x=tmp_p.xx ; 51 : D[x]=tmp_p.dd ; 52 : OK[x]=true ; 53 : 54 : for(i=id ;iD[x]+G[x][i]){ 56 : D[i]=D[x]+G[x][i] ; 57 : path[i]=x ; 58 : } 59 : } 60 : } 61 : } 62 : 63 : main(int argc, char** argv){ 64 : double t1, t2 ; 65 : ---dijk-reduce.cpp---

6.7. Különböz® adatstruktúrák használata

A bemutatott algoritmus két lépés ciklusát írja el® : az eddig nem kész csúcsok távolság

minimumának megkeresése, és a távolságok csökkentése ha találunk javítóutat. Ez a két lépés nagyban függ attól az adatstruktúrától, ahogy eltároljuk az adatokat.[Corm2009, pp. 661662.] S¶r¶ gráfok esetén a távolságok egyszer¶ tömbje hatékonyan használható,

ahogy mi is tettük a példaprogramunkban. Tesztelésünket is s¶r¶ gráfokon hajtottuk vég-

re. Ugyancsak mivel ez a legegyszer¶bb megközelítés tanítási szempontból is ezt kellett bemutatnunk.

Kevésbé s¶r¶ gráfok esetén más adatstruktúrákat érdemesebb használni, mint a bináris

kupac, binomiális kupac vagy a Fibonacci kupac. Ezeknek az adatstruktúráknak közös

tulajdonságuk, hogy értelmezett rajtuk a Min-Törlés illetve a Kulcs-Csökkentés m¶velete, melyeket ha ezeket az adatstruktúrákat használnánk az adott algoritmus használna a fent említett két lépésben. Az olvasó számára ajánljuk, hogy b®vebb részletek tekintetében olvassa el az idézett könyv idevágó részeit. Adódik viszont egy kérdés. Vajon ha más adatstruktúrát használtunk volna, miben

www.tankonyvtar.hu



75

különbözne a párhuzamos programunk ? A válasz egyszer¶ : szinte semmiben. Ugyancsak szétosztanánk a csúcsokat a folyamatok között, melyek azután a megfelel® adatstruktúrában tárolnák el ezeket és a hozzájuk tartozó távolságértékeket. A Min-Törlés algoritmusát némiképpen át kéne írnunk, hogy ne törölje ki a minimum csúcsot, csak adja meg azt el®ször. Ezek után a lokális minimumok redukciójával megkaphatjuk a globális minimumot, és csak ezek után kell törölni a megfelel® csúcsot. A második lépésben ugyancsak a csúcsok egy részhalmazán javítóutakat találva a Kulcs-Csökkentés m¶veletével tudjuk megváltoz-

DR AF T

tatni, csökkenteni a távolságadatokat.


www.tankonyvtar.hu


DR AF T

76

www.tankonyvtar.hu


7. fejezet

DR AF T

Gráfszínezés Adott egy

Γ = (V, E) egyszer¶ véges gráf, ahol V

a csúcsok véges halmaza és

E

a közöttük

futó irányítatlan élek halmaza. Két csúcs között pontosan egy vagy nulla él fut. Az élek nem súlyozottak. A

Γ gráf csúcsait színezzük úgy, hogy minden egyes csúcshoz pontosan egy színt rende-

lünk hozzá, és úgy, hogy az éllel összekötött (azaz szomszédos) csúcsok ne kapják ugyanazt a színt. Ezt a színezést szokás legális vagy jó színezésnek is hívni. Formálisabban a

Γ

gráf

r színnel tekinthetjük f :V →{1, . . . , r} szürjektív leképzésnek. Ebben az esetben az r darab színt az 1, . . . , r számokkal reprezentáljuk. Az f függvény nívóhalmazai az úgynevezett színosztályok. Az i. színosztályba mindazok a pontok kerülnek, melyeket az i színnel színeztünk, azaz Ci = {v : v ∈ V, f (v) = i}. A C1 , . . . , Cr színosztályok a V gráf csúcsainak particionálása. Természetesen a színezést egyértelm¶en meghatározzák a C1 , . . . , Cr színosztályok. Ezek a színosztályok ugyancsak a Γ gráf független csúcshalmazai, hiszen a színezés szabályai megtiltják, hogy szomszédos csúcsainak színezését

élek ugyanazt a színt kapják.

7.1. A probléma leírása

Maga a színezés egy NP nehéz feladat, viszont ismert sok jó mohó algoritmus amely közelít® megoldásokkal szolgáltat. Ezek az algoritmusok nem feltétlenül találják meg a

legjobb megoldást, ami alatt azt értjük, hogy a lehet® legkevesebb színnel kiszínezi a gráfot, de ehhez az optimumhoz esetleg közeli megoldást adhat. Egyes nehéz feladatok esetén ezeket a mohó algoritmusokat mint segédalgoritmusokat használjuk, mint például a maximális klikk keresésének feladata. Más esetekben, mint például ütemezési feladatok, maga a színezés adhat közvetlenül megoldást.

Maximális klikk keresésekor a színezés egy fels® határt ad a klikk méretére, hiszen bármely

∆

klikk csúcsai mind más színnel kell, hogy színezve legyenek, hiszen a klikk

csúcsai páronként össze vannak kötve. Így tehát bármely jó színezés fels® határt biztosít, hogy a legnagyobb klikk legfeljebb

k

k

színnel egyben egy

méret¶. Egyértelm¶, hogy minél

jobb színezést sikerül elérnünk, annál élesebb lehet ez a fels® korlát, ami a maximális klikk


www.tankonyvtar.hu

78


keresését nagyságrendekkel le tudja rövidíteni. Mivel a jó színezés sok helyen használható, így az ezt megoldó mohó algoritmusok igen hasznosak. Több különböz® algoritmust is használnak, melyek f®leg a sebességükben, illetve abban különböznek, hogy mennyire tudnak jó színezést találni abban a tekintetben, milyen kevés színt használnak. Természetesen választanunk kell a gyors futási id® és az igazán jó eredmény között, de mindegyiknek megvan a maga szerepe. Ütemezési feladatoknál többnyire lassabb, de jobb eredményt szolgáltató algoritmust érdemes használni. Klikk problémák esetén, ahol a színezés mint segédalgoritmus konkrétan milliószor

DR AF T

is futtathatjuk inkább a gyorsabb algoritmusok használatosak.

7.2. Daniel Brélaz DSATUR algoritmusa

Az egyik széleskör¶en ismert színezési algoritmus a Daniel Brélaz féle DSATUR.[Brel1979]

Ez a mohó algoritmus jó színezési eredményt tud elérni viszonylag kevés felhasznált színnel viszonylag gyors futásid® mellett. Nem a leggyorsabb algoritmus, de közel van azokhoz.

Ezen tulajdonságai miatt gyakran használják mind klikk-keres® algoritmusokban mint segédalgoritmus, mind olyan ütemezési problémák esetén, ahol a feladat mérete miatt más algoritmus egyszer¶en nem tudja megoldani ésszer¶ id®n belül a feladatot. A DSATUR algoritmus három lépésb®l áll.

I. Keressük meg az optimális csúcsot, amit színezni fogunk :

azt a csúcsot keressük, melynek a legkisebb a szabadsági foka amelyiket a legkevesebb színosztályba tudjuk belerakni ;

egyenl® szabadsági fokok esetén vegyük a legnagyobb fokszámú csúcsot ami-

nek a legtöbb szomszédja van. (Ezt a heurisztikát nem támogatja egyértelm¶en a szakirodalom.)

II. Színezzük ki a választott csúcsot :

rakjuk be az els® lehetséges színosztályba, vagy

nyissunk új színosztályt, ha nincs szabad színosztály amibe berakhatnánk. (Az

új színosztály megnyitása az összes maradék pont szabadsági fokát növeli eggyel !)

III. Frissítsük a maradék pontokról tárolt információkat :

ha a maradék pontok közül valamelyik szomszédja az éppen kiszínezett pontnak, akkor

azt nem helyezhetjük el ebben a színosztályban, így tehát az adott pont szabadsági foka csökken eggyel. Nézzük ezek után a programimplementációt. A

main()

függvény mellett további se-

gédfüggvényekre lesz szükségünk.

www.tankonyvtar.hu


7. fejezet. Gráfszínezés

read_clq

A

79

függvény a gráfot olvassa be egy

clq

állományból. Ez a le-formátum

egy gráfot ír le. A fejlécben jelöli a csúcsok és élek számosságát, majd felsorolja az éleket mint csúcspárokat. Ezt a formátumot a DIMACS Implementation Challenges honlapja specikálja :

http://dimacs.rutgers.edu/Challenges/,

és a gráfelméleti kutatásokban

résztvev® tudósok körében széleskör¶en használt.

A

write_pbm függvény egy nem szokványos formában írja ki a gráfot, mert a PBM for-

mát használja a szomszédsági mátrix grakus ábrázolására. Ez a formátum egy egyszer¶ szövegállományt használ a kép leírására. A fekete-fehér formátum, amit ebben a példában

DR AF T

használunk, 1-eseket és 0-kat használ a fehér és fekete pixelek ábrázolására, így a PBM képformátum explicite azonos a szomszédsági mátrixszal. A szürkeárnyalatos PBM képformátum, amit majd a laphevítés példánál fogunk használni, pixelenként egy 0 és 255 közötti számmal jelzi a szürke-értéket. A színes PBM formátum, amelyet majd a Man-

delbrot halmaz ábrázolásához használunk, 0 és 255 közötti számok hármasával jelzi egy képpont piros, zöld és kék értékeit.

Az ok, ami miatt arra az elhatározásra jutottunk, hogy a kimenet egy kép-le legyen

az, hogy a gráfot a színezés után átrendezzük a színosztályok szerint. Azaz az azonos színosztályba tartozó csúcsok egymás mellé kerülnek. Ezen átrendezés után a színezés szabad szemmel is leellen®rizhet® a szomszédsági mátrix alapján, tehát az azzal megegyez® kép-le

alapján is. Egy színosztály ugyanis független csúcsok halmaza, így a szomszédsági mátrixban az adott színosztályhoz tartozó részmátrix csupa 0-ból áll, hiszen ha él lenne benne

ott egy 1-es szerepelne, és ezek az átrendezés miatt az átló mentén helyezkednek majd el. Az üres dobozok megszámlálásával még a színosztályok számát is le tudjuk ellen®rizni,

ráadásul a képformátum miatt kifejezetten nagy gráfok esetén is. Nem lehetséges túlzásba esni annak a problémának a hangsúlyozásában, hogy mennyire fontos az eredmények

ellen®rzése még a nagy-teljesítmény¶ számítások esetén is, ahol a kimenet maga sokszor olyan nagy méret¶, hogy az ellen®rzés is problémákba ütközik.

A fent említett átrendezést szolgálja a

permutation_color függvény, amelyik el®állítja perm int-ekb®l álló vektor fogja tárolni ezt

a csúcsok színosztály szerinti permutációját. A

testperm függvény leellen®rizni, hogy a permutáció valóban permutációegyes szám egyszer és csakis egyszer fordul el® benne. A permto függvény

a permutációt. A

e, azaz minden

végzi el a szomszédsági mátrix permutációját a permutációs vektor alapján.

Végül az

initialize

függvény az, amely inicializálja a használt adatstruktúrákat a

megfelel® kezdeti értékek szerint. A használt adatstruktúrák : a szomszédsági mátrixot tároló

adj[][] tömb ; a

színosztályok tömbje, amiben az adott csúcsok színosztályba tar-

tozását tároljuk (colors[][]) ; a szabad színosztályok tömbje, amiben minden csúcshoz

letároljuk azokat a színosztályokat amibe még belehelyezhet® a csúcs (free_color[][]) ;

a csúcsok fokszáma, amiben a csúcsok szomszédainak számát tároljuk (sat[]) ; egy jelz®bitet, ami jelzi, hogy egy adott csúcs ki lett-e már színezve (OK[]) ; az eddig felhasznált

színosztályok száma (colors) ; és az


N

globális változó, ami a csúcsok számát adja meg.

www.tankonyvtar.hu

80


A program A program elején a globális változók és a függvények deklarálása található. A

main()

függvény elején kiíratjuk a program használatához tartozó információkat, illetve beolvassuk a paraméterként átadott

.clq

leból a gráf szomszédsági mátrixát és inicializáljuk az

adatstruktúrákat.

#include #include #include #include using namespace std ;

DR AF T

001 : 002 : 003 : 004 : 005 : 006 : 007 : 008 : 009 : 010 : 011 : 012 : 013 : 014 : 015 : 016 : 017 : 018 : 019 : 020 : 021 : 022 : 023 : 024 : 025 : 026 : 027 : 028 : 029 : 030 : 031 : 032 : 033 : 034 : 035 :

int N ;

string comment="" ;

bool **adj ; // szomszedsagi matrix bool **colors ; // szinosztalyok

bool **free_color ; // a csucsok szabad szinosztalyai int *sat ; // a csucs fokszama

int *free_num ; // a csucsok szabad szinosztalyainak szama

bool *OK ; // a csucs kesz int num_color=0 ;

read_clq(string) ; void write_pbm(string) ; void initialize() ; void permutation_color() ; void permto() ;

void

vector perm ; // a permutacio csucslistaja void int

testperm() ;


if(argc<2){

cerr<<"Usage :

exit (1) ;

"<<argv[0]<<" file.clq"<<endl ;

}

int i,j,c,min_free, min_sat, min_id ;

le_name(argv[1]) ; read_clq(le_name) ;

string

initialize() ;

www.tankonyvtar.hu



036 : 037 :

81

//N csucsot szinezunk egymas utan :

---color.cpp---

Maga a színezés egy ciklus, amelyik minden cikluslépésben egy csúcsot fog kiszínezni, azaz összesen

N -szer

fog lefutni. Els®ként egy bels® ciklusban megkeressük a legkisebb

szabadsági fokú csúcsot és azok közül a legnagyobb fokszámút. Ezt a csúcsot, melynek

min_id

változó tárolja, fogjuk kiszínezni ezt jelezzük az

OK[]

tömbben.

DR AF T

indexét a

---color.cpp---

035 : initialize() ; 036 : 037 : //N csucsot szinezunk egymas utan : 038 : for(int v=0 ;vfree_num[i] || 044 : min_free==free_num[i] && sat[i]<min_sat)){ 045 : min_free=free_num[i] ; 046 : min_sat=sat[i] ; 047 : min_id=i ; 048 : } 049 : OK[min_id]=1 ; //kesz arra, hogy kiszinezzuk 050 : 051 : //kiszinezzuk : ---color.cpp---

A következ® rész maga a színezés és a megfelel® adatstruktúrák frissítése. Ezek közé

tartozik a csúcsok szabadsági fokának frissítése és annak a jegyzése, mely színosztályokba

rakhatók bele ezek a csúcsok. Két esetet különböztetünk meg. A színezend® csúcs szabadsági foka lehet 0, azaz egy meglév® színosztályba sem helyezhet® el. Ebben az esetben egy új színosztályt nyitunk (a programban valójában a színosztályokat el®re elkészítjük és inicializáljuk az elején, hogy üresek ; így csak használatba kell vennünk az új színosztályt), és elhelyezzük benne a színezend® csúcsot. Ezek után megnöveljük eggyel a még nem kiszínezett csúcsok szabadsági fokát, majd csökkentjük a szabadsági fokát mindazon csúcsoknak melyek szomszédosak az éppen kiszínezett csúccsal. (Értelemszer¶en ezt egy lépésben is megtehetnénk ezeket, de így átláthatóbb kódot kaptunk, és ez a lépés érdemben


www.tankonyvtar.hu

82


nem hat a program futási idejére.) Végül megnöveljük a használt színosztályok számát.

num_color változó a színosztályok számát jelöli, melyek számozása 0-val kezd®dik. Így amikor a num_color számú színosztályra hivatkozunk a kódban, akkor valójában az utolsó (A

utáni színosztályt indexeljük. Ezért növeljük csak meg ezt a változót a kódrészlet végén.)

---color.cpp--OK[min_id]=1 ; //kesz arra, hogy kiszinezzuk

//kiszinezzuk :

if(min_free==0){

DR AF T

049 : 050 : 051 : 052 : 053 : 054 : 055 : 056 : 057 : 058 : 059 : 060 : 061 : 062 : 063 : 064 : 065 : 066 : 067 : 068 : 069 : 070 :

//uj szinosztalyra van szuksegunk colors[num_color][min_id]=1 ;

//az uj szinosztaly a tobbi csucs szamara lehetseges szinosztaly

for(i=0 ;i
free_color[i][num_color]=1 ; ++free_num[i] ;

}

//de nem a szomszedos csucsok szamara :

for(i=0 ;i
free_color[i][num_color]=0 ; --free_num[i] ;

}

}

++num_color ;

}else{

//egy mar meglevo szinosztalyba rakjuk a csucsot

---color.cpp---

A másik eset az, amikor létezik olyan színosztály, melybe elhelyezhetjük szabályosan a

kiválasztott csúcsot. El®ször kiválasztjuk a színosztályt, jelen esetben a legels® megfelel®t a

c változó fogja jelölni. Elhelyezzük a csúcsot ebbe a színosztályba, és ismételten, frissítjük

a többi csúcsról tárolt információkat. Azaz mindazon még nem kiszínezett csúcsoknak amik szomszédosak az éppen kiszínezett csúccsal csökkentjük a szabadsági fokát.

---color.cpp---

067 : 068 : 069 :

} ++num_color ;

}

else{

www.tankonyvtar.hu



070 : 071 : 072 : 073 : 074 : 075 : 076 : 077 : 078 : 079 : 080 : 081 : 082 : 083 : 084 :

83

//egy mar meglevo szinosztalyba rakjuk a csucsot //keressuk meg az elso szinosztalyt :

for(c=0 ; !free_color[min_id][c] ;++c) ; colors[c][min_id]=1 ;

//a szomszedos csucsok szabadsagi fokat csokkentjuk :

for(i=0 ;i
DR AF T

--free_num[i] ;

}

}

}

}

cout<<"number of DSATUR colors : "<
---color.cpp---

A program futásának végén kiírjuk a felhasznált színosztályok számát, létrehozzuk

a színosztályok szerinti permutációt, leellen®rizzük azt, és átrendezzük a szomszédsági mátrixot miel®tt kiírjuk a PBM képleba.

---color.cpp---

081 : 082 : 083 : 084 : 085 : 086 : 087 : 088 : 089 : 090 : 091 :

}

}

cout<<"number

of DSATUR colors: "<
permutation_color() ; testperm() ; permto() ; write_pbm(le_name) ;

}

void initialize(){

---color.cpp---

Az

initialize

függvény 0-ra állítja a használt színosztályok számát, 0-ra a szabad

színosztályok számát minden csúcshoz, minden csúcsnál jelzi, hogy még nincs kiszínezve (OK[]), és kinullázza a színosztályokat és a csúcsoknál jelzett szabad színosztályokat. Ugyancsak összeszámolja a csúcsok szomszédait, hogy a kés®bbiekben a fokszámot használhassuk.


www.tankonyvtar.hu

84


---color.cpp---

DR AF T

089 : } 090 : 091 : void initialize(){ 092 : int sum ; 093 : num_color=0 ; 094 : for(int i=0 ;i
A

read_clq függvény egyfel®l beolvassa a gráf szomszédsági mátrixát a paraméterként

átadott le-ból, másfel®l memóriát foglal a szükséges adatszerkezeteknek. Ezt nem tudjuk igazán máshol megtenni, mivel a le tartalmazza

N

értékét, így a dinamikus memória-

foglalást legf®képpen a szomszédsági mátrix tárolásához csak az után tehetjük meg,

hogy beolvastuk a gráf méretét a le-ból, de még az el®tt, hogy beolvassuk az éleket. A színosztályok számában azt reméljük, hogy legfeljebb

N/4-re

lesz szükségünk.

A clq le a csúcsokat 1-t®l számozza, míg a tömbök indexe 0-tól kezd®dik, ezért hasz-

náljuk ezen a ponton az

x-1

és az

y-1

shift-elést.

---color.cpp---

108 : 109 : 110 : 111 : 112 :

}

void

read_clq(string le_name){

int i,j,n,m,x,y ; string type,line ;

www.tankonyvtar.hu



n(le_name.c_str()) ; if( !n.is_open()){ ifstream

cout<<"ERROR

exit(1) ;

opening file"<<endl ;

}

//toroljuk ki a komment sorokat

while(n.peek()=='c'){ getline(n,line) ;

DR AF T

113 : 114 : 115 : 116 : 117 : 118 : 119 : 120 : 121 : 122 : 123 : 124 : 125 : 126 : 127 : 128 : 129 : 130 : 131 : 132 : 133 : 134 : 135 : 136 : 137 : 138 : 139 : 140 : 141 : 142 : 143 : 144 : 145 : 146 : 147 : 148 : 149 : 150 : 151 : 152 : 153 :

85

comment=comment+"#"+line+'\n' ;

}

n>>type ; // a matrix tipusa (P1)

n>>type ; // el

n>>N ; // csucsok n>>m ; // elek

//az N ertekenek megfelelo memoriaterulet lefoglalasa :

new bool*[N] ; colors=new bool*[N/6] ; free_color=new bool*[N] ; for(i=0 ;i
}

for(i=0 ;i>type ; // e

if(type=="e"){

n>>x ;n>>y ;

//cout<<"x : "<<x<<" ; y : "<
} } n.

close() ;


www.tankonyvtar.hu

86


154 : 155 : 156 :

} void write_pbm(string le_name){

---color.cpp---

A

write_pbm függvény egyszer¶en kiírja a szomszédsági mátrix 1-eseit és 0-áit a PBM

DR AF T

le-ba.

---color.cpp---

154 : } 155 : 156 : void write_pbm(string le_name){ 157 : int i,j ; 158 : le_name=le_name+".pbm" ; 159 : ofstream fout(le_name.c_str()) ; 160 : if( !fout.is_open()){ 161 : cout<<"ERROR opening file"<<endl ; 162 : exit(1) ; 163 : } 164 : fout<<"P1"<<endl ; 165 : fout<
A

permutation_colors függvény minden egyes színosztályban összegzi a benne talál-

ható csúcsok számát és a legnagyobb számosságú számát berakja egy vektorba. A színosztály kinullázása után újrakezdi az eljárást amíg az összes színosztály számát nem sorolta fel.

www.tankonyvtar.hu



87

---color.cpp---

DR AF T

175 : } 176 : 177 : void permutation_color(){ 178 : int i,j,k, max, maxcol, sum ; 179 : int *colors_sum= new int[N] ; 180 : 181 : for(i=0 ;imax){ 191 : max=colors_sum[j] ; 192 : maxcol=j ; 193 : } 194 : for(j=0 ;j
A

amit

permto függvény egy új szomszédsági mátrixot épít az adott permutáció segítségével a perm vektor tárol.

---color.cpp---

199 : } 200 : 201 : void permto(){ 202 : int i,j ; 203 : bool **tmp=new bool*[N] ; 204 : for(i=0 ;i

www.tankonyvtar.hu

88


DR AF T

205 : tmp[i]=new bool[N] ; 206 : for(i=0 ;i
Az utolsó függvény, a

test_perm, ellen®rzi, vajon az adott permutáció korrekt permutáció-

e, azaz minden egyes szám egyszer, és csakis egyszer fordul el® benne.

---color.cpp---

212 : } 213 : 214 : void testperm(){ 215 : int sum ; 216 : for(int i=0 ;i
7.3. Párhuzamosítás

A párhuzamosítás problémája bizonyos értelemben hasonló az el®z® fejezet példájához, a Dijkstra legrövidebb utak algoritmusához. Ismételten nincsenek egyértelm¶en független adatokon elvégezend® részfeladatok, így ismételten egy részleges munkafolyamat párhuzamosítást tudunk végezni. Nem az egész feladat részeit fogjuk a folyamatokra bízni, hanem szétosztva a csúcsokat azok adminisztrációs feladatait fogjuk rájuk bízni.

www.tankonyvtar.hu



89

Magát a csúcsok színezését minden egyes folyamat meg fogja csinálni, de a tárolt adatstruktúrák frissítését a szabadsági fokokat és hogy melyik színosztályba rakható be az adott csúcs csak azon csúcsok halmazán belül, melyek az adott folyamatra lettek bízva. Az els® lépés a minimális szabadsági fokkal rendelkez® csúcs megkeresése. Ezt el®ször lokálisan tesszük meg, az adott folyamathoz rendelt csúcsok között, melyekr®l teljes információja van a folyamatnak. Ezek után egy redukcióval a lokális minimumokból globális minimumot kapunk. A globális minimumhoz tartozó csúcsot fogjuk kiszínezni, minden folyamat egyszerre teszi ezt meg. Ezek után az adatstruktúrák frissítését már csak azokon

DR AF T

a csúcsokon hajtják végre a folyamatok, melyek hozzájuk vannak rendelve.

Blokkos ütemezést fogunk használni, mely választásunknak két oka van. El®ször is,

a csúcsok elosztása az adott gráf szempontjából teljesen érdektelen, hiszen a csúcsok

számozása bárhogyan történhet, azok bármilyen sorrendet felvehetnek, így tehát teljesen mindegy milyen szétosztást alkalmazunk. Mivel az el®z® példában ciklusos felbontást alkalmaztunk, ezért itt a példa kedv ;rt a blokkos felbontást fogjuk bemutatni. Dinamikus

felbontást viszont nem igazán lehet ebben a példában (sem) alkalmazni. Másodszor is, egy

ehhez hasonló algoritmus párhuzamosításának két célja szokott lenni : a futásid® csökkentése, illetve az a cél, hogy jóval nagyobb méret¶ problémákat tudjunk kezelni egy elosztott algoritmust sokszor fel tudunk úgy építeni, hogy egy folyamat csak egy részét tárolja le az egész feladatnak, így az elosztott architektúra memóriája összeadódhat, és nagyság-

rendileg több memória állhat a rendelkezésünkre. Bizonyos feladatokhoz kapcsolódó gráf

algoritmusok kifejezetten nagy méret¶ gráfokkal dolgoznak, ahol a memóriakapacitás kife-

jezetten kérdéses lehet. A jelen feladat esetén, ha a folyamatoknak a szomszédsági mátrix csak egy részét kell elküldenünk, akkor a blokkos ütemezés jóval hasznosabb tud lenni, mert a blokkos küldés megvalósítása jóval egyszer¶bb.

Az utóbbi memóriaoptimalizálást nem építettük be a példaprogramunkba, méghozzá

azért, hogy minél egyszer¶bb legyen a végeredmény, és minél közelebb legyen a forráskód

a szekvenciális programhoz. De nagyon nagy gráfok esetén az olvasónak át kell írnia a programot a fentieknek megfelel®en.

7.4. A program

A legtöbb függvény és adatszerkezet nem különbözik szekvenciális megvalósítástól két

kivétellel. A szomszédsági mátrix felépítése kissé cseles módon történik. Ahhoz, hogy a szomszédsági mátrixot egy blokkban küldhessük el, ahhoz folytonos memóriát kell fog-

lalnunk. Így tehát egy egy dimenziós tömböt foglalunk, melyekre külön pointer tömbbel

mutatunk rá abból a célból, hogy továbbra is kétdimenziós tömbként kezelhessük a program többi részében. Ez a pointertömb lesz az

adj tömb. A másik különbség a memory_init

függvény bevezetése, amire a következ®k miatt volt szükség. A mester folyamat, amelyik beolvassa a clq let más ponton kell, hogy memóriát allokáljon a szomszédsági mátrixnak (és a többi adatstruktúrának), mint a szolgák, melyek csak azután allokálhatnak memóriát, miután a mester értesítette ®ket


N

értékér®l. A többi függvény változatlan, így azokat

www.tankonyvtar.hu

90


nem tárgyaljuk külön. A program hasonlóképpen indul, továbbá a indítási függvények találhatóak az eddigieken

main() elején a szokásos MPI keretrendszer kívül. A mester folyamat (id = 0) beolvassa

a clq let.

#include #include #include #include #include <mpi.h> using namespace std ;

DR AF T

001 : 002 : 003 : 004 : 005 : 006 : 007 : 008 : 009 : 010 : 011 : 012 : 013 : 014 : 015 : 016 : 017 : 018 : 019 : 020 : 021 : 022 : 023 : 024 : 025 : 026 : 027 : 028 : 029 : 030 : 031 : 032 : 033 : 034 : 035 : 036 : 037 :

int N ;

string comment="" ;

char **adj ; // szomszedsagi matrix

char *adj_matrix ; // a valodi tarolo

bool **colors ; // szinosztalyok




read_clq(string) ; void write_pbm(string) ; void initialize() ; void memory_init() ; void permutation_color() ; void permto() ;

void


testperm() ;


int i,j,c,min_free, min_sat, min_id ; int id, nproc, id_from ;

int startval, endval, sv, ev ;

if(argc<2){

cerr<<"Usage :

exit (1) ;

} string


le_name(argv[1]) ;

www.tankonyvtar.hu



MPI_Status status ;

// Az MPI inicializalasa :

MPI_Init(&argc, &argv) ; // Rang lekerdezese :

MPI_Comm_rank(MPI_COMM_WORLD, &id) ; // A folyamatok szamanak lekerdezese :

MPI_Comm_size(MPI_COMM_WORLD, &nproc) ; if(id == 0){ read_clq(le_name) ;

DR AF T

038 : 039 : 040 : 041 : 042 : 043 : 044 : 045 : 046 : 047 : 048 : 049 : 050 : 051 :

91

}

MPI_Bcast(&N, 1, MPI_INT, 0, MPI_COMM_WORLD) ; if(id !=0)

---color-par.cpp---

Miután a mester beolvasta a clq let már tudja

N

értékét, így azt szétterítheti (broad-

cast) a szolgáknak. Csak ez után a pont után hívhatják meg a szolgák (id!=0) a

memory_init

függvényt. Mivel blokkos ütemezést fogunk alkalmazni a csúcsok tekintetében itt számoljuk ki az kezd® és végcsúcsok sorszámát, azaz a

startval

és az

endval

értékét. Az egész

szomszédsági mátrixot szétterítjük a folyamatok között (broadcast), ami után az inicializálást végz® folyamat kerül meghívásra. Figyeljük meg, hogy a szomszédsági mátrix szétterítése a fent részletezett egydimenziós tömb segítségével történik ! Ugyancsak itt kell megemlítenünk, hogy

bool típus helyett char típust használtunk, mert az openmpi keret-

rendszer amiben a fejlesztettünk csak az MPI 2.2 szabványt támogatja, amelyikben még nincs deniálva a

bool

típus az MPI kommunikáció számára.

Egy bonyolultabb implementáció nem az egész mátrixot, csak annak egy részét, pon-

tosabban a

startval

és

endval

közötti sávját adná át a szolgáknak. Mivel ez a program

jóval bonyolultabb lenne, döntöttünk a mellett, hogy ezt nem implementáljuk és a teljes mátrix szétterítését mutatjuk be példaprogramunkban.

---color-par.cpp---

048 : read_clq(le_name) ; 049 : } 050 : MPI_Bcast(&N, 1, MPI_INT, 051 : if(id !=0) 052 : memory_init() ; 053 : startval = N*id/nproc ; 054 : endval = N*(id+1)/nproc ; 055 :


0, MPI_COMM_WORLD) ;

www.tankonyvtar.hu

92


056 : MPI_Bcast(adj_matrix, N*N, MPI_CHAR, 057 : 058 : initialize() ; 059 : 060 : //N csucsot szinezunk egymas utan :


---color-par.cpp---

DR AF T

Ezek után kezd®dik maga a színezés. Hasonlóan a szekvenciális programhoz ciklusban

N

csúcsot fogunk kiszínezni. El®ször kiválasztjuk a legkisebb szabadsági fokkal rendelkez®

csúcsot, illetve az azonos szabadsági fokúak közül a legtöbb szomszéddal rendelkez®t.

---color-par.cpp---

058 : initialize() ; 059 : 060 : //N csucsot szinezunk egymas utan : 061 : for(int v=0 ;vfree_num[i] || 068 : min_free==free_num[i] && sat[i]<min_sat)){ 069 : min_free=free_num[i] ; 070 : min_sat=sat[i] ; 071 : min_id=i ; 072 : } 073 : 074 : struct{ ---color-par.cpp---

Hasonlóan az el®z® fejezet problémájához egy minimum hely redukciót fogunk végez-

ni a lokális minimumokon. Egy struktúrát hozunk létre a csúcs sorszámából (min_id) és

a hozzá tartozó szabadsági fokból (min_free). Ezek után az Allreduce függvénnyel ké-

pezzük a globális minimumot és annak helyét amely függvény szétszórja a végeredményt, azaz minden egyes folyamat tudomására jut az globális minimum csúcs sorszáma (id) és a szabadsági foka (f reedom). Egy kis csalást követtünk el ezen a ponton, mivel az eredeti algoritmus szerint azonos szabadsági fokok mellett a maximális fokszámú csúcsot kell kiválasztanunk. Ezt megtesszük a lokális minimum kiválasztásakor, de a lokális minimumok

www.tankonyvtar.hu



93

közül amikor kiválasztjuk a globálisat már nem tör®dünk ezzel. Azaz az el®írt algoritmust csak részben valósítjuk meg. Természetesen megtehetnénk, hogy a globális minimum választását nem a beépített redukáló függvénnyel valósítjuk meg, hanem a szolgák az id és a f reedom értékek mellett a csúcs fokszámát is elküldenék a mesternek, aki manuálisan választana közülük globális optimumot és küldené vissza az eredményt, pontosan követve az eredeti algoritmust. Ezzel egy kissé megbonyolítanánk a programot, miközben az els®dleges célunk az egyszer¶sítés. Továbbá, ahogy már említettük, a maximális fokszám választás heurisztikájának kérdése nem kell®képpen alátámasztott a szakirodalomban mennyire van hatással az algoritmus viselkedésére. Így tehát a minimum hely redukció választása jó

DR AF T

kompromisszumnak t¶nt a részünkr®l.

---color-par.cpp---

072 : 073 : 074 : 075 : 076 : 077 : 078 : 079 : 080 : 081 : 082 :

}

struct{

int free ; int id ;

} p, tmp_p ;

p.id=min_id ;

p.free=min_free ;

//nem optimalis,

//a minimum szabadsagi fokot es fokszamot egyszerre kene neznunk

MPI_Allreduce(&p,

&tmp_p,

1,

MPI_2INT,

MPI_MINLOC,

MPI_COMM_WORLD) ;

083 : 084 : 085 : 086 : 087 :

min_id=tmp_p.id ;

min_free=tmp_p.free ;

OK[min_id]=1 ; //kesz arra, hogy kiszinezzuk

---color-par.cpp---

Az adott csúcsokhoz tartozó adatstruktúrák (szabadsági fok, illetve melyik színosztály-

ba helyezhet® még el) frissítése hasonlóan történik a szekvenciális programhoz. El®ször is,

ha a színezend® csúcs szabadsági foka 0, azaz egyik színosztályba sem helyezhet®, akkor egy új színosztályt nyitunk neki, és abba helyezzük. Vegyük észre, hogy az a tény, hogy a szabadsági fok 0 ismert az összes folyamat számára, azaz mindegyik folyamat egy új szín-

osztályt nyit a csúcs számára. Megint csak növeljük az összes nem kiszínezett csúcs szabadsági fokát, majd csökkentjük azokét, akik szomszédosak az éppen kiszínezett csúccsal. A soros programtól való eltérés csak abban nyilvánul meg, hogy a ciklusok a az

endval

startval

és

csúcsindexek között futnak, mivel blokkos ütemezést valósítottunk meg, és csak

azon csúcsok információit frissítjük, melyek az adott folyamathoz vannak rendelve.


www.tankonyvtar.hu

94


---color-par.cpp--min_free=tmp_p.free ; OK[min_id]=1 ; //kesz arra, hogy kiszinezzuk

//kiszinezzuk :

if(min_free==0){ //uj szinosztalyra van szuksegunk colors[num_color][min_id]=1 ;

//az uj szinosztaly a tobbi csucs szamara lehetseges szinosztal

DR AF T

085 : 086 : 087 : 088 : 089 : 090 : 091 : 092 : 093 : 094 : 095 : 096 : 097 : 098 : 099 : 100 : 101 : 102 : 103 : 104 : 105 : 106 : 107 : 108 :

for(i=startval ;i<endval ;++i) if( !OK[i]){


}


for(i=startval ;i<endval ;++i){ if( !OK[i] && adj[i][min_id]){


}

}

++num_color ;

}

else{

//egy mar meglevo szinosztalyba rakjuk a csucsot //keressuk meg az elso szinosztalyt :

---color-par.cpp---

A másik eset az, amikor a választott csúcsot ki tudjuk színezni egy már meglév® színnel.

Ez az eset egy kicsit bonyolultabb, mivel csak az a folyamat tudja, melyik színosztályba kerül majd a csúcs, amelyhez az hozzá van rendelve. Így tehát els®nek meg kell találnunk, melyik folyamathoz van hozzárendelve a színezend® csúcs egy egyszer¶ ciklusban lépkedünk, és ugyanúgy számolunk, ahogy a

startval

és

endval értékeket feljebb kiszámoltuk. id_from változóban tároljuk, és

Az eredményt, azaz a tulajdonos folyamat sorszámát az

mivel a ciklust minden egyes folyamat lefuttatja, ezért minden folyamat tud róla. Ezek

után csak az a folyamat melyhez a színezend® csúcs tartozik (id==id_from) meghatároz-

za a színosztályt, majd ennek az értékét (c) szétszórja (broadcast) a többi folyamatnak.

Az ezt követ® kódrészlet azonos a szekvenciális programmal a blokk ütemezés kivételével, amely a ciklusokat a

www.tankonyvtar.hu

startval

és az

endval

között futtatja.



95

---color-par.cpp---

104 : 105 : 106 : 107 : 108 : 109 : 110 : 111 :

} ++num_color ;

}

else{

//egy mar meglevo szinosztalyba rakjuk a csucsot //keressuk meg az elso szinosztalyt : int id_from ;

DR AF T

for(id_from=0 ;id_from
break ;

112 : 113 : 114 : 115 : 116 : 117 : 118 : 119 : 120 : 121 : 122 : 123 : 124 : 125 : 126 :

if(id==id_from) for(c=0 ; !free_color[min_id][c] ;++c) ; MPI_Bcast(&c, 1, MPI_INT, id_from, MPI_COMM_WORLD) ; colors[c][min_id]=1 ;


for(i=startval ;i<endval ;++i){ if( !OK[i] && free_color[i][c] && adj[i][min_id]){ free_color[i][c]=0 ; --free_num[i] ;

}

}

}

}

cout<<"number of DSATUR colors : "<
---color-par.cpp---

A

main végén kiírjuk a felhasznált színosztályok számát (minden folyamat kiírja, hogy

az eredményeket tesztelés céljából összevethessük), és a mester folyamat elkészíti a permu-

write_pbm függvényt az átrendezett szomszédsági Végezetül a Finalize lezárja az MPI keretrendszert.

tációt, majd meghívja a kép-leba kiírásáért.

mátrix PMB

---color-par.cpp---

123 : } 124 : } 125 : cout<<"number of DSATUR colors: "<

www.tankonyvtar.hu

96


130 : write_pbm(le_name) ; 131 : } 132 : // Az MPI befejezese : 133 : MPI_Finalize() ; 134 : 135 : } 136 : 137 : void initialize(){

DR AF T

---color-par.cpp---

Az új

memory_init függvény az adatstruktúrák memória allokálásáért felel. Ugyancsak

itt történik az a trükk, ahogy megfeleltetjük az egydimenziós szomszédsági mátrixnak (adj_matrix) a kétdimenziós

adj

tömböt pointereken keresztül.

---color-par.cpp---

150 : } 151 : 152 : void memory_init(){ 153 : int i,j ; 154 : adj=new char*[N] ; 155 : adj_matrix=new char[N*N] ; 156 : colors=new bool*[N] ; 157 : free_color=new bool*[N] ; 158 : for(i=0 ;i
www.tankonyvtar.hu



97

read_clq függvény csak abban különbözik a szekvenciális programtól, hogy a konkrét memóriafoglalás helyett ez a függvény is meghívja a memory_init függvényt. A

7.4.1. A teljes párhuzamos program

#include #include #include #include #include <mpi.h> using namespace std ;

DR AF T

001 : 002 : 003 : 004 : 005 : 006 : 007 : 008 : 009 : 010 : 011 : 012 : 013 : 014 : 015 : 016 : 017 : 018 : 019 : 020 : 021 : 022 : 023 : 024 : 025 : 026 : 027 : 028 : 029 : 030 : 031 : 032 : 033 : 034 : 035 : 036 : 037 :

int N ;

string comment="" ;

char **adj ; // szomszedsagi matrix

char *adj_matrix ; // a valodi tarolo

bool **colors ; // szinosztalyok




read_clq(string) ; write_pbm(string) ; void initialize() ; void memory_init() ; void permutation_color() ; void permto() ;

void

void


testperm() ;


int i,j,c,min_free, min_sat, min_id ; int id, nproc, id_from ;

int startval, endval, sv, ev ;

if(argc<2){

cerr<<"Usage :

exit (1) ;

} string


le_name(argv[1]) ;


www.tankonyvtar.hu

98

MPI_Status status ;

// Az MPI inicializalasa :


MPI_Comm_rank(MPI_COMM_WORLD, &id) ; // A folyamatok szamanak lekerdezese :

MPI_Comm_size(MPI_COMM_WORLD, &nproc) ; if(id == 0){ read_clq(le_name) ;

DR AF T

038 : 039 : 040 : 041 : 042 : 043 : 044 : 045 : 046 : 047 : 048 : 049 : 050 : 051 : 052 : 053 : 054 : 055 : 056 : 057 : 058 : 059 : 060 : 061 : 062 : 063 : 064 : 065 : 066 : 067 : 068 : 069 : 070 : 071 : 072 : 073 : 074 : 075 : 076 : 077 : 078 :


}

MPI_Bcast(&N, 1, MPI_INT, 0, MPI_COMM_WORLD) ; if(id !=0) memory_init() ; startval = N*id/nproc ; endval =

N*(id+1)/nproc ;

MPI_Bcast(adj_matrix, N*N, MPI_CHAR, 0, MPI_COMM_WORLD) ; initialize() ;

//N csucsot szinezunk egymas utan :

for(int v=0 ;v
//keressuk meg a legkisebb szabadsagi fokkal rendelkezo csucsot :

for(i=startval ;i<endval ;++i) if( !OK[i] && (min_free>free_num[i] ||

min_free==free_num[i] && sat[i]<min_sat)){

min_free=free_num[i] ; min_sat=sat[i] ; min_id=i ;

}

struct{

int free ; int id ; } p, tmp_p ; p.id=min_id ;

www.tankonyvtar.hu



079 : 080 : 081 : 082 :

99

p.free=min_free ;

//nem optimalis, //a minimum szabadsagi fokot es fokszamot egyszerre kene neznunk

MPI_Allreduce(&p,

&tmp_p,

1,

MPI_2INT,

MPI_MINLOC,

MPI_COMM_WORLD) ; min_id=tmp_p.id ; min_free=tmp_p.free ;

DR AF T

083 : 084 : 085 : 086 : 087 : 088 : 089 : 090 : 091 : 092 : 093 : 094 : 095 : 096 : 097 : 098 : 099 : 100 : 101 : 102 : 103 : 104 : 105 : 106 : 107 : 108 : 109 : 110 : 111 :

break ;

112 : 113 : 114 : 115 : 116 : 117 :

OK[min_id]=1 ; //kesz arra, hogy kiszinezzuk

//kiszinezzuk :

if(min_free==0){

//uj szinosztalyra van szuksegunk colors[num_color][min_id]=1 ;

//az uj szinosztaly a tobbi csucs szamara lehetseges szinosztal

for(i=startval ;i<endval ;++i) if( !OK[i]){


}


for(i=startval ;i<endval ;++i){ if( !OK[i] && adj[i][min_id]){


}

}

++num_color ;

}

else{

//egy mar meglevo szinosztalyba rakjuk a csucsot //keressuk meg az elso szinosztalyt : int id_from ;

for(id_from=0 ;id_from

for(i=startval ;i<endval ;++i){


www.tankonyvtar.hu

100

if( !OK[i] && free_color[i][c] && adj[i][min_id]){ free_color[i][c]=0 ; --free_num[i] ; } } } } cout<<"number

of DSATUR colors: "<
if(id==0){ permutation_color() ; testperm() ; permto() ; write_pbm(le_name) ;

DR AF T

118 : 119 : 120 : 121 : 122 : 123 : 124 : 125 : 126 : 127 : 128 : 129 : 130 : 131 : 132 : 133 : 134 : 135 : 136 : 137 : 138 : 139 : 140 : 141 : 142 : 143 : 144 : 145 : 146 : 147 : 148 : 149 : 150 : 151 : 152 : 153 : 154 : 155 : 156 : 157 : 158 :


}

// Az MPI befejezese :

MPI_Finalize() ;

}

void

initialize(){

int sum ;

for(int i=0 ;i
for(int j=0 ;j
free_color[i][j]=0 ; sum += adj[i][j] ;

}

sat[i]=sum ;

free_num[i]=0 ; OK[i]=0 ;

}

}

void

memory_init(){

int i,j ;

new char*[N] ; adj_matrix=new char[N*N] ; colors=new bool*[N] ; free_color=new bool*[N] ; for(i=0 ;i
www.tankonyvtar.hu



adj[i]=adj_matrix+(i*N) ;

new bool[N] ; free_color[i]=new bool[N] ; colors[i]= }

new int[N] ; free_num = new int[N] ; OK = new bool[N] ; for(i=0 ;i
DR AF T

159 : 160 : 161 : 162 : 163 : 164 : 165 : 166 : 167 : 168 : 169 : 170 : 171 : 172 : 173 : 174 : 175 : 176 : 177 : 178 : 179 : 180 : 181 : 182 : 183 : 184 : 185 : 186 : 187 : 188 : 189 : 190 : 191 : 192 : 193 : 194 : 195 : 196 : 197 : 198 : 199 :

101

adj[i][j]=0 ;

}

void

read_clq(string le_name){

int i,j,n,m,x,y ;

string type,line ;

ifstream n(le_name.c_str()) ; if( !n.is_open()){ cout<<"ERROR

exit(1) ;


}

//toroljuk ki a komment sorokat

while(n.peek()=='c'){ getline(n,line) ;

comment=comment+"#"+line+'\n' ;

}

n>>type ; // a matrix tipusa (P1) n>>type ; // el

n>>N ; // csucso n>>m ; // elek

//az N ertekenek megfelelo memoriaterulet lefoglalasa :

memory_init() ;

for(i=0 ;i<m ;i++){ n>>type ; // e

if(type=="e"){

n>>x ;n>>y ;

//cout<<"x : "<<x<<" ; y : "<

www.tankonyvtar.hu

102

adj[y-1][x-1]=1 ; } } n.

close() ;

} void

write_pbm(string le_name){

int i,j ; le_name=le_name+".pbm" ;

DR AF T

200 : 201 : 202 : 203 : 204 : 205 : 206 : 207 : 208 : 209 : 210 : 211 : 212 : 213 : 214 : 215 : 216 : 217 : 218 : 219 : 220 : 221 : 222 : 223 : 224 : 225 : 226 : 227 : 228 : 229 : 230 : 231 : 232 : 233 : 234 : 235 : 236 : 237 : 238 : 239 : 240 :


fout(le_name.c_str()) ; if( !fout.is_open()){ ofstream

cout<<"ERROR

exit(1) ;


}

fout<<"P1"<<endl ; fout<
"<
for(i=0 ;i
";

fout<<"0

";

else

}

fout<<endl ;

}

fout.

close() ;

}

void

permutation_color(){

int i,j,k, max, maxcol, sum ; int *colors_sum=

new int[num_color] ;

for(i=0 ;i
for(j=0 ;j
sum += colors[i][j] ; colors_sum[i]=sum ; }

for(i=0 ;i
www.tankonyvtar.hu



max=0 ;

for(j=0 ;jmax){ max=colors_sum[j] ; maxcol=j ; }

for(j=0 ;j
DR AF T

241 : 242 : 243 : 244 : 245 : 246 : 247 : 248 : 249 : 250 : 251 : 252 : 253 : 254 : 255 : 256 : 257 : 258 : 259 : 260 : 261 : 262 : 263 : 264 : 265 : 266 : 267 : 268 : 269 : 270 : 271 : 272 : 273 : 274 : 275 : 276 : 277 : 278 : 279 :

103

colors_sum[maxcol]=0 ;

}

}

void

permto(){

int i,j ;

new bool*[N] ;

bool **tmp=

for(i=0 ;i
tmp[i][j]=adj[perm[i]][perm[j]] ;

for(i=0 ;i
adj[i][j]=tmp[i][j] ;

}

void

testperm(){

int sum ;

for(int i=0 ;i
for(int j=0 ;j
exit (1) ;

permutation! !"<<endl ;

}

}

}

A programunk m¶ködését két példával szeretnénk demonstrálni. A két példa clq le eredeti szomszédsági mátrixát is átkonvertáltuk kép-leba, és ugyancsak megmutatjuk a színezés


www.tankonyvtar.hu

104


után átrendezett szomszédsági mátrixot, ami a program kimenete. A két példa a fentebb már említett DIMACS honlapról való és a Keller sejtés problémájának különböz® méret¶ bizonyításai.

keller4

gráfot 25 színnel színezte ki :

DR AF T

A DSATUR algoritmus a

7.1. ábra. Az eredeti keller4 gráf

7.2. ábra. Az átrendezett keller4 gráf

A DSATUR algoritmus a

www.tankonyvtar.hu

keller5

gráfot 50 színnel színezte ki :


105

DR AF T


7.3. ábra. Az eredeti keller5 gráf


www.tankonyvtar.hu


DR AF T

106

7.4. ábra. Az átrendezett keller5 gráf

7.5. Felhasználás

Ebben a fejezetben néhány példát szeretnénk bemutatni melyekben az itt részletezett párhuzamosítás a segítségünkre lehet. Ahogyan azt már korábban említettük a p¶rhuzamosítás két korlát átlépését segítheti el® : az id®beli és a memória korlátokat.

A bemutatott párhuzamos program és variánsai kihasználva az elosztott memória jóval

nagyobb méretét sokkal nagyobb gráfok színezését is lehet®vé teszi, mint amit egy számítógép képes megcsinálni. Szó szerint száz gigabyte-nyi memóriát is használhatunk akár egy osztályteremnyi PC segítségével. Az egyik példánk a gráfok élszínezése azon szabályok szerint, amint azt Szabó Sándor cikkében kifejti.[Szab2012a] Ez a típusú elszínezés

ekvivalens azzal, mint amikor a gráf származtatott gráfját színezzük, ahol minden élnek az eredeti gráfban egy csúcs felel meg a származtatott gráfban. A párhuzamos program

www.tankonyvtar.hu



107

képes akkora gráfokat kiszínezni, melyek származtatott gráfja 200 0002 000 000 (két millió) csúccsal is rendelkezik. Az élet DSATUR színezése jobb optimum határt adott, mint ugyanazon gráfok csúcsszínezései. Ilyen méret¶ színezések csak párhuzamos architektúrán lehetségesek ésszer¶ id®n belül, hiszen a legnagyobb esetek színezése órákig tartott 100 processzoron is. A másik cél értelemszer¶en a gyorsabb számítás. Bizonyos típusú színezések sokkal több munkát igényelnek abban, hogy eldöntsük egy adott csúcsról bekerülhet-e egy színosztályba vagy sem. Egy példa az ilyen színezésre az

s-klikk

mentes színezés melyet az ol-

vasó Szabó Sándor és Zaválnij Bogdán cikkében talál meg.[Szab2012b] Ismételten, ahogy egyre nagyobb és nagyobb egyre több és több számítási kapacitásra van szükségünk,

DR AF T

s

és egy gépen a számítás egyszer¶en kivitelezhetetlen lesz. Csak a párhuzamosítás jelent megoldást ezekben az esetekben.


www.tankonyvtar.hu


DR AF T

108

www.tankonyvtar.hu


8. fejezet

DR AF T

Lineáris egyenletrendszerek megoldása

Ebben a fejezetben lineáris egyenletrendszereket megoldó algoritmusok lehetséges párhu-

zamosításait fogjuk tárgyalni. Lineáris egyenletrendszerek igen sok tudományos és mérnöki

probléma esetén kerülhetnek el®térbe, és számtalan numerikus algoritmus ismert ezek megoldására. Dierenciálegyenletek megoldásához éppúgy használatosak, mint optimalizációs

feladatok esetén. Az egyik lehetséges algoritmus a probléma megoldására a Gauss elimi-

náció, vagy ahogy gyakran említik a Gauss-Jordan elimináció. Ebben a fejezetben ezt az algoritmust fogjuk körüljárni.

A modern nagy-teljesítmény¶ számítások (high performance computing) igen gyakran

éppen erre a problémára koncentrálnak. Valójában napjaink szuper-számítástechnikájának de facto mérési eszköze a LINPACK Benchmark (teljesítményvizsgáló program), aminek

egyik kit¶zött célja a s¶r¶ lineáris egyenletrendszerek megoldása. Ezt a programot hasz-

nálja a leghíresebb szuper-számítástechnikai honlap is, a TOP500, hogy az aktuális listáját a világ szuperszámítógépeir®l összeállítsa (http://www.top500.org/).

Könyvünkben nem kívánunk versenyre kelni a korszer¶ fejlett soros és párhuzamos

programokkal amik ezt a problémát hivatottak megoldani, mindazonáltal szeretnénk egy jó példát bemutatni a Gauss elimináció párhuzamosításának lehet®ségeir®l.

8.1. A probléma

Az alapvet® probléma szerint adott egy lineáris egyenletekb®l álló rendszer, aminek a megoldását keressük. Bemutatjuk a feladat egy egyszer¶ megoldását és annak párhuzamosítását. Az egyenletrendszert a következ®képpen írhatjuk fel :

a(1,1)x1 + a(1,2)x2 + a(1,3)x3 + · · · + a(1, n)xn − b1 = 0 a(2,1)x1 + a(2,2)x2 + a(2,3)x3 + · · · + a(2, n)xn − b2 = 0

(8.1)

. . .

a(n,1)x1 + a(n,2)x2 + a(n,3)x3 + · · · + a(n, n)xn − bn = 0 A kiindulási állapotban ismerjük az összes

a(i, j) és bi értékét, és keressük azon x1 , x2 , . . . , xn

értékeket, melyek kielégítik az egyenletrendszert.


www.tankonyvtar.hu

110

Bevezetés az MPI programozásba példákon keresztül Gyakran ezeket az egyenletrendszereket mátrix formában is szokás felírni.

Ax − b ahol az

A egy n×n-es mátrix, melynek elemei a(i, j), az x vektor tartalmazza az x1 , x2 , . . . , xn b vektor elemei a b1 , b2 , . . . , bn konstansok. El®ször a lineáris

ismeretleneket, továbbá a

egyenletrendszerek megoldásának általános algoritmusát fogjuk ismertetni és bemutatunk egy szemléltet® példát is. Majd bemutatjuk a konkrét programot, illetve ezek után a párhuzamos algoritmust és programot.

b vektort az A mátrixés n + 1 oszlopa legyen.

DR AF T

Abból a célból, hogy leegyszer¶sítsük a feladatainkat hasznos a

ba integrálni, azaz úgy átalakítani a mátrixot, hogy annak

n

sora

Legyen

a(1, n + 1) = −b1 a(2, n + 1) = −b2

. . .

a(n, n + 1) = −bn

A (8.1) egyenletünk a következ®képpen fog ezek után kinézni :

a(1,1)x1 + a(1,2)x2 + a(1,3)x3 + · · · + a(1, n)xn + a(1, n + 1) = 0 a(2,1)x1 + a(2,2)x2 + a(2,3)x3 + · · · + a(2, n)xn + a(2, n + 1) = 0 . . .

a(n,1)x1 + a(n,2)x2 + a(n,3)x3 + · · · + a(n, n)xn + a(n, n + 1) = 0

Az algoritmus ismertetése során fogunk majd kitérni arra, mi célt szolgál ez a lépés.

8.2. Az elimináció

Az algoritmus két lépésb®l áll : els® az eliminációs lépés, majd második a visszahelyettesí-

tési lépés. Abból a célból, hogy szemléltessük az eliminációs lépést tekintsük a következ® három egyenletb®l álló rendszert :

2x1 − 4x2 + 24x3 − 12 = 0 6x1 + 18x2 + 12x3 + 24 = 0 3x1 + 7x2 − 2x3 − 4 = 0

Amit mátrix formában a következ®képpen írhatunk fel :

 2 −4 24 −12  6 18 12 24  3 7 −2 4 

www.tankonyvtar.hu


8. fejezet. Lineáris egyenletrendszerek megoldása El®ször elimináljuk az meghagyjuk az

x1 -et,

x1 -et

111

két egyenletb®l. A második egyenletet választjuk, amiben

mert ott az

x1

koeciensének abszolút értéke a legnagyobb. Ahhoz,

hogy elvégezzük az eliminációt ennek az egyenletnek, amib®l nem elimináljuk az összes

a(i, j)

koeciensét el kell osszuk ennek az egyenletnek az

x1

x1 -et,

az

koeciensével.

Az egyenleteket szokás olyan módon átrendezni, hogy azt az egyenletet helyezzük el legfelül, amib®l nem elimináljuk az

x1 -et.

Az átrendezett egyenletek a következ®k :

6x1 + 18x2 + 12x3 + 24 = 0 2x1 − 4x2 + 24x3 − 12 = 0 3x1 + 7x2 − 2x3 − 4 = 0

(8.2a) (8.2b)

DR AF T

(8.2c)

Amit mátrix alakban a következ®képpen írhatunk fel :

 24 6 18 12  2 −4 24 −12  4 3 7 −2 

Most elimináljuk az

x1 -et

az összes egyenletb®l a (8.2a) egyenletet kivéve. A (8.2a)

egyenletet pivot egyenletnek hívjuk, és az

x1

koeciensét ebben az egyenletben pivot

(−2/6)-al, azaz a második és az (−1)-szeresével, és hozzá kell adnunk az els®

elemnek. Az els® egyenletet tehát meg kell szoroznunk els® egyenlet

x1

tagja koeciensei arányának

egyenletet a második, a (8.2b) egyenlethez. A szorzás után a két egyenlet a következ® formát veszi fel :

−2x1 − 6x2 − 4x3 − 8 = 0 2x1 − 4x2 + 24x3 − 12 = 0

Összeadva a két egyenletet kapjuk, hogy

−10x2 + 20x3 − 20 = 0

A (8.2a)(8.2c) egyenletek ezek után :

6x1 + 18x2 + 12x3 + 24 = 0 − 10x2 + 20x3 − 20 = 0 3x1 + 7x2 − 2x3 − 4 = 0

Mátrix formában felírva :

(8.4a)

(8.4b) (8.4c)

 24 18 12  −10 20 −20  3 7 −2 4 

6

Megismételjük az eljárást, ezúttal a (8.2a) egyenletet

(−3/6)-al

megszorozva és az

eredményt hozzáadva a (8.2c) egyenlethez. Az eredményként kapott egyenletrendszer :

6x1 + 18x2 + 12x3 + 24 = 0 − 10x2 + 20x3 − 20 = 0 − 2x2 − 8x3 − 16 = 0 c Várady Géza, Zaválnij Bogdán, PTE

(8.5a) (8.5b) (8.5c)

www.tankonyvtar.hu

112





6



Ezek után az

x2 -®t

szeretnénk eliminálni a (8.5b) illetve a (8.5c) egyenletek egyikéb®l.

x2

A (8.5b) egyenletben nagyobb az egyenletb®l fogjuk eliminálni az egyenletet most

 18 12 24 −10 20 −20  −2 −8 −16

(−2/10)-vel

koeciensének abszolút értéke, így tehát a (8.5c)

x2 -®t, és a (8.5b) egyenlet lesz most a pivot egyenlet. Ezt az

szorozzuk, és az eredményként kapott egyenletet hozzáadjuk

DR AF T

a (8.5c) egyenlethez. A következ® egyenletrendszert kapjuk :

6x1 + 18x2 + 12x3 + 24 = 0 − 10x2 + 20x3 − 20 = 0 − 12x3 − 12 = 0

(8.6a)

(8.6b) (8.6c)




6



18 −10

 12 24 20 −20  −12 −12

Amivel be is fejeztük az eliminálási fázist. Vegyük észre, hogy az utolsó, a (8.6c) egyen-

letben csak egy ismeretlenünk van !

Általános esetre nézve az eliminálás algoritmusa a következ® lesz.

Algoritmus 2 Eliminálási lépés 1: for irow ← 1, n − 1 do 2: 3:

icol ← irow Az icol oszlopban keressük meg a maximális |a(jrow, icol)| koecienst minden jrow sorra irow és n között. 4: Ha irow 6= jrow cseréljük fel a irow sort és a jrow sort. A irow sor lesz a pivot sor.

5: 6:

for jrow ← irow + 1, n do Szorozzuk meg minden

a(irow, kcol)-t −a(jrow, irow)/a(irow, irow)-el minden

kcol ≥ irow-re.

7:

Adjuk hozzá a

irow

sort a

jrow

sorhoz. Az eredmény lesz az új

jrow

sor.

Az eliminációs lépés után az egyenletrendszerünk a következ® formában írható fel :

Wx = 0 www.tankonyvtar.hu


8. fejezet. Lineáris egyenletrendszerek megoldása

113

amit kifejtve

w(1,1)x1 + w(1,2)x2 + w(1,3)x3 + · · · + +w(1, n − 1)xn−1 +w(1, n)xn +w(1, n + 1)= 0 w(1,2)x2 + w(1,3)x3 + · · · + +w(1, n − 1)xn−1 +w(1, n)xn +w(1, n + 1)= 0 w(1,3)x3 + · · · + +w(1, n − 1)xn−1 +w(1, n)xn +w(1, n + 1)= 0 . . .

w(1, n − 1)xn−1 +w(1, n)xn +w(1, n + 1)= 0 w(1, n)xn +w(1, n + 1)= 0

DR AF T

(8.7)

i sorban minden w(i, k)=0, k
algoritmust Gauss eliminációnak.

8.3. Visszahelyettesítés

A második fázisban megoldjuk a 8.7 egyenleteket. Mivel az utolsó,

n-ik

sorban csak egy

xn , így ezt közvetlenül ki tudjuk számítani. Ezek után a xn értéket visszahelyettesíthetjük a korábbi, 1(n−1), egyenletekbe. Így, mivel az xn értékét már behelyettesítettük az (n − 1)-ik egyenletbe, ebbe az egyenletbe is már csak egy ismeretlen maradt, az xn−1 . Ennek az értékét ismételten ki tudjuk közvetlenül számítani az (n−1)-ik egyenletb®l. És így lépkedünk tovább lentr®l felfelé, végig az összes ismeretlenünk van, konkrétan az kiszámított

egyenleten. Ezt a fázist éppen azért hívják visszahelyettesítésnek, mert az ismeretlenek kiszámolt értékeit mindig visszahelyettesítjük a korábbi egyenletekbe.

A visszahelyettesítések lépéseit az el®z® példánk 8.6a8.6c egyenletein fogjuk bemutat-

ni. Els®ként

x3

értékét számoljuk ki a 8.6c egyenletb®l, így azt kapjuk, hogy

x3 = −1,

miközben a másik két egyenlet marad :

6x1 + 18x2 + 12x3 + 24 = 0 − 10x2 + 20x3 − 20 = 0

A visszahelyettesítés során az

(8.8a)

(8.8b)

x3 kiszámolt értékét visszahelyettesítjük ezekbe az egyen-

letekbe, így a következ® formát kapjuk :

6x1 + 18x2 + 12 = 0 − 10x2 − 40 = 0

A 8.9b egyenlet már csak egy ismeretlent, az

x2 -®t,

(8.9a)

(8.9b) tartalmaz, ami alapján

x2 = −4 c Várady Géza, Zaválnij Bogdán, PTE

www.tankonyvtar.hu

114

Bevezetés az MPI programozásba példákon keresztül Visszahelyettesítve ennek értékét a 8.9a egyenletbe

6x1 − 60 = 0

(8.10a)

Ami alapján

x1 = 10 Így tehát megkaptuk az egyenletrendszerünk megoldását

x1 , x2

and

x3

változókra.

A visszahelyettesítés általános algoritmusa :

DR AF T

Algoritmus 3 A visszahelyettesítés fázisa 1: for icol ← n, 1 lefelé lépked −1-el do 2: 3: 4:

xicol ← −w(icol, n + 1)/w(icol, icol)

for jrow ← 1, icol − 1 do

w(jrow, n + 1) ← w(jrow, n + 1) + a(jrow, icol)x(icol)

8.4. A program

Bemutatjuk a fentiek szerinti soros programot. A fejlécben deklaráljuk az

Ab

mátrixot és a

x

ismeretlenek vektorát. Az

N

konstans

határozza meg a probléma méretét.

001 : 002 : 003 : 004 : 005 : 006 : 007 : 008 : 009 : 010 : 011 : 012 : 013 : 014 : 015 : 016 : 017 : 018 : 019 : 020 :

#include #include #include <math.h> #include using namespace std ; const int N=8 ;

double Ab[N][N+1] ;

//az A matrix es a b oszlop

//az N-ik oszlopban a -b ertekek

double oriAb[N][N+1] ; //az eredeti Ab matrix az eredmeny tesztelesere double x[N]={0} ; //a megoldas vektor

PrintMatrix() ; SetMatrix() ; void TestSolution() ;

void

void

int

main(){

int irow,jrow, j, jmax ;

www.tankonyvtar.hu



021 :

115

double t, amul, item, item_max ;

---gauss.cpp---

A

int main()

függvény végzi magát a számítást. Az els® rész állítja fel a problémát,

az utolsó visszahelyettesítéssel leellen®rzi a megoldást. A számítás három alaplépése a pivotálás, az eliminálás ezek egy for ciklusban történnek és a visszahelyettesítés. Az

Ab

mátrixot és az

x

elemeit kiírjuk minden lépés után.

DR AF T

aktuális

---gauss.cpp---

017 : void TestSolution() ; 018 : 019 : int main(){ 020 : int irow,jrow, j, jmax ; 021 : double t, amul, item, item_max ; 022 : time_t ts, te ; 023 : 024 : SetMatrix() ; 025 : //az eredeti matrix : 026 : PrintMatrix() ; 027 : 028 : ts=clock() ; 029 : for(irow=0 ;irowitem_max){ 036 : jmax=jrow ; 037 : item_max=fabs(Ab[jrow][irow]) ; 038 : } 039 : //sorok felcserelese ha szukseges 040 : if(jmax !=irow) 041 : for(j=0 ;j

www.tankonyvtar.hu

116


t=-1.0/Ab[irow][irow] ;

for(jrow=irow+1 ;jrow
//a sor eliminalasa

for(j=irow ;j
DR AF T

048 : 049 : 050 : 051 : 052 : 053 : 054 : 055 : 056 : 057 : 058 : 059 : 060 : 061 : 062 : 063 : 064 : 065 : 066 : 067 : 068 : 069 : 070 : 071 : 072 : 073 : 074 : 075 : 076 : 077 : 078 : 079 :

//a felso garomszor matrix :

PrintMatrix() ;

//visszahelyettesitesi lepes

for(irow=N-1 ;irow>=0 ;--irow){

x[irow]= - Ab[irow][N]/Ab[irow][irow] ;

for(jrow=0 ;jrow
Ab[jrow][N] += x[irow] * Ab[jrow][irow] ; Ab[jrow][irow]=0 ;

}

}

clock() ;

te=

cout<<"time

elapsed: "<
//a megoldas matrix :

PrintMatrix() ; TestSolution() ;

}

void

SetMatrix(){

int i,j ;

srand(time(NULL)) ;

---gauss.cpp---

A

SetMatrix() függvény véletlen számokkal tölti fel a mátrixot. A bemutatott esetben

0 és 9 közötti nemnegatív számokkal. Ha jobban kívánjuk közelíteni a valós eseteket, akkor inkább egy

(double)rand()/rand()

szer¶ véletlen-generálást kellett volna választanunk,

amely egyenl®tlen eloszlású lebeg®pontos számokkal szolgálna a 0 és 1 közötti tartományban. Ahogy azt majd kés®bb látni fogjuk a pici abszolút-értékkel rendelkez® számok sok gondot okoznak, ha nem használunk pivotálást.

www.tankonyvtar.hu



117

---gauss.cpp---

DR AF T

075 : } 076 : 077 : void SetMatrix(){ 078 : int i,j ; 079 : srand(time(NULL)) ; 080 : for(i=0 ;i
allitva !

---gauss.cpp---

A kiíratás függvénye kiírja a mátrixot és az

x

értékeit. Ha a mátrix túl nagy, akkor

nem szeretnénk, ha az kiíratásra kerüljön.

---gauss.cpp---

083 : 084 : 085 : 086 : 087 : 088 : 089 : 090 : 091 : 092 : 093 : 094 : 095 : 096 : 097 : 098 : 099 : 100 : 101 : 102 :

}

void

PrintMatrix(){

//Vigyazat, az abrazolasi pontossag egy jegyre lesz allitva ! //Vizualis ellenorzesnel ezt gyelembe kell venni. int i,j ;

if(N>20){cout<<"Too big to display !"<<endl ;return ;} precision(1) ; for(i=0 ;i
cout<<xed<<"---"<<endl ;

for(i=0 ;i
";

for(j=0 ;j
}

for(i=0 ;i
}


www.tankonyvtar.hu

118


103 : 104 : 105 : 106 :

void

TestSolution(){

int i,j ; double di, sum ;

---gauss.cpp---

Az ellen®rz® függvény ellen®rzi le az eredményt, méghozzá úgy, hogy az

x

értékeit az

DR AF T

eredeti feladatba helyettesíti be. Az egyenlet sorának így kapott összegének és a megfelel®

b

értékének különbségét írjuk ki 20 jegy pontossággal azért, hogy a kerekítési hibákat is

láthassuk. A függvény külön gyelmeztet, ha a különbség túl nagy lett, amely az algoritmus lehetséges hibájára hívná fel a gyelmet.

---gauss.cpp---

102 : } 103 : 104 : void TestSolution(){ 105 : int i,j ; 106 : double di, sum ; 107 : cout.precision(20) ; 108 : for(i=0 ;i0.0001 || di<-0.0001) 114 : cout<<"ERROR ! "<<sum<<" ~ "<
N =8

értékre a következ® lehet :

The original matrix: ----------------------------------------------------------| 5.0 2.0 7.0 3.0 4.0 2.0 1.0 7.0 | 6.0 | | 6.0 2.0 9.0 1.0 3.0 4.0 4.0 8.0 | 8.0 | www.tankonyvtar.hu

x[ 0] = x[ 1] =

0.0 0.0



119

DR AF T

| 8.0 2.0 9.0 8.0 8.0 4.0 1.0 9.0 | 4.0 | x[ 2] = 0.0 | 3.0 0.0 7.0 2.0 5.0 1.0 2.0 1.0 | 7.0 | x[ 3] = 0.0 | 4.0 2.0 6.0 2.0 1.0 8.0 1.0 2.0 | 2.0 | x[ 4] = 0.0 | 8.0 8.0 2.0 8.0 9.0 6.0 9.0 7.0 | 4.0 | x[ 5] = 0.0 | 4.0 8.0 5.0 8.0 4.0 6.0 7.0 6.0 | 3.0 | x[ 6] = 0.0 | 1.0 8.0 4.0 8.0 4.0 7.0 5.0 7.0 | 8.0 | x[ 7] = 0.0 ----------------------------------------------------------The upper triangular matrix: ----------------------------------------------------------| 8.0 2.0 9.0 8.0 8.0 4.0 1.0 9.0 | 4.0 | x[ 0] = 0.0 | 0.0 7.8 2.9 7.0 3.0 6.5 4.9 5.9 | 7.5 | x[ 1] = 0.0 | 0.0 0.0 -9.2 -5.4 -1.3 -3.0 4.2 -6.5 | -5.8 | x[ 2] = 0.0 | 0.0 0.0 0.0 -6.7 -3.5 -0.1 3.9 -0.6 | 3.2 | x[ 3] = 0.0 | 0.0 0.0 0.0 0.0 3.1 -1.1 2.4 -4.3 | 2.5 | x[ 4] = 0.0 | 0.0 0.0 0.0 0.0 0.0 4.2 -0.4 -6.1 | -2.0 | x[ 5] = 0.0 | 0.0 0.0 0.0 0.0 -0.0 0.0 -1.9 -1.2 | -0.4 | x[ 6] = 0.0 | 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -8.5 | -4.7 | x[ 7] = 0.0 ----------------------------------------------------------time elapsed: 0.0 The solution matrix: ----------------------------------------------------------| 8.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 | -12.2 | x[ 0] = 1.5 | 0.0 7.8 0.0 0.0 0.0 0.0 0.0 0.0 | 6.4 | x[ 1] = -0.8 | 0.0 0.0 -9.2 0.0 0.0 0.0 0.0 0.0 | -6.7 | x[ 2] = -0.7 | 0.0 0.0 0.0 -6.7 0.0 0.0 0.0 0.0 | 10.4 | x[ 3] = 1.6 | 0.0 0.0 0.0 0.0 3.1 0.0 0.0 0.0 | 5.6 | x[ 4] = -1.8 | 0.0 0.0 0.0 0.0 0.0 4.2 0.0 0.0 | 1.3 | x[ 5] = -0.3 | 0.0 0.0 0.0 0.0 -0.0 0.0 -1.9 0.0 | 0.3 | x[ 6] = 0.1 | 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -8.5 | -4.7 | x[ 7] = -0.6 -----------------------------------------------------------6.00000000000000000000 ~ 6.00000000000000000000, diff:0.00000000000000000000 -8.00000000000000000000 ~ 8.00000000000000000000, diff:0.00000000000000000000 -4.00000000000000000000 ~ 4.00000000000000000000, diff:0.00000000000000000000 -7.00000000000000000000 ~ 7.00000000000000000000, diff:0.00000000000000000000 -2.00000000000000000000 ~ 2.00000000000000000000, diff:0.00000000000000000000 -3.99999999999999822364 ~ 4.00000000000000000000, diff:0.00000000000000177636 -2.99999999999999955591 ~ 3.00000000000000000000, diff:0.00000000000000044409 -8.00000000000000000000 ~ 8.00000000000000000000, diff:0.00000000000000000000 Az itt vázolt probléma kifejezetten számításigényes. Látható, hogy a három egymásba 3 ágyazott for ciklus miatt a számítások az O(n ) nagyságrendbe fognak esni. Egy modern, gyors számítógép egy

10 000 × 10 000

méret¶ s¶r¶ egyenletrendszert, ami tehát 10 000

egyenletet és ugyanennyi változót tartalmaz 10-30 perc alatt tud megoldani. Ez jól mutatja


www.tankonyvtar.hu

120


a probléma párhuzamosításának szükségességét.

8.5. Párhuzamosítás Annak érdekében, hogy párhuzamosíthassuk a feladatot szét kell osztanunk a munkát több folyamat között. Az algoritmus két lépése az eliminálás a pivotálással együtt, illetve a visszahelyettesítés egyértelm¶en különböz® komplexitásuak. A visszahelyettesítés 2 3 komplexitása O(n ), míg az eliminálásé O(n ). Ami azt jelenti, hogy nincs sok értelme a

DR AF T

visszahelyettesítés párhuzamosításának, hiszen a másik rész dominálja a futásid®t.

A felosztást végezhetjük azon a módon, hogy minden egyes folyamathoz bizonyos so-

rokat rendelünk, hiszen az eliminálás a pivot sor és a többi sor között történik. Így tehát

a folyamatok azokon a sorokon hajtanak majd végre eliminálást, amik hozzájuk vannak rendelve. Mindez összesen négy problémát vet fel.

Az els® probléma az, hogy a következ® sort fel kell cserélnünk a pivot sorral a pivo-

tálási lépés során. Egyes esetekben a csere egy folyamaton belül zajlik, más esetekben két folyamat közötti lesz, mert a sorok más-más folyamatokhoz lettek rendelve. Mindkét esetben meg kell találnunk a maximális abszolút érték¶ pivot elemet és annak a folyamatnak

a sorszámát, amihez az adott elem hozzá van rendelve. Kés®bb is szükségünk lesz majd folyamatközi kommunikációra amihez ezeket a számított id-kat tudjuk majd használni.

A második probléma az, hogy a pivot sort szét kell terítenünk. Ezt könnyeden meg

tudjuk majd tenni a

MPI_Bcast

segítségével.

A harmadik probléma az, hogy hogyan osszuk fel a sorokat ahhoz, hogy egyenletes

terhelést kapjunk. Ez egy cseles kérdés. Ha blokkos felosztást alkalmazunk, akkor

mat esetén a legels® folyamathoz nagyjából a sorok els®

1/p

p

folya-

része lesz hozzárendelve, ami

azt jelenti, hogy ez a legels® folyamat nagyon korán végez majd, a futásid® nagyjából

1/p

részében, és nem lesz dolga a kés®bbiekben. Ez az ütemezés látványosan nem hatékony. Ugyancsak nem alkalmazhatunk dinamikus ütemezést, hiszen a sorok, amikb®l a pivot sort kivonjuk a folyamatok memóriájában kell, hogy legyenek, ami azt jelenti, hogy el®re kell

szétosztanunk a sorokat. A harmadik opció a ciklusbontás (loop splitting). Emlékezzünk vissza az eliminálási lépés f® ciklusára :

---gauss.cpp---

046 : 047 : 048 : 049 : 050 : 051 : 052 : 053 : 054 :

//eliminacios lepes


for(jrow=irow+1 ;jrow
//a sor eliminalasa

for(j=irow ;j
www.tankonyvtar.hu



055 : 056 :

121

}

---gauss.cpp---

A szokásos ciklusbontással a következ® programot kapjuk :

DR AF T

1 : //eliminacios lepes 2 : t=-1.0/Ab[irow][irow] ; 3 : for(jrow=irow+1+id ;jrow
nproc){

De ez a megoldás egy problémához vezet. Ugyanis az

irow

értékét®l függ®en minden

egyes folyamathoz más és más sorok lesznek hozzárendelve. Egy rövid táblázatban mutatjuk be a problémát, ahol

nproc = 3

és a sorok száma

10.

A táblázatban a folyamatokhoz

rendelt sorok sorszámát tüntetjük fel.

8.1. táblázat. A szokásos ciklusbontás során a folyamatokhoz rendelt sorok

irow=

id=0

id=1

id=2

0

1,4,7

2,5,8

3,6,9

1

2,5,8

3,6,9

4,7

2

3,6,9

4,7

5,8

3

4,7

5,8

6,9

4

5,8

6,9

7

5

6,9

7

8

6

7

8

9

7

8

9

8

9

Habár az elosztás egyenletes a sorok amik egy adott folyamathoz lettek rendelve különböznek a ciklus minden egyes lefutása során. Ami azt jelenti, hogy a folyamatok ki kellene, hogy cseréljék a sorok értékeit egymás között minden egyes ciklusmag elején, ami elfogadhatatlan lassulást okozna. (Hasonló probléma merül fel a Gauss elimináció közös


www.tankonyvtar.hu

122


memóriával rendelkez® párhuzamos architektúrákra implementálása során is, ahol a ciklusbontás a cache memória rossz kihasználásához vezet, és a programozó ugyanazt a módszert kell, hogy kövesse ennek kiküszöbölésére, mint amit lentebb bemutatunk.) Annak érdekében, hogy a ciklust rávegyük arra, hogy ugyanazokat a sorokat ossza ki mindig ugyanannak a folyamatnak az egymást követ® lefutások során átrendezzük a bels® ciklust az eredeti

DR AF T

for(jrow=irow+1;jrow
ciklusról egy új formába :

for(jrow=N-1;jrow>=irow+1;--jrow)

Ez pontosan ugyanaz a ciklus, csak csökken® lépésékben. Ezt a ciklust a szokásos

módon párhuzamosíthatjuk ciklusbontással :

---gauss-par.cpp---

096 : 097 : 098 : 099 : 100 : 101 : 102 : 103 : 104 : 105 : 106 :

//eliminacios lepes


for(jrow=N-1-id ;jrow>=irow+1 ;jrow-=nproc){ amul=Ab[jrow][irow] * t ;

//a sor eliminalasa

for(j=irow ;j
Ab[jrow][j] += amul * Ab[irow][j] ;

}

}

if(id==0){

---gauss-par.cpp---

A legf®bb különbség a folyamatokhoz rendelt sorokban lesz. Nézzük meg az el®z® táblázatot ezzel a hozzárendeléssel. Az eljárás el®nye egyértelm¶, hiszen minden egyes cikluslefutás során ugyanazokat a sorokat rendeljük a folyamatokhoz :

www.tankonyvtar.hu



123

8.2. táblázat. A hozzárendelt sorok a módosított programban

id=0

id=1

id=2

0

9,6,3

8,5,2

7,4,1

1

9,6,3

8,5,2

7,4

2

9,6,3

8,5

7,4

3

9,6

8,5

7,5

4

9,6

8,5

7

5

9,6

8

7

DR AF T

irow=

6

9

8

7

9

8

8

9

7

A negyedik, és utolsó probléma a kész sorok összegy¶jtése a mester folyamat által,

aki majd a visszahelyettesítést fogja végezni. Figyeljük meg, hogy az eliminációs lépés ciklusának legelején szétszórjuk (broadcast) a pivot sort, és éppen ez a sor lett kész. Így

tehát ha a mester folyamat nem dobja ki a szétszórt pivot sorokat hanem elmenti azokat, akkor az eljárás végén már el lesz mentve nála a fels® háromszög mátrix ami elkészült. Természetesen ez nagyobb memóriafelhasználást jelent szemben azzal, ha a folyamatok

beleértve a mester folyamatot csak azokat a sorokat mentenék el, amiket hozzájuk rendeltünk. Ilyen esetben a mesternek a legvégén kéne összegy¶jtenie az eredményeket. Mi, a

bemutatott példában, az egyszer¶bb utat követtük, és minden egyes folyamatnak el®írtuk,

hogy az egész mátrixot mentse el, viszont csak azokat a sorokat frissítsék menet közben, amik hozzájuk vannak rendelve. Ez a verzió ráadásul közelebb esik az eredeti programhoz, mert a pivot sort rögtön a mátrixon belül menthetjük el, így minél kisebb változtatást vé-

gezve az eredeti soros programon. Ez nem csak abban segít, hogy könnyebben megértsük

a párhuzamos programot, de segít a helyes program megírásában is. Ne felejtsük el, hogy a helyes program célja sokkal fontosabb, mint néhány százaléknyi gyorsulás elérése még a nagy-teljesítmény¶ számítások területén is.

8.6. A párhuzamos program

Az elöbbi megfontolások után bemutatjuk magát a párhuzamos programot. Mivel a föggvények, amiket a

main-b®l

hívunk teljes mértékben megegyeznek a soros verzióval, így

azokat nem ismertetjük megint, csak a

main változásait mutatjuk be. A program legelején

találhatóak a változó deklarálások és a szokásos MPI keretrendszer indításához szükséges függvényhívások. A mester folyamat

(id==0)

elkezdi az id®mérést, inicializálja a

Ab

mátrixot, kiírja és szétszórja (broadcast) azt a többi folyamatnak, a szolgáknak.


www.tankonyvtar.hu

124


---gauss-par.cpp--void TestSolution() ; int


int id, nproc, id_from, id_to ; MPI_Status status ;

// az MPI inicializalasa :


MPI_Comm_rank(MPI_COMM_WORLD, &id) ;

DR AF T

018 : 019 : 020 : 021 : 022 : 023 : 024 : 025 : 026 : 027 : 028 : 029 : 030 : 031 : 032 : 033 : 034 : 035 : 036 : 037 : 038 : 039 : 040 : 041 : 042 : 043 :

// Az osszes folyamat szamossaganak lekerdezese :

MPI_Comm_size(MPI_COMM_WORLD, &nproc) ; int irow,jrow, i,j, jmax ;

double t, amul, item, item_max ; time_t ts, te ;

if(id==0){ SetMatrix() ; cout<<"The

original matrix :"<<endl ;

PrintMatrix() ;

MPI_Wtime() ;

ts= }

MPI_Bcast(Ab, N*(N+1), MPI_DOUBLE, 0, MPI_COMM_WORLD) ; for(irow=0 ;irow
---gauss-par.cpp---

Ezek után jön a f® ciklus az

irow

változóra, amiben el®ször a pivotálást kell elvégez-

nünk. Ehhez els®nek meg kell határoznunk, hogy melyik folyamathoz van hozzárendelve a

id_from változóban. Miel®tt ez a folyamat szétszórja (broadcserélnünk a soron lév® sort a valódi pivot sorral. Így a id_from

pivot sor, és ezt eltároljuk a cast) a pivot sort fel kell

folyamat szétszórja a pivot elem abszolút értékét.

---gauss-par.cpp---

041 : MPI_Bcast(Ab, N*(N+1), MPI_DOUBLE, 042 : 043 : for(irow=0 ;irow



045 : 046 : 047 : 048 : 049 : 050 : 051 : 052 :

125

//az a folyamat, akihez hozza van rendelve a kovetkezo //eliminalando sor szetszorja ezt a sort a tobbieknek id_from=(N-1-irow)%nproc ;

//pivotalasi lepes jmax=irow ;

fabs(Ab[irow][irow]) ; MPI_Bcast(&item_max,

item_max=

1,

MPI_DOUBLE,

id_from,

DR AF T

MPI_COMM_WORLD) ;

053 : 054 :

for(jrow=N-1-id ;jrow>=irow+1 ;jrow-=nproc)

---gauss-par.cpp---

A folyamatok megkeresik a lokális maximum értékeket és egy MAXLOC redukcióval,

amit a korábbi fejezetekben már tárgyaltunk, meghatározzuk a globális maximumot, ami

a valódi pivot elem lesz, illetve a helyét, azaz, hogy melyik sorban van, és az a sor melyik folyamathoz van hozzárendelve. Ez utóbbit az

id_to

változóban tároljuk.

---gauss-par.cpp---

052 :

MPI_Bcast(&item_max,

1,

MPI_DOUBLE,

id_from,

MPI_COMM_WORLD) ;

053 : 054 : 055 : 056 : 057 : 058 : 059 : 060 : 061 : 062 : 063 : 064 : 065 :

for(jrow=N-1-id ;jrow>=irow+1 ;jrow-=nproc) if(fabs(Ab[jrow][irow])>item_max){ jmax=jrow ;

fabs(Ab[jrow][irow]) ;

item_max=

}

//sorok felcserelese ha szukseges

struct{

double item ; int row ;

} p, tmp_p ;

p.item=item_max ; p.row=jmax ;

MPI_Allreduce(&p, &tmp_p, 1, MPI_DOUBLE_INT, MPI_MAXLOC,

MPI_COMM_WORLD) ;

066 : 067 : 068 : 069 : 070 :

jmax=tmp_p.row ;

//a masik folyamat rangja akivel a pivot kicserelesre kerul : id_to=(N-1-jmax)%nproc ; if(id_from==id_to){ //csere egy folyamaton belul : nincs kommunikacio


www.tankonyvtar.hu

126


---gauss-par.cpp---

Ha a két sort fel kell cserélnünk de ugyanazon folyamathoz vannak rendelve, akkor ezt egy soros programmal tehetjük meg :

---gauss-par.cpp--id_to=(N-1-jmax)%nproc ;

DR AF T

068 : 069 : 070 : 071 : 072 : 073 : 074 : 075 : 076 : 077 : 078 :

if(id_from==id_to){ //csere egy folyamaton if(id==id_from && jmax !=irow) for(j=0 ;j
belul : nincs kommunikacio

item=Ab[irow][j] ;

Ab[irow][j]=Ab[jmax][j] ; Ab[jmax][j]=item ;

}

}else{ //a cserehez kommunikacio kell if(id==id_to){

---gauss-par.cpp---

Ha a két felcserélend® sor más-más folyamathoz van hozzárendelve, akkor ezeket üze-

netküldésen keresztül kell felcserélnünk. Az

id_to

folyamat lokálisan átmásolja a pivot

irow sorba, majd elküldi azt a másik folyamatnak. Az id_from folyamat elmenti irow sort a megtalált pivot sor helyére, fogadja az irow sort a másik folyamattól, majd

sort a

az

átküldi az elmentett sort. Ezen a módon a két sort kicseréltük a két folyamat között, és azok a helyükre kerültek.

---gauss-par.cpp---

075 : 076 : 077 : 078 : 079 : 080 : 081 :

Ab[jmax][j]=item ; }

}

else{ //a cserehez kommunikacio if(id==id_to){ for(j=irow ;j
kell

Ab[irow][j]=Ab[jmax][j] ;

MPI_Send(&Ab[irow],

N+1,

MPI_DOUBLE,

id_from,

77,

MPI_COMM_WORLD) ;

082 : 083 : 084 : 085 :

MPI_Recv(&Ab[jmax], N+1, MPI_DOUBLE, id_from, 88, MPI_COMM_WORLD, &status) ; }

if(id==id_from){

www.tankonyvtar.hu



127

for(j=irow ;j
086 : 087 : 088 : 089 : 090 :

Ab[jmax][j]=Ab[irow][j] ;

MPI_Recv(&Ab[irow], N+1, MPI_DOUBLE, id_to, 77, MPI_COMM_WORLD, &status) ;

MPI_Send(&Ab[jmax],

N+1,

MPI_DOUBLE,

id_to,

88,

MPI_COMM_WORLD) ;

091 : 092 : 093 : 094 :

}

DR AF T

} MPI_Bcast(&Ab[irow],

N+1,

MPI_DOUBLE,

id_from,

MPI_COMM_WORLD) ; ---gauss-par.cpp---

Miután elvégeztük a szükséges cserét a pivot sor szétszórásra (broadcast) kerül minden

folyamatnak, majd az összes folyamat elvégzi az eliminációt a hozzá rendelt sorokon. Ezzel befejez®dik az eliminációs ciklus.

---gauss-par.cpp---

092 : 093 : 094 :

}

MPI_Bcast(&Ab[irow],

N+1,

MPI_DOUBLE,

id_from,

MPI_COMM_WORLD) ;

095 : 096 : 097 : 098 : 099 : 100 : 101 : 102 : 103 : 104 : 105 : 106 :

//eliminacios lepes


for(jrow=N-1-id ;jrow>=irow+1 ;jrow-=nproc){ amul=Ab[jrow][irow] * t ;

//a sor eliminalasa

for(j=irow ;j
Ab[jrow][j] += amul * Ab[irow][j] ;

}

}

if(id==0){

---gauss-par.cpp---

A végén a mester folyamat kiírja a fels® háromszög mátrixot és elvégzi a visszahelyettesítéseket éppen úgy, ahogy azt a soros programban is tettük. Végül kiírja a végrehajtás során eltelt id®t és a visszahelyettesített mátrixot. Ugyancsak itt ellen®rzi le az eredményt. A

MPI_Finalize()

függvényhívás lezárja az MPI keretrendszert.


www.tankonyvtar.hu

128


---gauss-par.cpp---

DR AF T

104 : } 105 : 106 : if(id==0){ 107 : cout<<"The upper triangular matrix:"<<endl ; 108 : PrintMatrix() ; 109 : 110 : //visszahelyettesitesi lepes 111 : for(irow=N-1 ;irow>=0 ;--irow){ 112 : x[irow]= - Ab[irow][N]/Ab[irow][irow] ; 113 : for(jrow=0 ;jrow
A teljes

001 : 002 : 003 : 004 : 005 : 006 : 007 : 008 :

main

függvény :

#include #include #include <math.h> #include #include <mpi.h> using namespace std ; const int N=8000 ;

www.tankonyvtar.hu



double Ab[N][N+1] ;

//az A matrix es a b oszlop //az N-ik oszlopban a -b ertekek double oriAb[N][N+1] ; //az eredeti Ab matrix az eredmeny tesztelesere double x[N]={0} ; //a megoldas vektor

PrintMatrix() ; SetMatrix() ; void TestSolution() ;

void void

DR AF T

009 : 010 : 011 : 012 : 013 : 014 : 015 : 016 : 017 : 018 : 019 : 020 : 021 : 022 : 023 : 024 : 025 : 026 : 027 : 028 : 029 : 030 : 031 : 032 : 033 : 034 : 035 : 036 : 037 : 038 : 039 : 040 : 041 : 042 : 043 : 044 : 045 : 046 : 047 : 048 : 049 :

129

int


int id, nproc, id_from, id_to ; MPI_Status status ;

// az MPI inicializalasa :


MPI_Comm_rank(MPI_COMM_WORLD, &id) ; // Az osszes folyamat szamossaganak lekerdezese :

MPI_Comm_size(MPI_COMM_WORLD, &nproc) ; int irow,jrow, i,j, jmax ;

double t, amul, item, item_max ; time_t ts, te ;

if(id==0){ SetMatrix() ; cout<<"The

original matrix :"<<endl ;

PrintMatrix() ;

MPI_Wtime() ;

ts= }

MPI_Bcast(Ab, N*(N+1), MPI_DOUBLE, 0, MPI_COMM_WORLD) ; for(irow=0 ;irow
//az a folyamat, akihez hozza van rendelve a kovetkezo //eliminalando sor szetszorja ezt a sort a tobbieknek id_from=(N-1-irow)%nproc ;

//pivotalasi lepes


www.tankonyvtar.hu

130

050 : 051 : 052 :


jmax=irow ;

fabs(Ab[irow][irow]) ; MPI_Bcast(&item_max,

item_max=

1,

MPI_DOUBLE,

id_from,

MPI_COMM_WORLD) ;

for(jrow=N-1-id ;jrow>=irow+1 ;jrow-=nproc) if(fabs(Ab[jrow][irow])>item_max){ jmax=jrow ;

fabs(Ab[jrow][irow]) ;

item_max=

DR AF T

053 : 054 : 055 : 056 : 057 : 058 : 059 : 060 : 061 : 062 : 063 : 064 : 065 :

}

//sorok felcserelese ha szukseges

struct{

double item ; int row ;

} p, tmp_p ;

p.item=item_max ; p.row=jmax ;

MPI_Allreduce(&p, &tmp_p, 1, MPI_DOUBLE_INT, MPI_MAXLOC,

MPI_COMM_WORLD) ;

066 : 067 : 068 : 069 : 070 : 071 : 072 : 073 : 074 : 075 : 076 : 077 : 078 : 079 : 080 : 081 :

jmax=tmp_p.row ;

//a masik folyamat rangja akivel a pivot kicserelesre kerul : id_to=(N-1-jmax)%nproc ;

if(id_from==id_to){ //csere egy folyamaton if(id==id_from && jmax !=irow) for(j=0 ;j
belul : nincs kommunikacio

item=Ab[irow][j] ;

Ab[irow][j]=Ab[jmax][j] ; Ab[jmax][j]=item ;

}

}

else{ //a cserehez kommunikacio if(id==id_to){ for(j=irow ;j
kell

Ab[irow][j]=Ab[jmax][j] ;

MPI_Send(&Ab[irow],

N+1,

MPI_DOUBLE,

id_from,

77,

MPI_COMM_WORLD) ;

082 : 083 : 084 : 085 : 086 : 087 :

MPI_Recv(&Ab[jmax], N+1, MPI_DOUBLE, id_from, 88, MPI_COMM_WORLD, &status) ;

}

if(id==id_from){ for(j=irow ;j
www.tankonyvtar.hu



131

MPI_Recv(&Ab[irow], N+1, MPI_DOUBLE, id_to, 77,

088 : 089 : 090 :

MPI_COMM_WORLD, &status) ;

MPI_Send(&Ab[jmax],

N+1,

MPI_DOUBLE,

id_to,

88,

MPI_COMM_WORLD) ;

091 : 092 : 093 : 094 :

} }

MPI_Bcast(&Ab[irow],

N+1,

MPI_DOUBLE,

id_from,

DR AF T

MPI_COMM_WORLD) ;

095 : 096 : //eliminacios lepes 097 : t=-1.0/Ab[irow][irow] ; 098 : for(jrow=N-1-id ;jrow>=irow+1 ;jrow-=nproc){ 099 : amul=Ab[jrow][irow] * t ; 100 : //a sor eliminalasa 101 : for(j=irow ;j=0 ;--irow){ 112 : x[irow]= - Ab[irow][N]/Ab[irow][irow] ; 113 : for(jrow=0 ;jrow

www.tankonyvtar.hu

132

MPI_Finalize() ; } void

SetMatrix(){

int i,j ;

srand(time(NULL)) ; for(i=0 ;i
DR AF T

127 : 128 : 129 : 130 : 131 : 132 : 133 : 134 : 135 : 136 : 137 : 138 : 139 : 140 : 141 : 142 : 143 : 144 : 145 : 146 : 147 : 148 : 149 : 150 : 151 : 152 : 153 : 154 : 155 : 156 : 157 : 158 : 159 : 160 : 161 : 162 : 163 : 164 : 165 : 166 : 167 :


}

void

PrintMatrix(){

//Vigyazat, az abrazolasi pontossag egy jegyre lesz allitva ! //Vizualis ellenorzesnel ezt gyelembe kell venni. int i,j ;

if(N>20){cout<<"Too big to display !"<<endl ;return ;} precision(1) ; for(i=0 ;i
cout<<xed<<"---"<<endl ;

for(i=0 ;i
";

for(j=0 ;j
}

for(i=0 ;i
}

void

TestSolution(){

int i,j ;

double di, sum ;

precision(20) ; for(i=0 ;i
sum=0 ;

for(j=0 ;j
sum += x[j] * oriAb[i][j] ; di=sum+oriAb[i][N] ;

if(di>0.0001 || di<-0.0001)

www.tankonyvtar.hu

cout<<"ERROR !

"<<sum<<" ~ "<


133

DR AF T

diff :"<
8.7. Futásid®k

Megmértük a futásid®ket 10 000 változó és egyenlet esetén a két szuperszámítógépen.

8.3. táblázat. Gauss elimináció pivotálással

nproc

A

B

1

665s

1510s

12

184s

24 48

3.6x

339s

4.5x

103s

6.5x

221s

6.8x

61s

10.9x

118s

12.8x

96

49s

13.6x

136s

11.1x

192

31s

21.5x

161s

9.4x

384

29s

22.9x

192s

7.9x

Ahogy láthatjuk közepes gyorsulást tudtunk elérni, ami határozottan limitált lesz egy

pont után. Természetesen nagyobb problémák esetén a gyorsulás is nagyobb tud lenni, mivel az elimináció több ideig fog tartani, mint a kommunikáció. Mindenesetre megállapíthatjuk, hogy valójában túl sok összességében a kommunikáció. Felvet®dhet az a kérdés, hogy vajon a ciklus elején a sorcsere nem tart-e túl sokáig, így lemértük a programunk futását e nélkül a pivotálási csere nélkül is.


www.tankonyvtar.hu

134

Bevezetés az MPI programozásba példákon keresztül 8.4. táblázat. Gauss elimináció pivotálás nélkül

A

B

1

614s

1498s

12

186s

3.3x

271s

5.5x

24

96s

6.4x

173s

8.7x

48

52s

11.8x

94s

15.9x

96

34s

18.1x

73s

20.5x

192

29s

21.2x

66s

22.7x

DR AF T

nproc

384

34s

18.1x

49s

30.6x

A gyorsulások egyértelm¶en javultak, de ez még mindig nem egy túl fényes eredmény.

Egyértelm¶, hogy a minden ciklus elején szétszórt pivotsor túl sok ideig tart.

Viszont nem lehetetlen úgy átírni a programot, ami sokkal kevesebb kommunikációt

eredményezne. Ebben a megközelítésben nem sorokat, hanem oszlopokat rendelnénk az egyes folyamatokhoz, azon megfontolás alapján, hogy maga az eliminálás mindig egy osz-

lopon belül történik. Továbbra is szükség lesz bizonyos kommunikációra, hiszen a pivot sorcseréhez az egyik folyamatnak meg kell majd mondani a többi folyamat számára, hogy melyik két sort kell felcserélni, de ezek után minden munkát lokálisan tudunk elvégezni. Értelemszer¶en ebben a megoldási javaslatban külön foglalkoznunk kell a korábban említett negyedik problémával, nevezetesen az adatok összegy¶jtésével a mester folyamat számára. Ez a megoldási javaslat jó alap lehet mint egy, a tanulók számára kiadott, házi feladat.

8.8. A pivotálás szerepe

Amikor kiválasztottuk a pivot elemet, akkor mindig az

xi

változók koecienseib®l a leg-

nagyobb abszolút érték¶t választottuk. Ezt az egyenletet neveztük pivot egyenletnek, és

ezt a koecienst neveztük pivot elemnek. Majd felcseréltünk két sort, hogy ez a pivot sor legyen a következ® sor, amit feldolgozunk az eljárásunkban.

Két okból jártunk el így a pivot elem választásában. Az els® ok, hogy a pivot (i.)

egyenletet meg kell szoroznunk a

−a(i, j)/a(i, i)

konstanssal miel®tt a

j.

egyenlethez hoz-

záadjuk. Ezt a konstanst csak abban az esetben tudjuk kiszámolni, ha az nem nulla. Két lehet®ség van. Ha az

xi

a(i, i)

értéke

koecienseinek legalább az egyike nem nulla, ak-

kor a legnagyobb abszolút érték¶ koeciens választásakor egy nem nulla érték¶t fogunk

választani, és ez megóv minket a nullával való osztástól. Ha nincs ilyen koeciens, akkor ez azt jelenti, hogy az egyenletrendszerünk valójában megoldhatatlan, mivel így kevesebb egyenletünk van, mint ahány az

xi -k

meghatározásához szükséges. (Programunkban az

els® tulajdonság, illetve az egyszer¶ségre való törekvés miatt nem végeztünk ellen®rzést a nullával való osztásra. Egy valódi program esetén értelemszer¶en ezt is vizsgálni kell.) A második ok az, hogy amikor a Gauss eliminációt végezzük, akkor az egyik célunk a numerikus stabilitás meg®rzése. A következ® példa határozottan problémás lesz a kerekítési

www.tankonyvtar.hu



135

hibák miatt amikor elvégezzük a Gauss eliminációt és a visszahelyettesítést.

0.003x1 + 59.14x2 + 59.17 = 0 5.291x1 − 6.13x2 + 46.78 = 0 Mátrix alakban felírva :

0.003 59.14 59.17 5.291 −6.13 46.78

x1 = 10.00 aés x2 = 1.000, de ha pontossággal végezzük el, akkor az a(1,1)

DR AF T

Ennek az egyenletrendszernek a konkrét megoldásai az

az eliminálást és visszahelyettesítést négy jegy

pici értéke miatt a kerekítési hibák továbbterjednek. Pivotálás nélkül az algoritmus az

x1 = 9873.3

és

x2 = 4

közelít® értékeket fogja adni. Ebben a helyzetben a pivotálás el®írja

a két sor felcserélését, hogy az

a(2,1)

kerüljön a pivot helyre, mivel az ® abszolút értéke a

nagyobb.

5.291x1 − 6.13x2 + 46.78 = 0 0.003x1 + 59.14x2 + 59.17 = 0

Mátrix alakban felírva :

5.291 −6.13 46.78 0.003 59.14 59.17

Ennek az egyenletrendszernek a megoldása eliminálással és visszahelyettesítéssel négy

jegy pontosságú aritmetikát használva a helyes

x1 = 10.00

és

x2 = 1.000

értékeket fogja

adni.


www.tankonyvtar.hu


DR AF T

136

www.tankonyvtar.hu


9. fejezet

DR AF T

Laphevítés

Jó példája lehet a párhuzamosításnak a laphevítéses modell. Képzeljünk el, egy

X ×Y

méret¶ lapot. A lap egyik sarkának hevítése folytán keletkez® h®terjedést szeretnénk modellezni a lap felületén. A modellünkben az egyszer¶ség kedvéért pár paramétert ideálisnak kezelünk. A lap s¶r¶sége és az anyag h®terjedési tulajdonságai egyenletesek, a szélek h®szi-

getelése tökéletes, stb.. Az analitikus megoldás a kétdimenziós h®egyenlet megoldása lenne, ahol az új h®mérsékletet az új h®mérsékletb®l a Laplace-operátorral kaphatjuk meg. Az

egyszer¶sítésünk miatt az alap modellünkben egy numerikus megoldást is adhatunk. Ez

a megoldás egy iterációs eljárást használ, ahol az aktuális értékekb®l lépésenként állítunk el® új értékeket. Az alapötlet nagyon egyszer¶. A h®terjedést ebben a zárt rendszerben úgy modellezhetjük, hogy az egyes pontok új értékeit a környezetében lév® pontértékek átlagolásával számítjuk ki.

9.1. ábra. A h®terjedési modell átlagolási mintája

Ha a lap pontjait egy képként fogjuk fel, akkor ez az eekt egy elkenést eredményez. Mi-


www.tankonyvtar.hu

138


vel a hevített sarkon lév® képpontok egy konstans h®értékkel rendelkeznek, az itt beadott h®mennyiség lassan elterjed az egész bels® felületen. Ehhez persze elég hosszú iterációs futtatásra van szükség. A valóságban persze számolnunk kéne a h®veszteséggel is ami a peremeken (vagy az egész felületen) lép föl, de a modellünkb®l ezt most nem vesszük gyelembe. Az átlagolásnál nem kell minden szomszédot bevonni, elegend® az alsó, fels®, jobb és bal értékeket gyelembe venni. A peremeken természetesen csak azokkal a szomszédokkal számolunk, amik léteznek is. Az iterációt addig folytathatjuk, amíg valamilyen el®re rögzített feltétel nem teljesül. Ez lehet a változás mértékére vonatkozó, ahol ha a lépések között kis változás van, feltételezzük, hogy elég jól közelítettük a végeredményt.

DR AF T

Feltétel lehet egy adott h®mérséklet az egyik pontban. A jelen példánkban egy egyszer¶,

x lépésszámig futtatjuk az iterációt, mivel a példában inkább a párhuzamosítási technika a fontos, nem a modell pontossága.

9.1. Szekvenciális implementáció

Az átlagolási eljárást a lap minden pontján végighaladva tehetjük meg. Minden pontban a szomszéd értékeket is használnunk kell. Ehhez két

X ,Y

méret¶ tömbre lesz szükségünk. Az

egyikben az aktuális értékek, míg a másikban a frissen kiszámított értékek lesznek. Erre

azért van szükség, mert minden számításhoz az eredeti értékekre többször is szükségünk van, így nem írhatjuk felül ®ket. Amint kész vagyunk az új tömbbel, ezt bemásoljuk a

régibe, hisz ez lesz az új iterációs lépés kiinduló tömbje. Az átlagolásnál a peremek és sarkok speciális esetek, mivel itt nincs meg az összes szomszéd.

9.2. Párhuzamos eljárás

A tömb nagy elemszáma azt sugallja, hogy itt a párhuzamos feldolgozással felgyorsít-

hatnánk az eljárást. Mivel minden pont kiszámításához csak egy sz¶k környezetére van szükség, a tömb darabjainak a külön feldolgozása m¶köd®képesnek t¶nik.

A párhuzamos verzió egyszer¶nek t¶nik. Fel kell vágnunk a lapunkat csíkokra. Minden

csíkkal egy külön feldolgozóegység, munkás fog dolgozni. Miel®tt ebbe belevágunk, pár dolgot tisztáznunk kell.

9.3. A munka felosztása

A kérdés ami el®ször felmerülhet a párhuzamosításnál : hogyan osszuk el az adatokat a

munkások között ? Az látszik, hogy egybefügg® blokkokat kell kiosztanunk, hiszen a számításhoz a szomszédokra is szükség van. Az is látszik, hogy érdemes egész sorokat kiosztanunk, különben az adatok kicserélése túl komplikált lesz. De hány sort kapjon egy munkás ?

Ha az összes sorok száma osztható a munkások számával, egyszer¶ mennyit osszunk ki a munkásoknak. Ha nem, akkor további lehet®ségeink vannak. Egyik lehet®ségünk az, hogy nem használjuk az összes munkást, csak annyit, ahány felé a sorok számát maradéktalanul

www.tankonyvtar.hu


9. fejezet. Laphevítés

139

eloszthatjuk. Ez nagy pazarlás is lehet, ha csak pár munkásunk van, pl. 7 és 2-t vagy 3-t kizárunk. De miért zárnánk ki bárkit is ? Az egyenl® felosztás utáni maradékot kioszthatjuk extra feladatként valamelyik munkásnak vagy munkásoknak. Persze a teljes futás ideje a leglassabb munkáson múlik, így az egyenl® elosztásra kell törekednünk. Általános érvény¶, hogy a munkafelosztást körültekint®en kell átgondolni, gyelembe véve a a munka jellegét. A felosztás befolyásolja a sebességet, így a párhuzamosításnál ez kulcsfontosságú hatékonysági kérdés. A statikus feladatkiosztás az algoritmus futása el®tt osztja fel a feladatokat. Ebben a példában egy statikus felosztást mutatunk be, ahol az

DR AF T

egyes munkások számára el®re deniáljuk, hogy melyik részeken dolgozzanak.

9.4. A peremadatok kicserélése

Minden pont új értékének a kiszámításához a szomszéd adatokra is szükségünk van. Mivel

egész sorokat fogunk kiosztani a munkásoknak, a jobb és bal oldali szomszédok kéznél lesznek. A fels® sor fels® szomszédai és az alsó sor alsó szomszédai viszont nem lesznek

lokálisan elérhet®ek, így ezeket az iterációs lépések között ki kell cserélni a munkások között ahhoz, hogy a következ® iterációban már a friss adatokkal dolgozhassunk. Ha az els® munkás például az els®

n+1

n

sorral dolgozik, a következ® lépéshez be kell gy¶jtenie az

sort az alsó szomszédjától. Azok a munkások, akik középen vannak, azaz nem az

els® és nem az utolsó pozícióban, ugyanezt meg kell, hogy tegyék a fels® sorukkal és fels® szomszédjukkal is. Ezeket a szomszédoktól lekért sorokat szellemsoroknak (ghost lines ) is

hívják, mivel csak virtuálisan vannak jelen és folyamatosan, csomópont-közti (internodal ) kommunikációval kell begy¶jteni ®ket.

9.5. Példa program szekvenciális megoldás

Ebben a fejezetben egy egyszer¶ laphevítéses szimulációt mutatunk be, mely a fenti ötleteken és eljárásokon alapszik. A kód C++-ban készült.

A kód els® sorai a szükséges függvénykönyvtárak betöltését végzik. Így elérhet®ek lesz-

nek az I/O funkciók, matematikai eljárások és a vector típus. Ez utóbbi segítségével dinamikus hosszúságú tömböket (vektorokat) használhatunk a x tömbhosszúság helyett. Ezek után deniálunk pár konstant. Az

heatp

X

Y

és

a lap dimenziói, amit egy tömbben tárolunk. A

érték mutatja a havített pontok h®fokát. Az

iteráció maximum meddig menjen és a

speed

iter_n

konstans mutatja, hogy az

konstanssal pedig a h®terjedés sebességét

befolyásolhatjuk, az átlagolásba beavatkozva. Az aktuális és az új h®értékeket az

001 : 002 : 003 : 004 :

old_array

és

new_array

tömbökben tároljuk.

#include #include #include <sstream> #include <math.h>


www.tankonyvtar.hu

140


#include using namespace std ; const int X=60 ; const int Y=60 ; const double heatp=100 ; const int iter_n=300 ; const double speed=1 ;

DR AF T

005 : 006 : 007 : 008 : 009 : 010 : 011 : 012 : 013 : 014 : 015 : 016 : 017 : 018 : 019 :

double old_array[X][Y] = {0} ;

double new_array[X][Y] = {0} ;

void iteration() {

--- serial_plate_hu.cpp ---

iteration()

Az

függvény számolja ki az

old_array()-b®l

a

new_array()

új értékeit

az összes ponton végighaladva. A számítás két egymásba ágyazott ciklusban, 0X és 0Y között fut.

Az új értékek kiszámítása után visszamásoljuk ®ket az

old_array()-be.

Ahhoz, hogy

a hevített pontok értéke állandó maradjon, a bal fels® sarok három pontjának értékeit a

heatp

konstans értékre állítjuk.


016 : 017 : 018 : 019 : 020 : 021 : 022 : 023 : 024 : 025 : 026 : 027 : 028 : 029 : 030 :

void

iteration()

{

int i=0 ;

int j=0 ;

int a,w,d,x ;

for(i=0 ;i<X ;i++) {

for(j=0 ;j
www.tankonyvtar.hu

// ha egy szelen vagyunk

if( i>0 && i<X-1 && j>0 && j
{ new_array[i][j] = (old_array[i-1][j] + old_array[i+1][j] +



141

old_array[i][j-1] + old_array[i][j+1] ) / 4 * speed ;

031 : 032 : 033 : 034 : 035 :

}

// ha felso szelen vagyunk

if( j==0 && i>0 && i<X-1 ) { new_array[i][j] = ( old_array[i-1][j] + old_array[i+1][j] +

old_array[i][j+1] ) / 3 * speed ; }

// ha jobb szelen vagyunk

DR AF T

036 : 037 : 038 : 039 : 040 :

if( i==0 && j>0 && j
new_array[i][j] = ( old_array[i][j-1] + old_array[i][j+1] +

old_array[i+1][j] ) / 3 * speed ;

041 : 042 : 043 : 044 : 045 :

}

// ha also szelen vagyunk

if( j==Y-1 && i>0 && i<X-1 ) {

new_array[i][j] = ( old_array[i-1][j] + old_array[i+1][j] +

old_array[i][j-1] ) / 3 * speed ;

046 : 047 : 048 : 049 : 050 :

}

// ha bal szelen vagyunk

if( i==X-1 && j>0 && j

old_array[i-1][j] ) / 3 * speed ;

051 : 052 : 053 : 054 : 055 :

}

// a negy sarkot is le kell kezelni

if( i==0 && j==0) {

new_array[i][j]=(old_array[i+1][j]+old_array[i][j+1] ) / 2 *

speed ;

056 : 057 : 058 : 059 :

}

if( i==0 && j==Y-1) {

new_array[i][j]=(old_array[i+1][j]+old_array[i][j-1] ) / 2 *

speed ;

060 : 061 : 062 : 063 :

}

if( i==X-1 && j==0) {

new_array[i][j]=(old_array[i-1][j]+old_array[i][j+1] ) / 2 *

speed ;


www.tankonyvtar.hu

142


}

if( i==X-1 && j==Y-1) { new_array[i][j]=(old_array[i-1][j]+old_array[i][j-1] ) / 2 * speed ; } } }

for(i=0 ;i<X ;i++)

DR AF T

064 : 065 : 066 : 067 : 068 : 069 : 070 : 071 : 072 : 073 : 074 : 075 : 076 : 077 : 078 : 079 : 080 : 081 : 082 : 083 : 084 : 085 : 086 : 087 :

{

for(j=0 ;j
old_array[i][j]=new_array[i][j] ;

}

}

old_array[0][0] = heatp ; // hevitett pontok old_array[0][1] = heatp ; old_array[1][0] = heatp ; }

int main() {


A

main() függvény a fájl írást és az iteration() függvény futtatását végzi. function.

El®ször nyitunk egy fájlkezel®t (myfile) amin keresztül kiírjuk az adatainkat egy PPM

fájlba. Kezdetben kiinduló h®értékeket adunk lap pontjainak, illetve beállítjuk a hevített sarokpontok h®mérsékletét.


084 : 085 : 086 : 087 : 088 : 089 : 090 : 091 :

int

main()

{

ofstream myle ;

// ebbe a fajlba fogunk irni

// az gesz lap kezdeti hoerteket allitjuk

for(int i=0 ;i<X ;i++)

www.tankonyvtar.hu



{

for(int j=0 ;j
}

// a foroo pontok allitasa a sarokban old_array[0][0] = heatp ; // hevitett pontok

DR AF T

092 : 093 : 094 : 095 : 096 : 097 : 098 : 099 : 100 : 101 : 102 : 103 : 104 : 105 :

143

old_array[0][1] = heatp ; old_array[1][0] = heatp ;

for(int x=0 ;x

iter_n-ig

Az iteráció 0-tól

fog futni. Minden lépésben futtatjuk az

iteration() függ-

vényt, amivel az egész felület új h®értékeit tudjuk kiszámolni. Minden iterációs lépés után az aktuális állást kiírjuk egy fájlba, hogy utólagosan lekövethessük a h®terjedést. A fájlnevek plate_XXX nev¶ek lesznek, ahol XXX 0 és

iter_n

közti számokat jelent.


102 : 103 : 104 : 105 : 106 : 107 : 108 : 109 : 110 : 111 : 112 : 113 : 114 : 115 : 116 : 117 : 118 : 119 :

old_array[1][0] = heatp ;

for(int x=0 ;x
// x "iter_n" ismetlesig futunk

iteration() ;

string lename1,lename2 ;

"plate_" ; =".ppm" ;

lename1 = lename2

std : :stringstream ss ;

if(x<10) {int b=0 ; ss << b ;} ; if(x<100) {int b=0 ; ss << b ;} ; ss << x ;

append(ss.str()) ; lename1.append(lename2) ;

lename1.

c_str() ;

char *leName = (char*)lename1.

open(leName) ;

myle.


www.tankonyvtar.hu

144


myle <<

"P3\r\n" ;

myle << X ; myle <<

" ";

myle << Y ; myle << myle <<

"\r\n" ; "255\r\n" ;

for(int i=0 ;i
DR AF T

120 : 121 : 122 : 123 : 124 : 125 : 126 : 127 : 128 : 129 :

{


Mivel a PPM formátum az RGB értékeket decimális számhármasokban várja, a

new_array

tömb értékein végigfutva (ekkora két tömb megegyez®) kell kiírni az h®értékeket. Ezeket az értékeket mind a három színkomponens helyére be kell írni, így szürke skálás képeket fogunk kapni a kiíráskor.


126 : 127 : 128 : 129 : 130 : 131 : 132 :

for(int i=0 ;i
{

for(int j=0 ;j<X ;j++) {

myle <<

min( (int)round(new_array[i][j]*255/(heatp*speed)*6),

myle <<

" ";

255) ;

133 : 134 :

myle <<

min(

(int)

round(new_array[i][j]*255/heatp*speed)*6,

(int)

round(new_array[i][j]*255/heatp*speed)*6,

255) ;

135 : 136 :

myle <<

" ";

myle <<

min(

255) ;

137 : myle << " " ; 138 : } 139 : myle << "\r\n" ; 140 : } 141 : 142 : myle.close() ; 143 : } 144 : return 0 ;

www.tankonyvtar.hu



145 : 146 :

145

}

Az eredmény PPM fájlok sorozata, amelyekben a h®terjedés tranziens viselkedését

DR AF T

követhetjük nyomon.

9.2. ábra. H®terjedési szimuláció az els® és második iterációk után

9.3. ábra. H®terjedési szimuláció a 20., 100. és 400. iterációk után

9.6. Párhuzamos megoldás példaprogramja

Ebben a fejezetben a laphevítéses modell párhuzamosított verzióját mutatjuk be. Ahogy korábban tárgyaltuk, a párhuzamosítás úgy történik, hogy a lapot reprezentáló tömb egyes részeit osztjuk ki az egyes munkásainknak. Ehhez le kell számlálnunk az aktív munkásainkat és ki kell osztani nekik a feladatot.


www.tankonyvtar.hu

146

Bevezetés az MPI programozásba példákon keresztül Az els® include sorok úgy néznek ki mint a szekvenciális változatban. Egy extra sort

kell beírnunk, az

mpi.h

könyvárat, amely az MPI függvények elérését biztosítja. A kons-

tansok is maradtak ugyan azok mint korábban, de pár újabb változót most deniálnunk kell. A

FROM

és

TO

változók tartalmazzák majd az egyes munkások egyéni induló és záró

sorszámait, melyekkel a saját adataikon dolgozni fognak. A

world_rank

és

world_size

változók tartalmazzák az adott munkás sorszámát és a munkások összes számát.

#include <mpi.h> #include #include #include <sstream> #include <math.h> #include

DR AF T

001 : 002 : 003 : 004 : 005 : 006 : 007 : 008 : 009 : 010 : 011 : 012 : 013 : 014 : 015 : 016 : 017 : 018 : 019 : 020 : 021 : 022 : 023 :

using namespace std ; const int X=800 ; //683 ; const int Y=800 ; //384 ; const double heatp=400 ; const int iter_n=1600 ; int FROM=0 ; int TO=0 ;

double old_array[X][Y] = {0} ;

double new_array[X][Y] = {0} ; int world_rank ; int world_size ;

void iteration(int i_from, int i_to) {

--- parallel_plate_hu.cpp ---

Az

iteration()

függvény nagyon hasonlít a korábbira, kivéve, hogy a függvénynek

extra paraméterei vannak. Az

i_from

és

i_to

paraméterek fogják beállítani, hogy me-

lyik sorokon dolgozzon a függvény. Erre azért van szükség, mert a különböz® munkások különböz® sorokon fognak dolgozni.


020 : 021 :

int world_size ;

www.tankonyvtar.hu



void

iteration(int i_from, int i_to)

{ int i=0 ; int j=0 ;

for(i=i_from ;i
for(j=0 ;j
DR AF T

022 : 023 : 024 : 025 : 026 : 027 : 028 : 029 : 030 : 031 : 032 : 033 : 034 :

147

// ha nem peremen vagyunk

if( i>0 && i<X-1 && j>0 && j
new_array[i][j] = (old_array[i-1][j] + old_array[i+1][j] +

old_array[i][j-1] + old_array[i][j+1] ) / 4 ;

035 : 036 : 037 : 038 : 039 :

}

// felso perem

if( j==0 && i>0 && i<X-1 ) {


old_array[i][j+1] ) / 3 ;

040 : 041 : 042 : 043 : 044 :

}

// jobb perem

if( i==0 && j>0 && j

old_array[i+1][j] ) / 3 ;

045 : 046 : 047 : 048 : 049 :

}

// also perem

if( j==Y-1 && i>0 && i<X-1 ) {


old_array[i][j-1] ) / 3 ;

050 : 051 : 052 : 053 : 054 :

}

// bal perem

if( i==X-1 && j>0 && j

old_array[i-1][j] ) / 3 ;

055 : 056 : 057 :

}

// negy sarok

if( i==0 && j==0)


www.tankonyvtar.hu

148


{ new_array[i][j]=(old_array[i+1][j]+old_array[i][j+1] ) / 2 ; }

if( i==0 && j==Y-1) { new_array[i][j]=(old_array[i+1][j]+old_array[i][j-1] ) / 2 ; }

if( i==X-1 && j==0) {

DR AF T

058 : 059 : 060 : 061 : 062 : 063 : 064 : 065 : 066 : 067 : 068 : 069 : 070 : 071 : 072 : 073 : 074 : 075 : 076 :

new_array[i][j]=(old_array[i-1][j]+old_array[i][j+1] ) / 2 ;

}

if( i==X-1 && j==Y-1) {

new_array[i][j]=(old_array[i-1][j]+old_array[i][j-1] ) / 2 ;

}

}

}

// irjuk az uj adatot a regire

for(i=i_from ;i

A fenti új paramétereket az új adatok régi tömbbe való másolásakor is használnunk

kell.


070 : 071 : 072 : 073 : 074 : 075 : 076 : 077 : 078 : 079 : 080 : 081 : 082 : 083 : 084 :

{

new_array[i][j]=(old_array[i-1][j]+old_array[i][j-1] ) / 2 ;

}

}

}

// irjuk az uj adatot a regire

for(i=i_from ;i
for(j=0 ;j
old_array[i][j]=new_array[i][j] ;

} }

// a sarok forro pontjait konstans erteken tartjuk

www.tankonyvtar.hu



085 : 086 : 087 : 088 : 089 : 090 : 091 : 092 :

149

old_array[0][0] = heatp ; // forro pontok old_array[0][1] = heatp ; old_array[1][0] = heatp ; } void interchange_borders(int FROM, int TO) {

DR AF T


A

main()

függvény ugyan úgy kezd®dik mint a korábbi, ahol a lekezel®t adtuk meg,

amivel majd kiírjuk az adatokat a PPM fájlba. Ezek után az MPI környezetet kell elindí-

MPI_Init() sorral. Az MPI_Comm_size() függvénnyel lekérdezhetjük az elérhet® munkások számát. Ezt a számot a második paraméterbe, a world_size-ba kapjuk meg. A MPI_Comm_rank()függvény adja meg a hívó processzus sorszámát. Innent®l kezdve kütanunk a

lönböz® dedikált tevékenységek hajthatók végre a különböz® munkásokkal.

A következ® pár lépésben a munkások közti munkaelosztást végezzük el. A fentiek

alapján, egyszer¶en elosztjuk a sorok számát a munkások számával. Ha van maradék, akkor azt az utolsó munkásnak adjuk. Ez a módszer nem a legkiegyensúlyozottabb, de nagyon

egyszer¶ és gyorssá teszi a leosztást. Ahogy egyre több sorral dolgozunk, a különbség az utolsó és a többi munkás között egyre inkább lecsökken. A

p_row

változóban lesz a sorok

száma, amivel egy munkásnak dolgoznia kell, kivéve az utolsó munkást. A

p_row_last

változóban lesz az utolsó munkásra jutó sorok száma.


175 : 176 : 177 : 178 : 179 :



// ki kell osztanunk a feladatot a tobbi munkasnak

// egyszeri kiosztast csinalunk, egyforma reszeket kap mindenki, a

maradekot az utolsonak kell kiszamolnia (ez rossz esetben akar a dupla munkat is jelentheti)

180 : 181 :

double p_row = (double)X / world_size ;

// elosztjuk a sorok szamat

(X) a munkasok szamaval

182 :

double p_row_last = 0 ; // ki lesz az utolso ? Ha nincs mas, akkor az elso

lesz az utolso is egyben.

183 : 184 : 185 :

if(oor(p_row) { p_row =

!= p_row) // van-e maradek ?

oor(p_row) ;


// egesz szamu sor amit egy munkas kap

www.tankonyvtar.hu

150


186 :

p_row_last = X - ((world_size-1)*p_row) ; // sorok szama amit az

utolso munkas ap (sajat + maradek) }

else

// nincs maradek, mindenki egyforman kap

{ p_row =

oor(p_row) ;

p_row_last = p_row ; }

// ha nem vagyunk az utolsok

DR AF T

187 : 188 : 189 : 190 : 191 : 192 : 193 : 194 : 195 : 196 : 197 : 198 : 199 : 200 : \r\n" ; 201 : 202 : 203 : 204 : 205 :

if(world_rank < world_size-1) {

cout <<

"Normal workers work : " << p_row << " lines.. \r\n" ;

}

else {

cout <<

"Last workers work : "

<< p_row_last <<

" lines..

}

// szamoljuk ki a FROM, TO ertekeket amikkel szamolnunk kell majd. if(world_rank < world_size-1) // ha nem a legutolsok vagyunk {


cout-al. Most már tudjuk, a kezd® (FROM) és vég (TO)

Rövid visszajelzést kapunk az egyes munkásoktól a konzolra

melyik munkás hány sorral fog dolgozni. Ki kell számolnunk,

sorszámokat amikkel az adott munkás számol majd. Ha az utolsó munkások vagyunk, lehet, hogy egy kis extra munkánk lesz.


200 : 201 : 202 : 203 : 204 : 205 : 206 : 207 : 208 : 209 :

cout << "Last workers work : " << p_row_last << " lines.. \r\n" ; }

// szamoljuk ki a FROM, TO ertekeket amikkel szamolnunk kell majd.

if(world_rank < world_size-1) //

ha nem a legutolsok vagyunk

{

FROM = world_rank*p_row ; TO = FROM+p_row ; }

else

www.tankonyvtar.hu

// Az utolso vagyok..



210 : 211 : 212 : 213 : 214 : 215 : 216 : 217 : 218 :

151

{ FROM = world_rank*p_row ; TO = FROM + p_row_last ; }

// minden munkas megmondja az intervallumot cout <<

"FROM : "

<< FROM <<

" -- TO : "

<< TO <<

" \r\n" ;

DR AF T

// elkezdjuk a kulso ciklust - minden munkas a sajat adatsorain vegzi a

muveletet.

219 : 220 :

for(int x=0 ;x

A küls® iterációban, minden pontban kiszámoljuk a hevített lap pontjain a h®terjedést

újra és újra. Minden munkás ezt végzi, de mindenki csak a saját adatain. A saját vonalakat a

FROM és TO értékekkel jelezzük. Ha nem egyedüli munkások vagyunk, a széls® vonalainkat interchange_borders() eljárást

(szellemvonalak) ki kell cserélni a többiekkel. Erre a

használjuk.


216 : 217 : 218 :

cout << "FROM : " << FROM << " -- TO : " << TO << " \r\n" ;

muveletet.

219 : 220 : 221 : 222 :

// elkezdjuk a kulso ciklust - minden munkas a sajat adatsorain vegzi a

for(int x=0 ;x
//

a belso ciklus jo alanya a parhuzamositasnak.

iteration(FROM, TO) ; // a FROM , TO ertekekekt minden munkashoz

a rangja alapjan hataroznak meg.

if(world_size>1) {interchange_borders(FROM,TO) ;}

223 :

// ha nem

vagyunk egyedul, a peremadatainkat ki kell cserelni a munkasok kozott

224 : 225 : 226 :

}

// ezen a ponton minden minden munkas feldolgozta az adatait, keszen

vagyunk

227 :

// az adatszeletek mas-mas csomópontban vannak, igy a fajl irashoz be

kell gyujtenem az adatokat az elso munkashoz.

228 : 229 :


www.tankonyvtar.hu

152


230 : 231 :

int rFROM ; int rTO ;


Ezen a ponton visszaugrunk az

interchange_borders()

függvényhez, amit korábban

átugrottunk. Ez a függvény is pluszban jelent meg a szekvenciális kódhoz képest. Mivel a szomszédos munkásoknak szükségük van egymás peremadataira, ezt egymással ki

DR AF T

kell cserélniük. Ez a csomópont-közi kommunikáció az MPI környezet segítségével valósul meg azMPI_Send() és

MPI_Recv() függvényekkel. Minden csomópont közel azonos id®ben

ér ide a futtatásban. A csomópont sorszámától függ®en egyes csomópontoknak mindkét

szomszédjukkal, egyeseknek csak egy szomszédjukkal kell cserélniük. Persze azt is gyelnünk kell, hogy nem egyedüli csomópontok vagyunk-e az MPI környezetben. Mivel minden

MPI_Send-hez

tartoznia kell egy

MPI_Recv

hívásnak, körültekint®en kell felépítenünk

a kommunikációt. Kommunikációs párosokat kell kialakítanunk. El®ször minden páros cso-

mópont fogja a fels® sorát felküldeni a felette lév® páratlan soroknak. Ezzel párhuzamosan minden páratlan sor fogadni fogja az adatokat alulról, az alsó soroktól. Ezek után a páratlan csomópontok küldenek fel adatot a páros csomópontoknak akik ezt fogadják.


088 : 089 : 090 : 091 : 092 : 093 : 094 : 095 : 096 : 097 : 098 :

}

void

interchange_borders(int FROM, int TO)

{

// peremek FEL kuldese

// parosak felfele kuldenek

if( {

!(world_rank % 2) && world_rank < world_size-1 )

MPI_Send(&old_array[TO-1][0],

Y, MPI_DOUBLE, world_rank + 1,

222 , MPI_COMM_WORLD) ; // 222 - egyedi tag

099 :

//cout << world_rank << " sending to " << world_rank + 1 << "

\r\n" ;

100 : 101 : 102 : 103 : 104 :

}

// paratlanok alulrol kapnak (kiveve ha legalsok)

if( (world_rank % 2) {

&& world_size>1 )

MPI_Recv(&old_array[FROM-1][0],

Y, MPI_DOUBLE, world_rank -

1, 222 , MPI_COMM_WORLD , MPI_STATUS_IGNORE) ; // 222 - egyedi tag

105 :

//cout << world_rank << " receiving from " << world_rank - 1 << "

www.tankonyvtar.hu



153

\r\n" ;

106 : 107 : 108 : 109 : 110 :

}

// paratlanok felfele adnak adatot (kiveve a legtetejen)

if( (world_rank % 2) {

&& world_rank < (world_size-1) )

MPI_Send(&old_array[TO-1][0],

Y, MPI_DOUBLE, world_rank + 1,


111 :

//cout << world_rank << " sending to " << world_rank + 1 << "

DR AF T

\r\n" ;

112 : 113 : 114 : 115 : 116 :

}

// parosok alulrol kapnak adatot (kiveve a legalsok)

if( {

!(world_rank % 2) && world_rank > 0)

MPI_Recv(&old_array[FROM-1][0],

Y, MPI_DOUBLE, world_rank -

1, 333 , MPI_COMM_WORLD , MPI_STATUS_IGNORE) ; // 333 - egyedi tag

117 :

//cout << world_rank << " receiving from " << world_rank - 1 << "

\r\n" ;

118 : 119 : 120 : 121 :

}

// Adatok LE kuldese

// parosak lekuldik az adatot (kiveve a legalsok)


Miután minden szükséges adat felkerült a fels® szomszédos csomópontokhoz, ugyan

ezt meg kell tenni lefele is, az alsó szomszédok irányába. A páros csomópontok küldenek

el®ször, a páratlanok fogadnak, aztán a páratlanok küldenek le és a párosak fogadják ezt.


118 : 119 : 120 : 121 : 122 : 123 : 124 :

}

// Adatok LE kuldese

// parosak lekuldik az adatot (kiveve a legalsok)

if( {

!(world_rank % 2) && world_rank > 0 )

MPI_Send(&old_array[FROM][0],

Y, MPI_DOUBLE, world_rank - 1,


125 :

//cout << world_rank << " sending to " << world_rank - 1 << "tol : "

<< FROM << "amimegy : " << old_array[FROM][0] <<" \r\n" ;

126 : 127 :

}

// paratlanok fentrol kapnak adatot (kiveve a legtetejen)


www.tankonyvtar.hu

154


if( (world_rank % 2)

128 : 129 : 130 :

{

&& world_rank < (world_size - 1))

MPI_Recv(&old_array[TO][0], Y, MPI_DOUBLE, world_rank + 1, 222

, MPI_COMM_WORLD , MPI_STATUS_IGNORE) ; // 222 - egyedi tag

131 :

//cout << world_rank << " receiving from " << world_rank + 1 << "ig :

" << TO+1 << "amijon : " << old_array[TO+1][0] <<" \r\n" ; }

// paratlanok lefele adnak adatot

if(

(world_rank % 2) )

// ha paatlanok vagyunk, legalabb a masodikak

DR AF T

132 : 133 : 134 :

vagyunk (nularol indul a szamolas)

135 : 136 :

{

MPI_Send(&old_array[FROM][0],

Y, MPI_DOUBLE, world_rank - 1,


137 :

//cout << world_rank << " sending to " << world_rank - 1 << "tol :"

<< FROM << " \r\n" ;

138 : 139 : 140 :

}

// parosak fentrol kapnak adatot

if(

!(world_rank % 2) && world_rank < (world_size -1) ) // parosak fentrol

kapnak

141 : 142 :

{

MPI_Recv(&old_array[TO][0], Y, MPI_DOUBLE, world_rank + 1, 333

, MPI_COMM_WORLD , MPI_STATUS_IGNORE) ; // 333 - egyedi tag

143 :

//cout << world_rank << " receiving from " << world_rank + 1 << "ig :

" << TO+1 << " \r\n" ;

144 : } 145 : 146 : 147 : } 148 : 149 : int main() 150 : { 151 : ofstream myle ; // ez lesz a kimeneti fajl kezelo 152 : 153 : // Inicializaljuk az MPI kornyezetet 154 : MPI_Init(NULL, NULL) ; 155 : 156 : // Lekerjuk a processzusok szamat 157 : // int world_size ; 158 : MPI_Comm_size(MPI_COMM_WORLD, &world_size) ; 159 : 160 : // Lekerjuk a processzusunk rangjat

www.tankonyvtar.hu



155

DR AF T

161 : // int world_rank ; 162 : MPI_Comm_rank(MPI_COMM_WORLD, &world_rank) ; 163 : 164 : // lap kezdeti ertekenek beallitasa (homerseklet 165 : for(int i=0 ;i<X ;i++) 166 : { 167 : for(int j=0 ;j
mindenki, a

maradekot az utolsonak kell kiszamolnia (ez rossz esetben akar a dupla munkat is jelentheti)


Miután a számítást elvégeztük, minden munkásnál meg van a végeredmény egy része.

Ahhoz, hogy ezt egy fájlba kiírathassuk az els® csomóponttal, össze kell gy¶jtetnünk vele az adatokat a többi csomóponttól. Mivel minden csomópont csak a saját magára vonatkozó kezd® és végsor számokat tudja(FROM,

TO),

az els® csomópontnak ki kell számolnia ezeket

az értékeket minden fogadáshoz. Ezek az értékek az

rFROM

és

rTO

változókban lesznek.

El®ször meg kell vizsgálnunk, hogy több munkás dolgozott-e. Ha igen, mindegyiknek el kell küldenie az adatát az els® munkásnak. Mivel minden csomópont ugyan azt a kódot futtatja, úgy kell azt kialakítanunk, hogy minden csomópont elküldi az adatait egyszer, ezeket pedig

for ciklussal tudjuk elvégeztetni, amiben p csomópontot kiolvasunk. Minden lépésben az els® csomópont a megfelel® helyre

az els® csomópont mind fogadja. Ezt egy egyszer minden

beolvassa ezeket az adatokat.


230 : 231 : 232 : 233 :


// az elso csomopontnak adatot kell gyujtenie a tobbiektol


www.tankonyvtar.hu

156


234 : 235 :

if(world_size>1)

// egyeduliek vagyunk ? Ha nem, akkor adatot kell

gyujteni

236 : 237 : 238 :

{

// minden munkas azonositonak (world_rank) kulduk vagy fogadunk

adatot.

for(int p=1 ;p<world_size ;p++) {

DR AF T

239 : 240 : 241 : 242 : 243 : 244 : from : 245 : 246 : 247 :

if(world_rank == p) //

ha kuldo vagyok

{

cout <<

"

<< FROM <<

" to : "

"I'm ("

<< world_rank <<

<< TO <<

" \r\n" ;

for(int r=FROM ;r
") sending lines

// kuldjuk a sorainkat

MPI_Send(&old_array[r][0], Y, MPI_DOUBLE,

0 , p*1000+r , MPI_COMM_WORLD) ; // 999 - egyedi tag

//

itt az egyedi tag ne legyen a for " R "je ? megelozik egymast ?

248 : 249 : 250 :

}

}

else if ( world_rank == 0) // Ha nem

vagyok "p" es nagyobb

a rangom mint 0, akkor a nullás munkás vagyok (0)

251 : 252 :

{

// melyik FROM,TO ertekek kozott olvassak ?

A munkasoktol (p ertek) milyen FROM, TO ertekeket kell beolvasnom ? Minden munkastol (p erteket), egyszerre. A receive_from az rFROM és a receive_to az rTO

253 :

if(p<world_size-1) //

nem az utolsok vagyunk (akinek

extra feladata lesz)

254 : 255 : 256 : 257 : 258 : 259 : 260 : 261 : 262 : 263 :

{

rFROM = p_row*p ;

rTO = p_row*(p+1) ;

}

else //

az utolsok dolgoznak.

{

rFROM = p_row*p ; rTO = X ;

}

// cout << "receiving (" << world_rank << ") lines

from : " << p << " interval : " << rFROM << " - " << rTO << " \r\n" ;

264 :

www.tankonyvtar.hu

for(int r=rFROM ;r


157

265 : 266 :

{

MPI_Recv(&new_array[r][0], Y, MPI_DOUBLE,

p , p*1000+r , MPI_COMM_WORLD, MPI_STATUS_IGNORE) ; // 999 - egyedi

tag

} } } }

DR AF T

267 : 268 : 269 : 270 : 271 : 272 : 273 :


A beolvasás után az egész tömb az els® csomópontnál van. Ett®l a pillanattól kezdve

a fájlba írás ugyan az, mint a szekvenciális kód esetén, csak most egyetlen fájlt írunk, a végs® eredményekkel.


269 : 270 : 271 : 272 : 273 : 274 : 275 : 276 : 277 : 278 : 279 : 280 : 281 : 282 : 283 : 284 : 285 : 286 : 287 : 288 : 289 : 290 :

}

}

if(world_rank==0) {

// csak a legvegen irjuk ki a fajlt string lename1 ; lename1 =

"plate_par.ppm" ;

c_str() ;

char *leName = (char*)lename1.

cout <<

" irom a fajlt : "

<< leName <<

"\r\n" ;

open(leName) ;

myle.

myle <<

"P3\r\n" ;

myle << X ; myle <<

" ";

myle << Y ; myle << myle <<

"\r\n" ; "255\r\n" ;


www.tankonyvtar.hu

158


DR AF T

291 : 292 : 293 : for(int i=0 ;i
9.7. Egyszer¶bb adatcsere Ha az

interchange_borders()

függvényt megnézzük, azt látjuk, hogy az adatcsere ál-

talános feladata kicsit komplikáltnak t¶nik. Az

MPI_Sendrecv() függvény segítségével a MPI_Sendrecv() függvény az adat-

kódot tömörebbé, ezáltal átláthatóbbá tehetjük. Az

küldést és adat fogadást egyszerre tudja elvégezni (pontosabban, a küldést és fogadást a háttérben az MPI réteg bonyolítja le). Ebben a formában az adatcserét három blokkban

végezhetjük el. Lentr®l felfelé haladva az els® blokkban a legalsó munkás cserél peremet a felette lev® munkás alsó peremével. A következ® blokkban a köztes csomópontok cserélik

ki alsó és fels® peremeiket mindkét irányban. A harmadik blokkban pedig az utolsó és az utolsó el®tti csomópontok cserélnek sorokat.

--- parallel_plate_v2.cpp ---

113 : 114 :

// this function communicates border lines (ghost lines) between processors

www.tankonyvtar.hu



115 : 116 : 117 :

void

159

interchange_borders(int TOL, int IG)

{

// we get in here, if there are at least 2 processors (function is called after an

if outside)

118 : 119 : 120 : 121 :

// processor with rank 0 has to communicate only with process 1

if (world_rank == 0) {

// we send the upper line of process 0 to process 1 and receive the bottom

DR AF T

line of process 1. We use an unique tag, ex. "222".

MPI_Sendrecv(®i[IG-1][0],

122 :

Y, MPI_DOUBLE, world_rank

+ 1, 222 ,

123 :

®i[IG][0], Y, MPI_DOUBLE,

world_rank + 1, 222 ,MPI_COMM_WORLD, MPI_STATUS_IGNORE) ;

124 : 125 :

}

// if our rank is between RANK_0 and RANK_LAST, we are a middle point

and have to communicate with two neighbours. We have to send our border lines and receive the ghost lines of the neighbours

126 : 127 : 128 :

if (world_rank > 0 && world_rank < world_size-1) {

// upper border line is going up to next process and we receive a ghost line

from beneath.

129 :

MPI_Sendrecv(®i[IG-1][0],

Y, MPI_DOUBLE, world_rank

+ 1, 222 ,

130 :

®i[TOL-1][0], Y, MPI_DOUBLE,

world_rank - 1, 222 ,MPI_COMM_WORLD, MPI_STATUS_IGNORE) ;

131 :

// lower border is going beneath and we receive a ghost line from

above.

MPI_Sendrecv(®i[TOL][0], Y, MPI_DOUBLE, world_rank -

132 :

1, 222 ,

133 :

®i[IG][0], Y, MPI_DOUBLE,

world_rank + 1, 222 ,MPI_COMM_WORLD, MPI_STATUS_IGNORE) ;

134 : 135 : 136 : 137 : 138 :

beneath

139 :

}

// if we are the last process, we only communicate beneath

if (world_rank == world_size-1) {

// we send lower bottom line beneath and get a ghost line from

MPI_Sendrecv(®i[TOL][0], Y, MPI_DOUBLE, world_rank -

1, 222 ,

140 :

®i[TOL-1][0], Y, MPI_DOUBLE,

world_rank - 1, 222 ,MPI_COMM_WORLD, MPI_STATUS_IGNORE) ;


www.tankonyvtar.hu

160

141 : 142 : 143 : 144 : 145 :


} } int main()

DR AF T

--- parallel_plate_v2.cpp ---

www.tankonyvtar.hu


10. fejezet

DR AF T

Gyors Fourier-transzformáció (FFT) 10.1. Fourier-transzformáció

A Fourier-transzformáció ((10.1)) egy matematikai eszköz, mellyel a függvény id®tarto-

mányából a frekvenciatartományába válthatunk. Az eljárást Joseph Fourier után nevezték el, aki megmutatta, hogy bármely periodikus függvény felírható egyszer¶ szinuszos és koszinuszos tagok összegeként (Fourier-sorok). A Fourier-transzformáció kiterjeszti ezt az ötletet megengedve, hogy a függvény periódusa végtelenhez tartson. A Fourier-transzformáció deníciója [Weisst] a következ® :

Z

+∞

f (ν) = Ft [f (t)](ν) =

f (t)e−2πiνt dt

(10.1)

−∞

Ezt miképpen tudjuk kihasználni ? A fentiek értelmében függvényeket több egyszer¶

függvény keverékeként kezelhetjük. Ha ismerjük ezeket az egyszer¶ összetev®ket, különkülön tudunk velük számításokat végezni, vagy akár egyes csoportjaikat kisz¶rhetjük,

megváltoztatva az eredeti függvény tulajdonságait. Az eredeti függvényt jobban kielemezhetjük, ha egyszer¶bb szinuszos összetev®kre bontjuk ®ket.

A gyakorlatban a függvény bizonyos frekvenciáit kisz¶rhetjük (zaj, túl magas, túl

alacsony frekvenciák), megjeleníthetjük az adott frekvenciaspektrumot (hangszerkeszt®k

spektrum analizátora). További elterjedt felhasználási terület a képfeldolgozás. Több képfeldolgozó algoritmus is ezen a technikán alapszik.

Mivel a legtöbb mérnöki és számítástechnikai alkalmazás diszkrét értékekkel dolgozik,

a diszkrét Fourier-transzformációt (DFT) is vizsgálnunk kell.

10.2. Diszkrét Fourier-transzformáció (DFT)

A digitális számítógépek diszkrét értékekkel számolnak, így ebben az esetben a Fouriertranszformációnknak is diszkrét értékekkel kell dolgoznia, azaz a diszkrét Fourier-transzformációt (DFT) kell használnunk. A diszkrét értékeket az analóg jelb®l mintavételezéssel nyerhetjük, így az adott mintavételezési frekvenciával vett diszkrét jelek sorozata reprezentálja a


www.tankonyvtar.hu

162


jelünket. Ha a megfelel® mintavételezési frekvencián dolgozunk, ezekb®l a diszkrét jelekb®l egyértelm¶en visszaállítható az eredeti analóg jel. Nyquist és Shannon munkásságából következik, hogy a mintavételezési frekvenciának legalább kétszer nagyobbnak kell lennie mint a minta-vett jelben szerepl® legnagyobb frekvencia. Ebb®l az is sejthet®, hogy nekünk a szükséges és elégséges, legkevesebb adatot igényl® frekvenciát kell választanunk, a kell® sebesség elérése érdekében. A továbbiakban feltételezzük, hogy a megfelel® mintavételi frekvenciát használtuk és az adatsorainkat ennek megfelel®en tekintjük. A diszkrét Fourier-transzformáció nagyon hasonlít az eredeti analóg formára.

DR AF T

Eredeti forma :

Z

∞

f (t)e−jωt dt

F (jω) =

(10.2)

−∞

Adott diszkrét értékek egy halmazára az integrál ezen értékek összegén értend® :

F (jω) = T

N −1 X

f (kT )e−jωkT

(10.3)

k=0

ahol

N

mintánk van,

T

mintavételi id®kkel. Véges számú adatmennyiségre a DFT

feltételezi, hogy az adatsor periodikus. Ennek megfelel®en az alapfrekvenciát és felharmonikusait kell vizsgálnunk. Ezek alapján :

ω = (0,

2π 2π 2π , × 2, .., × (N − 1)) NT NT NT

(10.4)

általánosan megfogalmazva :

F [n] =

N −1 X

2π

f [k]e−j N nk (n = 0 : N − 1)

(10.5)

k=0

F [n]

a diszkrét Fourier-transzformáltja a

Bár a bemen®

f [k]

f [k]

sornak.

értékek legtöbbször valós (real ) értékek, ne felejtsük, hogy az

F [n]

értékek komplexek. Az inverz transzformált pedig ez :

N −1 2π 1 X F [n]e+j N nk f [k] = N n=0

(10.6)

10.3. Gyors Fourier-transzformáció (FFT)

A DFT számítás összeadási és szorzási m¶veleteket használ. A szorzás a lassabb m¶velet, így a számítás sebessége f®leg azon múlik, hogy ebb®l hányat kell elvégezni. Ha tekintjük a DFT egyenletet, láthatjuk, hogy minden

n ∈ {0,1, .., N − 1} www.tankonyvtar.hu

(10.7)


10. fejezet. Gyors Fourier-transzformáció (FFT)

163

2 diszkrét értékre N darab szorzást kell összeadnunk. Ebb®l egy N -es id®függés követke2 zik (O(N )). Mivel a transzformációkra legtöbbször valós id®ben van szükség, valamint a valóságban több tíz-, százezer vagy még több adatponttal dolgozunk, a számítási sebesség egy fontos kérdés. Több módszer is kidolgozásra került mely a DFT tulajdonságait kihasználva jól közelíti az eredményt. Az alapötlet a redundáns számítások egyszer¶sítésének kihasználásán, illetve az összegek egy elem¶vé redukálásán alapszik. Gauss már ismerte ezeket a lehet®ségeket 2 és a DFT id®faktorát O(N )-r®l O(N log N )-re csökkentette. Ezeket a módszereket Gyors Fourier-transzformációnak (Fast Fourier Transformation

DR AF T

(FFT)) [Hilb2013b] hívják.

A módszert, ami képes a DFT-t

O(N log N )

id® alatt elvégezni újra felfedezték és a

publikálók után Cooley-Tukey Algoritmus -nak[Cool1965] nevezték el. Az algoritmust 1999ben a A 20. század legjobb 10 algoritmusába választották. A Danielson-Lanczos Lemma azt mondja ki, hogy

N/2

N

pont DFT-je lebontható két külön

pontos DFT-re. Az egyik minden els®, a másik pedig minden második adatra, azaz

az eredeti

N

adat páros és páratlan elemeire.

Legyen

2π

e−j N nk = WNnk

(10.8)

.

A Danielson-Lanczos Lemma alapján :

N

F [n] =

−1 2 X

N

f [2k]WN2kn +

k=0

−1 2 X

2k+1)n =

(

f [2k + 1]WN

k=0

N

−1 2 X

N

f [2k]WN2kn +

k=0

−1 2 X

f [2k + 1]WN2kn WNn

k=0

(10.9)

Egy kompakt formában :

F [n] = E[n] + WNn O[n]

ahol

A

WN

E[n]

jelöli a páros bemeneti adatokat,

O[n]

(10.10)

pedig a páratlan bemeneti adatokat.

pedig a Twiddle Factor -nak nevezett együttható.

Mivel a páros és páratlan részek hossza az eredeti bemenet hosszának a fele, a szum-

mázás ezekben

0

és

N 2

között megy.

Ezt az ötletet a két külön

E[n]

és

O[n]

halmazra újra alkalmazni lehet :

F [n] = E[n] + WNn O[n] = EE[n] + W Nn EO[n] + WNn OE[n] + WNn W Nn OO[n] 2

(10.11)

2

Ezt a dekompozíciót addig folytathatjuk, amíg már nem tudunk újabb kettéválasztást végezni (Danielson-Lanczos lemma kiterjesztése), azaz egy elem¶ szummázandó halmazt n kapunk. Az egy elem szummája önmaga, így ekkor már csak a megfelel® WN faktorral


www.tankonyvtar.hu

164


kell foglalkoznunk. A módszernek azonban van el®feltétele. Mivel mindig felezni akarjuk a kapott fél halmazokat is, a bementi elemek száma kett® hatvány kell, hogy legyen (léteznek

m=log2 N lépést kell tennünk az N elemre. Innen O(N 2 )-ról O(N log2 N )-re. Ezt a felezéses módszert

más módszerek is). Ha ez teljesül, akkor ered a sebességnövekedés (speed-up )

Radix-2 módszernek is hívjuk. Egy elterjedt technika, hogy ha bemeneti elemszám nem kett® hatvány, akkor annyi nullával egészítjük ki a végén, hogy kett® hatvány számú legyen [Hilb2013a] [Lyons2004]. Ez nem befolyásolja negatívan a végeredményt, csak a frekvencia felbontást nagyobbá teszi. A módszer el®nye az mellett, hogy új adathoz így nem jutunk, csak alkalmazhatjuk

DR AF T

a Radix-2 módszert, a frekvenciatartományban történ® látványosabb ábrázolás. A kés®bbi példánkban ezt a kiegészítéses módszert fogjuk alkalmazni mi is. A fentiek alapján

N = 4-re

és

N = 2-re

az összegzés a következ®képpen néz ki :

F (n) = x(0) + W2n x(1)

(10.12)

F (n) = x(0) + W2n x(2) + W4n x(1) + W4n W2n x(3)

(10.13)

F (n) = x(0) + W2n x(4) + W4n x(2) + W4n W2n x(6) + W8n x(1)+ +W8n W2n x(5) + W8n W4n x(3) + W8n W4n W2n x(7)

(10.14)

pedig

N = 8-ra

pedig

.

Ha közelebbr®l vizsgáljuk az egyenleteket, az

x(n)

komponensek érdekes sorrendjét -

gyelhetjük meg. Ez a sorrend a bemenetek ismétl®d® páros-páratlan átrendezéséb®l adódik. Nyolc bemeneti pont esetén háromszor kell ketté választanunk (feleznünk) az adatokat,

hogy egy elem¶ szummákat kapjunk. Képzeljük el, hogy a bemeneti értékeink a következ®k :

0,1,2,3,4,5,6,7.

Azért ezeket az értékeket választottuk, hogy egyben a sorszámukat is

lássuk, hol helyezkednek el a bemeneti sorban. Ha felosztjuk ®ket páros-páratlan elemekre (DL lemma), a következ® két, négy tagú sorozatot kapjuk : bontjuk ®ket, ezeket kapjuk :

0,4, 2,6, 1,5, 3,7.

0,4,2,6

és

1,5,3,7.

Ha tovább

Az utolsó felbontásnál azt a sorrendet kap-

juk, amit a 10.14 egyenletben láthattunk. Ez a sorrend egy trükkel, a bináris fordított (binary reverse sorrenddel megkaphatjuk. Innen is jön a név : fordított bináris sorrend (reverse binary. Ha a bemeneti értékek bináris reprezentációiban megfordítjuk az egyes helyiértékek sorrendjét (10.1), pontosan ezt a fordított bináris sorrendet kapjuk.

www.tankonyvtar.hu



165

10.1. táblázat. Bináris fordított értékek

bináris

fordított bináris (fb)

0

000

000

0

1

001

100

4

2

010

010

2

3

011

110

6

4

100

001

1

5

101

101

5

fb érték

DR AF T

érték

6

110

011

3

7

111

111

7

Az FFT algoritmushoz jól jöhet egy fordított binárist képezni tudó függvény. A Danielson-

Lanczos lemma alapján az algoritmusunknak a páros és páratlan részeket kell kombinálnia n úgy, hogy a páros részt szoroznunk kell a WN értékkel. Ezek után egy új adatsort kapunk,

az eredeti hossz felével (N/2). Ezen újra végig kell mennünk és kombinálnunk a páros és n páratlan részeket, a páros részeket W2N -el szorozva. Ezt egészen addig kell folytatnunk, míg egyetlen értéket nem kapunk a végén. Ez lesz az FFT n-edik kimenete.

A fordított bináris függvény segítségével ehhez az eredeti bemeneti sorból a megfelel®

párokat tudjuk azonnal kiválasztani a megfelel®

n

értékek kiszámításához.

Foglaljuk össze az eddigieket. A diszkrét Fourier-transzformáltat (DFT) akarjuk kiszá-

molni egy gyors módszerrel (FFT). Mintavételezéssel el®állítottuk a diszkrét értékeinket az eredeti jelb®l a számításhoz. A Danielson-Lanczos lemma kiterjesztése révén a beme-

neti sorozatunkat rekurzív módon páros-páratlan részsorozatokra bonthatjuk. Ezt egy fa struktúraként is elképzelhetjük. A bemeneti értékek balról jobbra a fa levelei, egy speci-

ális (bináris fordított) sorrendben. Más dolgunk nincs, mint balról jobbra haladva a két szomszédos levélb®l (páros, páratlan) egy új értéket állítsunk el®. Nem elég összeadni ®ket, n a páros részt még a speciális WN Twiddle Factor-al is szoroznunk kell el®tte. Ezen faktor értéke az aktuális szintt®l függ, azaz, hogy a fastruktúra hányadik szintjén állunk. N

bemeneti ponthoz

log2 N

szintünk lesz. Miután a két részt összeadtuk, egy új adatsort n kapunk, amiken ugyanezt végig kell hajtani, felhasználva az új WN faktort. Mivel log2 N

n-edik kiN bemenet

bemeneti értékünk van (Radix-2), egyetlen értéket kapunk a végén. Ez lesz az menetünk, azaz a frekvenciatartományunk minden egyes

n

n-edik

eleme. Ezt a procedúrát az

értékére végig kell csinálni, generálva az

n

elem¶ kimenetet.

10.3.1. Szekvenciális FFT példaprogram

Ebben a fejezetben az FFT szekvenciális megvalósítását mutatjuk be. A programban a fenti elveket használjuk. Mivel az FFT komplex számokkal dolgozik, ahol valós és imaginárius rész is van, a valós (real ) és imaginárius (imaginary ) részeket két külön tömbben tároljuk. Az els® része a kódnak a szokásos include sorokkal és változó deniálásokkal kezd®dik.


www.tankonyvtar.hu

166


#include #include #include <sstream> #include <math.h> #include #include #include #include //

erre a specialis binaris megjelenites miatt lehet szukseg

DR AF T

001 : 002 : 003 : 004 : 005 : 006 : 007 : 008 : 009 : 010 : 011 : 012 : 013 : 014 : 015 : 016 : 017 : 018 : 019 : 020 : 021 : 022 : 023 : 024 : 025 : 026 : 027 : 028 : 029 : 030 : 031 : 032 : 033 : 034 : 035 :

using namespace std ; // bemeno adatok

double * data_in_r ; double * data_in_i ;

// kimeno adatok

double * data_out_r ; double * data_out_i ;

// atmeneti puer

double * buer_r ; double * buer_i ;

// forditott binaris adatok puere double * rb_buer_r ; double * rb_buer_i ; int p_length=32380 ; int p2_length=0 ; int bitlength ;

int what_power=0 ;

unsigned int mask=0x00000001 ; unsigned int

revbit(unsigned int val)

{

unsigned int rval=0 ;

--- t_serial_hu.cpp ---

A nyolcadik sorban egy

bitset

nev¶ include állomány van. Ez azt a célt szolgálja,

hogy bináris számokat tudjunk egyszer¶en kiíratni. Ez a funkció megjegyzésben van, de

data_in_i[] tömbök tartalmazzák a részeit a bemenetnek. Hasonlóan, a data_out_r[] és data_out_i[]

monitorozáshoz bent hagytuk. A

valós és imaginárius

www.tankonyvtar.hu

data_in_r[]

és



167

tömbök tartalmazzák majd a spektrális kimen® adatokat. Az algoritmusnak kell majd két átmeneti buer (buffer_r[] és

buffer_i[]),

amiben az átmeneti eredményeket tároljuk

majd a további számításokhoz. A számításokhoz szükségünk lesz a bemen® adatok egy speciális sorrendjére (bináris fordított). Mivel a bináris fordított sorbarendezés id®igényes, jó ötlet, ha ennek az eredményét két tömbben tároljuk (rb_buffer_r[],

rb_buffer_i[])

és mindig csak innen másoljuk ki a buerbe, ha szükségünk van rá. A

p_length

változó tárolja a bemeneti adatok mennyiségét. Egy valós alkalmazásnál

ezt a bemeneti adatok (fájl, vagy valamilyen stream) leszámlálásával kellene meghatározni. A mi teszt céljainkhoz az inputot generálni fogjuk. Ha a bemeneti adatmennyiség nem ket-

DR AF T

t® hatvány, akkor ki kell terjesztenünk az adatainkat nullákkal a legközelebbi kett® hatvány

p2_length változó fogja tartalmazni. A bitlength változót monitorozásra használjuk, hogy láthassuk az eredeti bithosszát a bemeneteknek. A what_power változón ban a kett® n-edik kitev®je lesz, 2 bemeneqti érték esetén (mely érték a p2_length-ben van). Ezt a next_2pow() függvény fogja használni, amikor azt a minimális bithosszúságot keressük, melyen a bemeneti adatok száma (p2_length) ábrázolható (pl. 8 bemeneti értékre ez 3 lesz). A mask változót a revbit() függvény fogja használni. Ez a függvény méretre. Ezt a

végzi el a bináris fordítást a bemenetén.

A következ® sorok a kódban pár rövid függvénydeníciót tartalmaznak.


030 : 031 : 032 : 033 : 034 : 035 : 036 : 037 : 038 : 039 : 040 : 041 : 042 : 043 : 044 : 045 : 046 :

int what_power=0 ;

unsigned int mask=0x00000001 ; unsigned int


{

unsigned int rval=0 ; unsigned int fval=0 ;

for(int i=0 ;i<what_power ;i++) {

rval = (val >> i) & mask ; fval = fval

|

(rval << (what_power-i-1)) ;

}

return fval ;

}

// ez az eljarass generalja a bemeno adatainkat

// a mi esetunkben ez most egy fureszfog jel lesz


A

revbit()

függvény az adott

val

bemenetének bináris fordítottját adja meg. Több

trükkös megoldás is létezik ennek a gyors kiszámítására, de az egyik legegyszer¶bb és


www.tankonyvtar.hu

168


világosabb módszer a bitek jobbról való egyesével történ® kiemelése és a másik oldalon való rögzítése. Így megfordítjuk a bitek sorrendjét. Fontos megemlíteni, hogy a bináris fordítás dinamikus hosszakkal m¶ködik, azaz tudnunk kell a minimális bithosszt, amin a bemeneteink tömbindexeit ábrázolni tudjuk. Ha 8 bemen® adatunk van, akkor ez a szám a 3. Ha 16 bemen® adatunk van, akkor ez a szám a 4, ha 1024 bemen® adatunk van, akkor ez

rval az els®, majd második, stb. bitjét kapja meg a bemenetnek. Eltoljuk (shift) ezt egy bittel balra és logikai OR kapcsolatba hozzuk fval-al. Miután what_power lépés lement, fval tartalmazza a végs® fordított binárist, amivel visszatérünk.

DR AF T

a szám a 10. Az


043 : 044 : 045 : 046 : 047 : 048 : 049 : 050 : 051 : 052 : 053 : 054 : 055 : 056 :

}


// a mi esetunkben ez most egy fureszfog jel lesz void {

gen_data(unsigned int size)

if (size>p2_length) {size=p2_length ;} // hogy ne irhassunk rossz cimre for(unsigned int i=0 ;i<size ;i++)

{

data_in_r[i] = (double)i ; data_in_i[i] = 0 ;

}

for(unsigned

int i=size ;i
szukseges

057 : 058 : 059 : 060 : 061 : 062 : 063 : 064 : 065 :

{

data_in_r[i] = 0 ;

data_in_i[i] = 0 ;

}

}

// ez a fuggveny a legkozelebbi nagyobb ketto hatvanyt adja vissza int next_2pow(int input)


gen_data() függvény egy f¶részfog alakú bemeneti jelet generál, 0 és size között növelt értékekkel. A size érték a függvény paramétere. Egy rövid ellen®rzésen után, ahol azt biztosítjuk, hogy ne írjunk felül adatot, a növekv® adatot a data_in_r[] és data_in_i[] A

tömbökbe tesszük. Bár többnyire egész számokkal dolgozunk a bemeneti oldalon, komplex számok is lehetnének a bemeneten. A mostani példánkban szimplán kinullázzuk az ima-

www.tankonyvtar.hu


10. fejezet. Gyors Fourier-transzformáció (FFT) ginárius részt. Ha a

size

169

kisebb mint a kett® következ® hatványa, ki kell egészítenünk a

bemenetünket nullákkal.

--- t_serial_hu.cpp --}

// ez a fuggveny a legkozelebbi nagyobb ketto hatvanyt adja vissza int

next_2pow(int input)

DR AF T

061 : 062 : 063 : 064 : 065 : 066 : 067 : 068 : 069 : 070 : 071 : 072 :

{

what_power =

ceil(log((double)input)/log(2.0)) ;

return (int)pow(2.0, what_power) ;

}

// W Twiddle faktor - valos resz //


A

next_2pow()

függvény a kett® legközelebbi nagyobb hatványával tér vissza. Ez a

függvény a nullákkal való kitöltésnél lesz szükséges, ahol biztosítanunk kell, hogy a beme-

neti értékek száma kett® valamely hatványa. El®ször a kettesalapú logaritmusát vesszük a logx b ) majd kerekítjük ezt a következ® egészre (ceil()). A kapott bemeneteknek (loga b = logx a értéket a what_power globális változóba tesszük, és a függvény a kett® legközelebbi egész hatványát adja vissza.


068 : return (int)pow(2.0, what_power) ; 069 : } 070 : 071 : // W Twiddle faktor - valos resz 072 : // 073 : double WLn_r(unsigned int L, unsigned int n)

// A W komplex, igy egy valos

(_r) es egy imaginarius (_i) resze lesz.

074 : 075 : 076 : 077 : 078 : 079 : 080 :

{

return( (double)cos( 2*M_PI*n /L )) ;

}

// W Twiddle faktor - imaginarius resz double

WLn_i(unsigned int L, unsigned int n)

{


www.tankonyvtar.hu

170


081 : 082 : 083 : 084 : 085 :

return( (double)sin( 2*M_PI*n /L )) ; } int main() {


WLn_r()

és a

WLn_i()

a korábban deniált

WNn

Twiddle

DR AF T

A következ® két függvény, a

Factor valós és imaginárius részeit adják meg. Mivel a Twiddle Faktor komplex,

WNn = e

−j2πn N

(10.15)

az Euler-formulát használva

eix = cos(x) + i sin(x)

(10.16)

külön kiszámolhatjuk a valós (cos()) és imaginárius (sin()).

W Ln_r(L, n) = cos(

A

main()

függvény a

p2_length

2πn ) L

and

W Ln_i(L, n) = sin(

2πn ) L

érték kiszámításával kezd®dik, aminek a hossza ket-

t® hatványú és lehet nullákkal kiegészített ennek az érdekében. Pár monitorozó kimenet

konzolra való kirakása után memóriát foglalunk a bemeneti adatainknak (data_in_r[],

data_in_i[]), kimeneti adatainknak (data_out_r[], data_out_r[]), átmeneti tárolóinknak (buffer_r[], buffer_r[]) és a fordított bináris sorrend¶ adatainknak (rb_buffer_r[], rb_buffer_r[]). --- t_serial_hu.cpp ---

081 : 082 : 083 : 084 : 085 : 086 : 087 : 088 : 089 : 090 : 091 : 092 : 093 :

return( (double)sin( 2*M_PI*n /L )) ;

}

int

main()

{

next_2pow(p_length) ; //

a kovetkezo ketto hatvany hossz

log(p2_length) / log(2) ; //

bit hossz

p2_length=

bitlength =

// informacio a kiszamolt ertekekrol cout << cout << cout <<

www.tankonyvtar.hu

"p_length " << p_length << endl ; ; "p2_length " << p2_length << endl ; ; "bitlength " << bitlength << endl ; ; c Várady Géza, Zaválnij Bogdán, PTE


cout <<

"what_power "

<< what_power << endl ; ;

// memoriafoglalas a bemeno adatok valos reszenek data_in_r =

new double[p2_length] ;

// memoriafoglalas a bemeno adatok imaginarius reszenek data_in_i =


// memoriafoglalas a kimeno adatok valos reszenek

DR AF T

094 : 095 : 096 : 097 : 098 : 099 : 100 : 101 : 102 : 103 : 104 : 105 : 106 : 107 : 108 : 109 : 110 : 111 : 112 : 113 : 114 : 115 : 116 : 117 : 118 : 119 :

171

data_out_r =


// memoriafoglalas a kimeno adatok imaginarius reszenek data_out_i =


// memoriafoglalas az atmeneti puer valos reszenek buer_r =


// memoriafoglalas az atmeneti puer imaginarius reszenek buer_i =


// memoriafoglalas a forditott binaris adatok puerenek rb_buer_r =


rb_buer_i =


// bemeno, fureszfog jel generalasa

gen_data(p_length) ;

// P_length mennyisegu adatot generalunk, ami

ha nem ketto hatvany, akkor a fuggvenyben kiterjesszuk a legkozelebbi ketto hatvany mennyisegig

120 : 121 : 122 : 123 : 124 :

//

/* csak egy kis debug informacio a forditott binaris ertekek kovetesere for(int i=0 ;i

A következ® pár sort kikommenteltük, de bent hagytuk a példában.


120 : 121 :

//


www.tankonyvtar.hu

172


122 : 123 : 124 : 125 : 126 : 127 : 128 :

/* csak egy kis debug informacio a forditott binaris ertekek kovetesere for(int i=0 ;i x(i) ; unsigned int rev = revbit(i) ; std : :bitset<32> y(rev) ; // cout << "szam : " << i << " (" << x << ") reverse : " << rev <<

" (" << y << ") \r\n" ; }

DR AF T

129 : 130 : 131 : 132 : 133 :

*/

// itt kezdodnek a ciklusok

// komplex szamokkal dolgozunk, igy lesz valos (_r) es imaginarius (_i)

reszunk is


Ezt a kódrészt aktiválva az értékek bináris reprezentációit gyelhetjük meg normál és

fordított sorrendben. A számításhoz ez a megjelenítés nem szükséges.


130 : 131 : 132 : 133 :

*/



reszunk is

134 : 135 :

unsigned int puf_l = p2_length ;

// munkavaltozo - a hossz kezdoerteke - ez

valtozni fog menet kozben (felezodik es felezodik..)

136 :

unsigned int divider = 1 ;

// oszto valtozo, ez, ahogy lepegetunk elore a

paros-paratlan osszegzesben, duplazodni fog

137 : 138 : 139 :

unsigned int ind = 0 ;

// atmeneti tarolo az adatmasolashoz

// eloszor egy forditott binaris sorrendu munka pufert csinalunk a be-

menetunkbol. Ezt egyszer erdemes generalni es utana mar csak bemasolgatni a munkapuerbe amikor kell.

140 : // masoljuk a bemeno adatot a puerbe forditott binaris sorrendben 141 : // a bemeno adatunk komplex, igy van valos es imaginarius resz is 142 : for(unsigned int i=0 ;i
www.tankonyvtar.hu



173

145 : rb_buer_r[i]=data_in_r[ind] ; 146 : rb_buer_i[i]=data_in_i[ind] ; 147 : } 148 : 149 : for(unsigned int n=0 ;n
DR AF T


Mivel

p2_length

darabszámú bemen® adattal dolgozunk, a küls® ciklusnak ennyiszer

kell lefutnia. Ahogy korábban említettük, rekurzív módon fogunk adatpárokból új adatokat el®állítani. Az átmeneti tárolónk méretét a puf_l változóban tartjuk. A divider változó n az aktuális WN Twiddle Faktor (WLn_r és WLn_i) kiszámításában lesz hasznunkra. Az ind változó tartalmazza majd a fordított bináris index értéket. A küls® ciklus el®tt a bemen®

adatainkat a fordított bináris sorrend szerint újrarendezzük. Mivel minden adatpont szá-

mításakor szükségünk lesz erre, jó ötlet csak egyszer kiszámolni és elrakni az eredményt kés®bbre. Ezt az újrarendezett adatsort a

rb_buffer_r[]

és

rb_buffer_i[]

tömbökbe

mentjük el. Most, hogy el®készítettük a küls® ciklust, elkezdhetjük végrehajtani.


146 : rb_buer_i[i]=data_in_i[ind] ; 147 : } 148 : 149 : for(unsigned int n=0 ;n
a munka-puerbe,

minden n-lepesben azt meg kell tennunk

152 : 153 : 154 : 155 : 156 : 157 : 158 :

for(unsigned int i=0 ;i
buer_r[i]=rb_buer_r[i] ; buer_i[i]=rb_buer_i[i] ;

}

// ezzel a valtozoval jeloljuk "N"-et

divider=1 ;

puf_l = p2_length ;

// a hossz mindig a bemenet hosszatol

kezdodik es a kovetkezo ciklusban valtozik

159 :

for(unsigned int b=0 ;b<what_power ;b++)

// b 0-tol logN szintig

megy

160 : 161 :

{ divider = divider*2 ;


// ahogy epunk elore, az N erteket

www.tankonyvtar.hu

174


duplaznunk kell

for(unsigned int k=0 ;k
162 : 163 : 164 : ,n)

{ buer_r[k] = buer_r[2*k] + buer_r[2*k+1]*

WLn_i(divider, n) ;

WLn_r(divider

- buer_i[2*k+1]*

165 : 166 :

// a+bi

x

c+di

= (ac - bd) + i(ad + bc)

WLn_i(divider

buer_i[k] = buer_i[2*k] + buer_r[2*k+1]*

WLn_r(divider, n) ;

,n) + buer_i[2*k+1]*

167 :

+

(a+bi x c+di)

even + odd * w

-->

r:

DR AF T

// m+ni

m+(ac - bd)

168 : 169 : 170 : 171 : 172 : 173 : 174 : 175 :

i:

n+(ad + bc) }

puf_l = puf_l / 2 ;

}

data_out_r[n]=buer_r[0] ; data_out_i[n]=buer_i[0] ;

// megnezhetjuk a bemeno es kimeno adatainkat

"-- Input " << n << " : " << data_in_r[n] << "," << " -- output : " << data_out_r[n] << "," << data_out_i[n]

cout <<

data_in_i[n] << << endl ; ;

176 : 177 : 178 :

}

// ezen sorok utan elvesztunk minden adatot, barmilyen kimenetet ezek elott

kell elvegezni

179 :

delete[] data_out_i ; // memoria felszabaditasa


Az FFT eredménye

N

bemen® adathoz

N

kimen® adat lesz, így a küls® ciklust 0

p2_length között kell futtatnunk. Minden lépésben a speciálisan újrarendezett bemen® rb_buffer_r[]b®l és a rb_buffer_i[]-b®l az átmeneti buffer_r[]-be és buffer_i[]-be kell másolnunk. A következ® ciklus 0 és what_power között fut, ezzel deniálva, hány párosítási lépést kell és

adatokkal dolgozunk, így az el®z®ekben generált fordított bináris adatokat a

megtennünk. Ha gyelembe vesszük, hogy a bemeneteink száma kett® hatvány, könnyen N beláthatjuk, hogy log2 lépést kell tennünk. Pontosan ez az érték van a what_power válto-

zóban. Minden lépésnél a fordított bináris lista egymás melletti elemeit kell párosítanunk. Az összeadás mellett a speciális komplex

WLn_r

és

WLn_i

Twiddle Faktort is gyelembe

kell vennünk. A pár (második) páros részét kell szoroznunk a Twiddle Faktorral, miel®tt a páratlan részhez adnánk. A Twiddle Faktornak két változó része van. Az egyik a páro-

N -ként n értékkel ne kever-

sítási szinttel vagy lépés szinttel áll kapcsolatban. Erre a paraméterre korábban hivatkoztunk. Azért, hogy a korábban használt és más jelentéssel bíró jük, a függvényben

www.tankonyvtar.hu

N -et L-ként

jelöljük. Az

N

jelöli a bemen® adatok számát. A legfels®



175

p2_length és minden további szinten ez osztódik ketté. A legalsó szinten, a fa struktúra leveleinél a N értéke csupán 2. Alulról felfele így ezt az értéket minden lépésben duplázni kell. Ezt a divider változó teszi meg, mely a Twiddle Faktor els® paramétere. A második paraméter a n, ami az aktuális bemen® adat indexe. Ezt a küls® ciklusból kapjuk meg. A harmadik ciklus 0 és puf _l között fut és a párosítási eljárást végzi el. szinten ez a

Minden szinten ki kell választanunk a buerb®l az els® (odd ) és második (even ) értéket. A párosítási lépés után az új adatsor hossza csak a fele, aztán megint a fele lesz, egészen addig, míg csak egy érték marad. Ennek megfelel®en változik a

puf_l

változó. Ennél a

pontnál meg kell emlékezzünk arról, hogy az algoritmus komplex számokkal dolgozik. Bár

DR AF T

a tipikus bementi adatainknak csak valós része van, a számítást komplex számokra kell elvégezni. Két komplex szám összeadása elég egyszer¶, pusztán össze kell adnunk a valós

(a+ib)×(c+id) = (ac−bd)+i(ad+bc). A ciklusban a párok els® elemei 2k indexel, a második elemek 2k + 1 indexel szerepelnek. Ha a párok els® elemeit m + in-ként, a második elemeket a + ib-ként, a Twiddle Faktort pedig c + di-ként jelöljük, akkor ezt kell kiszámítanunk : m + in + (a + ib) ∗ (c + id). Ennek az eredménye (m + (ac − bd)) + i(n + (ad + bc)) lesz. A tömböket behelyettesítve a valós és és imaginárius részeket. A szorzás már trükkösebb :

imaginárius részeket két külön sorban számoljuk ki :

buffer_r[k] = buffer_r[2*k] + buffer_r[2*k+1]*WLn_r(divider ,n) - buffer_i[2*k+1]*WLn_i(divider, n); and

buffer_i[k] = buffer_i[2*k] + buffer_r[2*k+1]*WLn_i(divider ,n) + buffer_i[2*k+1]*WLn_r(divider, n);

Miután minden szint minden párosával végeztünk, egyetlen komplex értéket kapunk

minden

n

bemenethez. Ezt az adatot a

data_out_r[]

és

data_out_i[]

eredmény töm-

bökbe kell elmentenünk. Monitorozás okán a konzolra kiírhatunk visszajelzést, amiben a bemenetet és kimenetet vethetjük össze az egyes

n-ekre.


174 : 175 :

// megnezhetjuk a bemeno es kimeno adatainkat

cout << "-- Input " << n << " : " << data_in_r[n] << "," <<

data_in_i[n] << " -- output : " << data_out_r[n] << "," << data_out_i[n] << endl ; ;

176 : 177 : 178 :

}


kell elvegezni

179 : delete[] 180 : delete[] 181 : delete[]

data_out_i ; // memoria felszabaditasa data_out_r ; data_in_i ;


www.tankonyvtar.hu

176


delete[] data_in_r ; delete[] buer_r ; delete[] buer_i ; delete[] rb_buer_r ; delete[] rb_buer_i ; return 0 ; }

DR AF T

182 : 183 : 184 : 185 : 186 : 187 : 188 : 189 : 190 :

Ha kiszámoltuk az

kiírhatjuk

egy

n bemenetre az FFT-t, meg vannak a frekvencia adataink. Ezt most

fájlba,

vagy

kirajzolhatjuk

valamilyen

grakus

alkalmazásban.

10.1. ábra. Bemen® adat : f¶részfog jel 0 és 240 között, kiegészítve 256-ra.

www.tankonyvtar.hu


177

DR AF T


10.2. ábra. Kimen® adat : frekvencia spektrum. Ha a mintavételezés 256 Hz-en történt, a frekvencia lépés 1 Hz-es, azaz a spektrum 0 és 256 Hz között ábrázolt. Az értékeket

log10

skálán ábrázoltuk.

Ahogy láthatjuk, az FFT felgyorsítja a DFT eljárást, így hasznos eszközünk. Nagy

adatokkal számolni azonban még így is nagyon számításigényes. A megvalósításunk még tartalmaz lehet®ségeket a javításra, de az

O(N log2 N )

futási id®nél jobbat így sem ér-

hetünk el. Ha megvizsgáljuk az algoritmust, észrevehetjük, hogy a párhuzamosítás itt is segíthet a további gyorsulás elérésében.

10.3.2. Párhuzamos FFT példaprogram

Az el®z®ekben vizsgált FFT algoritmus lehet®séget ad a párhuzamosításra. A szekvenciális megoldásban a hatalmas bemeneti adatmennyiséget egyesével dolgozzuk fel a küls®

ciklusban. Bár minden számításnak szüksége van az egész bemen® adatmennyiségre, ez a kezdésnél mindenhol rendelkezésre áll. Ez a párhuzamosítás lehet®ségét adja, ahol a munkások adott mennyiség¶ adaton dolgozhatnak párhuzamosan.

Az els® include és deníciós blokk csak pár extra sorral több mint a szekvenciális

változat.

001 : 002 : 003 : 004 : 005 :

#include <mpi.h> #include #include #include <sstream> #include <math.h>


www.tankonyvtar.hu

178


#include #include #include #include // erre a specialis binaris megjelenites miatt lehet szukseg using namespace std ; // bemeno adatok double * data_in_r ; double * data_in_i ;

DR AF T

006 : 007 : 008 : 009 : 010 : 011 : 012 : 013 : 014 : 015 : 016 : 017 : 018 : 019 : 020 : 021 : 022 : 023 : 024 : 025 : 026 : 027 : 028 : 029 : 030 : 031 : 032 : 033 : 034 : 035 : 036 : 037 : 038 : 039 : 040 : 041 : 042 : 043 :

// kimeno adatok

double * data_out_r ; double * data_out_i ;

// atmeneti puer

double * buer_r ; double * buer_i ;

// forditott binaris adatok puere double * rb_buer_r ; double * rb_buer_i ; int p_length=32380 ; int p2_length=0 ; int bitlength ;

int what_power=0 ;

unsigned int mask=0x00000001 ;

// MPI valtozok

int world_rank ; // a processzus rangja

int world_size ; // a vilagunk merete, azaz a felhasznalhato munkasok szama int FROM ; int TO ;


unsigned int revbit(unsigned int val) {

--- t_parallel_hu.cpp ---

El®ször is újra használnunk kell az

www.tankonyvtar.hu

mpi.h függvénykönyvtárat, hogy az MPI-függvényekkel c Várady Géza, Zaválnij Bogdán, PTE


179

dolgozhassunk. A kommunikációhoz pár extra változót kell deniálnunk. Ahogy korábban is, a

world_rank

és

world_size

változók tárolják az adott munkás sorszámát illetve az

összes munkás darabszámát. Az adatfelosztáshoz is deniálunk pár változót, amelyekben a különböz® munkások adattartományait követhetjük nyomon (FROM,

TO, rFROM, rTO).

Mivel a párhuzamos verzió függvényei megegyeznek a szekvenciális változat függvényeivel, ezeket ugyan úgy deniáljuk.

--- t_parallel_hu.cpp --int rFROM ; int rTO ;

DR AF T

039 : 040 : 041 : 042 : 043 : 044 : 045 : 046 : 047 : 048 : 049 : 050 : 051 : 052 : 053 : 054 : 055 : 056 : 057 : 058 : 059 : 060 : 061 : 062 : 063 : 064 : 065 : 066 : 067 : 068 : 069 : 070 : 071 : 072 :

unsigned int


{

unsigned int rval=0 ; unsigned int fval=0 ;

for(int i=0 ;i<what_power ;i++) {

rval = (val >> i) & mask ; fval = fval

|

(rval << (what_power-i-1)) ;

}

return fval ;

}


// a mi esetunkben ez most egy fureszfog jel lesz void {

gen_data(int size)

for(int i=0 ;i<size ;i++)

{

data_in_r[i] = (double)i ; data_in_i[i] = 0 ;

}

for(int i=size ;i
nullaval valo kitoltes, ha szukseges

{

data_in_r[i] = 0 ;

data_in_i[i] = 0 ;

}

}

// ez a fuggveny a legkozelebbi nagyobb ketto hatvanyt adja vissza


www.tankonyvtar.hu

180


DR AF T

073 : int next_2pow(int input) 074 : { 075 : what_power = ceil(log((double)input)/log(2.0)) ; 076 : return (int)pow(2.0, what_power) ; 077 : } 078 : 079 : // ez a fuggveny a legkozelebbi kisebb ketto hatvanyt adja vissza 080 : int last_2pow(int input) 081 : { 082 : return (int)pow(2.0, oor(log((double)input)/log(2.0))) ; 083 : } 084 : 085 : // W Twiddle faktor - valos resz 086 : // 087 : double WLn_r(unsigned int L, unsigned int n) // A W komplex,

igy egy valos

(_r) es egy imaginarius (_i) resze lesz.

088 : 089 : 090 : 091 : 092 : 093 : 094 : 095 : 096 : 097 : 098 : 099 :

{

return ( (double)cos( 2*M_PI*n /L )) ;

}

// W Twiddle faktor - imaginarius resz double {

WLn_i(unsigned int L, unsigned int n)

return ( (double)sin( 2*M_PI*n /L )) ;

}

int main() {


Ezek a függvények a párhuzamosításban nem érintettek, kivéve egyet, mellyel a munká-

sok számát fogjuk megkapni. Ez a

last_2pow() függvény, ami a bemenetéhez legközelebbi

kisebb kett® hatványt adja meg. A részletekre kés®bb térünk ki. A következ® eltérés a

main()

függvény els® soraiban van.


094 : 095 : 096 : 097 :

{ return ( (double)sin( 2*M_PI*n /L )) ; }

www.tankonyvtar.hu



098 : 099 : 100 : 101 :

int

181

main()

{ double s_time ; // MPI idoziteshez

// MPI kornyezet inditasa - innentol az MPI_Finalize-ig hasznalhatjuk

az MPI rutinokat.

MPI_Init(NULL, NULL) ; MPI_Wtime() ;

s_time=

// processzusok szama

DR AF T

102 : 103 : 104 : 105 : 106 : 107 : 108 : 109 : 110 : 111 : 112 : 113 : 114 :

MPI_Comm_size(MPI_COMM_WORLD, &world_size) ; // processzusunk rangja

MPI_Comm_rank(MPI_COMM_WORLD, &world_rank) ; // ketto hatvanyra igazitjuk a bemenetunket

next_2pow(p_length) ; // kovetkezo nagyobb ketto hatvany bitlength = log(p2_length) / log(2) ; // bit hossz, monitorozashoz

p2_length=

// munkasok kozott a feladatot el kell osztani


Deniálunk egy double típusú változót,

használni az

MPI_Wtime()

s_time névvel, amit az MPI id®zítéshez fogunk

függvénnyel. Ez utóbbi egy múltbéli id®ponthoz képest eltelt

id®t adja meg milliszekundumokban. Nekünk két ilyen eltelt id® különbségére van szükségünk. Az MPI környezet indítása után (MPI_Init()), megszámoljuk a felhasználható munkásokat az alapértelmezett kommunikátorunkban a

MPI_Comm_size()

függvénnyel és

world_size. A következ® lépésben azonosítjuk magunkat és sorszámunkat MPI_Comm_rank() függvénnyel a world_rank-ba. A következ®

betesszük az eredményt a beolvassuk a

két sor már ismer®s lehet a szekvenciális változatból : a bemenetek számát kett® hatványra állítjuk és beállítunk pár monitorozó paramétert.


111 : 112 : 113 : 114 : 115 : 116 : 117 : 118 : 119 :

p2_length=next_2pow(p_length) ; // kovetkezo nagyobb ketto hatvany bitlength = log(p2_length) / log(2) ; // bit hossz, monitorozashoz

// munkasok kozott a feladatot el kell osztani // ketto hatvanynyi munkas

int ws_temp = world_size ;

// ha kevesebb az adat mint a munkas

if ( p2_length < world_size ) {


www.tankonyvtar.hu

182


120 : 121 : 122 : 123 : 124 : 125 :

ws_temp = p2_length ;

// ez mindig ketto hatvany lesz, mivel p2_length is az }

else { ws_temp =

last_2pow(world_size) ;

// ketto hatvany szamu

munkast hasznalunk }

DR AF T

126 : 127 : 128 : 129 : 130 : 131 : 132 : 133 : 134 : 135 : 136 : 137 :

// szuksegtelen munkasok ellenorzese

if(world_rank > ws_temp-1) {

// nincs rank szukseg, kilepunk cout << world_rank <<

MPI_Finalize() ; exit(1) ;

" : -- Bye ! -- "

<< endl ;

}

// elosztjuk a bemenetunk mennyiseget a munkasok szamaval


Ennél a pontnál el® kell készítenünk az adatkiosztást. Ebben a példában egyforma

mennyiség¶ adatot osztunk ki minden munkásnak. Ha kevesebb adat van mint munkás, akkor a bemeneti adatok szám szerinti munkást aktiválunk, azaz a

p2_length-re

ws_temp

változót

állítjuk.

Ha több adatunk van mint munkásunk, ami legtöbbször így van, akkor a munkásaink

számát a legközelebbi kett® hatványig redukáljuk. Például, ha 5 munkásunk van, 32 be-

men® adattal, akkor csak 4 munkást használunk. Miért kett® hatvány számú munkással akarunk dolgozni ? Azért, mert nem tudunk más létszámmal dolgozni. Ha kett® hatvány

mennyiség¶ adatunk van és egyenl® részekre akarjuk osztani, a részek száma is kett® hat-

vány lesz, valamint a munkásokra jutó adatmennyiség is kett® hatvány lesz. Mivel az extra munkásokra itt nincs szükség, egyszer¶en elengedjük ®ket, lezárjuk az MPI környezetüket és kilépünk a programból. Annak ellenére, hogy ez a példaprogramunkban jól m¶ködik, egy dologra gyelnünk kell ezzel kapcsolatban. Ha valamelyik munkás kilép az MPI kör-

nyezetb®l, minden kollektív kommunikációt használó funkcionalitást elveszítünk. Erre egy megoldást mutatunk az alfejezet végén (10.3.2).

A következ® blokk, pár adat kezelését kivéve, hasonló mint a szekvenciális kódban.


133 :

MPI_Finalize() ;

www.tankonyvtar.hu



183

DR AF T

134 : exit(1) ; 135 : } 136 : 137 : // elosztjuk a bemenetunk mennyiseget a munkasok szamaval 138 : unsigned int dataslice = p2_length / ws_temp ; 139 : FROM = dataslice*world_rank ; 140 : TO = FROM + dataslice ; 141 : 142 : // a szamitott ertekeink 143 : if (world_rank == 0) 144 : { 145 : cout << "p_length " << p_length << endl ; 146 : cout << "p2_length " << p2_length << endl ; 147 : cout << "bitlength " << bitlength << endl ; 148 : cout << "what_power " << what_power << endl ; 149 : cout << "No. of workers : " << ws_temp << endl ; 150 : } 151 : 152 : // memoriafoglalas a bemeno adatok valos reszenek 153 : data_in_r = new double[p2_length] ; 154 : 155 : // memoriafoglalas a bemeno adatok imaginarius reszenek 156 : data_in_i = new double[p2_length] ; 157 : 158 : // memoriafoglalas a kimeno adatok valos reszenek 159 : data_out_r = new double[p2_length] ; 160 : 161 : // memoriafoglalas a kimeno adatok imaginarius reszenek 162 : data_out_i = new double[p2_length] ; 163 : 164 : // memoriafoglalas az atmeneti puer valos reszenek 165 : buer_r = new double[p2_length] ; 166 : // memoriafoglalas az atmeneti puer imaginarius reszenek 167 : buer_i = new double[p2_length] ; 168 : 169 : // memoriafoglalas a forditott binaris adatok puerenek 170 : rb_buer_r = new double[p2_length] ; 171 : 172 : rb_buer_i = new double[p2_length] ; 173 : 174 : // bemeno, fureszfog jel generalasa


www.tankonyvtar.hu

184


gen_data(p_length) ;

175 :

// P_length mennyisegu adatot generalunk, ami

ha nem ketto hatvany, akkor a fuggvenyben kiterjesszuk a legkozelebbi ketto hatvany mennyisegig //

/* csak egy kis debug informacio a forditott binaris ertekek kovetesere for(int i=0 ;i
DR AF T

176 : 177 : 178 : 179 : 180 : 181 : 182 : 183 : 184 : 185 :

std : :bitset<32> x(i) ;

unsigned int rev = revbit(i) ; std : :bitset<32> y(rev) ;

// cout << "szam : " << i << " (" << x << ") reverse : " << rev <<

" (" << y << ") \r\n" ;

186 : 187 : 188 : 189 : 190 :

}

*/



reszunk is

191 : 192 :

unsigned int puf_l = p2_length ;

// munkavaltozo - a hossz kezdoerteke - ez

valtozni fog menet kozben (felezodik es felezodik..)

193 :

unsigned int divider = 1 ;

// oszto valtozo, ez, ahogy lepegetunk elore a

paros-paratlan osszegzesben, duplazodni fog

194 : 195 : 196 :

unsigned int ind = 0 ;

// atmeneti tarolo az adatmasolashoz

// eloszor egy forditott binaris sorrendu munka pufert csinalunk a be-

menetunkbol. Ezt egyszer erdemes generalni es utana mar csak bemasolgatni a munkapuerbe amikor kell.

197 : // masoljuk a bemeno adatot a puerbe forditott binaris sorrendben 198 : // a bemeno adatunk komplex, igy van valos es imaginarius resz is 199 : for(unsigned int i=0 ;i
www.tankonyvtar.hu



185

El®ször beállítjuk az egy munkásra jutó adatmennyiséget a den munkás kiszámolja a saját adattartományát (FROM,

TO).

dataslice-ba,

majd min-

A következ® pár sorban vál-

tozókat deniálunk, memóriát foglalunk a listáinkhoz, legeneráljuk a bemeneti adatokat és a fordított bináris adatsort, pont mint a szekvenciális kódban.


DR AF T

202 : rb_buer_r[i]=data_in_r[ind] ; 203 : rb_buer_i[i]=data_in_i[ind] ; 204 : } 205 : 206 : // A FROM es TO valtozok minden munkasnak egyedi erteket kapnak 207 : for(unsigned int n=FROM ;n
210 : 211 : 212 : 213 : 214 : 215 : 216 :

for(unsigned int i=0 ;i
buer_r[i]=rb_buer_r[i] ; buer_i[i]=rb_buer_i[i] ;

}

// ezzel a valtozoval jeloljuk "N"-et

divider=1 ;

// a hossz mindig a bemenet hosszatol

puf_l = p2_length ;

kezdodik es a kovetkezo ciklusban valtozik

217 :

for(unsigned int b=0 ;b<what_power ;b++)

// b 0-tol logN szintig

megy

218 : 219 :

{

divider = divider*2 ;

duplaznunk kell

for(unsigned int k=0 ;k
220 : 221 : 222 :

,n)

// ahogy epunk elore, az N erteket

{

buer_r[k] = buer_r[2*k] + buer_r[2*k+1]*

WLn_i(divider, n) ;

WLn_r(divider

- buer_i[2*k+1]*

223 : 224 :

// a+bi

x

c+di

= (ac - bd) + i(ad + bc)

WLn_i(divider

buer_i[k] = buer_i[2*k] + buer_r[2*k+1]*

WLn_r(divider, n) ;

,n) + buer_i[2*k+1]*

225 :

m+(ac - bd)

226 : 227 : 228 :

// m+ni

i:

+

(a+bi x c+di)

even + odd * w

-->

r:

n+(ad + bc) } puf_l = puf_l / 2 ;

}


www.tankonyvtar.hu

186


229 : 230 : 231 : 232 : 233 :

data_out_r[n]=buer_r[0] ; data_out_i[n]=buer_i[0] ;

// bemeneo es kimeno adatok vizsgalata // cout << "-- Input " << n << " : " << data_in_r[n] << ","

<< data_in_i[n] << " -- output : " << data_out_r[n] << "," << data_out_i[n] << endl ; }

DR AF T

234 : 235 : 236 :

// be kell gyujtenunk az adatokat


A bemen® adatokon futó küls® ciklus minden munkáson egy adott intervallumon fut.

A ciklustörzs nem változik a szekvenciális megvalósításhoz képest. Mivel minden munkás

rendelkezésére áll az egész bemeneti adatsor és az algoritmus nem függ a többiek részeredményeit®l, minden munkás párhuzamosan tudja futtatni. Miután lefuttattuk az FFT-t

az egyes bemeneti adatintervallumokon, minden munkásnál meg van a végeredmény egy része. Ezeket egy processzusnak be kell gy¶jtenie.


232 : 233 :

// bemeneo es kimeno adatok vizsgalata

// cout << "-- Input " << n << " : " << data_in_r[n] << ","

<< data_in_i[n] << " -- output : " << data_out_r[n] << "," << data_out_i[n] << endl ;

234 : 235 : 236 : 237 : 238 : 239 :

}

// be kell gyujtenunk az adatokat

if(ws_temp>1) {

// csak akkor gyujtunk, ha egy processzusnal tobb volt

for(int

p=1 ;p<ws_temp ;p++) // be kell gyujtenunk ws_temp-1

adatot

240 : 241 : 242 : 243 :

{


ha mi jovunk mind kuldok, kuldunk

{

// cout << "I'm sending (me : " << world_rank << ")

data from " << FROM << " to " << TO << ". dataslice : " << dataslice << endl ;

244 :

MPI_Send(&data_out_r[FROM],

dataslice,

MPI_DOUBLE, 0 , 900 , MPI_COMM_WORLD) ;

245 :

MPI_Send(&data_out_i[FROM],

dataslice,

MPI_DOUBLE, 0 , 900 , MPI_COMM_WORLD) ;

www.tankonyvtar.hu



246 : 247 : 248 :

187

}

else if ( world_rank == 0) // ha a 0-as processzusok vagyunk,

begyujtjuk az adatokat

249 : 250 :

{

// mennyi legyen az rFROM es az rTO ? Melyik

sorokat gyujtsuk be ? Ezt a tavoli processzus p rangjabol szamithatjuk ki

251 : 252 : 253 : 254 :

rFROM = dataslice*p ;

DR AF T

rTO = dataslice*(p+1) ;

// cout << "I receive (me : " << world_rank << ") the

lines from : " << p << ". Interval : " << rFROM << " - " << rTO << endl ;

MPI_Recv(&data_out_r[rFROM],

255 :

dataslice,

MPI_DOUBLE, p , 900 , MPI_COMM_WORLD, MPI_STATUS_IGNORE) ;

MPI_Recv(&data_out_i[rFROM],

256 :

dataslice,


257 : 258 : 259 : 260 : 261 : 262 : <<

}

}

}

if(world_rank == 0) {

cout << world_rank <<

MPI_Wtime()-s_time << endl ;

263 : 264 : 265 :

" collecting done ! - MPI_time : "

}

// egy kis monitorozasi kimeno adat, hogy lassuk mit gyujtottunk be


El®ször leellen®rizzük, hogy egynél több munkás van-e jelen. Ha igen, akkor be kell

gy¶jtenünk

ws_temp-1

munkástól az adatait. Jó ötlet a nullás azonosítójú munkással

begy¶jtetni az adatokat, ez ugyanis mindíg létezik. Így ha több munkásunk van, akkor minden nullánál nagyobb azonosítójú munkásnak el kell küldenie (MPI_Send()) a va-

lós (data_out_r[]) és imaginárius (data_out_i[]) adat részeit a 0-ás azonosítójú els®

munkásnak. Ezzel párhuzamosan természetesen a nullás azonosítújú munkásnak fogadnia (MPI_Recv()) kell ezeket az adatrészeket (dataslice) a megfelel® valós és imaginárus

adattömbökbe. A megfelel® pozíciókat persze mindig ki kell számolni a fogadás el®tt. Mivel tudjuk, melyik azonosítójú munkástól akarunk fogadni, könnyen kiszámolhatjuk a hozzá tartozó kezd® (rFROM) és vég (rTO) pontokat, amiket ezen pozícióba akarunk elhelyezni a fogadó oldalon.


www.tankonyvtar.hu

188



263 : 264 : 265 : 266 : 267 : 268 : 269 :

}

// egy kis monitorozasi kimeno adat, hogy lassuk mit gyujtottunk be

if(world_rank == 0) {

for(int n=0 ;n
"-- Input " << n << " : " << data_in_r[n] << "," << " -- output : " << data_out_r[n] << "," << data_out_i[n]

cout <<

DR AF T

data_in_i[n] << << endl ;

270 : 271 : 272 :

}


kell elvegezni

273 : 274 : 275 : 276 : 277 : 278 : 279 : 280 : 281 : 282 :

delete[] data_out_i ; // delete[] data_out_r ; delete[] data_in_i ; delete[] data_in_r ; delete[] buer_r ; delete[] buer_i ; delete[] rb_buer_r ; delete[] rb_buer_i ;

memoria felszabaditasa

// MPI kornyezet leallitasa. Minden mas munkassal itt elveszitjuk a

kapcsolatot

283 : MPI_Finalize() ; 284 : 285 : return 0 ; 286 : } 287 :

A végén kiírjuk az eredeti bemeneti értékeket és a számított FFT értékeket egy listába.

Ezt le lehet menteni további feldolgozáshoz. Ez után felszabadítjuk az átmeneti tárolóknak lefoglalt memóriát (delete[]

some buer).

Ett®l a ponttól az adatain elvesztek a

memóriából. Miután bezárjuk az MPI környezetet az aktív munkásainkkal is és ett®l a

ponttól nem tudnak már egymással kommunikálni. Az egyes processzusok tovább futhatnak, feladatokat végezhetnek el, de az MPI környezetet már nem indíthatják újra.

Finalize

megoldás

Ahogy tárgyaltuk is, ha

m

munkással kezdünk, de ebb®l csak

n-re

van szükségünk, ahol

m>n, akkor a felesleges munkásokat leállíthatjuk. A példányban csak egy MPI_Finalize() www.tankonyvtar.hu


10. fejezet. Gyors Fourier-transzformáció (FFT) és

exit()

189

párost futtattunk rajtuk, ami megfelel® megoldásnak bizonyult. Arra azonban

gyelnünk kell, hogy ha a kezdeti munkásokból párat így leállítunk, akkor ®k a kollektív kommunikáció szempontjából halottként viselkednek. Ez rossz m¶ködéshez, akár a program lefagyásához is vezethet (pl. a

MPI_Barrier()

esetében biztos a fagyás). Szerencsére

erre is van könny¶ megoldás. Miel®tt a szükségtelen munkásokat lel®nénk, deniálhatunk egy új kommunikátort, melyben a szükségtelen munkások nem szerepelnek, így kés®bb ezt használva a bennmaradtak kommunikálni tudnak. A példánkban a munikátorról átváltunk egy tetsz®leges,

MPI_COMM_ANYTHING

MPI_COMM_WORLD kom-

kommunikátorra. Az ehhez

DR AF T

szükséges pár alap lépést ismertetjük a következ®kben.

01 : 02 : 03 : 04 : 05 : 06 :

// MPI_Finalize() megoldas int world_size ;

int world_rank ;

// Az MPI kornyezet inditasa - az MPI_Finalize fuggvenyig hasznalhatjuk

az MPI fuggvenyeket.

07 : 08 : 09 : 10 : 11 : 12 : 13 : 14 : 15 : 16 : 17 : 18 : 19 : 20 : 21 :

MPI_Init(NULL, NULL) ; s_time=

MPI_Wtime() ;


MPI_Comm_size(MPI_COMM_WORLD, &world_size) ; // processzusunk rangja

MPI_Comm_rank(MPI_COMM_WORLD, &world_rank) ; // hanyan vannak a csoportban MPI_Group wgroup ;

MPI_Comm_group(MPI_COMM_WORLD, &wgroup) ;

// vagjuk le a szuksegtelen munkasokat MPI_Group newgroup ;

MPI_Group_range_excl(wgroup, 1, { last_active_worker, world_size-

1, 1}, &new_group) ;

22 : 23 : 24 : 25 :

// uj kommunikatort hozunk letre

MPI_Comm MPI_COMM_ANYTHING ;

MPI_Comm_create(MPI_COMM_WORLD,

newgroup,

&MPI_COMM_ANYTHING) ;

26 : 27 : 28 : 29 :

if(MPI_COMM_ANYTHING == MPI_COMM_NULL) {

// ha szuksegtelen munkasok vagyunk..


www.tankonyvtar.hu

190


30 : 31 : 32 : 33 : 34 :

MPI_Finalize() ; exit(0) ; } // innentol az MPI_COMM_ANYTHING ikommunikatort kell hasznalni

kollektiv kommunikaciora az

MPI_COMM_WORLD helyett

35 :

DR AF T

--- t_mpi_nalize_workaround_hu.cpp ---

Az els® sorok már ismer®sek, inicializáljuk az MPI környezetet, leszámoljuk az ak-

tív munkásokat és megállapítjuk a saját sorszámunkat. Az MPI környezetünk processzus

MPI_Group struktúrába tároljuk. Mivel ez egy rendezett lista, a rangok (rank ). A kommunikátorok (communicator ) egy csoport-

csoportját lekérve azt az processzusok azonosítói

ból (group) és kommunikációs szabályokból állnak. Az alapértelmezett kommunikátorunk a

MPI_COMM_WORLD.

Ez a kommunikációs világunk, a név erre utal. Miután meg van a

processzusaink csoportja, a nem kívánatosakat el kell távolítani, és a maradékot egy új

MPI_Group_range_excl() függvénnyel tehetjük meg. Ennek az els® csoport (wgroup). A második bemenete a harmadik bemenetben sze-

csoportba tenni. Ezt a

bemenete az eredeti

repl® háromtagú csoportok száma. A harmadik paraméter pedig számhármasok (ranges ) sorozata. A hármasok jelentése : intervallum kezdete (last_active_worker), intervallum

vége (world_size-1) és lépésköz az intervallumban (1). A függvény kimenete az új átsza-

bott csoport (new_group). A csoportokban deniált intervallumokba es® azonosítók nem

kerülnek be az új csoportba.

Ezzel az új csoporttal egy új kommunikátort hozhatunk létre, a

függvénnyel. A függvény

MPI_COMM_NULL

MPI_Comm_create()

értékkel tér vissza, ha olyan processzus hívta

meg, aki nem része az új csoportnak. Ezt felhasználva kiválaszthatjuk, kik hagyják el az MPI környezetünket.

Egy másik, kevésbé kinomult megoldás lehet, hogy a program indulásakor megvizs-

gáljuk a munkások számát, és ha nem felel meg a céljainknak, egyszer¶en kilépünk a programból egy üzenettel, hogy hány munkással kell újraindítani azt.

www.tankonyvtar.hu


11. fejezet

DR AF T

Mandelbrot

A Mandelbrot halmaz pontok egy halmaza, ahol egy speciális tulajdonsága van a pontoknak. Ehhez a tulajdonsághoz színeket rendelhetünk, amib®l színes és látványos ábrák jönnek ki.

11.1. ábra. A szekvenciális programunkkal készült Mandelbrot halmaz


www.tankonyvtar.hu

192

Bevezetés az MPI programozásba példákon keresztül Ezt a speciális halmazt a lengyel születés¶, francia-amerikai matematikus, Benoit

Mandelbrot-ról nevezték el, aki mélyreható vizsgálatokat végzett a fraktál geometria területén. A Fraktálok matematikai halmazok, melyeknek egy extra fraktáldimenziója van. Ez a dimenzió a komplexitás egy statisztikai indexe, ami a részletesség és felbontás változásának arányára jellemz®. A Mandelbrot-halmaz egy végtelen fraktál forma, amibe tetsz®legesen belenagyítva speciális formák ismétlik önmagukat. Ezt önhasonlóságnak is nevezzük. A matematikai deníció a következ® :

(11.1)

Z0 = cZn+1 = Zn2 + c

(11.2)

DR AF T

M = {c ∈ C| lim Zn 6= ∞} n→∞

ahol :

Ezek alapján, a Mandelbrot halmaz azon

függvény a

c

számra nem tart a végtelenbe,

c komplex számok halmaza, ahol a Zn rekurzív ha n a végtelenbe tart. A végtelen a függvény

attraktora, ahogy ezt a fraktálok kapcsán nevezni szoktuk.

A fenti képet tekintve (11.1), a Mandelbrot halmaz a fekete terület a kép középen. A

színes pontok a halmazon kívül különböz® színei jelentik az adott pont

n iterációs számát.

Hogy ilyen szettekkel dolgozni tudjunk, el®ször mindenképpen kell pár praktikus lépést

tennünk. Az els® problémánk a végtelen kérdésének vizsgálata. Véges id®ben nem tudjuk

vizsgálni, hogy egy függvény végtelenbe tart-e vagy sem. Még az sem túl praktikus, ha azt teszteljük, hogy egy nagyon-nagy számhoz tart-e. Szerencsére bizonyítható, hogy ha a

abszolút értéke 2 fölé megy, azaz a

0 + i0

Z

számtól való távolsága nagyobb mint 2, akkor

végtelenbe fog tartani. Ez egy nagy segítség a programban a feltételvizsgálathoz. Ahhoz, hogy megvizsgáljuk, hogy

Z

2 fölé megy-e vagy sem, pár tíz iterációs szám

szükséges. Ezt a maximális iterációszámot úgy kell beállítani, hogy az adott felbontáshoz

illeszkedjen. Egy adott felbontás mellett nincs értelme tetsz®legesen növelni a maximális

iterációs számot, mert a felbontás miatt úgy is vesztünk adatot. Ha nagyon nagy felbontáson szeretnénk dolgozni (pl. nagyítható képet szeretnénk számolni), akkor a maximális iterációs számot is növelnünk kell. Ez, természetesen több id®t vesz majd igénybe.

Ha meg vannak az adataink és a színsémánk, egy tetszet®s színpalettát kell összeál-

lítanunk. A példánkban egyszer¶en fogjuk a

n

értéket és a következ®

R, G, B

értékeket

rendeljük hozzá :

11.1. táblázat. RGB színbeállítások az

n

R érték

G érték

n

0

0

256-511

255

n

0

512-767

255

255

n

érték

0-255

www.tankonyvtar.hu

n

értékekhez

B érték


11. fejezet. Mandelbrot

193

Ez a színbeállítás a feketét®l a vörösig, majd a vöröst®l a sárgáig és a sárgától a fehérig megy. Ez a t¶z érdekes benyomását kelti, mint ahogy a programunk által generált nagyított

DR AF T

képen is látni (11.2).

11.2. ábra. Mandelbrot halmaz a soros programunkkal készítve

11.1. Mandelbrot halmaz, szekvenciális példa

Ebben az alfejezetben a Mandelbrot halmazt generáló szekvenciális programot vizsgáljuk meg.

Mint általában, a kód els® sorai header fájlok beillesztésével és konstansok deniálá-

sával kezd®dik.

001 : 002 : 003 : 004 : 005 : 006 : 007 :

#include #include #include #include <sstream> #include <math.h> #include #include


www.tankonyvtar.hu

194


DR AF T

008 : 009 : using namespace std; 010 : const int imgX=3000; // vizszintes kepi felbontas 011 : const int imgY=3000; // fuggoleges kepi felbontas 012 : const int iter_n=3000; // maximalis iteracios szam 013 : const double yMin= -0.135; // Mandelbrot jelenet y tartomany 014 : const double yMax= -0.115; 015 : const double xMin= -0.79; // Mandelbrot jelenet x tartomany 016 : const double xMax= -0.77; 017 : 018 : int img_array[imgX][imgY] = {0}; // Mandelbrot halmaz ertekek tombje 019 : 020 : // konvergacio-fuggveny , a Mandelbrot halmaz eloallitasanak a lelke

--- mandelbrot_serial_hu.cpp ---

A kimeneti kép aktuális felbontása az

épp

3000-re.

Az

iter_n

imgX

és

imgY

változókban van beállítva, most

változó adja meg, hogy az iteráció maximum meddig menjen

a vizsgálatnál. Az aktuálisan vizsgált komplex sík két tartománnyal kerül megadásra. Az

yMin

és

yMax,

valamint az

xMin

és

xMax

értékek határozzák azt meg. Ezen a síkon

pontonként haladunk a fenti képfelbontás alapján. A a kiszámított

n

img_array[imgX] fogja tartalmazni

értékeket.

--- mandelbrot_serial_hu.cpp --017 : 018 : 019 : 020 : 021 : 022 : 023 : 024 : 025 : 026 : 027 : 028 :

int img_array[imgX][imgY] = {0}; // Mandelbrot halmaz ertekek tombje

// konvergacio-fuggveny , a Mandelbrot halmaz eloallitasanak a lelke // ket parametert var (x es y koordinatak) es egy iteracios szammal ter vissza int converges(double cx,double cy) { int n=0; double zx=0; double new_zx=0; double zy=0; // az iteracio a maximalis iteracios ertekig (iter_n) vagy addig fut, amig z^2 (komplex!) eleri a 4-et (azaz a sor vegtelenbe tart, igy nem lesz eleme a halmaznak a bemeno ertek) 029 : while( (n new_zx = (zx*zx - zy*zy) new_zy = (zx*zy + zx*zy) // komplex szamokkal dolgozunk 032 : // z*z + c = zx^2 - zy^2 +cx + i(zx*zy*2 + cy) 033 : new_zx = zx*zx - zy*zy + cx; 034 : zy = 2*zx*zy + cy; 035 : zx = new_zx; 036 : n++; 037 : } 038 : return n;

www.tankonyvtar.hu



195

039 : } 040 : 041 : 042 : int main(int argc, char **argv)


converges() függvénynek két paramétere van, cx és cy ahol az x, y értékek koordináták a komplex síkon és a függvény az ehhez a ponthoz tartozó n iterációs számmal tér 2 vissza. A függvényben deniáljuk a szükséges változókat a zn+1 = zn + c számításához. A converges() függvény ciklusa nullától addig fut, amíg el nem érjük a maximális iterációs p 2 x + y 2 -t kell értéket (iter_n) vagy 2-nél messzebb távolodunk a 0 + i0 ponttól. Mivel 2 2 gyelnünk, elég, ha azt vizsgáljuk, hogy x + y nagyobb-e mint 4.

DR AF T

A

--- mandelbrot_serial_hu.cpp --038 : return n; 039 : }

040 : 041 : 042 : int main(int argc, char **argv) 043 : { 044 : if(argc<2) 045 : { 046 : cout << "Használat :" <<endl; 047 : cout<<argv[0]<<" out_file.ppm"<<endl; 048 : exit(1); 049 : } 050 : double resX=0; // Az iteracios lepeseink felbontasa 051 : double resY=0; // ezt az (yMax-yMin) / imgY ertekbol szamoljuk majd ki .. 052 : double cx=xMin; // innen indul a szamitas es ezt valtoztatjuk menet kozben 053 : double cy=yMin; 054 : time_t mytime1,mytime2; // idozitesi adatokhoz 055 : 056 : ofstream myle; // fajlba irashoz 057 : 058 : string lename1(argv[1]); 059 : // lename1 = "mandel.ppm"; 060 : char *leName1 = (char*)lename1.c_str(); 061 : 062 : //lepeskoz beallitasa 063 : resX = (xMax-xMin) / imgX; 064 : resY = (yMax-yMin) / imgY; 065 : 066 : time(&mytime1); // idozites kezdete - ido lekerese 067 :



www.tankonyvtar.hu

196

Bevezetés az MPI programozásba példákon keresztül A

main()

függvény a szükséges argumentumok vizsgálatával kezd®dik. Ha az argu-

mentumok száma (argc) kevesebb mint

2,

kiírjuk, hogy milyen argumentumokat vár a

program. A programnak egy kimeneti nevet kell megadnunk. A Mandelbrot halmazunk

yMin, yMax, xMin, xMax konstansokban adtuk meg, a kép felbontását pedig az imgX és imgY konstansokban. Ezekb®l kiszámolhatjuk a lépésközök nagyságát (resX és resY) amivel felületen lépkedünk. A kiinduló pontok a xMin és yMin lesznek, az aktuális pozíciónkat pedig cx-ben és cy-ben könyveljük. Deniálunk egy time_t változót is mely méretét a

DR AF T

az id®zítésekhez kell, illetve el®készítjük a kimeneti fájlunkat.

--- mandelbrot_serial_hu.cpp --063 : resX = (xMax-xMin) / imgX; 064 : resY = (yMax-yMin) / imgY; 065 : 066 : 067 : 068 :

time(&mytime1); // idozites kezdete - ido lekerese

// elvegezzuk a szamitast a komplex sik minden pontjara, azaz a 2D-s kepunk pontjaira, a megfelelo lepeskozzel 069 : for(int i=0;i
<< endl;;

cout << "Számítás alatt eltelt id® : " << mytime2-mytime1 << " másodperc."

084 : 085 :

// fajl IO --- mandelbrot_serial_hu.cpp ---

mytime1-be elkezdjük a beágyazott f®ciklusainkat futtatni. A képünk minden egyes pontjára elvégezzük a számítást (indulva 0-tól imgX-ig és 0-tól imgY-ig). Minden új sor yMin-tól indul így ezt az értéket kell cy-ba tennünk el®ször. A bels® ciklusban az adott cx, cy értékhez tartozó konvergenciaértéket számoljuk ki és tesszük a img_array[] tömbbe. A végén újra lekérjük az aktuális eltelt id®t a mytime2 Miután az aktuális id®t megkaptuk a

változóba és ennek illetve az el®z® lekérésnek az eredményét, azaz a ciklusok alatt eltelt id®t kiírjuk a konzolra.

www.tankonyvtar.hu



197

--- mandelbrot_serial_hu.cpp --080 : // ujabb idoerteket lekerdezve ezen a ponton, kiszamolhatjuk az eltelt idot 081 : time(&mytime2); 082 : 083 :

<< endl;;

// fajl IO myle.open(leName1); myle << "P3\r\n" ; myle << imgX; myle << " " ; myle << imgY; myle << "\r\n" ; myle << "255\r\n" ;

DR AF T

084 : 085 : 086 : 087 : 088 : 089 : 090 : 091 : 092 : 093 : 094 :

cout << "Számítás alatt eltelt id® : " << mytime2-mytime1 << " másodperc."

// ki kell szineznunk az adathalmazunkat. A halmaz elemei mind feketek, igy a megjelenites szempontjabol nincs nagy jelentoseguk. 095 : // a kulso pontok iteracios lepes ertekehez szineket rendelve viszont erdekes es jellegzetes formakat es szineket kapunk 096 : for(int i=0;i
megyunk

if( (img_array[i][j] < 256) ) // ebben a tartomanyban feketebol vorosbe

{ myle << img_array[i][j] << " 0 0" ; // (int)(84*pow(img_array[i][j],0.2)) << " 0 0"; //myle << img_array[i][j] << " 0 0"; 104 : } 105 : else if( img_array[i][j] < 512) // ebben a tatomanyban vorosbol sargaba megyunk 106 : { 107 : myle << "255 " << img_array[i][j]-256 << " 0" ; 108 : } 109 : else if( img_array[i][j] < 768) // ebben a tartomanyban sargabol feherbe megyunk 110 : { 111 : myle << "255 255 " << img_array[i][j]-512; 112 : } 113 : /* // a szinplaettat tovabb allithatjuk, ha nagyobb felbontasra, nagyobb iteracios-lepesmennyisegre terunk at 114 : else if( img_array[i][j] < 1024) 115 : { 116 : myle << 1024-img_array[i][j] << " 255 255"; 117 : } 118 : else if( img_array[i][j] < 1280) 119 : { 120 : myle << "0 " << 1280-img_array[i][j] << " 255"; 102 : 103 :


www.tankonyvtar.hu

198


DR AF T

121 : } 122 : else if( img_array[i][j] < 1536) 123 : { 124 : myle << "0 0 " << 1536-img_array[i][j]; 125 : } 126 : */ 127 : else // minden mas fekete 128 : { 129 : myle << "0 0 0 " ; 130 : } 131 : 132 : myle << " " ; 133 : 134 : } 135 : myle << "\r\n" ; 136 : } 137 : 138 : myle.close(); // bezarjuk a fajlunkat 139 : 140 : time(&mytime2); // es tovabbi eltelt ido informaciot irunk ki (IO-val egyutt) 141 : 142 : cout << "Összes eltelt id® : " << mytime2-mytime1 << " másodperc. \r\n" ; 143 : return 0; 144 : } 145 : A kimenetünk ismét egy

.PPM

fájl. Miután beállítottuk a fájlnevet és a kimeneti pa-

ramétereket, ki kell írnunk az értékeinket a fájlba. Mivel a kép

R,G,B

hármasokból áll,

a Mandelbrot halmazunk adatait erre át kell alakítanunk. Egész pontosan, a Mandelbrot halmaz pontjai és minden más pont is a

img_array[]

tömbben van. Ha a konvergencia-

érték (iterációk száma) nem éri el a maximumot, akkor a pont nem része a halmaznak.

256 nulla G

A konvergenciaérték szerint valamilyen színt fogunk ezekhez a pontokhoz rendelni. A alatti értékek a

(zöld) és

R (vörös) csatorna értékeit fogják jelenteni, nullától a maximumig,

B (kék) értékekkel. Ez egy színátmenetet jelent a feketéb®l a vörösig. Hasonlóan, 256 érték (255 < n < 512) vörös és sárga között fut, és a következ® 256 ér-

a következ®

ték pedig sárgából fehérbe megy. Ha növeljük a felbontást és további színeket deniálunk (kikommentálva) további színátmeneteket adhatunk hozzá a meglév®khöz.

.PPM fájlt és kiírjuk ennek a futási idejét. yMin, yMax, xMin és xMax értékek állításával belenagyíthatunk

A végén lezárjuk a A

(zoom in) az áb-

ránkba.

11.2. Mandelbrot halmaz, párhuzamos példa

Mivel a Mandelbrot halmaz egyik látványos tulajdonsága, hogy a halmaz határvonalát végtelen bonyolultsággal lehet deniálni, tetsz®legesen belenagyíthatunk ebbe a területbe. Ehhez azonban az kell, hogy valós id®ben tudjuk a képeket generálni, vagy nagyon-nagy

www.tankonyvtar.hu



199

felbontású képet generáljunk, vagy mindkett®. Mivel minden képpont számítása egy közelít®függvény számítása, ez az eljárás nagyon számításigényes. Ez újra a párhuzamosítással oldható meg. A következ® pár példában bemutatunk pár munkaelosztási stratégiát, el®nyeiket és hátrányaikat összevetve.

11.2.1. Mester-szolga, egy els® megközelítés Els® példánkban a munkások egy mester-szolga kommunikációs modelljét mutatjuk be. Az alap koncepció az, hogy van egy mester, praktikusan a nullás azonosítójú, illetve szolgák.

DR AF T

A szolgák a mestert®l munkát kérnek, aki erre válaszként egy soron következ® pontot ad

ki a komplex síkról, hogy a szolga végezze el rajta a közelítéses számítást, majd a mester

begy¶jti az eredményt. Az ötlet egyszer¶. Minden processzus a saját sebességén dolgozik,

az aktuális feladat bonyolultságától függ®en. Ha kész a feladat, az eredményt visszaküldjük a mesternek és újat kérünk. A mester csak a feladatkiosztást és begy¶jtést végzi, illetve a

végén lelövi a szolgákat. A szolgák egy végtelen ciklusban dolgoznak, és csak akkor állnak le, ha a mester lelövi ®ket.

A kód els® sorai hasonlóak a szekvenciális verzióéhoz.

001 : 002 : 003 : 004 : 005 : 006 : 007 : 008 : 009 : 010 : 011 : 012 : 013 : 014 : 015 : 016 : 017 : 018 : 019 : 020 : 021 : 022 : 023 : 024 : 025 : 026 : 027 : 028 :

#include #include #include #include <sstream> #include <math.h> #include #include #include <mpi.h>

using namespace std; const int imgX=3000; // vizszintes kepi felbontas const int imgY=3000; // fuggoleges kepi felbontas const int iter_n=3000; // maximalis iteracios szam const double yMin= -0.135; // Mandelbrot jelenet y tartomany const double yMax= -0.115; const double xMin= -0.79; // Mandelbrot jelenet x tartomany const double xMax= -0.77;


// konvergacio-fuggveny , a Mandelbrot halmaz eloallitasanak a lelke // ket parametert var (x es y koordinatak) es egy iteracios szammal ter vissza int converges(double cx,double cy) { int n=0; double zx=0; double new_zx=0; double zy=0; // az iteracio a maximalis iteracios ertekig (iter_n) vagy addig fut, amig z^2 (komplex!) eleri a 4-et (azaz a sor vegtelenbe tart, igy nem lesz eleme a halmaznak a bemeno ertek)


www.tankonyvtar.hu

200


while( (n
029 : 030 : 031 :

{

// komplex

DR AF T

// z * z => new_zx = (zx*zx - zy*zy) new_zy = (zx*zy + zx*zy) szamokkal dolgozunk 032 : // z*z + c = zx^2 - zy^2 +cx + i(zx*zy*2 + cy) 033 : new_zx = zx*zx - zy*zy + cx; 034 : zy = 2*zx*zy + cy; 035 : zx = new_zx; 036 : n++; 037 : } 038 : return n; 039 : } 040 : 041 : 042 : int main(int argc, char **argv) 043 : { 044 : //az MPI kommunikacio valtozoi:

--- mandel-par1_hu.cpp ---

Az egyetlen új sor a

mpi.h

main() függvény pár, már ismer®s változó MPI_Status típusú változót status néven,

header fájl. A

deklarálásával kezd®dik. Itt deniálunk egy

hogy kés®bb lekérdezhessük egy MPI üzenet státuszát (küld®, üzenet jelöl® (tag), hiba

státusz ). Az

answer[4]

tömb tartalmazza majd az üzenet eredmény struktúráját (kül-

d® azonosítója, iterációs szám vagy

−1

az els® alkalommal, X koordináta, Y koordiná-

coordinates[2] struktúra tárolja majd a feldolgozott képünk question[2] struktúra pedig a feldolgozott pont komplex síkon vett a ta). A

koordinátáit és a

valós és imaginá-

rius részét.

--- mandel-par1_hu.cpp --040 : 041 : 042 : 043 : 044 : 045 : 046 : 047 : 048 : 049 : 050 : 051 : 052 : 053 : 054 : 055 : 056 :

int main(int argc, char **argv) { //az MPI kommunikacio valtozoi: int id, nproc; MPI_Status status; int answer[4]; int coordinates[2]; double question[2];

double resX=0; // Az iteracios lepeseink felbontasa double resY=0; // ezt az (yMax-yMin) / imgY ertekbol szamoljuk majd ki .. double cx=xMin; // innen indul a szamitas es ezt valtoztatjuk menet kozben double cy=yMin; double s_time, e_time;

www.tankonyvtar.hu



201

DR AF T

057 : // MPI inicializalasa: 058 : MPI_Init(&argc, &argv); 059 : // Rangunk lekerdezese: 060 : MPI_Comm_rank(MPI_COMM_WORLD, &id); 061 : // Az osszes processzus szamanak lekerdezese: 062 : MPI_Comm_size(MPI_COMM_WORLD, &nproc); 063 : 064 : MPI_Barrier(MPI_COMM_WORLD) ;// pontos idozites miatt 065 : 066 : if(id == 0){ //Mester 067 : 068 : if(argc<2)


A változók deniálása után elindítjuk az MPI környezetet. Az aktuális sorszámunkat

(rank) az

id

, az MPI viéág nagyságát (munkások számát) pedig az

kapjuk meg. Az

MPI_Barrier()

nproc

változókba

függvénnyel az összes munkást ebben a pontban szinkro-

nizáljuk, azaz mindenkinek el kell érkeznie ehhez a ponthoz a végrehajtásban, hogy tovább

lépjünk bármely processzusban. Erre itt azért van szükség, hogy a szétosztott munkában töltött eltelt id®t pontosan tudjuk kimérni.

A mester-szolga módszer ennél a pontnál kezd®dik.

--- mandel-par1_hu.cpp --064 : MPI_Barrier(MPI_COMM_WORLD);// pontos idozites miatt

065 : 066 : 067 : 068 : 069 : 070 : 071 : 072 : 073 : 074 : 075 : 076 : 077 : 078 : 079 : 080 : 081 : 082 : 083 : 084 : 085 : 086 :

if(id == 0){ //Mester if(argc<2) {

}

cout << "Használat :" <<endl; cout<<argv[0]<<" out_file.ppm"<<endl; MPI_Abort(MPI_COMM_WORLD, 1); exit(1);

ofstream myle; // fajlba irashoz string lename1(argv[1]); // lename1 = "mandel.ppm"; char *leName1 = (char*)lename1.c_str();

//lepeskoz beallitasa resX = (xMax-xMin) / imgX; resY = (yMax-yMin) / imgY;

s_time=MPI_Wtime(); // idozites kezdete - ido lekerese


www.tankonyvtar.hu

202


// elvegezzuk a szamitast a komplex sik minden pontjara, //azaz a 2D-s kepunk pontjaira, a megfelelo lepeskozzel

for(int i=0;i
cy=yMin; // minden uj X iranyu lepesnel az Y iranyt 0-rol kezdjuk for(int j=0;j
DR AF T

087 : 088 : 089 : 090 : 091 : 092 : 093 : 094 : 095 : 096 : 097 : 098 : 099 : 100 : 101 : 102 : 103 : 104 : 105 : 106 : 107 : 108 : 109 : 110 : 111 : 112 : 113 : 114 : 115 : 116 : 117 : 118 :

if(answer[1]>=0){ // nem az elso valasz

img_array[answer[2]][answer[3]]=answer[1]; // a konvergacios lepesszamot //vagy a maximum (iter_n) erteket kapjuk

} coordinates[0]=i; // uj koordinatak amiket ki kell szamolni coordinates[1]=j; MPI_Send(coordinates, 2, MPI_INT, answer[0], 2, MPI_COMM_WORLD); question[0]=cx; question[1]=cy; MPI_Send(question, 2, MPI_DOUBLE, answer[0], 3, MPI_COMM_WORLD); cy=cy+resY;

} cx=cx+resX;

} //maradek valaszok: for(int i=1;i
Ha a processzusunk rangja (azonosítója,

id) 0,

akkor mi vagyunk a mesterek. Ha az

argumentumszámunk rendben, akkor megnyitunk egy fájlt írásra és beállítjuk a lépés felbontást, valamint lekérjük az eltelt id®t

s_time-ba. Ezen a ponton kezdjük el a beágyazott

ciklust, ahol végigmegyünk a képpontokon. Minden képpontra, valamely szolga válaszá-

ra várakozunk. Ez el®ször csak munka lekérés lesz, de kés®bb a kérés mellett az el®z®

eredmény is megérkezik. Ha válasz is érkezik, akkor a fogadott adatot a megfelel® koordinátába helyezzük. A válasz részei az id (answer(1)), az iterációs szám (answer[1])

és a számított pont koordinátái (answer[2],

answer[3]). Az els® kérést, azaz azt, hogy most csak munkát kér, a szolga az iterációs szám -1-re állításával jelzi. A válasz követése után a mester egy újabb pontot küld ki feldolgozásra. Ezt egy MPI_Send()-el teszi meg, amiben az új kép koordinátái (coordinates) (where ?) és a kérdéses (question) cx, cy értékek vannak. Addig adjuk ki a pontokat, amíg el nem fogynak a koordináták. Az utolsó

www.tankonyvtar.hu



203

kiküldések után még begy¶jtjük ezen adatokat is, majd kiküldjük a leállási parancsot a szolgáknak. Ezt a koordináták

−1

értékre való beállításával tehetjük meg.

DR AF T

--- mandel-par1_hu.cpp --114 : cx=cx+resX; 115 : } 116 : //maradek valaszok: 117 : for(int i=1;i
endl;

131 : 132 : 133 : 134 : 135 : 136 : 137 : 138 : 139 : 140 : 141 :

}

//a terminalo jel kuldese coordinates[0]=-1; MPI_Send(coordinates, 2, MPI_INT, answer[0], 2, MPI_COMM_WORLD);

// ujabb idoerteket lekerdezve ezen a ponton, kiszamolhatjuk az eltelt idot e_time=MPI_Wtime();

cout << "Számítás alatt eltelt id® : " << e_time-s_time << " másodperc." <<


147 : 148 : 149 : 150 :

if( (img_array[i][j] < 256) ) // ebben a tartomanyban feketebol vorosbe megyunk

{ myle << img_array[i][j] << " 0 0" ; // (int)(84*pow(img_array[i][j],0.2)) << " 0 0"; //myle << img_array[i][j] << " 0 0"; 151 : } 152 : else if( img_array[i][j] < 512) // ebben a tatomanyban vorosbol sargaba megyunk 153 : {


www.tankonyvtar.hu

204


154 : 155 : 156 :

}

megyunk

{

157 : 158 : 159 : 160 :

}

myle << "255 " << img_array[i][j]-256 << " 0" ;

else if( img_array[i][j] < 768) // ebben a tartomanyban sargabol feherbe myle << "255 255 " << img_array[i][j]-512;

DR AF T

/* // a szinplaettat tovabb allithatjuk, ha nagyobb felbontasra, nagyobb iteracios-lepesmennyisegre terunk at 161 : else if( img_array[i][j] < 1024) 162 : { 163 : myle << 1024-img_array[i][j] << " 255 255"; 164 : } 165 : else if( img_array[i][j] < 1280) 166 : { 167 : myle << "0 " << 1280-img_array[i][j] << " 255"; 168 : } 169 : else if( img_array[i][j] < 1536) 170 : { 171 : myle << "0 0 " << 1536-img_array[i][j]; 172 : } 173 : */ 174 : else // minden mas fekete 175 : { 176 : myle << "0 0 0 " ; 177 : }

178 : 179 : 180 : 181 : 182 : 183 : 184 : 185 : 186 : 187 : 188 : 189 : 190 : 191 : 192 : 193 : 194 : 195 : 196 : 197 : 198 : 199 : 200 : 201 :

myle << " " ;

}

} myle << "\r\n" ;

myle.close(); // bezarjuk a fajlunkat

e_time=MPI_Wtime(); // es tovabbi eltelt ido informaciot irunk ki (IO-val egyutt) cout << "Összes eltelt id® : " << e_time-s_time << " másodperc \r\n" ; } else{ //Slave //int NN=0; answer[0]=id; answer[1]=-1; MPI_Send(answer, 4, MPI_INT, 0, 1, MPI_COMM_WORLD);

while(1){ MPI_Recv(coordinates, 2, MPI_INT, 0, 2, MPI_COMM_WORLD, &status); if(coordinates[0]<0) break ; // terminalo parancsot kaptunk! //++NN;

www.tankonyvtar.hu



205

DR AF T

202 : answer[2]=coordinates[0]; 203 : answer[3]=coordinates[1]; 204 : 205 : MPI_Recv(question, 2, MPI_DOUBLE, 0, 3, MPI_COMM_WORLD, &status); 206 : answer[1]=converges(question[0],question[1]); 207 : 208 : MPI_Send(answer, 4, MPI_INT, 0, 1, MPI_COMM_WORLD); 209 : } 210 : //cout<<"id: "<
A következ® pár sor a szekvenciális verzióhoz hasonló tevékenységeket végez. Kiírjuk

az eltelt id®t, valamint kiírjuk az begy¶jtött adatokat egy kép fájlba. Külön megmutatjuk az I/O m¶velethez szükséges id®t is.

Ha a processzusunk rangja (azonosítója) nagyobb mint nulla, akkor

szolgák vagyunk.

A szolgák feladatot kérnek, elvégzik és visszaküldik az eredményeket. Minden szolga egy speciális üzenettel kezd, amellyel csak munkát kér (answer[0] a rang (id),

answer[1] −1),

aztán egy végtelen munkaciklusba kezd. Ebben a ciklusban megkapjuk az új koordinátákat amit fel kell dolgozni. Ha leállási utasítás jön, azaz a

coordinates[0]

<

0,

a végtelen

ciklus leállításra kerül (break), majd az MPI környezet leállítása után a program leáll. A leállásig a szolgák megkapják a kép koordinátákat (coordinates), a halmaz koordinátákat

(question) és ezek alapján a

converges()

függvénnyel kiszámolják az iterációs számot.

A négyelem¶ válasz felépítése után visszaküldik az eredményt a mesternek.

A fenti példát els® megközelítésnek hívjuk. Bár az ötlet, hogy a feladatot adagokban

adjuk ki a szolgáknak akkor, amikor jelentkeznek munkára, jó, de egyetlen pont kiszámításának a számítási igénye túl kicsi a kommunikációs felárhoz viszonyítva.

A programot két különböz® architektúrán teszteltük. Ahogy a második rész bevezetésében említettük, az

A egy SMP gép és B egy fürtözött (cluster) gép. A táblázat a futási

id®ket mutatja két gépen, különböz® magszámok mellett.


www.tankonyvtar.hu

206


11.2. táblázat. Mester-szolga kommunikáció, ahol a mester mindig egy pontot oszt ki

nproc

A-v1

B-v1

56.0s 9.9s

5.7x

89s 24s

3.7x

24

16.6s

3.4x

25s

3.6x

48

22.6s

2.5x

31s

2.9x

96

25.2s

2.2x

51s

1.7x

DR AF T

1 12

192

29.4s

1.9x

38s

2.3x

11.3. ábra. Futási id®k és gyorsulás (speedup

Ahogy láthatjuk a táblázatban, a gyorsulás trendje a növeked® processzorszámmal inkább egy lassulás mindkét architektúrán. A kommunikációs többletmunka ellenére az

www.tankonyvtar.hu



207

egyprocesszoros m¶ködéshez képest azért van gyorsulás. Jobb ötlet lenne, ha nagyobb feladatokat osztanánk ki az egyes munkásoknak, mint ahogy a következ® példában bemutatjuk.

11.2.2. Mester-szolga, egy jobb megoldás A második példa nagyon hasonlít az els®re, kivéve, hogy nagyobb feladatokat osztunk ki, egész vonalakon kell a szolgáknak dolgozniuk. A program els® sorai nagyon hasonlítanak az els® verzióra. Bevezetünk egy új tömböt, az

img_line[imgY]-t amivel a mester és szolgák

DR AF T

közt kommunikáljuk az adatsorokat.

001 : 002 : 003 : 004 : 005 : 006 : 007 : 008 : 009 : 010 : 011 : 012 : 013 : 014 : 015 : 016 : 017 : 018 : 019 : 020 : 021 : 022 : 023 : 024 : 025 : 026 : 027 : 028 : 029 :



int img_array[imgX][imgY] = {0}; // Mandelbrot halmaz ertekek tombje int img_line[imgY] = {0};

// konvergacio-fuggveny , a Mandelbrot halmaz eloallitasanak a lelke // ket parametert var (x es y koordinatak) es egy iteracios szammal ter vissza int converges(double cx,double cy) { int n=0; double zx=0; double new_zx=0; double zy=0; // az iteracio a maximalis iteracios ertekig (iter_n) vagy addig fut, amig z^2 (komplex!) eleri a 4-et (azaz a sor vegtelenbe tart, igy nem lesz eleme a halmaznak a bemeno ertek) 030 : while( (n new_zx = (zx*zx - zy*zy) new_zy = (zx*zy + zx*zy) // komplex szamokkal dolgozunk 033 : // z*z + c = zx^2 - zy^2 +cx + i(zx*zy*2 + cy) 034 : new_zx = zx*zx - zy*zy + cx; 035 : zy = 2*zx*zy + cy;


www.tankonyvtar.hu

208


036 : 037 : 038 : 039 : 040 : 041 : 042 : 043 : 044 : 045 :

}

zx = new_zx; n++;

return n;

}

DR AF T

int main(int argc, char **argv) { //az MPI kommunikacio valtozoi: --- mandel-par2_hu.cpp ---

main() függvény szintén nagyon hasonlóan kezd®dik mint az els® példában, coordinates[] változót hagyjuk el, mivel most egész sorokkal dolgozunk. A

csak a

--- mandel-par2_hu.cpp --041 : 042 : 043 : 044 : 045 : 046 : 047 : 048 : 049 : 050 : 051 : 052 : 053 : 054 : 055 : 056 : 057 : 058 : 059 : 060 : 061 : 062 : 063 : 064 : 065 : 066 : 067 : 068 : 069 : 070 : 071 : 072 :

int main(int argc, char **argv) { //az MPI kommunikacio valtozoi: int id, nproc; MPI_Status status; int answer[2]; double question;

double resX=0; // Az iteracios lepeseink felbontasa double resY=0; // ezt az (yMax-yMin) / imgY ertekbol szamoljuk majd ki .. double cx=xMin; // innen indul a szamitas es ezt valtoztatjuk menet kozben double cy=yMin; double s_time, e_time;

// MPI inicializalasa: MPI_Init(&argc, &argv); // Rangunk lekerdezese: MPI_Comm_rank(MPI_COMM_WORLD, &id); // Az osszes processzus szamanak lekerdezese: MPI_Comm_size(MPI_COMM_WORLD, &nproc);

MPI_Barrier(MPI_COMM_WORLD) ;// pontos idozites miatt


cout << "Usage :" <<endl; cout<<argv[0]<<" out_file.ppm"<<endl;

www.tankonyvtar.hu



}

MPI_Abort(MPI_COMM_WORLD, 1); exit(1);



DR AF T

073 : 074 : 075 : 076 : 077 : 078 : 079 : 080 : 081 : 082 : 083 : 084 : 085 : 086 : 087 : 088 :

209


// elvegezzuk a szamitast a komplex sik minden pontjara, azaz a 2D-s kepunk pontjaira, a megfelelo lepeskozzel 089 : for(int i=0;i
if(answer[1]>=0){ //nem az elso valasz MPI_Recv(&img_array[answer[1]][0], imgY, MPI_INT, answer[0], }

2, MPI_COMM_WORLD, &status);

MPI_Send(&i, 1, MPI_INT, answer[0], 3, MPI_COMM_WORLD); MPI_Send(&cx, 1, MPI_DOUBLE, answer[0], 4, MPI_COMM_WORLD);

}

cx=cx+resX;

//maradek valaszok int term=-1; --- mandel-par2_hu.cpp ---

Mesterként egész sorokat fogunk megkapni az img_array[answer[1]][0]-ba, answer[1] az X koordináta, a feldolgozni kívánt sor száma.

ahol

--- mandel-par2_hu.cpp --103 : cx=cx+resX; 104 : } 105 : 106 : 107 :

//maradek valaszok int term=-1;


www.tankonyvtar.hu

210

108 : 109 :


for(int i=1;i
&status);

MPI_Recv(&img_array[answer[1]][0], imgY, MPI_INT, answer[0], 2, MPI_COMM_WORLD, &status);

}

//a terminalo jel kuldese MPI_Send(&term, 1, MPI_INT, answer[0], 3, MPI_COMM_WORLD);


DR AF T

110 : 111 : 112 : 113 : 114 : 115 : 116 : 117 : 118 : 119 : 120 :

endl;;

121 : 122 : 123 : 124 : 125 : 126 : 127 : 128 : 129 : 130 : 131 :

cout << "Time elapsed during calculation : " << e_time-s_time << " secs." <<



{ myle << img_array[i][j] << " 0 0" ; // (int)(84*pow(img_array[i][j],0.2)) << " 0 0"; //myle << img_array[i][j] << " 0 0"; 141 : } 142 : else if( img_array[i][j] < 512) // ebben a tatomanyban vorosbol sargaba megyunk 143 : { 144 : myle << "255 " << img_array[i][j]-256 << " 0" ; 145 : } 146 : else if( img_array[i][j] < 768) // ebben a tartomanyban sargabol feherbe megyunk 147 : { 148 : myle << "255 255 " << img_array[i][j]-512; 149 : } 150 : /* // a szinplaettat tovabb allithatjuk, ha nagyobb felbontasra, nagyobb

www.tankonyvtar.hu



211

DR AF T

iteracios-lepesmennyisegre terunk at 151 : else if( img_array[i][j] < 1024) 152 : { 153 : myle << 1024-img_array[i][j] << " 255 255"; 154 : } 155 : else if( img_array[i][j] < 1280) 156 : { 157 : myle << "0 " << 1280-img_array[i][j] << " 255"; 158 : } 159 : else if( img_array[i][j] < 1536) 160 : { 161 : myle << "0 0 " << 1536-img_array[i][j]; 162 : } 163 : */ 164 : else // minden mas fekete 165 : { 166 : myle << "0 0 0 " ; 167 : }

168 : 169 : 170 : 171 : 172 : 173 : 174 : 175 : 176 : 177 : 178 : 179 : 180 : 181 : 182 :

myle << " " ;

}

} myle << "\r\n" ;


e_time=MPI_Wtime(); // es tovabbi eltelt ido informaciot irunk ki (IO-val egyutt)

cout << "Time elapsed total : " << e_time-s_time << " secs \r\n" ; } else{ //Slave //lepeskoz beallitas --- mandel-par2_hu.cpp ---

Az iteráció után be kell gy¶jtenünk a megmaradt sorokat, és az egész adatot újra egy

.PPM

fájlba kell írnunk.

Ha szolgák vagyunk, el®ször ki kell küldenünk egy üzenetet, amelyben jelezzük, hogy

készen állunk a munkára. Az els® üzenet után egy ciklusba kerülünk, ahol egy sor számot kapunk és az egész sort visszaküldjük.


178 : 179 : cout << "Time elapsed total: " << e_time-s_time << " secs \r\n"; 180 : } 181 : else{ //Slave 182 : //lepeskoz beallitas


www.tankonyvtar.hu

212


DR AF T

183 : resX = (xMax-xMin) / imgX; 184 : resY = (yMax-yMin) / imgY; 185 : 186 : int i; 187 : answer[0]=id; 188 : answer[1]=-1; 189 : MPI_Send(answer, 2, MPI_INT, 0, 1, MPI_COMM_WORLD); 190 : 191 : while(1){ 192 : MPI_Recv(&i, 1, MPI_INT, 0, 3, MPI_COMM_WORLD, &status); 193 : if(i<0) break ; // terminalo parancsot kaptunk! 194 : answer[1]=i; 195 : 196 : MPI_Recv(&question, 1, MPI_DOUBLE, 0, 4, MPI_COMM_WORLD, &status); 197 : 198 : cy=yMin; // minden X iranyu uj lepesben az Y elso ertekevel kezdunk 199 : 200 : for(int j=0;j
A

question-ben

cx jelöli a sort amivel dolgoznunk kell, és ezen a vonalon cx, cy pozícióra az iterációs számot. Ezen iterációs számok img_line[] tömbbe.

érkezett

haladva számoljuk ki minden

halmaza kerül vissza a

Ez a méret¶ feladat úgy látszik elég nagy, a kommunikációs többletmunka pedig már nem olyan nagy gond, ahogy azt a 11.3 táblázat mutatja is. A gyorsulás sokkal jobb mindkét architektúra esetében. Ez a módszer szinte lineáris gyorsulást mutat 192 processzorig.

www.tankonyvtar.hu



213

11.3. táblázat. Mester-szolga kommunikáció, a mester egy egész sort oszt ki

nproc

A-v2

B-v2

56.0s 5.3s

10.6x

7.4s

89s 12.0x

24

2.5s

22.4x

3.7s

26.8x

48

1.3s

43.1x

2.2s

40.5x

96

0.7s

80.0x

2.0s

44.5x

DR AF T

1 12

192

0.4s

140.0x

2.1s

42.4x

384

0.3s

186.7x

2.1s

42.4x

512

0.2s

280.0x

11.4. ábra. Futási id®k és gyorsulás


www.tankonyvtar.hu

214


11.2.3. Loop splitting ciklusbontás A harmadik példában megváltoztatjuk a munkaleosztási stratégiánkat. Az un. loop splitt-

ing , azaz ciklusbontás technika az iterációs lépéseket váltott soronként osztja szét az egyes munkások között. Mivel nem blokkokat osztunk ki, hanem különböz® sorokban lév® adatrészeket, bizonyos teherelosztás valósul meg. Ebben a példában a mester csak kiosztja a feladatot és begy¶jti az eredményeket. A kód hasonló mint eddig, kivéve az adatok elosztásának menetét.


DR AF T

001 : 002 : 003 : 004 : 005 : 006 : 007 : 008 : 009 : 010 : 011 : 012 : 013 : 014 : 015 : 016 : 017 : 018 : 019 : 020 : 021 : 022 : 023 : 024 : 025 : 026 : 027 : 028 :




www.tankonyvtar.hu



} int main(int argc, char **argv) { //az MPI kommunikacio valtozoi: int id, nproc; MPI_Status status; int id_from; double resX=0; // Az iteracios lepeseink felbontasa double resY=0; // ezt az (yMax-yMin) / imgY ertekbol szamoljuk majd ki .. double cx=xMin; // innen indul a szamitas es ezt valtoztatjuk menet kozben double cy=yMin; double s_time, e_time; // idozitesi adatokhoz

DR AF T

039 : 040 : 041 : 042 : 043 : 044 : 045 : 046 : 047 : 048 : 049 : 050 : 051 : 052 : 053 : 054 : 055 : 056 : 057 : 058 : 059 : 060 : 061 : 062 : 063 : 064 : 065 : 066 : 067 : 068 : 069 : 070 : 071 : 072 : 073 : 074 : 075 : 076 : 077 : 078 : 079 : 080 : 081 : 082 : 083 : 084 : 085 : 086 : 087 : 088 :

215


MPI_Barrier(MPI_COMM_WORLD); // pontos idozites miatt if(id == 0){ //Mester if(argc<2) {

}

cout << "Usage :" <<endl; cout<<argv[0]<<" out_file.ppm"<<endl; MPI_Abort(MPI_COMM_WORLD, 1); exit(1);



//fogadas for(int j=1;j

www.tankonyvtar.hu

216


089 : 090 : 091 : 092 : 093 : 094 : 095 : 096 :

for(int i=id_from-1;i


DR AF T

--- mandel-par3a_hu.cpp ---

Ha mesterek vagyunk, a válaszokat egy ciklusban kapjuk. Az els® választ adó szolga

id_from-ban. Ezzel az értékkel dolgozva, minden nproc−1-edik értéket id_f rom − 1-t®l indulva. Ezt minden munkással elvégezve (a id-k sorrendje

megadja a rangját olvassuk be,

véletlenszer¶) megkapjuk a végeredmény összes adatdarabkáját. A kimenet hasonlóan megy mint az el®z®ekben.

--- mandel-par3a_hu.cpp --092 : } 093 : 094 : 095 : 096 : 097 :

endl;;

098 : 099 : 100 : 101 : 102 : 103 : 104 : 105 : 106 : 107 : 108 :





{ myle << img_array[i][j] << " 0 0" ; // (int)(84*pow(img_array[i][j],0.2)) << " 0 0"; //myle << img_array[i][j] << " 0 0"; www.tankonyvtar.hu



217

118 : 119 :

}

120 : 121 : 122 : 123 :

{

megyunk

}

megyunk

{

124 : 125 : 126 : 127 :

myle << "255 " << img_array[i][j]-256 << " 0" ;

else if( img_array[i][j] < 768) // ebben a tartomanyban sargabol feherbe myle << "255 255 " << img_array[i][j]-512;

DR AF T

}

else if( img_array[i][j] < 512) // ebben a tatomanyban vorosbol sargaba


145 : 146 : 147 : 148 : 149 : 150 : 151 : 152 : 153 : 154 : 155 : 156 : 157 : 158 : 159 :

myle << " " ;

}

} myle << "\r\n" ;


e_time=MPI_Wtime(); // es tovabbi eltelt ido informaciot irunk ki (IO-val egyutt)

cout << "Time elapsed total : " << e_time-s_time << " secs \r\n" ; } else{ //Slave //mivel a szolgak 1..nproc: --- mandel-par3a_hu.cpp ---

Ha szolgák vagyunk, a fenti adatokat olyan rendszerben kell küldenünk mint ahogy azt fogadtuk.


www.tankonyvtar.hu

218


--- mandel-par3a_hu.cpp --cout << "Time elapsed total: " << e_time-s_time << " secs \r\n"; } else{ //Slave //mivel a szolgak 1..nproc: //id -> id-1 //nproc -> nproc-1


DR AF T

155 : 156 : 157 : 158 : 159 : 160 : 161 : 162 : 163 : 164 : 165 : 166 : 167 : 168 : 169 : 170 : 171 : 172 : 173 : 174 : 175 : 176 : 177 : 178 : 179 : 180 : 181 : 182 : 183 : 184 : 185 : 186 : 187 : 188 : 189 : 190 : 191 : 192 : 193 : 194 : 195 : 196 : 197 : 198 : 199 : 200 : 201 : 202 : 203 :

//mivel a Mester-Szolga futtatasban a 0-as nem dolgozik cx=cx+resX*(id-1); //ugras a megfelel cx ertekre //gyelem, kerekitesi hiba! //ez az ertek kicsit kulonbozik attol, mint //resX-et hozzaadni startval-szor cx-hez. //ez nem eszreveheto kis valtozast okoz a kepen

for(int i=id-1;i
cy=yMin; // Minden uj X iranyu lepesnel //az elso Y ertekkel kezdunk for(int j=0;j
cx=cx+resX*(nproc-1); //nproc-onkenti lepesek //gyelem, kerekitesi hiba!

}

MPI_Send(&id, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); for(int i=id-1;i
}

MPI_Send(&img_array[i][0], imgY, MPI_INT, 0, 2, MPI_COMM_WORLD);

}

// MPI leallitasa MPI_Finalize();

}

return 0;

www.tankonyvtar.hu



219

Szolgaként ki kell számolnunk a kezd® sort (cx) ahol megkezdjük a számítást. Ez a

cx=cx+resX*(id-1) érték lesz. Ez az érték kicsit eltér az eddigi módszereinkben használt cx értékt®l. Ez egy kerekítésb®l származó eltérés, mivel id-1-szer resX -et adni cx-hez id-1 kerekítést jelent az összeadásban, míg resX*(id-1)-el csak egy összeadás és egy szorzás. Ez egy icipicit módosítja a képünket. Ennek az elkerülése végett a szorzást leválthatnánk összeadások sorozatára, így teljesen ugyan azt az értéket kapnánk.

cx-et és kiszámítottuk a megfelel® vonalakat, vissza

DR AF T

Miután kiválasztottuk a megfelel®

kell küldenünk az

id-nket

és az adatokat a mesternek.

Ahogy a következ® táblázatban láthatjuk, a gyorsulás itt is elég jó, a futási id®k alapján

ez a módzser is használhatónak t¶nik a probléma megoldására. Ugyanakkor a gyorsulás nem olyan mérték¶ mint az el®z® módszerben.

11.4. táblázat. Loop splitting, a mester nem végez számítást

nproc

A-v3a

B-v3a

1

56.0s

89s

12

5.8s

9.7x

7.7s

11.6x

24

2.8s

20.0x

4.4s

20.2x

48

1.5s

37.3x

2.3s

38.7x

96

1.7s

32.9x

1.7s

52.3x

192

1.1s

50.9x

2.1s

42.4x

384

1.3s

43.1x

3.4s

26.2x

512

1.4s

40.0x


www.tankonyvtar.hu


DR AF T

220


11.2.4. Loop splitting variáció

A negyedik példa a loop splitting technika egy variánsa. Az el®z®höz képest az a változás,

hogy itt most a mester is beszáll a számítási feladatok elvégzésébe. Els®re ez jól hangzik,

mivel több munkásnak gyorsabban kellene végeznie. A valóságban ez a processzusok egy

bizonyos számáig lesz csak igaz. Egy id® után a mester adminisztrációs többlettevékenysége ®t teszi a leglassabb munkássá és így a szolgáknak rá kell majd várniuk. Adatot pedig majd csak akkor küldhetnek, ha a mester is elkészül végre. A mester ekkor azonban az egyszerre várakozó szolgáktól csak sorban tudja az adatokat fogadni (torlódás !). Az el®z® példában

a mester processzus a fájlnév adminisztrációt elvégezte amíg a szolgák dolgoztak. Most még ezt az extrát is ki kell várniuk a szolgáknak. A kód hasonló az eddigiekhez, kivéve azt a részt ahol azt vizsgáljuk, hogy mesterek vagyunk-e, vagy szolgák.

www.tankonyvtar.hu



#include #include #include #include <sstream> #include <math.h> #include #include #include <mpi.h> using namespace std; const int imgX=3000; // vizszintes kepi felbontas const int imgY=3000; // fuggoleges kepi felbontas const int iter_n=3000; // maximalis iteracios szam const double yMin= -0.135; // Mandelbrot jelenet y tartomany const double yMax= -0.115; const double xMin= -0.79; // Mandelbrot jelenet x tartomany const double xMax= -0.77;

DR AF T

001 : 002 : 003 : 004 : 005 : 006 : 007 : 008 : 009 : 010 : 011 : 012 : 013 : 014 : 015 : 016 : 017 : 018 : 019 : 020 : 021 : 022 : 023 : 024 : 025 : 026 : 027 : 028 :

221


// konvergacio-fuggveny , a Mandelbrot halmaz eloallitasanak a lelke // ket parametert var (x es y koordinatak) es egy iteracios szammal ter vissza int converges(double cx,double cy) { int n=0; double zx=0; double new_zx=0; double zy=0; // az iteracio a maximalis iteracios ertekig (iter_n) vagy addig fut, amig z^2 (komplex!) eleri a 4-et (azaz a sor vegtelenbe tart, igy nem lesz eleme a halmaznak a bemeno ertek) 029 : while( (n new_zx = (zx*zx - zy*zy) new_zy = (zx*zy + zx*zy) // komplex szamokkal dolgozunk 032 : // z*z + c = zx^2 - zy^2 +cx + i(zx*zy*2 + cy) 033 : new_zx = zx*zx - zy*zy + cx; 034 : zy = 2*zx*zy + cy; 035 : zx = new_zx; 036 : n++; 037 : } 038 : return n; 039 : } 040 : 041 : 042 : 043 : 044 : 045 : 046 : 047 : 048 :

int main(int argc, char **argv) { //az MPI kommunikacio valtozoi: int id, nproc; MPI_Status status; int id_from;


www.tankonyvtar.hu

222


double resX=0; // Az iteracios lepeseink felbontasa double resY=0; // ezt az (yMax-yMin) / imgY ertekbol szamoljuk majd ki .. double cx=xMin; // innen indul a szamitas es ezt valtoztatjuk menet kozben double cy=yMin; double s_time, e_time; // idozitesi adatokhoz ofstream myle; // ebbe a fajlba irunk char *leName1;


DR AF T

049 : 050 : 051 : 052 : 053 : 054 : 055 : 056 : 057 : 058 : 059 : 060 : 061 : 062 : 063 : 064 : 065 : 066 : 067 : 068 : 069 : 070 : 071 : 072 : 073 : 074 : 075 : 076 : 077 : 078 : 079 : 080 : 081 : 082 : 083 : 084 : 085 : 086 :

MPI_Barrier(MPI_COMM_WORLD); // pontos idozites miatt


}


string lename1(argv[1]); // lename1 = "mandel.ppm"; leName1 = (char*)lename1.c_str();

}

//lepeskoz beallitasa s_time=MPI_Wtime(); // idozites kezdete - ido lekerdezese

//a lepeskoz beallitasa resX = (xMax-xMin) / imgX; --- mandel-par3b_hu.cpp ---

Ha mesterek vagyunk, meg kell vizsgálnunk az argumentumokat, el® kell készítenünk a

fájl írást, id®t kell lekérdeznünk. Ezek után minden processzus ugyan azt csinálja : kiszámolják a rájuk es® munkát amit a rangjukból (id) állapítanak meg és a Tudva a kezdeti

cx

cx sortól kezd®dik. cx+nproc*resX sorral dolgozik. img_array[i][j] eredményblokkokat felépítve el kell

értéket, minden porcesszus

A számítások végén az egyéni

küldenünk illetve fogadnunk kell ezeket.

www.tankonyvtar.hu



223

--- mandel-par3b_hu.cpp --082 : s_time=MPI_Wtime(); // idozites kezdete - ido lekerdezese 083 : }

//a lepeskoz beallitasa resX = (xMax-xMin) / imgX; resY = (yMax-yMin) / imgY; cx=cx+resX*id-; //ugras a megfelel cx ertekre //gyelem, kerekitesi hiba! //ez az ertek kicsit kulonbozik attol, mint //resX-et hozzaadni startval-szor cx-hez. //ez nem eszreveheto kis valtozast okoz a kepen

DR AF T

084 : 085 : 086 : 087 : 088 : 089 : 090 : 091 : 092 : 093 : 094 : 095 : 096 : 097 : 098 : 099 : 100 : 101 : 102 : 103 : 104 : 105 : 106 : 107 : 108 : 109 : 110 : 111 : 112 : 113 : 114 : 115 : 116 : 117 : 118 : 119 : 120 : 121 : 122 : 123 : 124 : 125 : 126 : 127 : 128 : 129 : 130 :

for(int i=id;i
}

cx=cx+resX*nproc; //nproc-onkenti lepesek //gyelem, kerekitesi hiba!

if(id != 0){ //Szolgak kuldenek MPI_Send(&id, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); for(int i=id;i
MPI_Send(&img_array[i][0], imgY, MPI_INT, 0, 2, MPI_COMM_WORLD);

}else{//Mester fogad for(int j=1;j
for(int i=id_from;i
}




www.tankonyvtar.hu

224


131 :


132 : 133 : 134 : 135 : 136 : 137 : 138 : 139 : 140 : 141 :

//fajl IO myle.open(leName1); myle << "P3\r\n" ; myle << imgX; myle << " " ; myle << imgY; myle << "\r\n" ; myle << "255\r\n" ;

DR AF T

endl;;


{ myle << img_array[i][j] << " 0 0" ; // (int)(84*pow(img_array[i][j],0.2)) << " 0 0"; //myle << img_array[i][j] << " 0 0"; 151 : } 152 : else if( img_array[i][j] < 512) // ebben a tatomanyban vorosbol sargaba megyunk 153 : { 154 : myle << "255 " << img_array[i][j]-256 << " 0" ; 155 : } 156 : else if( img_array[i][j] < 768) // ebben a tartomanyban sargabol feherbe megyunk 157 : { 158 : myle << "255 255 " << img_array[i][j]-512; 159 : } 160 : /* // a szinplaettat tovabb allithatjuk, ha nagyobb felbontasra, nagyobb iteracios-lepesmennyisegre terunk at 161 : else if( img_array[i][j] < 1024) 162 : { 163 : myle << 1024-img_array[i][j] << " 255 255"; 164 : } 165 : else if( img_array[i][j] < 1280) 166 : { 167 : myle << "0 " << 1280-img_array[i][j] << " 255"; 168 : } 169 : else if( img_array[i][j] < 1536) 170 : { 171 : myle << "0 0 " << 1536-img_array[i][j]; 172 : } 173 : */

www.tankonyvtar.hu



else // minden mas fekete {

}

myle << "0 0 0 " ;

myle << " " ;

}

} myle << "\r\n" ;

DR AF T

174 : 175 : 176 : 177 : 178 : 179 : 180 : 181 : 182 : 183 : 184 : 185 : 186 : 187 : 188 : 189 : 190 : 191 : 192 : 193 : 194 : 195 : 196 : 197 :

225


e_time=MPI_Wtime(); // es tovabbi eltelt ido informaciot irunk ki (IO-val egyutt) cout << "Time elapsed total : " << e_time-s_time << " secs \r\n" ; }


}

return 0;

Ha szolgák vagyunk (a rangunk nem nulla), akkor több

Az

els®

az

id-nket,

a

továbbiak

pedig

az

MPI_Send()-et kell futtatnunk.

eredménysorainkat

küldik

el.

Ha mesterek vagyunk, fogadnunk kell ezeket a sorokat, az els® üzenetben érkez® rang

szerint értelmezve. Mesterként a fájlkimenetet is intéznünk kell. A 11.5 táblázatban tekinthetjük meg mindkét gépen a gyorsulást.

11.5. táblázat. Loop splitting, mester is végez számítást

nproc

A-v3b

B-v3b

1

56.0s

89s

12

5.8s

9.7x

7.0s

12.7x

24

2.9s

19.3x

4.1s

21.7x

48

1.5s

37.3x

2.3s

38.7x

96

1.8s

31.1x

1.7s

52.3x

192

1.2s

46.7x

1.8s

49.4x

384

0.7s

80.0x

3.4s

26.2x

512

1.5s

37.3x


www.tankonyvtar.hu


DR AF T

226


11.2.5. Block scheduling tömbös ütemezés

A tömbös ütemezés a következ®, ismert stratégiánk. Ebben a módszerben az adatainkat

egymást követ® egybefügg® darabokra osztjuk és ezeket adjuk oda feldolgozásra az egyes

munkásainknak. Az els® tömbös ütemezési példánkban a mester ismét csak adatot gy¶jt a többiekt®l, nem végez számítási feladatot. A kód így változatlan, a kiosztásig.

001 : 002 : 003 : 004 : 005 : 006 : 007 : 008 : 009 :


www.tankonyvtar.hu



010 : 011 : 012 : 013 : 014 : 015 : 016 : 017 : 018 : 019 : 020 : 021 : 022 : 023 : 024 : 025 : 026 : 027 : 028 :

227



DR AF T

// konvergacio-fuggveny , a Mandelbrot halmaz eloallitasanak a lelke // ket parametert var (x es y koordinatak) es egy iteracios szammal ter vissza int converges(double cx,double cy) { int n=0; double zx=0; double new_zx=0; double zy=0; // az iteracio a maximalis iteracios ertekig (iter_n) vagy addig fut, amig z^2 (komplex!) eleri a 4-et (azaz a sor vegtelenbe tart, igy nem lesz eleme a halmaznak a bemeno ertek) 029 : while( (n new_zx = (zx*zx - zy*zy) new_zy = (zx*zy + zx*zy) // komplex szamokkal dolgozunk 032 : // z*z + c = zx^2 - zy^2 +cx + i(zx*zy*2 + cy) 033 : new_zx = zx*zx - zy*zy + cx; 034 : zy = 2*zx*zy + cy; 035 : zx = new_zx; 036 : n++; 037 : } 038 : return n; 039 : } 040 : 041 : 042 : 043 : 044 : 045 : 046 : 047 : 048 : 049 : 050 : 051 : 052 : 053 : 054 : 055 : 056 : 057 :

int main(int argc, char **argv) { //az MPI kommunikacio valtozoi: int id, nproc; MPI_Status status; int id_from; int startval; int endval;



www.tankonyvtar.hu

228


DR AF T

058 : 059 : // MPI inicializalasa: 060 : MPI_Init(&argc, &argv); 061 : // Rangunk lekerdezese: 062 : MPI_Comm_rank(MPI_COMM_WORLD, &id); 063 : // Az osszes processzus szamanak lekerdezese: 064 : MPI_Comm_size(MPI_COMM_WORLD, &nproc); 065 : 066 : MPI_Barrier(MPI_COMM_WORLD); // pontos idozites miatt 067 : 068 : 069 : if(id == 0){ //Mester 070 : 071 : if(argc<2) 072 : { 073 : cout << "Usage :" <<endl; 074 : cout<<argv[0]<<" out_file.ppm"<<endl; 075 : MPI_Abort(MPI_COMM_WORLD, 1); 076 : exit(1); 077 : } 078 : 079 : string lename1(argv[1]); 080 : // lename1 = "mandel.ppm"; 081 : leName1 = (char*)lename1.c_str(); 082 : 083 : s_time=MPI_Wtime(); // idozites kezdete - ido lekerdezese 084 : 085 : //fogadas 086 : for(int j=1;j

Ha

mesterek

vagyunk, a szokásos módon adatbegy¶jtéssel kezdünk. A különbség itt

a begy¶jtend® adatblokk meghatározásában van. Az els® üzenetben megkapjuk a

id_from - startval).

rangot. Ezt felhasználva kiszámolhatjuk az adatblokkunk helyét és nagyságát (endval Ezek alapján

(endval − startval)

lines

× imgY

méret¶ adatblokkot fogunk fogadni.


084 : 085 : 086 : 087 : 088 : 089 : 090 : 091 :

//fogadas for(int j=1;j
www.tankonyvtar.hu



startval = imgX*(id_from-1)/(nproc-1); endval = imgX*id_from/(nproc-1);

}

//for(int i=startval;i<endval; ++i) MPI_Recv(&img_array[startval][0], (endval-startval)*imgY, MPI_INT, id_from, 2, MPI_COMM_WORLD, &status);


DR AF T

092 : 093 : 094 : 095 : 096 : 097 : 098 : 099 : 100 : 101 : 102 : 103 :

229

endl;;

104 : 105 : 106 : 107 : 108 : 109 : 110 : 111 : 112 : 113 : 114 :



120 : 121 : 122 : 123 :


{ myle << img_array[i][j] << " 0 0" ; // (int)(84*pow(img_array[i][j],0.2)) << " 0 0"; //myle << img_array[i][j] << " 0 0"; 124 : } 125 : else if( img_array[i][j] < 512) // ebben a tatomanyban vorosbol sargaba megyunk 126 : { 127 : myle << "255 " << img_array[i][j]-256 << " 0" ; 128 : } 129 : else if( img_array[i][j] < 768) // ebben a tartomanyban sargabol feherbe megyunk 130 : { 131 : myle << "255 255 " << img_array[i][j]-512; 132 : } 133 : /* // a szinplaettat tovabb allithatjuk, ha nagyobb felbontasra, nagyobb iteracios-lepesmennyisegre terunk at 134 : else if( img_array[i][j] < 1024)


www.tankonyvtar.hu

230


{ myle << 1024-img_array[i][j] << " 255 255"; } else if( img_array[i][j] < 1280) { myle << "0 " << 1280-img_array[i][j] << " 255"; } else if( img_array[i][j] < 1536) { myle << "0 0 " << 1536-img_array[i][j]; }

DR AF T

135 : 136 : 137 : 138 : 139 : 140 : 141 : 142 : 143 : 144 : 145 : 146 : 147 : 148 : 149 : 150 : 151 : 152 : 153 : 154 : 155 : 156 : 157 : 158 : 159 : 160 : 161 : 162 : 163 : 164 : 165 : 166 : 167 : 168 : 169 : 170 : 171 : 172 : 173 : 174 : 175 : 176 :

*/

else // minden mas fekete {

}

myle << "0 0 0 " ;

myle << " " ;

}

} myle << "\r\n" ;


e_time=MPI_Wtime(); // es tovabbi eltelt ido informaciot irunk ki (IO-val egyutt) cout << "Time elapsed total : " << e_time-s_time << " secs \r\n" ;

}else{//Szolga

//mivel a szolgak 1..nproc kozottiek: //id -> id-1 //nproc -> nproc-1 //a lepeskoz beallitasa resX = (xMax-xMin) / imgX; resY = (yMax-yMin) / imgY;

startval = imgX*(id-1)/(nproc-1); endval = imgX*id/(nproc-1);


A kód továbbra is hasonló mint az el®z®ekben, kivéve a szolgák adatblokk számítását. Ez ugyan úgy megy mint ahogy azt a mesternél láttuk. Ki kell számolnunk a

endval

startval és

értékeket, és ezeknek megfelel®en kell küldenünk az adatblokkunkat.

www.tankonyvtar.hu



231

--- mandel-par4a_hu.cpp --172 : resY = (yMax-yMin) / imgY; startval = imgX*(id-1)/(nproc-1); endval = imgX*id/(nproc-1); cx=cx+resX*startval; //ugras a megfelel cx ertekre //gyelem, kerekitesi hiba! //ez az ertek kicsit kulonbozik attol, mint //resX-et hozzaadni startval-szor cx-hez. //ez nem eszreveheto kis valtozast okoz a kepen

DR AF T

173 : 174 : 175 : 176 : 177 : 178 : 179 : 180 : 181 : 182 : 183 : 184 : 185 : 186 : 187 : 188 : 189 : 190 : 191 : 192 : 193 : 194 : 195 : 196 : 197 : 198 :

for(int i=startval;i<endval;++i) {

}

cx=cx+resX;

//kuldes

MPI_Send(&id, 1, MPI_INT, 0, 1, MPI_COMM_WORLD); MPI_Send(&img_array[startval][0], (endval-startval)*imgY, MPI_INT, 0, 2,

MPI_COMM_WORLD); 199 : } 200 : 201 : // MPI leallitasa 202 : MPI_Finalize(); 203 : 204 : return 0; 205 : } 206 :

Ez a fajta adatfelosztás egyszer¶. Az egymás utáni adatblokkokat egyszerre el lehet

küldeni. A munka eloszlása ugyanakkor kiegyenlítetlen is lehet, mivel egymás utáni adatrészeken dolgoznak az egyes munkások. A Mandelbrot halmazt számítva egyes blokkok teljesen a halmaz részei lehetnek, azaz az iterációk a maximális értékig futhatnak, míg mások kívül eshetnek a halmazon. Ennek ellenére a futási id®k elég jól skálázódnak mindkét gép esetében (11.6).


www.tankonyvtar.hu

232

Bevezetés az MPI programozásba példákon keresztül 11.6. táblázat. Block scheduling, a mester nem végez számítást

nproc

A-v4a

B-v4a

56.0s 13.2s

4.2x

17.3s

89s 5.1x

24

6.7s

8.4x

8.3s

10.7x

48

3.3s

17.0x

4.1s

21.7x

96

1.7s

32.9x

2.2s

40.5x

DR AF T

1 12

192

1.1s

50.9x

5.2s

17.1x

384

1.2s

46.7x

12.1s

7.4x

512

0.9s

62.2x


www.tankonyvtar.hu



233

11.2.6. Block scheduling variáció Az utolsó párhuzamos Mandelbrot halmaz generátor példánk a tömbös ütemezés egy variánsa. Ebben a változatban a mester is dolgozik. Ez az eset hasonlít a loop splitting

variáns -ra (11.2.4, 220. oldal). A folytonos adatblokkokat kiosztjuk és a mesternek is jut egy. Ez egy oldalról jó, többen dolgoznak. Másfel®l ha a mester lassabb mint egyes szolgák, ezeknek mind várniuk kell a mesterre, és amikor elkezdhetnek adni, akkor egymásra kell sorban várniuk, torlódást okozva ezzel. Ez a hatás a teszteredményeken is látszódik.


DR AF T

001 : 002 : 003 : 004 : 005 : 006 : 007 : 008 : 009 : 010 : 011 : 012 : 013 : 014 : 015 : 016 : 017 : 018 : 019 : 020 : 021 : 022 : 023 : 024 : 025 : 026 : 027 : 028 :





www.tankonyvtar.hu

234

} int main(int argc, char **argv) { //az MPI kommunikacio valtozoi: int id, nproc; MPI_Status status; int id_from; int startval; int endval;

DR AF T

039 : 040 : 041 : 042 : 043 : 044 : 045 : 046 : 047 : 048 : 049 : 050 : 051 : 052 : 053 : 054 : 055 : 056 : 057 : 058 : 059 : 060 : 061 : 062 : 063 : 064 : 065 : 066 : 067 : 068 : 069 : 070 : 071 : 072 : 073 : 074 : 075 : 076 : 077 : 078 : 079 : 080 : 081 : 082 : 083 : 084 : 085 : 086 : 087 : 088 :




MPI_Barrier(MPI_COMM_WORLD); // pontos idozites miatt


}


string lename1(argv[1]); // lename1 = "mandel.ppm"; leName1 = (char*)lename1.c_str();

//lepeskoz beallitasa s_time=MPI_Wtime(); // idozites kezdete - ido lekerdezese } //a lepeskoz beallitasa resX = (xMax-xMin) / imgX;

www.tankonyvtar.hu



089 : 090 : 091 : 092 : 093 : 094 : 095 : 096 : 097 :

235

resY = (yMax-yMin) / imgY;

//Mivel a Mester-Szolga futtatasban a 0-as processz nem dolgozik startval = imgX*id/nproc; endval = imgX*(id+1)/nproc;

DR AF T

cx=cx+resX*startval; //ugras a megfelel cx ertekre //gyelem, kerekitesi hiba! --- mandel-par4b_hu.cpp ---

startval és végs® endval nproc végezzük el.

A kód a kezd®

így a felosztást

számításban tér el. A mesternek is jut rész,

--- mandel-par4b_hu.cpp --093 : startval = imgX*id/nproc; 094 : endval = imgX*(id+1)/nproc;

095 : 096 : cx=cx+resX*startval; //ugras a megfelel cx ertekre 097 : //gyelem, kerekitesi hiba! 098 : //ez az ertek kicsit kulonbozik attol, mint 099 : //resX-et hozzaadni startval-szor cx-hez. 100 : //ez nem eszreveheto kis valtozast okoz a kepen 101 : 102 : for(int i=startval;i<endval;++i) 103 : { 104 : cy=yMin; // Minden uj X iranyu lepesnel 105 : //az elso Y ertekkel kezdunk 106 : for(int j=0;j
MPI_COMM_WORLD); 120 : //}

121 : 122 : }else{///Mester fogad 123 : for(int j=1;j

www.tankonyvtar.hu

236

MPI_Recv(&id_from, 1, MPI_INT, MPI_ANY_SOURCE, 1, MPI_COMM_WORLD, &status); //fontos, hogy BARMELYIK forrasbol fogadhatunk //mivel a processzek inditasa nagyban elterhet startval = imgX*id_from/nproc; endval = imgX*(id_from+1)/nproc;

//for(int i=startval;i<endval; ++i) MPI_Recv(&img_array[startval][0], (endval-startval)*imgY, MPI_INT, id_from, 2, MPI_COMM_WORLD, &status);

DR AF T

124 : 125 : 126 : 127 : 128 : 129 : 130 : 131 : 132 : 133 : 134 : 135 : 136 : 137 : 138 : 139 : 140 :


endl;;

141 : 142 : 143 : 144 : 145 : 146 : 147 : 148 : 149 : 150 : 151 :

}





{ myle << img_array[i][j] << " 0 0" ; // (int)(84*pow(img_array[i][j],0.2)) << " 0 0"; //myle << img_array[i][j] << " 0 0"; 161 : } 162 : else if( img_array[i][j] < 512) // ebben a tatomanyban vorosbol sargaba megyunk 163 : { 164 : myle << "255 " << img_array[i][j]-256 << " 0" ; 165 : } 166 : else if( img_array[i][j] < 768) // ebben a tartomanyban sargabol feherbe megyunk 167 : {

www.tankonyvtar.hu



168 : 169 : 170 :

237

}

myle << "255 255 " << img_array[i][j]-512;

DR AF T


188 : 189 : 190 : 191 : 192 : 193 : 194 : 195 : 196 : 197 : 198 : 199 : 200 : 201 : 202 : 203 : 204 : 205 : 206 : 207 :

myle << " " ;

}

} myle << "\r\n" ;


e_time=MPI_Wtime(); // es tovabbi eltelt ido informaciot irunk ki (IO-val egyutt) cout << "Time elapsed total : " << e_time-s_time << " secs \r\n" ; }


}

return 0;

A kód további része hasonló mint eddig, mindenki számol, aztán a

mester begy¶jti az

adatokat. A szolgáknak erre lehet, hogy várniuk kell, és ez növekv® munkás számmal egy egyre nagyobb probléma. A futási id®k az

A (SMP ccNUMA) és B

(Fat-node tree cluster)

gépeken a 11.7 táblázatban láthatóak. A gyorsulás nagyobb létszám esetén letörni látszik, ez valószín¶leg az elfoglalt mester miatti torlódásnak (jam) köszönhet®. Ezt a hatást a

B

architektúrán el®bb tapasztalhatjuk a kommunikációs késleltetés miatt.


www.tankonyvtar.hu

238

Bevezetés az MPI programozásba példákon keresztül 11.7. táblázat. Block scheduling, a mester is dolgozik

nproc

A-v4b

B-v4b

56.0s 12.7s

4.4x

15.8s

89s 5.6x

24

6.4s

8.8x

8.3s

10.7x

48

3.5s

16.0x

5.1s

17.5x

96

1.9s

29.5x

3.8s

23.4x

DR AF T

1 12

192

1.2s

46.7x

6.0s

14.8x

384

1.4s

40.0x

12.5s

7.1x

512

1.2s

46.7x

11.8. ábra. Running times and speedup

www.tankonyvtar.hu



239

11.2.7. Gondolatok a munkamegosztásról Az els® dolog amit át kell gondolni a párhuzamosításnál, a munka leosztásának a logikája. Ezt nagyon körültekint®en kell el®készíteni, mert rejtett késleltetések, nem jól szinkronizált tevékenységek er®sen ronthatják a több processzusból származó el®nyöket. A használni kívánt algoritmusunkat elemeznünk kell a kommunikációban részt vev® adatok nagysága és struktúrája szempontjából. A végs® beállításnak gyelembe kell vennie a használt architektúrát (SMB, cluster) és a hálózati tulajdonságokat (átereszt® képesség, késleltetés) hogy a legjobb eredményt érjük el. A kommunikációnak mindig volt felára. A túl kis ada-

DR AF T

tok küldése és fogadása nem túl jó ötlet. Ha viszont túl nagy adatokkal dolgozunk, azt kockáztatjuk, hogy az egyes processzusok nem kiegyensúlyozottan dolgoznak majd. Az

algoritmustól és az architektúrától függ® optimális beállításokat kell találnunk, hogy a

legjobb eredményt érjük el. Jó ötlet a beállítások teszteléséhez kisebb adatokkal méréseket elvégezni, így hamarabb juthatunk eredményre.

A Mandelbrot halmaz generáló példánkban a halmaz egy olyan részét vizsgáltuk, ami

a bonyolultság szempontjából inhomogén volt. Ahogy azt a 11.2 ábrán is láthatjuk, egyes

sorokban majdhogynem nincs is halmazbeli adat. Ez azt jelenti, hogy a különböz® sorok

különböz® számítási id®vel kerülnek feldolgozásra, azaz a munkásaink más és más sebességgel dolgoznak. A legjobbnak itt egy mester-szolga variáns bizonyult, ahol egész sorokat osztunk ki a szolgák között. A hat különböz® kiosztási stratégia teljesítményének az össze-

hasonlítását az SMP (A) és a Fat Node Cluster (B) gépeken futtatott eredményekkel a 11.9 és 11.10 táblázatokban láthatjuk.


www.tankonyvtar.hu


DR AF T

240

11.9. ábra. Gyorsulások a hat különböz® stratégiával, SMP gépen

www.tankonyvtar.hu


241

DR AF T


11.10. ábra. Gyorsulások a hat különböz® stratégiával, Fat Node Cluster gépen (48magos csomópontokkal)


www.tankonyvtar.hu


DR AF T

242

www.tankonyvtar.hu


12. fejezet

DR AF T

Sugárkövetés Raytracing 12.1. Képi megjelenítés

Az egyik legszámításigényesebb feladat a képi megjelenítés. Mindenki látott már modern

számítógépes játékokat és mozi eekteket. Az ilyen típusú feladatok célja a 3D tér 2D-

s kijelz®re való leképezése úgy, hogy a lehet® legéleth¶bb képet kapjuk. A számítógépes grakának nagy és kiterjedt történelme van. A 3D-s képalkotásnak is számos, a célnak legjobban megfelel® változata van. Az interaktív játékokban a sebesség egy f® szempont, így az objektumok többnyire egyszer¶sítettek, síkokból, textúrákból és grakai trükkökb®l

épülnek fel, melyek valódihoz hasonlóvá teszik a megjelenést. Ahol a való idej¶ megjelenés nem annyira fontos, ott komplexebb ábrázolási módszereket használhatunk.

A leglátványosabb, de leger®forrásigényesebb képi megjelenítési módszer a sugárköve-

tés (raytracing). Ez a módszer nem használ trükköket, hanem a fényterjedés valós zikai jelenséget modellezi. A sugárkövetés azt jelenti, hogy legkövetjük a szemünkbe jutó összes

fénysugár útját a forrásáig. A szemünk az optikai sugárzás intervallumában kb. 380nm és 780nm közötti hullámhossztartományban érzékeny. Ebben a tartományban az elektromág-

neses sugárzás egyens vonalon halad és a felületekr®l visszaver®dik. Az egyes hullámhosszak

más és más módon ver®dnek vissza, így a fény, ami különböz® hullámhosszúságú komponensekb®l áll, változik a visszaver®dések folyamán attól függ®en, hogy milyen felületeken ver®dött vissza. Ez a hatás befolyásolja az érzékletet, amit a bees® fény kelt bennünk. Egyes anyagok elnyelik a fényt, egyes anyagok vezetik a fényt és a geometriai struktúra

miatt a fény más-más irányokba ver®dik vissza. Ezeket és egyéb jelenségeket matematika-

ilag le lehet írni, modellezni lehet és így nagyon életh¶ 2d-s képeket lehet készíteni a 3D-s elrendezésekr®l.

Az alapötlet az, hogy kövessük a különböz® fotonok útját a térben minden irányba,

minden fényforrásból és számoljuk ki a visszaver®déseiket, szóródásukat és esetleges vesz-

teségeiket. Ez a módszer azonban nagyon nagy számítási igény¶ és a számítások java része felesleges is lenne. Hogy elkerüljük az ilyesfajta alacsony hatékonyságot, a sugárkövetés technikája megfordítja a sugarak útkövetési irányát, így csak azokat a sugarakat követjük le, amik valóban be is érkeztek a szemünkbe. Innen visszafele minden visszaver®désen és jelenségen keresztül a fényforrásig jutunk. Ezzel a módszerrel a felesleges számításokat


www.tankonyvtar.hu

244


kizárjuk ugyan, de még így is hatamas nagy munka a sugarankénti visszakövetés.

12.2. Sugárkövetéses példa A példánkban a párhuzamosítás erejét a sugárkövetéses módszer több processzoron való futtatásával mutatjuk be. Mivel a tér és objektumok elrendezése kiinduláskor minden munkás rendelkezésére áll, valamint az egyes sugarak követése nem függ a többit®l, a párhuzamos munka elég hatékonynak ígérkezik. Egy sugár lekövetése viszont még mindig

DR AF T

elég munkaigényes, hiszen több visszaver®dést is ki kell számolni, valamint egy pixelhez

annyi sugár tartozik, ahány fényforrás található az elrendezésben. Két sugárkövetéssel ké-

szült kép látható a 12.1 ábrán. Az egyiken 5 gömb látható, szépen nyomon-követhet®en a reexiókkal. A másikon egy 512 gömbb®l álló tömb látható, amin a sokszoros reexió számítását szemléltettük. Ez utóbbi persze már nem olyan látványos, mivel a bels® gömbökön a sokszoros visszaver®dések miatt zavaró hatás jelenik meg.

12.1. ábra. Példaprogramunk által számított, sugárkövetéses kép 5 és 512 gömbbel.

El®ször tekintsük át a sugárkövetés módszerét, majd ezek után a párhuzamosítás le-

het®ségeit.

12.2.1. Soros sugárkövetés

A sugárkövetés programkódja a POV-Ray (Persistence of Vision Ray-Tracer [PovRay]) oldal dokumentációján és Darren Abbey PHP kódján alapul. A példaprogramunk egy raytracer pár elemi funkcionalitását implementálja. A példaprogram öt színes gömböt fog megjeleníteni fekete háttér el®tt, három fényforrással.

www.tankonyvtar.hu


12. fejezet. Sugárkövetés Raytracing

245

A megjelenítést ambiens (környez®) fény, diúz (szórt) fény és tükrözött (specular/mirrored) fény fogja befolyásolni. Ezek együtt adják a Phong-reexiós modellt. A felületek tükröz®d®ek lesznek. A 2D-s képet pixelenként fogjuk számolni. A kiszámolni kívánt 2D-s képet úgy is tekinthetjük, mint egy balakot a 3D-s világunkra, amit a saját néz®pontunkból nézünk. A megjelenítés folyamata pont ezt az absztrakciót fogja használni. A saját néz®pontunk (camera) egy speciális pont, ahonnan a 2D-s ablakunk minden képpontjába indítunk sugarakat. Ezek a vonalak aztán a 3D-s világban különböz® objektumoknak fognak ütközni, vagy a végtelenbe tartva semmivel sem találkoznak. Ha az utóbbi történik, akkor a képünkön

DR AF T

a háttérszín fog megjelenni (alapból fekete). Ha egy gömbnek ütközünk, a metszési pont színét ki kell számolnunk és ezt megjelenítenünk. A számítás a következ®ket tartalmazza

the shadow test

, ahol teszteljük, hogy egy fényforrás megvilágítja-e az adott pontot

vagy sem,

the normal vector

, ami mer®leges a felszínre és a diúz világításhoz valamint a tükrö-

z®déshez is kelleni fog,

the reected ray

, ami a tükröz®dési komponenst és színét adja meg.

A példában a számításhoz pár értéket el®re meg kell adnunk. Deniálunk egy Point

osztályt, ami a 3D-s világunkban egy vektort reprezentál. Mivel ezekkel a vektorokkal fogunk dolgozni, jól jön, ha deniálunk pár gyakran használt vektorm¶veletet is az osztályhoz. Az osztály alapja egy double értékeket tartalmazó háromelem¶ tömb (p[3]). A

get() metódussal olvashatjuk ki. length() metódussal kapjuk meg. Az osztálynak van metódusa a normálvektor számítására (norm()), illetve a vektorokon értelmezett operátorok is léteznek benne : +, -, *, skalár *, / és egy barát funkció : point_dot(), amivel két Point vektor objektum skaláris szorzatát kapjuk meg. tömb értékeit a

set()

metódussal állíthatjuk be és a

Ezen három értékkel reprezentált vektor hosszát a

A deniciók a

ray6v7.h include

fájlban vannak.

001 : // Parhuzamos Raytracer header 002 : #include 003 : #include <math.h> 004 : 005 : class Point{ // Point

osztaly denicio - haromdimenzios vektorok

osztalya

006 : private : 007 : double p[3] ; 008 : 009 : public : 010 : Point(){ 011 : p[0]=0 ;


www.tankonyvtar.hu

246


DR AF T

012 : p[1]=0 ; 013 : p[2]=0 ; 014 : } 015 : Point(double x, double y, double z){ 016 : p[0]=x ; 017 : p[1]=y ; 018 : p[2]=z ; 019 : } 020 : void set(double x, double y, double z){ 021 : p[0]=x ; 022 : p[1]=y ; 023 : p[2]=z ; 024 : } 025 : double get(int i){ 026 : return p[i] ; 027 : } 028 : double length() const { 029 : return( sqrt( p[0]*p[0] + p[1]*p[1] + p[2]*p[2] ) ) ; 030 : } 031 : Point norm() const { // normalas 032 : double l=length() ; // tudjuk a vektor hosszat 033 : Point normalized ; 034 : normalized.p[0] = p[0] / l ; 035 : normalized.p[1] = p[1] / l ; 036 : normalized.p[2] = p[2] / l ; 037 : return normalized ; 038 : } 039 : Point operator+(const Point& a) const{ // kimenet : vektor 040 : Point output ; 041 : output.p[0]=a.p[0]+p[0] ; 042 : output.p[1]=a.p[1]+p[1] ; 043 : output.p[2]=a.p[2]+p[2] ; 044 : return output ; 045 : } 046 : Point operator-(const Point& a) const{ // kimenet : vektor 047 : Point output ; 048 : output.p[0]=p[0]-a.p[0] ; 049 : output.p[1]=p[1]-a.p[1] ; 050 : output.p[2]=p[2]-a.p[2] ; 051 : return output ; 052 : }

www.tankonyvtar.hu



247

DR AF T

053 : Point operator*(double scal) const { 054 : Point output ; 055 : output.p[0]=p[0]*scal ; 056 : output.p[1]=p[1]*scal ; 057 : output.p[2]=p[2]*scal ; 058 : return output ; 059 : } 060 : Point operator/(double scal) const { 061 : Point output ; 062 : output.p[0]=p[0]/scal ; 063 : output.p[1]=p[1]/scal ; 064 : output.p[2]=p[2]/scal ; 065 : return output ; 066 : } 067 : Point operator*(const Point& a) const { 068 : Point output ; 069 : output.p[0]=a.p[0]*p[0] ; 070 : output.p[1]=a.p[1]*p[1] ; 071 : output.p[2]=a.p[2]*p[2] ; 072 : return output ; 073 : } 074 : friend double point_dot(const Point&, const Point&) ; 075 : } ; 076 : 077 : 078 : 079 : 080 : double point_dot(const Point& a, const Point& b) // ket

vektor szorzata

(dot-product)

081 : { 082 : return (a.p[0]*b.p[0]+b.p[1]*a.p[1]+a.p[2]*b.p[2]) ; 083 : } 084 : 085 : 086 : // diuz es tukrozodo (specular) vilagitas kapcsoloi 087 : const bool Diuse_test = true ; 088 : const bool Specular_test = true ; 089 : const bool Reection_test = true ; 090 : 091 : 092 : // a kovetkezo valtozokat globalidan kell denialni


www.tankonyvtar.hu

248


int max_Reclev=7 ;

// visszafverodes (reexion)

limit

double bg_Color[3] = {0,0,0} ; // hatterszin int max_Dist = 3000 ; // maximalis tavolsag (renderelt vilag nagysaga)

// jelenet denicio // fenyforrasok

(hely(x,y,z) ;irany(x,y,z))

// harom fenyforras double lights[3][6] =

DR AF T

093 : 094 : 095 : 096 : 097 : 098 : 099 : 100 : 101 : 102 : 103 : 104 : 105 : 106 : 107 : 108 : 109 :

{

{-1, 0,-0.5,0.8,0.4,0.1}, { 1,-1,-0.5,1, 1, { 0,-1,

1},

0,0.1,0.2,0.5}

};

// Gombok

// kozeppont 3, sugar 1, tukrozodes 1, szin(rgb) 3, phong meret 1, phong mennyi-

seg 1

110 : double spheres[5][10] = 111 : { 112 : {-1.05, 0 ,4,1 ,0.5,1 , 0.5,0.25, 40,0.8}, 113 : { 1.05, 0 ,4,1 ,0.5,0.5 , 1 ,0.5 , 40,0.8}, 114 : {0 , 3 ,5,2 ,0.5,0.25, 0.5,1 ,30,0.4}, 115 : {-1 ,-2.3,9,2 ,0.5 ,0.5 , 0.3,0.1 ,30,0.4}, 116 : { 1.3 ,-2.6,9, 1.8,0.5,0.1 , 0.3,0.5,30,0.4} 117 : } ; 118 : 119 : const int X=4800 ; 120 : const int Y=4800 ; 121 : 122 : // MPI 123 : // egy atmeneti tarat denialunk 124 : double t_frame[X][Y][3] = {0} ; 125 : 126 :

Az els® sorokban pár további átmeneti és globális változó deniálunk. A

T

változó tá-

rolja majd a távolság értéket. A sugár-gömb metszésnél lesz jelent®sége és ott részletesen

obj_Amnt és light_Amnt változók fogják tárolni az objektumok (gömambient(r,g,b) változóban saját (camera) pozíciónkat a camera(x,y,z) változó fogja tárolni.

tárgyaljuk majd. Az

bök) és fényforrások számát. Az ambiens sugárzás értékét a tároljuk, míg a

www.tankonyvtar.hu



#include #include #include <math.h> #include #include "ray6v7.h" using namespace std ;

DR AF T

001 : 002 : 003 : 004 : 005 : 006 : 007 : 008 : 009 : 010 : 011 : 012 :

249

Point

Trace(Point &P_vv, Point &D_vv, int recLev) ;

double T = -1 ; //

sugar - gomb metszés eredmenye - ez egy tavolsag lesz, ha

-1, akkor nincs metszet

013 : 014 : 015 : 016 : 017 : 018 :

int obj_Amnt ;

int light_Amnt ;

// kornyezeti feny es kamera ertekek double ddd = 0.2 ; Point

ambient(ddd,0.2,0.2) ;

// diuz vilagitas RGB ertekei - meg nem 8biten

(szurke - 0,2 ; 0,2 ; 0,2)

019 : 020 : 021 : 022 :

Point

camera(-4,0,-16) ;

// kamera pozicio

- 0,0,-3

int main() {

--- raytrace_serial_hu.cpp ---

main() a szabvány f®funkció ami a program calcRaySphereIntersection() függvény az adott sugár és gömb adja vissza, míg a Trace() függvény az adott x,y pont színét adja meg

A példánkban három függvény van. A

futásakor elindul. A metszési pontját

a 2D-s felületen.

Pár globális és átmeneti változó deniálása után a

main()

függvényt az objektumok

(gömbök) és fényforrások leszámlálásával kezdjük. Mivel ezek tömbökben vannak, használhatjuk a

sizeof()

függvényt, ami a tömb méretét adja meg bájtokban. Ha az elemek

méretét is megtudjuk bájtokban, egyszer¶en kiszámolhatjuk, hány elem van a tömbben.


019 : 020 : 021 : 022 :

Point camera(-4,0,-16) ; int

// kamera pozicio

- 0,0,-3

main()

{


www.tankonyvtar.hu

250


Point Pixel ; ofstream myle ;

//

// ebbe a fajlba

fogunk irni

meg kell szamolnunk a jelent objektumait (gombok es fenyforrasok)

int array_size,element_size ;

sizeof(spheres) ; element_size = sizeof(spheres[0]) ; array_size =

obj_Amnt = array_size/element_size ; // a tombmerettel es elemmerettel

DR AF T

023 : 024 : 025 : 026 : 027 : 028 : 029 : 030 : 031 :

szamolunk (byteban)

032 : 033 : 034 : 035 : 036 : 037 : 038 :

// fenyforrasok szamolasa

sizeof(lights) ; element_size = sizeof(lights[0]) ; array_size =

light_Amnt = array_size/element_size ; // ugyan azt csinaljuk a gombokkel

// normalizalnunk kell a fenyvektorokat. Ez ahhoz kell, hogy az egysegvektort

felszorozva koordinatakba mutato vektorokat kapjunk - reszeltek a povray oldalon. --- raytrace_serial_hu.cpp ---

A továbbiakhoz szükség lesz a fényforrások irányvektorának normalizálására. A ké-

s®bbi megvilágítás számításokhoz egységvektorokat kell majd használnunk. Mivel itt az

irány fontos, nyugodtan normalizálhatjuk ezeket. A következ®kben a .PPM fájl el®készítését végezzük el, majd pár változót deklarálunk a következ® f®ciklushoz. A

coordY

coordX

és

változókban az aránykorrigált X,Y koordinátákat tesszük majd, amik felé a saját

pozíciónkból nézünk. Ezek az X,Y koordináták és egy Z konstans (3) kerül a

temp_coord

változónkba.


036 : 037 : 038 :



felszorozva koordinatakba mutato vektorokat kapjunk - reszeltek a povray oldalon.

039 : int i=0 ; 040 : 041 : Point normalized ; 042 : while(i
www.tankonyvtar.hu



normalized=normalized.

norm() ; //

A norm() metodussal normalizalhatunk

// A normalt "i" ertekeket visszatesszuk a lights[] tombbe

get(0) ; get(1) ; lights[i][2] = normalized.get(2) ; lights[i][0] = normalized. lights[i][1] = normalized.

i++ ; }

DR AF T

046 : 047 : 048 : 049 : 050 : 051 : 052 : 053 : 054 : 055 : 056 : 057 : 058 : 059 : 060 : 061 : 062 : 063 : 064 : 065 : 066 : 067 : 068 : 069 : 070 : 071 : 072 : 073 : 074 :

251

// Kep osszeallitasa int c,c2 ;

open("probakep.ppm") ;

myle.

myle <<

"P3\r\n" ;

myle << X ; myle <<

" ";

myle << Y ; myle <<

myle <<

"\r\n" ; "255\r\n" ;

double coordX,coordY ;

//double Pf ;

Point temp_coord ; c=0 ;

c2=0 ;

for(int i=0 ;i

main() f®ciklusa beágyazott ciklusokból áll, melyek i és j változókkal futnak. Ezek változók 0 és X valamint 0 és Y között kapnak értéket. X és Y az általunk látott kép A

a

felbontása, azaz a 3D-s elrendezés 2D-s kimeneti kép felbontása. A párhuzamos résznél látni fogjuk, hogy a bels® ciklus

FROM

TO értékek között megy majd. Miután végeztünk Trace() függvény bemeneteit. Szükségünk van a

és

egy képarány korrekciót, megkapjuk a

kamera koordinátákra (camera), az aktuális pontra amin keresztül nézzük az elrendezést

(temp_coord) és egy értékre, amely a sugárkövetés rekurziós mélységét mutatja. Ez utóbbi 1-r®l indulva

max_recLev értékig változhat. A sugárkövetés után az aktuális, vizsgált pixel

színét kapjuk visszatérésként. Az R,G,B (Red, Green, Blue) komponenseket a 0-255 tartományba méretezzük és kiírjuk a .PPM fájlba. Miután minden koordinátához elvégeztük


www.tankonyvtar.hu

252


a sugárkövetést, kész vagyunk, nincs más dolgunk, mint lezárni a fájlunkat és kilépni.


DR AF T

071 : c=0 ; 072 : c2=0 ; 073 : for(int i=0 ;i
//

kepernyo arany korrekcio

080 : 081 : 082 :

temp_coord. Pixel =

set(coordX,coordY,3) ;

Trace(

camera, temp_coord, 1) ;

// itt az aktualis koordinatan

levo pixel szinet kapjuk meg. Bemenetkent a kamera poziciot (camera), a pixel

koordinatat amin at nezzuk a jelenetet (temp_coord) es a rekurzio szintjet, amivel a reexiok szamat allithatjuk, kerjuk. A maximalis rekurziot a max_recLev -ben adjuk meg es a kezdeti erteket (most 1) minden rekurzios lepesben emeljuk egyel

083 : 084 :

myle <<

min(

round(Pixel.get(0)*255),

(int)

255) ;

// Az analog

szinertekunket (ami nem 0-255 kozott fut) atkonvertaljuk 0-255 kozottire

085 : myle << " " ; 086 : myle << min( (int)round(Pixel.get(1)*255), 255) ; 087 : myle << " " ; 088 : myle << min( (int)round(Pixel.get(2)*255), 255) ; 089 : myle << " " ; 090 : c2=c2+1 ; 091 : } 092 : c2=0 ; 093 : myle << "\r\n" ; 094 : c=c+1 ; 095 : } 096 : 097 : myle.close() ; 098 : 099 : return 0 ; 100 : } 101 : 102 : // ez a funkcio vizsgalja, hogy egy sugar metsz-e gombot.

Ha igen, egy "T"

tavolsagot kapunk, ami megadja a kiinduloponttol valo tavolsagat a metszesi pontnak.

www.tankonyvtar.hu



103 :

double

253

calcRaySphereIntersection(Point&

P_ray,

Point&

D_ray,

int

sp_index) // A kiindulasi pont es a sugar iranya referencia szerint megadva, az index

dinamikusan valtozik es a gombot jeloli ki

104 : 105 :

{ Point C_sp (spheres[sp_index][0],

// A gomb kozeppontjat kapjuk -

spheres[sp_index][0,1,2]

DR AF T


Látható, hogy a feladat bonyolult része a

Trace()

-függvényben zajlik. Nézzük meg

részletesen, mi az. A

Trace()

függvény a vizsgált felület egy koordinátájára megadja a színt. A vizsgált

felület az ablak, amin keresztül a 3D-s elrendezést nézzük. Amit látunk az az egyes koordinátákban megjelen® színek. A sugárkövetéses módszernek megfelel®en, a saját szem-

szögünkb®l (camera) minden koordinátába indítunk egy sugarat. Ha ez a sugár eltalál valamit, akkor ezen a koordinátán valamilyen színt fogunk látni. Ha nem, akkor a háttérszínt fogjuk látni ezen a pixelen. A függvény bemenetei a

D_vv,

és a végtelen rekurziót szabályozó változó :

recLev.

P_vv

kamera pozíció, az irány

A while vezérlési struktúrában

minden gömbön átfutunk és a legközelebbi metszési pontot keressük. Minden iterációban a

closest

index tartalmazza az aktuálisan legközelebb lév® gömb indexét. A metszési

calcRaySphereIntersection() függvényt használjuk, melyet kés®bb részletezünk. Ha az aktuális T kevesebb mint a minT, azaz találtunk egy közelebbi metszési pontot, akkor ezt (T) betesszük minT-be. pont kiszámításához a


140 :

// Trace fuggveny, egy indulo pont, irany es rekurzios szint bemenete van.

Keppont szint ad vissza

141 :

Point Trace(Point &P_vv, Point &D_vv, int recLev)

// we need a local

recLev, since we call it recursively

142 : 143 : 144 : 145 :

{

Point Pixel ;

// bemenet P, D, reclev - P kezdeti pont , D sugar irany , reclev - rekurzios

szint

146 : 147 :

double minT = max_Dist ; // maximalis tavolsag (vilagunk merete)

int closest = obj_Amnt ; // a legkozelebbi objektum (gomb) tavolsaga. Az

objektumszam ervenytelen index, errol indulunk

148 : 149 : // a legkozelebbi metszesi 150 : int ind = 0 ; 151 : while(ind

pontot hatarozzuk meg

www.tankonyvtar.hu

254


152 : 153 : 154 : 155 :

{

// tavolsag kiszamitasa

calcRaySphereIntersection(P_vv,D_vv,ind) ; if ((T>0) && (T<minT)) // ha az elobbinel kozelebbi

T =

jon ki, akkor ez lesz

az uj ertek

DR AF T

156 : { 157 : minT = T ; 158 : closest = ind ; 159 : // cout << "BINGO - " ; 160 : } 161 : ind++ ; 162 : // cout << closest ; 163 : // cout << " " ; 164 : } 165 : ind=0 ; 166 : 167 : if (closest == obj_Amnt) // ha nincs metszes, a szin 168 : { 169 : Pixel.set(bg_Color[0],bg_Color[1],bg_Color[2]) ; 170 : // harom (RGB) erteku globalis valtozo

a hatterszin lesz


Ha találunk egy metszési pontot (azaz

érvénytelen !), akkor betesszük a

closest

értéke érvényes, az

obj_Amnt

érték

IP változóba (Intersection Point). Ez után a kiszámoljuk

a gömb ezen pontjához tartozó normálvektort. Ezt a gömb középpontjának és a rádiusz segítségével tehetjük meg. A középpontból a metszési pontba mutató vektor leosztva a

rádiusszal adja meg a normál ezt vektort. Ezt a normálvektort több mindenre fogjuk használni. El®ször is, a visszavert fény irányát tudjuk kiszámolni, ha a bees® sugarat tükrözzük a normálvektorra. Kés®bb a diúz világítás számításához is kelleni fog.


167 : if (closest == obj_Amnt) // ha nincs metszes, a szin a hatterszin lesz 168 : { 169 : Pixel.set(bg_Color[0],bg_Color[1],bg_Color[2]) ; 170 : // harom (RGB) erteku globalis valtozo 171 : } 172 : else 173 : { 174 : // ha van metszes, akkor ebbol a pontbol is kell inditanunk egy sugarat,

majd az uj metszesnel is, meg ujra, meg ujra, egeszen a maximalis rekurzios szamig.

www.tankonyvtar.hu



Az adott keppont szinet a

255

visszaverodo feny szinebol, az objektum szinebol es a

megvilagitas szineibol szamoljuk Point IP = P_vv + (D_vv * minT) ;

// metszesi pont

// a metszett gomb sugara is kell, hogy a normalvektort ki tudjuk szamolni double R_sp = spheres[closest][3] ; Point normal ; Point

SP_cent(spheres[closest][0],

DR AF T

175 : 176 : 177 : 178 : 179 : 180 : 181 : 182 : 183 : 184 : 185 : 186 : 187 : 188 : 189 : 190 : 191 :

spheres[closest][1],

spheres[closest][2]) ;

// metszesi pont - sp_center -> normal vect.. SP_cent = IP - SP_cent ;

normal = SP_cent / R_sp ; Point V = P_vv - IP ;

Point Re = (normal * (2 *

point_dot(normal, V))) - V ;

// a visszaverodo

sugarat ugy kaphatjuk meg, hogy a metszesi pontban allo normal vektorra tukrozzuk a beeso sugarat . Ha a tukrozodes be van kapcsolva, akkor ezt a tukrozodo sugarat.

192 : 193 : 194 :

// Feny szamitas

- az osszes fenyforras fenyet gyelembe veve a metszesi

pontora eso hatast

195 : 196 : 197 : 198 : 199 :

Pixel = ambient ;

// alapbol a hatterszinrol indulunk

int ind = 0 ;

int ind2 = 0 ; Point Light ;

Point Light_col ;


Ezen a ponton elkezdünk az adott pixel több hatásból adódó kompozit színével fog-

lalkozni. El®ször is, van egy ambiens fényünk, aminek a színéhez adunk minden további komponenst. Az ambiens fény olyan, mintha a képünk maszkja lenne. Ha valami eltalálunk

az adott pixelen át vezetett sugárral, lesz ambiens fény, ha nem, akkor ott nem lesz, csak a háttér színe (alapból fekete). Minden további szín, ami a különböz® hatások révén merül fel, erre az alap, ambiens színre rakódik rá. A további hatások vizsgálatát azzal kell kezdeni, hogy megnézzük, az adott metszési pontot valamely fényforrás megvilágítja-e ? Ezt

while(ind
minden fényforrásra meg kell vizsgálni ( esetén az irányukat a


www.tankonyvtar.hu

256


sphere_col

metszett gömb színe pedig a

változóba kerül.

--- raytrace_serial_hu.cpp --int ind = 0 ; int ind2 = 0 ; Point Light ; Point Light_col ; Point sphere_col ; bool Shadowed=

false ;

// megvizsgaljuk, hogy a metszesi pont arnyekban

DR AF T

196 : 197 : 198 : 199 : 200 : 201 :

van-e, azaz, hogy a pont és egy fényforrás között van-e más objektum

202 : 203 : 204 : 205 : 206 : 207 : 208 : 209 : 210 : 211 : 212 : 213 : 214 : 215 : 216 : 217 : 218 : 219 : 220 : 221 : 222 : 223 :

double Factor ; // megvilagitas szamitashoz Point Temp ;

double Temp_d ;

while(ind
// minden fenyforrast vegignezunk a jellenetben

set(lights[ind][0],lights[ind][1],lights[ind][2]) ;

Light.

// iranyvektor - elso 3 ertek a 6-bol (a masodik 3 a szin)

set(lights[ind][3],lights[ind][4],lights[ind][5]) ;

Light_col.

// feny szine sphere_col.

set(spheres[closest][5],

spheres[closest][6],

spheres[closest][7]) ;

// gomb szin

// Arnyek teszt - kitakart a fenyforras vagy sem ? Shadowed =

ind2 = 0 ;

false ;

while(ind2
if( (ind2 !=closest) && (calcRaySphereIntersecti-

on(IP,Light,ind2) > 0) )


Minden fényforrásra meg kell vizsgálnunk, hogy a metszési pontot kitakarja-e valamilyen objektum. Ha igen, akkor ezt a fényforrást nem vesszük gyelembe. Ha nem, akkor számítunk egy diúz komponenst (amit globálisan a

diffuse_test konstanssal kapcsolhaFactor faktorból áll, ami

tunk ki és be). Ezt a fényforrás színéb®l, a gömb színéb®l és egy

a gömb normálisa és a bees® fény koszínuszából jön ki. Ez a színintenzitásra van hatással.

www.tankonyvtar.hu



257


220 : 221 : 222 : 223 :

ind2 = 0 ; while(ind2
if(

on(IP,Light,ind2) > 0) ) 224 : 225 : 226 : 227 : 228 : 229 : 230 : 231 : 232 : 233 :

(ind2 !=closest) && (

{

calcRaySphereIntersecti-

true ; //

Shadowed=

DR AF T

ind2=obj_Amnt ;

}

ind2++ ;

}

if( !Shadowed) //

hamis

{

if(Diuse_test)

// ha be van kapcsolva, a diuz vilagitast

is szamoljuk

234 : 235 :

{

// ha ket vektor koszinusza negativ, akkor nem

latjuk, ha pozitiv, akkor latjuk

236 : 237 : 238 : 239 : 240 : 241 : 242 : 243 : 244 : 245 :

Factor =

point_dot(normal, Light) ;

// szog koszinusza

// cout << Factor << " --" ;

if(Factor>0) {

Pixel = Pixel

+((Light_col * sphere_col)* Factor) ; }

}

if(Specular_test) // ha a csillogo (tukor szeru) visszaverodes

be van kapcsolva, akkor ezt is szamolnunk kell (Phong eekt)

246 : 247 : 248 : 249 : 250 :

{

point_dot(Re.norm(), Light) ; if(Factor>0) Factor = {

Temp_d = pow(Factor,


Ha a

Specular_test változó igaz, még egy komponenssel számolnunk kell, ami a fény-

forrás fényes tükröz®d® hatását kelti a gömb felületén. Ez a komponens a csillanó hatást kelt® specular reection komponens. Az ambiens, diúz és csillanó specular komponen-


www.tankonyvtar.hu

258


sek együttesen használatát

Phong reexiós modellnek is nevezzük.


247 : 248 : 249 : 250 : 251 : 252 :

Factor = point_dot(Re.norm(), Light) ; if(Factor>0) { Temp_d =

pow(Factor,

spheres[closest][8])

//

pow(factor, phong

DR AF T

*spheres[closest][9] ;

size) * phong_amount

253 : 254 : 255 : 256 : 257 : 258 : 259 : 260 : 261 : 262 : 263 : 264 : 265 :

Temp.

set(lights[ind][3],

lights[ind][4],

lights[ind][5]) ;

Pixel = Pixel + (Temp*Temp_d) ;

}

}

}

ind++ ;

}

// Keppont (Pixel)

if

( Reection_test )

// ha a visszaverodes be van kapcsolva, akkor

szamolnunk kell a visszaverodott fenyekkel is az adott metszesi pontban.

266 : 267 :

{

if ( recLev < max_Reclev && spheres[closest][4] > 0)

// ha nem leptuk

meg at a maximum reexio szamot es az objektumnak van visszaverodesi erteke

268 : 269 : 270 :

{

Temp_d = spheres[closest][4] ;

// cout << "Temp_d : " << Temp_d << " ---" ;


Amikor a fényforrások hatásait kiszámoltuk, jöhetnek a gömbfelületek tükröz®dései.

Ezt a számítást szintén ki és be lehet kapcsolni a

Reflection_test

konstans állításával.

Ha be van kapcsolva, akkor minden metszetponti pixel színértékét befolyásolni fogja a többi

gömbr®l érkez® tükrözött kép. Mivel ezek a visszaver®dések újabb és újabb visszaver®dé-

sekb®l jöhetnek, rekurzív módon kell meghívnunk az ezt számító eljárást. A számításhoz a

Trace() függvényt használjuk. Mivel a tükröz®dések száma nagyon magas, érdemes egy

limitet bevezetni, hogy ne kelljen örökké várnunk a számítással. Ez a maximális rekurzió

max_RecLev Trace() minden

szint a

változóban van deniálva. Ennél több visszaver®dést nem követünk

le.

rekurzív hívása növeli a

www.tankonyvtar.hu

recLev

értéket, ami ha eléri a maximumot,



259

meggátolja a további rekurzív hívásokat. Amíg nem érjük el a limitet, és a gömb reexiós komponense deniált (a gömbök adatiban az 5. adat), akkor az aktuálisan hozzáadandó színt a reexiós komponenssel kell súlyoznunk.


267 :

if ( recLev < max_Reclev && spheres[closest][4] > 0) // ha nem leptuk meg

at a maximum reexio szamot es az objektumnak van visszaverodesi erteke

268 : 269 : 270 : 271 :

{

DR AF T

Temp_d = spheres[closest][4] ;

// cout << "Temp_d : " << Temp_d << " ---" ; Temp =

Trace(

IP, Re, recLev+1 ) ;

// rekurziv hivas, amiben

minden visszaverodest kezelunk, ami az adott metszesi pontot befolyasolja

272 :

Pixel = Pixel + (Temp*Temp_d) ; // minden tovabbi visszaverodesi

erteket a keppont szinadatahoz adunk

273 : 274 : 275 : 276 : 277 : 278 :

}

}

}

//

cout << "Pixel : " << (int)(Pixel[0]*255) << "-" << (int)(Pixel[1]*255)

<< "-" << (int)(Pixel[2]*255) << "|| " ;

279 : return Pixel ; 280 : } 281 : // END - program

utolso sora

Térjünk vissza a legutóbb nem részletezett

calcRaySphereIntersection() függvény-

re. Ez a függvény számolja ki, hogy egy sugár metsz-e egy gömböt, és ha igen, milyen

T

koordinátában ? Ha nincs keresztezés, a visszatérési érték -1. Ha van, akkor egy

faktor

a visszatérési érték. Ez a faktor mondja meg, hogy a vizsgált egységnyi irányvektorunkat

mennyivel szorozva kapjuk meg a metszési pontba mutató vektort. A függvény bemenetei a következ®k :

P_ray

sugár kezd®pontja

D_ray

sugár iránya

sp_index

a gömb indexe a gömb tömbben

A gömb indexével az adott index¶ gömb középpont koordinátáit be tudjuk tenni a gömb sugarát pedig

R_sp-be.

C_sp-be,

Az ötelt az, hogy a következ® egyenl®ség fent áll :

vectorl ength(P _ray + T ∗ D_ray − C _sp) = R_sp c Várady Géza, Zaválnij Bogdán, PTE

www.tankonyvtar.hu

260

Bevezetés az MPI programozásba példákon keresztül Azaz, ha van metszési pont, akkor a metsz¶ sugárból egy vektor lesz, ami a metszési

pontba mutat (T*D_ray). Ezt a vektort úgy állíthatjuk össze, hogy összeadjuk a gömb középpontjába mutató vektort (C_sp) és a metszési pontba mutató rádiusz vektort (R_sp). A

P_ray-C_sp-t

helyettesíthetjük

V-vel,

ekkor a következ®t kapjuk :

vector_length(T ∗ D_ray + V ) = R_sp Ha kifejtjük a formulát. a következ®t kapjuk :

DR AF T

(T ∗ Dx + Vx )2 + (T ∗ Dy + Vy )2 + (T ∗ Dz + Vz )2 − R_sp2 = 0 Ebb®l a formulából megkaphatjuk

T-t,

a következ® másodfokú kifejezés megoldásával :

T = (−D ∗ V + −sqrt((D ∗ V )2 − D2 (V 2 − R2 )))/D2

Ha a determináns nem nulla, egy vagy két megoldásunk van. Ha két megoldás van, a

kisebb lesz a jó, ami közelebb van az origóhoz. A függvény a

T

faktort adja vissza.


102 :

// ez a funkcio vizsgalja, hogy egy sugar metsz-e gombot. Ha igen, egy "T"

tavolsagot kapunk, ami megadja a kiinduloponttol valo tavolsagat a metszesi pontnak.

103 :

double calcRaySphereIntersection(Point& P_ray, Point& D_ray, int sp_index)

// A kiindulasi pont es a sugar iranya referencia szerint megadva, az index dinamikusan valtozik es a gombot jeloli ki

104 : 105 :

{

Point

C_sp

(spheres[sp_index][0],

// A gomb kozeppontjat kapjuk -

spheres[sp_index][0,1,2]

106 : 107 : 108 : 109 :

spheres[sp_index][1],

spheres[sp_index][2]) ;

// a metszesi pontot "T" tavolsagbol es az egyseg iranyvektorbol kapjuk

meg

110 :

// P - kezdopont, D - irany, C - kozeppont, R - sugar, vlength(P+T*D-

C)=R, V=P-C, vlength(v+T*D)=R

111 : 112 :

// (T*Dx+Vx)2 + (T*Dy+Vy)2 + (T*Dz+Vz)2 - R2 = 0 // T = (-D·V +/- sqrt((D·V)2 - D2(V2-R2))) / D2

// a masodfoku

egyenlet megoldasa (ket metszessel, a kozelebbi a jo)

113 : 114 : 115 : 116 : 117 :

// http ://www.povray.org/documentation/view/3.6.1/130/ // P_ray - C_sp Point V = P_ray - C_sp ;

double R_sp = spheres[sp_index][3] ; // a harmadik ertek a sugar

www.tankonyvtar.hu



118 : 119 : 120 : 121 : 122 : 123 : 124 : 125 : 126 : 127 : 128 : 129 : 130 : 131 : 132 : 133 : 134 :

// D*V double DV =

// D*D double D2 =

261

point_dot(D_ray, V) ; point_dot(D_ray,D_ray) ;

double SQ = DV*DV - D2*(

if (SQ <= 0)

//

point_dot(V,V)-R_sp*R_sp) ;

ha negativ, akkor nincs gyok, nincs metszesi pont.

DR AF T

{

T = -1 ;

}

else {

SQ =

sqrt(SQ) ;

double T1 = (-DV+SQ)/D2 ; double T2 = (-DV-SQ)/D2 ; T =

min(T1,

T2) ;

// az elso metszesi pont (kozelebbi) a jo, amit

keresunk

135 : 136 : 137 :

}

// if (T>0) {cout << "T : " << T << " ! " ;}

return T ; // ez a tavolsag, ami az iranyvektorral egyutt kiadja a metszesi

pontot

138 : 139 : 140 :

}

// Trace fuggveny, egy indulo pont, irany es rekurzios szint bemenete van.

Keppont szint ad vissza

141 :

Point Trace(Point &P_vv, Point &D_vv, int recLev)

// we need a local

recLev, since we call it recursively

142 :

{


Ezzel a sugárkövetéses példánk m¶ködését leírtuk. Látható, hogy bár egy er®sen egy-

szer¶sített implementációt tárgyalunk, az er®forrás igénye így is nagy. Több rekurzív szá-

mítást kell végeznünk számos koordinátában, hogy megkapjuk a 2D-s látványt. Ha az elrendezésben több fényforrás és tükröz®d® objektum van és nagy felbontású képet sze-

retnénk generálni, egyetlen képkock kiszámítása is hosszú percekbe telhet. Ez felveti a kérdést, hogy hogyan lehetne a számítást párhuzamosítással felgyorsítani ? Az látható, hogy nézeti kép egyes képpontjai függetlenek egymástól. Ebb®l kifolyólag

elvileg minden egyes pixelt külön lehetne számoltatni, párhuzamosan. A kommunikációs többlet miatt ez nem lesz eektív, de ha a számításigény növekedni, még akár a pixelenkénti kiosztás is segíthetne. A párhuzamosítás azonban ennél a bonyolultságnál is segítségünkre


www.tankonyvtar.hu

262


lesz.

12.2.2. Párhuzamos sugárkövetés A fenti sugárkövetéses példa számításigényes feladat. A soros kód 10-20 másodpercig dolgozott egy kétmagos rendszeren (Intel Xeon 2,5GHz). Itt egy 4800x4800-as felbontás mellett generáltunk képet öt gömbr®l, minden tükröz®dést bekapcsolva, három fényforrást használva. Ahhoz, hogy több képkockát lehessen generálni másodpercenként, a folyamatot sokkal gyorsabbá kell tennünk. Egy két programozási trükkel lehet még gyorsulást elérni,

DR AF T

de ez nem segítene túl sokat. Nagyobb teljesítményre van szükség és ezt a munka feldarabolásával és leosztásával érhetjük el. A fenti paraméterekkel, a párhuzamos verziót futtatva

256 magon, a kép kiszámítása 0,3 másodpercre csökkent. Sajnos a nagy mennyiség¶ adat begy¶jtése és kiírása ezek után még további 6 másodpercet igényelt, mivel a kimeneti fájlunk 150 MB-os lett. A párhuzamosítás könnyen megoldható, mert a nagy adatmennyiség

független számítási eljárásokba osztható, nem kell menet közben adatokat cserélni egymás-

sal. A nézeti kép pixelei nem függenek egymástól, csak a 3D-s elrendezés objektumaitól.

Az elrendezés statikus geometriai adatokból áll, ezeket az adatokat minden munkás megkapja az elején. A mi feladatunk csak a 2D-s kép felosztása a magok között. Ugyanazt a technikát használjuk, mint a lapmelegít®s példánkban. Az adatokat blokkonként leosztjuk

az egyes magok között egyenl® arányban, majd a maradék feladatot odaadjuk az utolsó munkásunknak.

Trace() függvénynek csak két adott pont között bels® ciklus FROM változótól TO értékig fog futni.

Mivel a nézeti képünket felosztottuk, a

kell számolnia. A

main()

függvényben a

Mindegyik számítást végz® mag saját azonosítóval (rank) rendelkezik és ez alapján egyedi intervallumokat számolnak a saját

FROM

és

TO

értékeik között.

A párhuzamos verzió ugyanazt az include állományt (ray6v7.h) használja mint a soros

verzió, így ezt nem tárgyaljuk újra.

double t_f rame[X][Y ][3] = 0;

Ez az átmeneti tömb lesz minden munkás esetében az a hely, ahova a számított értéke-

ket tárolják. A munkások a 3D-s statikus elrendezés alapján generálják a 2D-s értékeket, ezeket valahova el kell tárolni átmenetileg. A tömb X,Y koordinátáiban az egyes képpontok R,G,B színértékei kerülnek eltárolásra.

A párhuzamos program hasonló sorokkal kezd®dik, mint a soros program. Az els®

eltérés az MPI include sor az elején (mpi.h). Egy pár MPI-al és a párhuzamos m¶ködéssel

kapcsolatos változót is deklarálnunk kell, mint ahogy eddig is (world_rank,

FROM, TO).

world_size,

001 : // Raytrace demo - parhuzamos megvalositas 002 : // a kod a povray.org dokumentacio és Darren Abbey ((C) 2002) php megoldasan www.tankonyvtar.hu



263

alapjan keszult

#include <mpi.h> #include #include #include <math.h> #include #include "ray6v7.h"

DR AF T

003 : 004 : 005 : 006 : 007 : 008 : 009 : 010 : 011 : 012 : 013 : 014 : 015 : 016 : 017 :

using namespace std ;

// a Trace() fuggveny elodenialasa Point

Trace(Point &P_vv, Point &D_vv, int recLev) ;

double T = -1 ;

// sugar - gomb metszés eredmenye - ez egy tavolsag lesz, ha

-1, akkor nincs metszet

018 : 019 : 020 : 021 : 022 : 023 :

int obj_Amnt ;

int light_Amnt ;

/ kornyezeti feny es kamera ertekek double ddd = 0.2 ; Point

ambient(ddd,0.2,0.2) ;

// diuz vilagitas RGB ertekei - meg nem 8biten

(szurke - 0,2 ; 0,2 ; 0,2)

024 : 025 : 026 : 027 : 028 : 029 : 030 : 031 : 032 : 033 : 034 : 035 : 036 :

Point

camera(-4,0,-16) ;

// kamera pozicio

- 0,0,-3

// MPI valtozok

int world_rank ; // az aktualis processzus rangja

int world_size ; // size of world, thus number of processors in this world

int FROM ; int TO ;

int

main()

{

Point Pixel ;

--- raytrace_parallel_hu.cpp ---

A

Main()

függvény elején is van pár extra sor a párhuzamos verzióban. Az MPI világ

inicializálása után elmentünk egy aktuális id® értéket a


s_time változóba az MPI_Wtime() www.tankonyvtar.hu

264


függvénnyel. Az aktuálisan dolgozó munkások számát beolvassuk a illetve a saját rangunkat (rank) a

world_rank

world_size változóba,

változóba. Innent®l a kód hasonló mint a

soros megoldásban, egészen a 98-as sorig.


int

main()

{ Point Pixel ;

DR AF T

032 : 033 : 034 : 035 : 036 : 037 : 038 : 039 :

ofstream myle ;

// ebbe a fajlba

fogunk irni

double s_time ;

// Az MPI kornyezet inicializalasa - innentol az MPI_Finalize hivasaig

hasznalhatjuk az MPI fuggvenyeket

040 : 041 : 042 : 043 : 044 : 045 : 046 : 047 : 048 : 049 : 050 : 051 : 052 : 053 : 054 :

MPI_Init(NULL, NULL) ;

MPI_Wtime() ;

s_time=


MPI_Comm_size(MPI_COMM_WORLD, &world_size) ; // sajat processzusunk rangja (sorszama)

MPI_Comm_rank(MPI_COMM_WORLD, &world_rank) ;

// meg kell szamolnunk a jelent objektumait (gombok es fenyforrasok) int array_size,element_size ;

sizeof(spheres) ; element_size = sizeof(spheres[0]) ; array_size =

obj_Amnt = array_size/element_size ; // a tombmerettel es elemmerettel

szamolunk (byteban)

055 : 056 : 057 : 058 : 059 : 060 :

// fenyforrasok szamolasa array_size =

sizeof(lights) ; sizeof(lights[0]) ;

element_size =



felszorozva koordinatakba mutato vektorokat kapjunk - reszeltek a povray oldalon.

061 : int i=0 ; 062 : 063 : Point normalized ; 064 : while(i
www.tankonyvtar.hu



// az adatokat atmenetileg a "normalized"-be tesszuk normalized=normalized.

norm() ; //

A norm() metodussal normalizalhatunk

// A normalt "i" ertekeket visszatesszuk a lights[] tombbe

get(0) ; lights[i][1] = normalized.get(1) ; lights[i][2] = normalized.get(2) ; lights[i][0] = normalized.

i++ ;

DR AF T

066 : 067 : 068 : 069 : 070 : 071 : 072 : 073 : 074 : 075 : 076 : 077 : 078 :

265

}

// MPI START

// ki kell szamolnunk hany soron fog dolgozni a processzusunk, azaz mennyi

adatot kell kiosztanunk a munkasoknak

079 :

// az adathalmaz felosztasa kulcsmomentum a parhuzamos szamitasokban,

a futasi idot erosen meghatarozza --- raytrace_parallel_hu.cpp ---

Ezen a ponton a munkások kiszámolják, hogy mi lesz a munkarészük. Minden mag a

FROM

és

TO

közötti sorokkal fog dolgozni. Ahogy korábban, a pár extra sort a végén az

utolsó munkásra bízzuk.


075 : 076 : 077 : 078 :

}

// MPI START

// ki kell szamolnunk hany soron fog dolgozni a processzusunk, azaz mennyi

adatot kell kiosztanunk a munkasoknak

079 :

// az adathalmaz felosztasa kulcsmomentum a parhuzamos szamitasokban,

a futasi idot erosen meghatarozza

080 : 081 :

// egy egyszeru, de nem a legeektivebb modszert valasztottunk : egyenloen

osztjuk el a feladatot es a kis maraddekot megkapja az utolso munkasunk

082 : 083 :

int p_row = Y / world_size ;

// a sorok szamat leosztjuk a munkasok

szamaval

084 :

int p_row_last = 0 ; // egy specialis valtozot keszitunk elo az utolso

munkas szamara

085 : 086 :

if((Y % world_size) != 0) //

ha nem lehet maradek nelkul osztani

{


www.tankonyvtar.hu

266


087 : 088 :

// p_row =

ennyit kap egy

089 :

oor(p_row) ;

// akkor az osztas egesz reszet vesszuk,

munkas, kiveve az utolsot.. p_row_last = Y - ((world_size-1)*p_row) ; // .. es az utolso kapja

a maradekot is }

else // szerencses esetben nincs maradek, igy mindenki egyenloen dolgozik { p_row =

oor(p_row) ;

DR AF T

090 : 091 : 092 : 093 : 094 : 095 : 096 : 097 :

p_row_last = p_row ;

}

// ki kell szamitanunk

az elso

(FROM) es utolso (TO-1) sort, amivel

dolgoznunk kell

098 : 099 : 100 : 101 : 102 : 103 : 104 : 105 : 106 : 107 : 108 : 109 : 110 :

if(world_rank < world_size-1) //

ha nem az utolso munkas vagyunk

{

FROM = world_rank*p_row ; TO = FROM+p_row ;

}

else

// utolso munkas vagyunk

{

FROM = world_rank*p_row ; TO = FROM + p_row_last ;

}

// MPI END

// ------------------------


Pár információ kiíratása után, el®készítjük az egymásba ágyazott ciklusunkat, mellyel

a 2D-s képünk egyes pontjainak színét határozzuk majd meg. Mivel ez a kódot minden munkás párhuzamosan futtatja, mindenki a saját sorait fogja számítani, egyszerre.


106 : 107 : 108 : 109 : 110 : 111 :

TO = FROM + p_row_last ;

}

// MPI END // ------------------------ // ------ Visszajelzes, kikapcsolva no a sebesseg ---

www.tankonyvtar.hu



267

DR AF T

112 : if(world_rank < world_size-1) // visszajelzes, hogy ki mivel dolgozik 113 : { 114 : cout << "Én vagyok a " << world_rank << " munkás. Ezeket a sorokat fogom kiszámolni : " << p_row << " \r\n" ; 115 : } 116 : else 117 : { 118 : cout << "Én vagyok az utolsó munkás : " << world_rank << ". A maradék " << p_row_last << " soron fogok dolgozni. \r\n" ; 119 : } 120 : // ------ visszajelzes vege ----------- 121 : // ------------------------ 122 : 123 : 124 : 125 : // // A kep megepitese 126 : 127 : int c,c2 ; 128 : 129 : double coordX,coordY ; 130 : double Pf ; 131 : Point temp_coord ; 132 : 133 : c=0 ; 134 : c2=0 ; 135 : for(int i=0 ;i
143 : 144 : 145 :

temp_coord. Pixel =

set(coordX,coordY,3) ;

Trace(

camera, temp_coord, 1) ;

// itt az aktualis koordinatan

levo pixel szinet kapjuk meg. Bemenetkent a kamera poziciot (camera), a pixel koordinatat amin at nezzuk a jelenetet (temp_coord) es a rekurzio szintjet, amivel a reexiok szamat allithatjuk, kerjuk. A maximalis rekurziot a max_recLev -ben adjuk meg es a kezdeti erteket (most 1) minden rekurzios lepesben emeljuk egyel


www.tankonyvtar.hu

268


146 : 147 : 148 :

t_frame[j][i][0] = Pixel.

get(0) ;

// Az analog szinertekunket (ami nem

0-255 kozott fut) atkonvertaljuk 0-255 kozottire

get(1) ; t_frame[j][i][2] = Pixel.get(2) ; t_frame[j][i][1] = Pixel.

c2=c2+1 ; }

DR AF T

149 : 150 : 151 : 152 : 153 : 154 : 155 : 156 : 157 : 158 :

c2=0 ;

c=c+1 ;

}

// az MPI szamitas kesz, ossze kell szednunk az adatokat cout

<<

world_rank

MPI_Wtime()-s_time << "\r\n" ; 159 : 160 :

<<

" kész a munka ! MPI_time : "

<<

// a munka kesz ezen a ponton..

// ..de meg minden munkastol be kell gyujtenunk az adatokat. Ezt

praktikusan a 0-as rangju munkassal tesszuk meg --- raytrace_parallel_hu.cpp ---

Miután minden munkás kiszámolta a saját pontjait, ezeket az adatrészeket össze kell

gy¶jtenünk. Minden munkás a saját sorait a

t_frame átmeneti tárolójába helyezi el, a meg-

felel® sorokba. Mivel az els® munkás biztosan létezik (rank 0), jó ötlet, ha vele gy¶jtetjük össze a többiek adatait egy helyre.

Miután az eltelt id®t (MPI_Wtime()-s_time) kiíratjuk a konzolra (work done !), az

els® munkásnak fogadnia kell az adatokat a többiekt®l (p<world_size). Ha küld®k vagyunk, az

MPI_Send()

függvényt használjuk. A küldésnél egy trükköt alkalmazunk, ami

C++ környezetben ezen az architektúrán deniáltak szerint m¶ködik. A tömbök ebben a környezetben sorfolytonosak, azaz az egyes soraink egymás után azonnal következnek a

memóriában. Egyébként érdemes ezt a folytonosságot az MPI környezetben mesterségesen el®idézni, mert ezzel kommunikációs többletid®ket spórolhatunk meg. Ez még az extra programsorok árán is jó ötlet lehet. A trükk pedig az, hogy nem

n

darab sort küldünk,

n*line hosszú (181-es sor). Ha az els® csomópont vagyunk, MPI_Recv() függvénnyel. El®tte azonban egy kis számítást

hanem egy egész blokkot, ami ugyanezt tesszük a fogadó,

kell végeznünk, hogy a kapott sorokat pontosan a megfelel® helyekre illesszük be. Itt ha hibázunk, a bejöv® sorokat más helyre írhatjuk, felülírva már megkapott adatokat. Ez

logikai hiba lenne, a program lefutna, nem jelezne hibát, de az adatok rosszak lennének. Amikor az adatgy¶jtéssel készen vagyunk, akkor a begy¶jtött teljes képet kiírhatjuk egy PPM fájlba. Tesztelési céllal a végén is kiolvasunk egy futási id®t, hogy összevethessük a párhuzamos számítás futási idejét az adatbegy¶jtés idejével.

www.tankonyvtar.hu



269


157 : 158 :

// az MPI szamitas kesz, ossze kell szednunk az adatokat cout << world_rank << " kész a munka ! MPI_time : " << MPI_Wtime()-

s_time << "\r\n" ;

159 : 160 :

// a munka kesz ezen a ponton.. // ..de meg minden munkastol be kell gyujtenunk az adatokat. Ezt

praktikusan a 0-as rangju munkassal tesszuk meg // ezekben a valtozokban tartja majd a 0-as processzus, hogy milyen sorokat

DR AF T

161 : 162 :

kap a kuldi processzusoktol

163 : 164 : 165 : 166 :


if(world_size>1)

// csak akkor gyujtunk be sorokat, ha nem egyeduli

processzusok vagyunk ...

167 : 168 :

{

for(int p=1 ;p<world_size ;p++) //

world_size-1 darab adatot kell

begyujtenunk

169 : { 170 : 171 : 172 : adatokat ett®l: " "\r\n" ; 173 : 174 :


ha mi jovunk mint kuldok, kuldunk

{

" Én (" << world_rank << ") küldöm az " eddig : " << TO << ". Y : " << Y <<

cout <<

<< FROM <<

/*

for(int r=FROM ;r
egyszerusitjuk..

175 : 176 :

{

MPI_Send(&t_frame[r][0][0], Y*3,

MPI_DOUBLE, 0 , 999 , MPI_COMM_WORLD) ; // 999 - egyedi

177 : 178 :

tag

}*/

// Mivel a c++ tombok, mint pl. a t_frame folytonos

memoriateruleten helyezkednek el, egy kis trukkot alkalmazhatunk :

MPI_Send(&t_frame[FROM][0], Y*3*(TO-FROM),

179 :

MPI_DOUBLE, 0 , 999 , MPI_COMM_WORLD) ; // feltetelzzuk, hogy folytonos

memoriateruleten vannak a sorok

180 : 181 :

}

else if ( world_rank == 0) //

ha a 0-as processzus vagyunk,

fogadjuk a kuldott adatokat..

182 : 183 :

{

// mennyi legyen az rFROM es az rTO ? Melyik sorokat


www.tankonyvtar.hu

270


fogadjuk ? Ezt a tavoli processuzs rangjabol (p) kell kiszamolnunk

if(p<world_size-1) //

184 :

nem az utolso adatblokk jon. Az

utolso hosszabb lehet mint a tobbi (normal hossz + maradek !)

DR AF T

185 : { 186 : rFROM = p_row*p ; 187 : rTO = p_row*(p+1) ; 188 : } 189 : else // utolso jon 190 : { 191 : rFROM = p_row*p ; 192 : rTO = X ; 193 : } 194 : cout << "Én (" << world_rank << ") kapom az adatokat a " << p << " processzustól, ett®l : " << rFROM << " eddig: " << rTO << " \r\n" ; 195 : /* 196 : for(int r=rFROM ;r
197 : 198 :

{

MPI_Recv(&t_frame[r][0][0], Y*3,

MPI_DOUBLE, p , 999 , MPI_COMM_WORLD, MPI_STATUS_IGNORE) ; // 999 - unique tag

199 : 200 :

}*/

MPI_Recv(&t_frame[rFROM][0], Y*3*(rTO-rFROM),


//

a sorokat folytonosnak feltetelezzuk a memoriaban

201 : 202 : 203 : 204 : 205 :

}

}

}

cout << world_rank <<

MPI_Wtime()-s_time << "\r\n" ; 206 : 207 : 208 : 209 : 210 : 211 : 212 :

" kész a gy¶jtés ! - MPI_time : "

<<

// MPI_Barrier(MPI_COMM_WORLD) ; // MPI

// kesz vagyunk, be kell gyujteni az adatokat

// az adatok a 0-as processzusnal vannak // kiirjuk egy fajlba

if(world_rank==0)

// ha a 0-as processzusok vagyunk, ki kell irjunk

adatokat

213 :

{

www.tankonyvtar.hu



271

DR AF T

214 : 215 : string lename1 ; 216 : lename1 = "raytrace_par.ppm" ; 217 : char *leName = (char*)lename1.c_str() ; 218 : 219 : cout << " Ezt a fajlt fogom irni : " << leName << ". \r\n" ; 220 : 221 : myle.open(leName) ; 222 : myle << "P3\r\n" ; 223 : myle << X ; 224 : myle << " " ; 225 : myle << Y ; 226 : myle << "\r\n" ; 227 : myle << "255\r\n" ; 228 : 229 : for(int i=0 ;i
235 : 236 : 237 : 238 : 239 : 240 : 241 : 242 : 243 : 244 : 245 :

myle <<

myle <<

min( (int)round(t_frame[j][i][1]*255), 255) ;

myle <<

myle << myle <<

" "; " ";

min( (int)round(t_frame[j][i][2]*255), 255) ; " ";

}

myle <<

"\r\n" ;

}

close() ;

myle.

cout

<<

world_rank

MPI_Wtime()-s_time << "\r\n" ; 246 : 247 : 248 : 249 : 250 : 251 : 252 :

<<

" kész az írás ! - MPI_time : "

<<

}

/*

// File

myle.open("probakep.ppm") ; myle << "P3\r\n" ; myle << X ;


www.tankonyvtar.hu

272


253 : 254 : 255 : 256 : 257 :

myle << " " ; myle << Y ; myle << "\r\n" ; myle << "255\r\n" ;


Trace() és calcRaySphereIntersection() függvények pontosan ugyanúgy m¶köd-

DR AF T

A

nek, mint a soros megvalósításban, a párhuzamos implementálás nem érintette ezeket.

www.tankonyvtar.hu


13. fejezet

DR AF T

Projekt munkák

Ebben a fejezetben különböz®, a könyv témakörébe vágó feladatokat t¶ztünk ki. Ezek na-

gyobb lélegzetvétel¶ek, így leginkább házi feladatként tudjuk elképzelni a diákok számára. Néhány közülük egy-két héten belül megoldható, mások viszont ennél hosszabb id®t igé-

nyelnek, mondjuk egy szemeszternyi munkát, így akár egy BSc szint¶ szakdolgozat alapját is képezhetik.

13.1. Rendezések

A rendezések az összetettebb algoritmusok jól ismert tipikus alap-példái. A párhuzamos rendez®algoritmusok ugyancsak hasznosak a párhuzamosítás témakörének mélyebb

megértésében.[Akl1985] Néhány projektmunkát szeretnénk kit¶zni, melyeket MPI környe-

zetben lehet megoldani, és amelyek közepes nehézség¶ek, így néhány hetes házi feladatnak ajánljuk ®ket.

A rendezés célja, hogy egy adott számokból álló tömböt növekv® (vagy csökken®)

sorrendbe rendezzen. Habár más típusú rendezések is ismertek (mint például a radix ren-

dezés), itt kizárólag az összehasonlításon alapuló rendezésekr®l beszélünk. Ez azt jelenti, hogy a megengedett m¶veletek a következ®ek : két szám összehasonlítása, és a számok felcserélése vagy egy másik tömbbe kiemelése, és a hasonló m¶veletek. Az ilyen rendezések

O(n log n). Az olvasónak egy rendkívül egyszer¶ C++ példaprogramot ajánösszehasonlítási alapnak, amely az STL sort() algoritmusát használja. A függvény

komplexitása

lunk

paramétere két pointer, az esetünkben a tömb elejének címe és az utolsó utáni elem címe. A program alapverziója a következ®képpen néz ki :

01 : // basic program for sorting 02 : // with the sort() algorithm 03 : 04 : #include 05 : #include


www.tankonyvtar.hu

274


using namespace std ; const long long SIZE=1ll<<25 ; // 2^25 with use of shifting operators // 1ll is "1" for long long double *a = int

new double[SIZE] ;


time_t t1, t2 ;

DR AF T

06 : 07 : 08 : 09 : 10 : 11 : 12 : 13 : 14 : 15 : 16 : 17 : 18 : 19 : 20 : 21 : 22 : 23 : 24 : 25 : 26 : 27 : 28 : 29 : 30 : 31 : 32 : 33 : 34 : 35 : 36 : 37 : 38 :

srand(time(NULL)) ;

for(int i=0 ;i<SIZE ;i++)a[i]=(double)rand()/rand() ; for(int i=0 ;i<40 ;i++)cout<
clock() ; sort(a,a+SIZE) ; t2=clock() ; t1=

cout<<endl<<"******************************"<<endl<<endl ; cout<<"time

elapsed: "<
cout<<endl<<"first

40 :"<<endl ; for(int i=0 ;i<40 ;i++)cout<
for(int i=SIZE/2 ;i<SIZE/2+40 ;i++)cout<
40 :"<<endl ;

for(int i=SIZE-40 ;i<SIZE ;i++)cout<
}

Néhány megjegyzést f¶znénk a programhoz. El®ször is, azért használtunk double tí-

pust, mert azok összehasonlítása jóval számításigényesebb, és fontos, hogy valóban nehéz feladatot állítsunk fel. Másodszor is, a

(double)rand()/rand()

véletlenszám gene-

rálás egyenl®tlen elosztáshoz vezet, mivel nagyon sok érték esik majd 1 környékére, és jóval kevesebb a 0 illetve a

RAND_MAX

felé. Jól ismert, hogy abban az esetben, ha ismer-

jük a számok eloszlását könnyebb megszervezi egy rendez®algoritmust, és a kézenfekv®

(double)rand()/RAND_MAX www.tankonyvtar.hu

számítás éppen ilyenre vezetne.


13. fejezet. Projekt munkák

275

13.1.1. Összefésül® rendezés Az els® kit¶zött feladatunk az ismert összefésül® algoritmuson alapul. Az eredeti soros algoritmus [Corm2009, pp. 2937] egy oszd-meg-és-uralkodj algoritmus. Ezt az elvet használhatjuk arra, hogy egy párhuzamos algoritmust építsünk. A mester (ahol

id = 0) félbeid = 1.

osztja a tömböt és az egyik felét elküldi az egyik szolgának, nevezetesen ahol az Ezek után a mester ismét félbeosztja a nála maradt résztömböt és elküldi a miközben az

2-es szolgának,

1-es szolga is felosztja a résztömbjét és a felét elküldi a 3-as szolgának. És így

tovább, minden folyamat lépésenként felosztja a tömböt és továbbküldi a felét egy másik

DR AF T

folyamatnak, aki még nem kapott feladatot. Amikor nem marad több folyamat aki nem kapott résztömböt, akkor minden folyamat

a nála lév® résztömböt lokálisan rendezi. Az egyszer¶ség kedvéért azt ajánljuk, hogy a lokális rendezést a fent már említett STL

sort() algoritmussal végezze el az olvasó. Ennél

sokkal gyorsabb soros rendez®t nehéz lenne megírni és a feladat lényege a párhuzamosítás. Miután a folyamatok végeztek a lokális rendezéssel minden folyamat visszaküldi a

rendezett részsorozatot pontosan annak a folyamatnak, akit®l kapta. Az a folyamat fogja

összefésülni a kapott sorozatot a nála lév® sorozattal, majd az összefésült sorozatot is

továbbküldi annak a folyamatnak, akit®l eredetileg a rendezetlen részsorozatot kapta. Az

olvasó elképzelhet egy képzeletbeli fát, ami lerajzolja a kommunikációt, ahol a mester, azaz

0. folyamat gy¶jti össze a fa legtetején az egész sorozatot és fésüli össze az utolsó lépésben.

Küls® táras rendezés

Az el®z® feladat egy variánsa a küls® táras rendezés, ahol az adatok egy küls® táron, például a merevlemezen, találhatóak, és összességében olyan nagy adatmennyiségr®l van szó, hogy az egyszerre nem fér el a memóriában.

A feladat a következ®képpen párhuzamosítható. A különböz® folyamatok a tömb más-

más részét olvassák be és külön rendezik a lokális memóriában. Értelemszer¶en az a szelet, amit beolvasnak el kell, hogy férjen a helyi memóriában, azaz vagy elég sok gépet kell

használunk ahhoz, hogy az össz memória mennyiség elegend® legyen, vagy a folyamatok több a memória méretének megfelel® részt is beolvasnak és rendeznek egymás után. A rendezett részsorozatokat rendezés után visszaírják a háttértárra.

Amikor a folyamatok elkészültek, akkor a mester folyamat beolvassa a rendezett részso-

rozatokat és összefésüli ®ket miközben az eredményt folyamatosan írja vissza a háttértárra. Ebben az esetben egy sok sorozat bemenetes összefésülést kell megvalósítani, amely ha az egyik sorozat beolvasott része elfogyott újabb részt olvas be.

13.1.2. Gyorsrendezés

Egy másik közismert példa a rendezésekre a gyorsrendezés.[Corm2009, pp 170190] Ismételten egy oszd-meg-és-uralkodj algoritmusról van szó, amely elv a párhuzamosítás alapja lehet, ahogyan fent leírtuk az összefésül® rendezés esetén. A különbség az, hogy az elemek szortírozását az elküldés el®tt kell megtennünk így amikor visszakapjuk a rendezett


www.tankonyvtar.hu

276


részsorozatokat azokat nem kell összefésülni csak egymás után írni. Azaz a rendezett részsorozatokat közvetlenül a mesternek küldhetjük vissza.

13.1.3. Mintavételez® rendezés Az el®bb bemutatott gyorsrendezés párhuzamosítása nem igazán optimális üzenetküld® klaszter architektúrák esetén. Túl sok benne az adatmozgatás. A mintavételez® rendezés a gyorsrendezés egy olyan változata, ami ezeket a problémákat küszöböli ki, és jól használható ezeken az architektúrákon.

DR AF T

A rendezés lépései a következ®ek :

I. A mester folyamat mintákat vesz a rendezend® tömbb®l. Egy nagyságrenddel több elemet vesz ki, mint amennyi a rendezésre álló processzormagok száma. Például

mag esetén százszor többet, azaz

12 800

128

elemet vesz ki véletlenszer¶en. Ezek után

ezeket a mintákat rendezi, és kiveszi a rendezett sorból minden századik elemet (a példánknál maradva.) Ezek a kivett elemek lesznek a határok. A határok tömbjét

a mester folyamat szétteríti (broadcast) a szolgák között. A mintavétel célja, hogy

a határok által befoglalt elemek száma közel azonos legyen minden részre, és ez ne függjön az eredeti elemek eloszlásától.

II. A teljes tömb ezek után szétterítésre (broadcast) kerül, és minden folyamat kiválogatja bel®le azokat az elemeket, melyek a folyamathoz rendelt határok közé esnek.

k -ik folyamat lesznek, és azokat az elemeket válogatja ki, melyekre bk ≤ ax < bk+1 .

Ha a határok értéke határai a

bk , bk+1

p

folyamat esetén

b0 , b1 , b2, . . . , bp−1 , bp ,

akkor a

III. A folyamatok a kiválogatott elemeket lokálisan rendezik (ismét az STL

sort()

al-

goritmusát ajánljuk.

IV. A rendezett részsorozatokat ezek után a folyamatok visszaküldik a mester folyamatnak, amelyik egymás után helyezi azokat, így megkapjuk a végeredményt.

Megjegyzések

Mivel a részsorozatok mérete különböz® lesz, ezért a szolgáknak el®bb el kell külde-

niük a kiválogatott sorozat méretét a mesternek, hogy az a megfelel® méret¶ tömböt tudja fogadni, és csak ezek után küldhetik magát a rendezett tömböt.

A sok különböz® küldés-fogadás miatt az implementálás során különösen gyelni kell arra, hogy a megfelel® sorrendezéssel elkerüljük a halálos ölelés (deadlock) szituációt,

és hogy a különböz® funkciójú küldés-fogadásokhoz mindig különböz® címkéket (tag) használjunk, hogy azok ne keveredjenek össze.

Valójában a rendezett részsorozatok mérete már a határok szerinti kiválogatás után közvetlenül ismert, így ezt az információt már ekkor elküldhetik a szolgák a mesternek. A mester, ha megkapta az összes résztömb méretet a résztömbök végs® helyét

www.tankonyvtar.hu



277

már ekkor ki tudja számolni az eredménytömbben. Ennek segítségével a rendezett résztömbök fogadásának sorrendje nem kötött, azokat elkészülésük sorrendjében tudja a mester fogadni. A mester a rendezett résztömböket rögtön az eredménytömb, azaz az eredeti tömb megfelel® helyére tudja fogadni. Ebben az esetben a fogadó puerre mutató pointer az

a

helyett

a+k

formát veszi fel, ami azt jelenti, hogy az

fogadjuk a rendezett elemeket, az

a

a

tömb

k -ik

helyét®l

tömb közepébe.

DR AF T

13.2. K-átlagú csoportosítás

A bemutatott probléma az adatkezelés és csoportosítás (clustering) témakörébe tartozik. Adott egy nagy adathalmaz amit egy ponthalmaz reprezentál egy sokdimenziós térben

és a feladatunk ezen pontok csoportosítása, azaz olyan csoportok kialakítása, ahogy a csoportban lév® pontok közelebb vannak egymáshoz mint a többi ponthoz. Az egyik lehetséges algoritmus a problémára a k-átlagú csoportosítás (k-means) algoritmusa, amelyik a pontokat

k

csoportba rendezi. Az algoritmus f®bb lépései a következ®k :

I. Kiválasztunk

k

véletlenszer¶ pontot a térben, ezek lesznek a csoportok középpontjai.

II. Minden egyes pontra kiszámítjuk a középpontoktól vett távolságot, és minden pontot abba a csoportba soroljuk, melynek középpontjához a legközelebb esik.

III. Miután létrehoztuk a csoportokat minden csoportra térbeli átlagot számolunk, azaz a csoport számtani középpontját. Ezt úgy tudjuk kiszámolni, hogy minden pont minden egyes dimenziója szerinti elhelyezkedését átlagoljuk.

IV. Ezek az átlag-középpontok adják meg a csoportok új középpontjait. Az eljárást a

2. ponttól folytatjuk mindaddig, amíg nem lesz olyan lépés, amikor egy pont sem vált csoportot, azaz kaptunk egy relaxált megoldást.

A fenti algoritmus párhuzamosítását ugyanazon elvek alapján tudjuk elvégezni mint a

Dijkstra-féle legrövidebb utak algoritmusának vagy a DSATUR színezés párhuzamosítását. A pontok egy részhalmazát fogjuk hozzárendelni minden egyes folyamathoz. A hoz-

zárendelt pontok középpontoktól vett távolságának kiszámítása, majd a legközelebbihez

rendelése függetlenül, tehát párhuzamosan számítható. Értelemszer¶en így minden folyamat számára csak részcsoportok lesznek láthatóak. A csoportok átlag-középpontjait a

következ®képpen számolhatjuk. Minden folyamat külön kiszámolja a részcsoportok átlagközéppontját, majd a mester folyamat összegy¶jti ezeket, és kiszámolja a globális átlag-

középpontokat majd visszaküldi ®ket az összes folyamatnak. Fontos, hogy a lokális átlagközéppontok mellé el kell küldeni azon pontok számosságát is, melyeket ezek az átlag-

középpontok reprezentálnak, mert az átlag számításhoz ezekkel az értékekkel kell súlyoznunk. Tesztelési célból ajánljuk a GraphLab csomag letöltését és fordítását, melyben implementálva van a KMeans++ algoritmus.


http://docs.graphlab.org/clustering.html www.tankonyvtar.hu

278


D dimenziós input generálására adott számosságú központ környezetében. Az inputle sok sornyi adatból fog állni, ahol minden sorban D valós szám található.

A program képes egy

Ez az input jól használható a programunk tesztelésére, ahogy a csomagban implementált KMeans algoritmus változata (a KMeans++) arra, hogy leellen®rizzük és összehasonlítsuk az eredményt. Egy jó k-átlagú csoportosítás algoritmust megvalósító program egy praktikus, sok feladatra használható program. A párhuzamosítás legf®bb erényét abban látjuk, hogy a folyamatok az adatmennyiség csak egy részét kell, hogy a memóriában tartsák. Ez azt jelenti, hogy olyan feladatok is megoldhatóak ezzel az implementációval, melyek egy gép memóri-

DR AF T

ájába nem férnének el. A programozási feladatot BSc szakdolgozat alapjának ajánljuk.

13.3. A Gauss elimináció jobb párhuzamosítása

A project célja, hogy a könyvünkben bemutatott Gauss eliminációnak egy jobb párhuza-

mosítását hozzuk létre. Ahogy láthattuk a bemutatott módszer túl sok kommunikációval

jár, ezt próbáljuk meg csökkenteni. A tárgyalt megoldás a sorok ciklusos bontásával oldot-

ta meg a feladat szétosztását. Most azt ajánljuk, hogy az oszlopok ciklikus felbontásával oldjuk meg a feladatot, minthogy az elimináció mindig egy adott oszlopon belül törté-

nik. Így ha oszloponként osztjuk szét az adatokat, akkor az eliminációs lépés függetlenül történhet minden egyes folyamaton belül.

Csak a pivotáláshoz szükséges kommunikáció, ahol a pivot elemért felel®s folyamat

megkeresi az adott oszlopban a legnagyobb abszolút-érték¶ elemet. Ezek után azt az infor-

mációt küldi szét, hogy mely sorokat kell kicserélni, így minden egyes folyamat megteheti a cserét maga a hozzárendelt oszlopokon belül. Más kommunikációra nincs is szükség, csak a végén, amikor a mester folyamat összegy¶jti a fels®-háromszög mátrixot.

A projekt nehézsége abból adódik, hogy nem szokványos adatábrázolást kell alkalmaz90◦ -al, így

nunk. Javasoljuk, hogy az olvasó képzeletben forgassa el az egész mátrixot

az oszlopokból sorokat kapunk, amit könnyebben tudunk kezelni kétdimenziós tömbben. Fontos, hogy többszörösen ellen®rizzük le a programunk helyességét !

13.4. FFT további párhuzamosítási lehet®ségek

Az FFT példánkban egy egyszer¶ párhuzamosítást alkalmaztunk. A bemen® adatainkat n kiküldtük 2 processzusnak és hagytuk, hogy a különböz® kimeneti részeket kiszámolják. m Mivel minden bemeneti adat meg volt egy processzusnál, 2 kimeneti darabot számít ki minden munkás. Még egyszer, ehhez mindenkinek ki kell osztanunk az összes bemeneti m adatot. Képzeljük el a párhuzamosítás egy másik lehet®ségét. Ha 2 mennyiség¶ bemeneti

adatot osztunk szét (nem mindet !) a processzusoknak, egy bizonyos lépésszámig így is dolgozhatnak. Amikor kész vannak, ezt az adatmennyiséget egy processzusnak elküldhetik, aki ezekb®l további lépésekkel a végs® eredményt számolhatja, amíg csak egy szám marad, ami az

n-edik

kimenet. Ezt a többszint¶ számítást nem csak kett®, de több szinten is

elvégezhetjük, azaz az els® adatcserénél, több, de nem az összes processzus dolgozik a

www.tankonyvtar.hu



279

következ® lépéseken. Tud-e az, hogy nem osztunk ki minden adatot minden processzornak gyorsítani a számoláson ? Tudunk-e spórolni a kommunikáción, ha így a kés®bbiekben (sokkal kevesebb) adatot kell egymás közt kicserélni ? Ez az új implementáció jó példa lehetne arra, hogy más logikával közelítsük meg a megoldást. A többlet kommunikáció a számítás közben kerülend®nek t¶nhet, de ne feledjük, hogy így a teljes bemen® adat leosztását megspórolhatjuk az indulásnál (a mi példánkban a statikus bemenetet minden munkás látja, de sok esetben ennek az üzentekben való kiosztásával kellene kezdenünk).

DR AF T

13.5. Akusztikai példa

A Raytracer példánk a fény 3D-s környezetben való terjedését modellezte. Hasonló feladat

lehetne a hanghullámok 3D-s térben való terjedésének szimulációja. A fény spektrumát három komponensre egyszer¶sítettük (R,G,B) és feltételeztük, hogy a fényforrások kime-

nete id®ben konstans. Képzeljünk el egy hangforrást, amely id®ben változó, különböz® spektrum komponensekb®l álló hangot sugároz. Az id®ben változó jel nem szükséges, de valósabb élményt adna. A spektrumot keskeny-sávú komponensekre vághatjuk (pl. 16 da-

rabra). Minden térbeli objektumra megadhatunk egy reexiós faktort, külön az egyes

keskeny-sávú komponensekre vonatkoztatva. A távolságot is gyelembe vehetjük, hogy

adott pontban szuperponálódó hangot helyesen kapjunk meg. Ezzel az egyszer¶ modellel a térben való hangterjedést modellezhetnénk.

A példát a Raytracer példára építhetnénk, a színeket hangokra cserélve és a terjedési

id®ket is gyelve.

Természetesen alapból a modell úgy nézne ki, mintha a tér hangjait egy ablakon át

hallgatnánk. Egy további lépés lehet, ha egy gömb-szer¶ testet (kocka, tetrahedron, dodecahedron vagy komplexebb) használnánk, ahol a tér egyes pontjaiból jöv® hangokat az egyes felületekre mint ablakokra bees® komponensekb®l raknánk össze.


www.tankonyvtar.hu


DR AF T

280

www.tankonyvtar.hu


DR AF T Harmadik rész Függelék


www.tankonyvtar.hu

DR AF T

14. fejezet

DR AF T

Az MPI keretrendszer installálása

Mivel könyvünk alapvet®en tankönyv azok számára, akik szeretnének az MPI programozással megismerkedni, nem fogunk hosszas részletezésbe bocsátkozni a telepítéssel kapcsolatban. Mindazok számára, akik egy nagyobb rendszert szeretnének installálni és nomhangolni azt ajánljuk, hogy egy komoly tudású rendszergazdát kérjenek fel a feladatra.

Mindazonáltal, ha valaki csak játszani kíván az itt ismertetett lehet®ségekkel, vagy netán egy egyszer¶bb hálózatot felállítani egy kis segítséget szeretnénk biztosítani.

Els®ként szeretnénk megjegyezni, hogy a nagyteljesítmény¶ számítások (HPC High

Performance Computing) világa UNIX világ, gyakran Linux. Kifejezetten nehéz egy Windowsos PC-ket rávenni arra, hogy az egyik a másikon távoli parancsokkal folyamatokat indítson, a biztonsági kérdésekr®l nem is beszélve. (Persze kifejezetten pici méretben, ta-

nulási céllal egy Windows is használható.) Így tehát arra biztatjuk az olvasót, hogy ismerkedjen meg a Linux világával. Nem csak azért, mert ez egy kifejezetten szórakoztató

világ, hanem mert ha érdekesnek találják a könyvünkben bemutatott témát, és szeretnének jobban elmélyedni benne, akkor talán el®bb utóbb lehet®ségük lesz egy szuperszámítógép

használatára a jöv®ben. Egy olyan szuperszámítógép használatára, amin teljesen biztosan egy Linux vagy UNIX fog futni.

Az olvasónak tehát egy Linuxos számítógépre, vagy akár egy csoport Linuxos számí-

tógépre lesz szüksége, hogy kipróbálhassa az MPI-t. Egy modern Linuxon szüksége lesz egy fordító csomagra, általában a

gcc jó választás ehhez, melyet a szokásos csomagkezel®n g++ csomag telepíté-

keresztül tudunk telepíteni. Néhány rendszeren szükséges lesz még a

sére is, ha az olvasó C++ nyelven szeretne programozni. Az MPI programok, könyvtárak és headerek az

openmpi

csomag telepítésével rakhatók fel. Ha az olvasó több számítógé-

openssh-client szükséges a /etc/ssh/

pet is használ, akkor szüksége lesz az ssh kommunikációra is, melyet az és az

openssh-server

csomagok felrakásával biztosíthat, és ha

könyvtárban lév® le-okban kongurálhat.

Ha valakinek nincs hozzáférése egy Linux rendszerhez (bár ma már egy virtuális gépre is könnyedén telepíthet®), akkor Windows alatt használhatja a Cygwyn Unix rendszerét. Ez a programcsomag Windowsra települ, és egy teljes Linux környezetet biztosít a Windows-on belül. De a szerz®k kifejezetten azon a véleményen vannak, hogy ez csak egy félmegoldás, és egy rendes Linux installálás az igazán megfelel®.


www.tankonyvtar.hu

284


14.1. Kommunikáció ssh segítségével Els® tanácsunk : Soha ne használj rsh-t ! Az rsh protokoll nem biztonságos, és ha az olvasó saját környezetet állt fel soha nem szabad, hogy ez az opció akár felmerüljön, mint lehet®ség. (Természetesen speciális HPC környezetek esetén, amit professzionális rendszergazdák állítanak fel és a gépek kívülr®l semmilyen módon nem hozzáférhet®ek lehetséges a használata megfelel® el®vigyázatosság mellett.) Az ssh használata viszont els®re egy kis nehézséget fog okozni. A protokoll megköve-

DR AF T

teli, hogy mindig jelszót adjunk meg. Ahhoz, hogy felülírjuk ezt a viselkedést biztonsági kulcspárt kell létrehoznunk.

El®ször le kell generálnunk a kulcsokat (minden kérdésre igennel yes válaszoljunk,

és hagyjuk a felajánlott paramétereket változatlanul) :

shell$ ssh-keygen -t rsa

Másodszor át kell másolnunk a létrehozott kulcsot a megfelel® helyre :

shell$ cd $HOME/.ssh shell$ cp id_rsa.pub authorized_keys

Meg kell jegyezzük hogy a fenti példa azt feltételezi, hogy a gépek közös le-rendszert

használnak, mint például ahogy az egy egyetemi gépteremben szokás. Ha a használt gépek

felhasználójának home könyvtárai különböznek (tipikus esete mondjuk egy otthoni hálózatnak), akkor a mester gép amin majd az található

id_rsa.pub

mpirun programot futtatjuk le-rendszerén

le-t at kell vinnünk a szolga gépekre és felülírni a felhasználó ot-

tani home könyvtárában lév®

authorized_keys

le-t. Fontos, hogy a felhasználói nevek

azonosak kell, hogy legyenek a rendszereken !

Az ssh tesztelésére a legjobb módszer, ha be-ssh-zunk a másik gépre, és megnézzük,

hogy kér-e az jelszót. (Az els® belépéskor egy yes/no meger®sítést fog kérni !) Az

mpirun

program tesztelésére az olvasó kipróbálhatja mondjuk a következ® parancsot :

mpirun -hostfile hostfile.txt hostname vagy

mpirun -hostfile hostfile.txt date amelyik a

hostname linux parancsot fogja majd lefuttatni a szolga gépeken és kiírni annak

a gép-nevét. Akkor m¶ködik jól, ha különböz® neveket kapunk ! Illetve a második parancs kiírja a távoli gépeken lév® id®t és dátumot. A

-hostfile

kapcsolót kés®bb ismertetjük

majd. Részletesen :

http://www.open−mpi.org/faq/?category=rsh

www.tankonyvtar.hu


14. fejezet. Az MPI keretrendszer installálása

285

14.2. A programok futtatása egy gépen A programok fordításához mindig egy mpi fordító wrapper programmal kell elvégezzük. Ez a program fogja meghívni magát a fordítót (a gcc-t, icc-t vagy más fordítót), és linkeli össze a programot a szükséges könyvtárakkal. Minden nyelvhez egy adott wrapper tartozik, a C++ nyelvhez, amit a könyvünkben használunk, általában az

mpicxx

program. C kódokhoz általában az

mpicc,

Fortranhoz az

mpif77

mpic++ vagy az

vagy az

mpif90

programok használhatóak. A kapcsolók ugyanazok, mint amit a fordítónak adnánk meg. A

g++

fordítónál ezek általában a

-O3

az optimalizációhoz, illetve a

-o,

hogy elnevezzük

DR AF T

a futtatható állományt.

Egyedi gépen nem kell külön foglalkoznunk a kommunikációval. A programunkat az

mpirun

paranccsal tudjuk futtatni, és a

-np

kapcsolóval, melynek egy szám paramétert

adunk át, állíthatjuk be, hogy hány folyamat induljon. Ha például 4 folyamatot szeretnénk elindítani, akkor a következ® parancsot adjuk ki :

mpirun -np 4 ./test_program.out.

Ha csak tesztelésre használjuk a futtatást, akkor a gépünkben lév® magok száma nem

igazán fontos. Könnyedén lehet mondjuk 51 folyamatot indítani így egy 2 magos gépen.

Természetesen sebességben nem nyerünk vele, s®t, valójában a programunk lassabban fog futni. Másfel®l sokszor szükség van kimerít® tesztelésre, és ezekben az esetekben az

mpirun

ezen kapcsolója kifejezetten hasznos tud lenni.

14.3. A programok futtatása több gépen

Ha az olvasónak több gép áll a rendelkezésére, például egy egyetemi gépterem, akkor a

kommunikáció beállítása után, ahogy azt fentebb már részleteztük, meg kell mondanunk az

mpirun

parancsnak, hogy mely gépeket kívánjuk használni. Erre a célra egy egyszer¶

szöveges hostle-ra lesz szükségünk, amely minden sorában egy gépnevet, és ha szükség

van rá a processzorok (magok) számát adja meg az adott gépben. Egy lehetséges hostle a következ® lehet :

lab-201b-1 lab-201b-2 lab-201b-3 lab-201b-4 lab-201b-5 lab-201b-6

cpu=2 cpu=2 cpu=2 cpu=2 cpu=2 cpu=2

Tehát 6 gépet szeretnénk használni, és mindegyikben 2 mag van. A parancs, amit kiadunk :

mpirun -hostfile hostfile.txt ./test_program.out.

Az

mpirun

program a

hostle-ból fogja meghatározni, hogy összesen hány példányt kell majd futtatni a kívánt programból és hol. A

-hostfile és az -np kapcsolók használata egyszerre tehát értelmet-

len.


www.tankonyvtar.hu

286


14.4. Szuperszámítógépes használat Ha az olvasó szuperszámítógépet használ, akkor az olvasó a gép dokumentációját kell, hogy megismerje els® sorban, ami leírja a konkrét használat módját. Általában a programokat ugyanazzal a wrapperrel kell fordítani, például az

mpic++ paranccsal. A programok futta-

tása azonban különbözik a PC-t®l, mivel a szuperszámítógépeken külön feladatütemez®k, feladatsorok vannak, melyek számlázzak és irányítják a gép használatát. A felhasználónak általában egy rövid shell scriptet kell írnia példascriptek mindig vannak a dokumentációban , és beküldenie a scriptet a batch sorba egy speciális paranccsal. Erre is találhatóak

DR AF T

példák a dokumentációban.

A mi esetünkben (a Mandelbrot halmaz második verziójának 192 processzoron történ®

futtatására) a következ®

mpi-2.sh

nev¶ scriptet használtuk :

#!/bin/sh #$ -N Mandel-2-192 mpirun -np $NSLOTS ./mandel2 mandel-2-192.ppm

mandel2, a munkamenet (job) neve Mandel-2-192 volt. A Mandel-2-192.o57979 le-ba került, lévén egy szuperszámítógépen a kimenet

A végrehajtható le neve

kimenet a

nem kerülhet a képerny®re, hanem át van irányítva egy le-ba.

Végezetül a következ® paranccsal küldtük be az ütemez®nek a feladatot :

qsub -l h_rt=0:5:0 -pe mpi 192 mpi-2.sh

amivel azt mondtuk a rendszernek, hogy indítson egy 192 folyamatból álló mpi jobot 5 perces futási id®limittel.

www.tankonyvtar.hu


15. fejezet

DR AF T

MPI függvények 15.1. Kommunikáció

Ez a fejezet röviden összefoglalja az MPI OpenMPI implementációjának alapvet® kommunikációs függvényeit.

15.1.1. Blokkoló és nem blokkoló

Az MPI környezetben alapvet®en kétféle kommunikáció van. A blokkoló és a nem blokkoló.

A blokkoló megoldások nem térnek addig vissza, amíg a kommunikáció le nem zajlott, azaz blokkolják a végrehajtást. Ez egy biztonságos módszer, biztosak lehetünk benne, hogy az

adatok átküldésre kerültek az utasítások visszatérése után. A legtöbb esetben ezt a mód-

szert használjuk, bár a nem blokkoló módszereknek is van el®nye. Bár egy nem blokkoló eljárás nem garantálja az adatok átérkezését, így ezt külön erre való MPI függvényekkel vizsgálnunk kell, a küldést és a további program futtatást párhuzamosan vihetjük véghez.

Elindíthatunk egy átvitelt, közben számolhatunk valamit, és leellen®rizhetjük, hogy az átvitel végzett-e. Ilyen módon nekünk kell az ellen®rzéssel foglalkoznunk, viszont az átfedés miatt a hatékonyságot növelhetjük.

15.1.2. Küldés

Ez a függvény az üzenetek szabvány blokkoló küldése. Addig vár, míg az üzenetet el nem küldte (amíg a send buer -t nem lehet használni), innen a

blokkoló elnevezés.

int MPI_Send( void *buffer, //Küld® puffer címe int count, //Elemek száma a küld® pufferben MPI_Datatype datatype, //A küld® puffer tartalmának adattípusa c Várady Géza, Zaválnij Bogdán, PTE

www.tankonyvtar.hu

288


int dest, //A cél rangja int tag, //Üzenet jelöl® (tag) MPI_Comm comm //Kommunikátor )

DR AF T

http://www.open−mpi.org/doc/current/man3/MPI_Send.3.php

puerelt MPI_Bsend

Ez a b uerelt küldés. Egy felhasználói puer területet használ az üzenet átmeneti tárolására. Ezért küldéskor, száz-százalékig biztos, hogy a felhasználói puer az MPI puerbe másolódott. A felhasználói puert az

MPI_Buffer_Attach()

függvénnyel hozhatjuk létre

(15.1.2). A puerelt küldést kerüljük, majdnem minden MPI implementációban késleltetést hoznak be.

int MPI_Bsend( void *buffer, //Küld® buffer címe int count, //Elemek száma a küld® bufferben MPI_Datatype datatype, //A küld® puffer tartalmának adattípusa int dest, //A cél rangja int tag, //Üzenet jelöl® (tag) MPI_Comm comm //Kommunikátor )

http://www.open−mpi.org/doc/current/man3/MPI_Bsend.3.php

MPI_Ssend

Ez az üzenet küldési módszer nem fejez®dik be, amíg a másik oldalon egy fogadás meg nem történt. Ez miatt ez az eljárás egy páronkénti szinkronizációs m¶velet.

int MPI_Ssend( void *buffer, //Küld® puffer címe int count, www.tankonyvtar.hu


15. fejezet. MPI függvények

289

DR AF T

//Elemek száma a küld® pufferben MPI_Datatype datatype, //A küld® puffer tartalmának adattípusa int dest, //A cél rangja int tag, //Üzenet jelöl® (tag) MPI_Comm comm //Kommunikátor )

http://www.open−mpi.org/doc/current/man3/MPI_Ssend.3.php

MPI_Isend

Az azonnali küldés el®készíti és indítja a küldést, majd azonnal visszatér. A vezérlést

nagyon gyorsan visszakapjuk és dolgozhatunk tovább, de tesztelnünk kell, hogy az átvitel

MPI_Wait eljárással tehetjük meg. Az MPI_Isend után MPI_Wait megegyezik egy MPI_Send hívással. Ha ezt szétválasztjuk kett®

megtörtént-e vagy sem. Ezt majd a rögtön kiadott

felé, akkor a küldéssel párhuzamosan egyéb tevékenységeket végezhetünk a kódunkban. Valamikor azonban elérünk egy olyan pontra a végrehajtásban, ahol már biztosak akarunk lenni abban, hogy a küldött adatok átmentek, így egy

MPI_Wait-el

megvárjuk ezt.Ezzel a

módszerrel a küldés közben is dolgozhatunk, tovább gyorsítva a munkát.

int MPI_ISend( void *buffer, //Küld® puffer címe int count, //Elemek száma a küld® pufferben MPI_Datatype datatype, //A küld® puffer tartalmának adattípusa int dest, //A cél rangja int tag, //Üzenet jelöl® (tag) MPI_Comm comm //Kommunikátor MPI_Request *request //Kommunikációs kérés )

A kommunikációs kérés kezel®vel (handle ) követhetjük a kommunikáció státuszát vagy várhatunk arra, hogy végbe menjen.

http://www.open−mpi.org/doc/current/man3/MPI_Isend.3.php c Várady Géza, Zaválnij Bogdán, PTE

www.tankonyvtar.hu

290


MPI_Rsend Ez a r eady küldés. Az üzenetet azonnal elküldjük, feltételezve, hogy a túloldalon a megfelel® fogadási parancs már kiadásra került. A kódot úgy kell el®készíteni, hogy a fogadó oldali puer már készen álljon amikor küldünk.

DR AF T

int MPI_Rsend( void *buffer, //Küld® puffer címe int count, //Elemek száma a küld® pufferben MPI_Datatype datatype, //A küld® puffer tartalmának adattípusa int dest, //A cél rangja int tag, //Üzenet jelöl® (tag) MPI_Comm comm //Kommunikátor )

http://www.open−mpi.org/doc/current/man3/MPI_Rsend.3.php

Felhasználói puer

A nem blokkoló kommunikációhoz felhasználó által deniált puer terület szükséges. A puer terület lefoglalása után a küld® ezt az MPI környezethez kötheti, hogy onnan használni lehessen. Ezt az

MPI_Buffer_attach()

függvénnyel lehet megtenni.

int MPI_Buffer_attach( void *buffer, //Küld® puffer címe int size, //puffer mérete bájtokban )

http://www.open−mpi.org/doc/current/man3/MPI_Buffer_attach.3.php

Felhasználói puer leválasztása

Ezzel a funkcióval leválaszthatjuk az el®z®leg hozzárendelt puert az MPI környezetr®l.

int MPI_Buffer_detach( void *buffer, //Küld® puffer címe www.tankonyvtar.hu



291

int *size, //puffer mérete bájtokban ) http://www.open−mpi.org/doc/current/man3/MPI_Buffer_detach.3.php

MPI_Wait Az eljárás az MPI kérés (request teljesülésére vár. Ezt a kérést pl. a

ISend()(15.1.2) küldte

DR AF T

el®zetesen. A hívó futása ezen a ponton áll, míg az MPI kérés nem teljesül.

int MPI_Wait( MPI_Request *request //Kommunikációs kérés MPI_Status *status //Státusz objektum )

http://www.open−mpi.org/doc/current/man3/MPI_Wait.3.php

MPI_Test

A megadott küldés vagy fogadás teljesülését tesztelhetjük ezzel a függvénnyel. A háttérben zajló átvitelr®l kaphatunk információt és ennek a függvényében végezhetünk tovább egyéb tevékenységet.

int MPI_Test( MPI_Request *request //Kommunikációs kérés handle int *flag //Igaz, ha kész a m¶velet MPI_Status *status //Státusz objektum )

http://www.open−mpi.org/doc/current/man3/MPI_Test.3.php

MPI_Cancel

Egy el®z®leg indított MPI kommunikációs kérést szakíthatunk meg ezzel a függvénnyel. Pl. akkor lehet hasznos, ha egy hosszabb adatküldést indítottunk az

MPI_Isend-el és még

sincs szükségünk az adatokra (mert pl. már mástól megkaptuk).

int MPI_Wait( MPI_Request *request //Kommunikációs kérés ) c Várady Géza, Zaválnij Bogdán, PTE

www.tankonyvtar.hu

292


http://www.open−mpi.org/doc/current/man3/MPI_Cancel.3.php 15.1.3. Fogadás Az

MPI_Recv függvény az MPI_Send párja. A feladata az üzenetek blokkoló fogadása. Addig

vár, amíg az üzenet meg nem érkezik, ez miatt nevezzük blokkoló nak. A kimenetei a fogadó

buer címe, és a státusz objektum status, amely struktúra a következ® mez®kb®l áll :

MPI_SOURCE

a küld® processzus azonosítója

DR AF T

MPI_TAG

MPI_ERROR

üzenet jelöl® (tag ) hiba státusz

int MPI_Recv( void *buffer, //Fogadó puffer címe int count, //Elemek száma a fogadó pufferben MPI_Datatype datatype, //A fogadó puffer tartalmának adattípusa int source, //Forrás rangja int tag, //Üzenet jelöl® (tag) MPI_Comm comm, //Kommunikátor MPI_Status *status //Státusz objektum )

http://www.open−mpi.org/doc/current/man3/MPI_Recv.3.php

Nem blokkoló, azonnal fogadás Az

MPI_Irecv függvény az MPI_Isend párja. A feladata az, hogy jelezze az üzenet fogadá-

sának azonnali igényét. A visszatérése egy státusz objektum, ami a következ® elemekb®l áll :

MPI_SOURCE

MPI_TAG

MPI_ERROR

a küld® processzus azonosítója

üzenet jelöl® (tag ) hiba státusz

www.tankonyvtar.hu



293

DR AF T

int MPI_Irecv( void *buffer, //Address of recieve puffer int count, //Elemek száma a fogadó pufferben MPI_Datatype datatype, //A fogadó puffer tartalmának adattípusa int source, //Forrás rangja int tag, //Üzenet jelöl® (tag) MPI_Comm comm, //Kommunikátor MPI_Status *status //Státusz objektum MPI_Request *request //Communicatin request )

http://www.open−mpi.org/doc/current/man3/MPI_Irecv.3.php 15.1.4. KüldésFogadás SendReceive Az

MPI_Sendrecv

függvény egyszerre küld is és fogad is üzenetet. Ez a funkció hasznos

lehet, amikor láncban akarunk adatokat processzusok között átadni. Az

MPI_Recv-el ellentétben, nem kell gyelnünk a küldés

MPI_Send-el

és

és fogadás párok helyes sorrendjére.

Az MPI kommunikációs alrendszere lekezeli helyettünk ezt a feladatot. A függvény képes

MPI_Send

és

MPI_Recv

függvényekkel üzenetet váltani.

int MPI_Sendrecv( void *sendbuf, //Küld® puffer címe int sendcount, //Elemek száma a küld® pufferben MPI_Datatype sendtype, //A pufferben lév® elemek adattípusa int dest, //A cél rangja int sendtag, //Üzenet jelöl® (tag) void *recvbuf, //Fogadó puffer címe int recvcount, c Várady Géza, Zaválnij Bogdán, PTE

www.tankonyvtar.hu

294


DR AF T

//A fogadó pufferben lév® elemek száma MPI_Datatype recvtype, //A fogadó pufferben lév® elemek adattípusa int source, //Forrás rangja int recvtag, //Üzenet jelöl® (tag) MPI_Comm comm //Kommunikátor MPI_Status *status //Státusz objektum )

http://www.open−mpi.org/doc/current/man3/MPI_Sendrecv.3.php 15.1.5. Többesküldés Broadcast Az

MPI_Bcast() függvény count

számú datatype típusú adatot küld ki a buer -b®l, a root

processzustól minden további processzushoz a comm kommunikátorba. Ezzel a függvénnyel ugyan azt az adatot küldhetjük el minden másik processzusnak egyszerre. Mivel a kommu-

nikáció egy fa struktúrában zajlik, sokkal hatékonyabb, mintha mindenkinek elküldenénk az üzenetet egy ciklusban.

int MPI_Bcast( void *buffer, //küld® puffer címe int count, //Elemek száma a küld® pufferben MPI_Datatype datatype, //A küld® puffer tartalmának adattípusa int root, //A küld® processzus rangja MPI_Comm comm //Kommunikátor )

http://www.open−mpi.org/doc/current/man3/MPI_Bcast.3.php

15.2. Redukció Reduction

A redukció kifejezés egy számhalmaz kisebb halmazokra, gyakran egytagú halmazokra való felbontására utal, melyet valamilyen m¶velettel oldunk meg. Pl. az összeadás egy összeadási m¶velettel elvégzett redukció. Az elosztott adatokon való redukció nulláról való

www.tankonyvtar.hu



295

implementációja bonyolult feladat lenne. Szerencsére az MPI ezt a funkcionalitást már tartalmazza.

15.2.1. Csökkentés Reduce

MPI_Reduce() függvénnyel elemi redukálást valósíthatunk meg. A részt vev®k sendbuf helyi pueréb®l count darab datatype típusú adaton egy globális m¶veletet végez az op m¶velettel és a kimenetét a hívó helyi root recvbuf puerébe teszi. Az

DR AF T

int MPI_Reduce( void *sendbuf, //Küld® puffer címe void *recvbuf, //Fogadó puffer címe (csak a gyökérben érdekes) int count, //Elemek száma a küld® pufferben MPI_Datatype datatype, //A pufferben lév® elemek adattípusa MPI_Op op, //Redukció m¶velet int root, //A fogadó processzus rangja MPI_Comm comm //Kommunikátor )

http://www.open−mpi.org/doc/current/man3/MPI_Reduce.3.php 15.2.2. Teljes redukció All-reduce Az

MPI_Allreduce()

függvény hasonlóan m¶ködik mint az el®z®, de minden résztvev®

megkapja az eredményt. A

sendbuf

használ, hogy végrehajtsa a globális

helyi puerb®l

op

count

datatype típusú adatot munkás recvbuf-ébe vissza-

darab

m¶veletet és minden

küldje az eredményt.

int MPI_Allreduce( void *sendbuf, //Küld® puffer címe void *recvbuf, //Fogadó puffer címe (csak a gyökérben érdekes) int count, //Elemek száma a küld® pufferben MPI_Datatype datatype, //A pufferben lév® elemek adattípusa c Várady Géza, Zaválnij Bogdán, PTE

www.tankonyvtar.hu

296


MPI_Op op, //Redukció m¶velet MPI_Comm comm //Kommunikátor )

DR AF T

http://www.open−mpi.org/doc/current/man3/MPI_Allreduce.3.php

15.2.3. Scan redukció Scan reduce Az

MPI_Scan() egy i processzus 0

és az

0. . . n processzusunk, 0. . . i processzusok Op m¶veletet végezzük el a 0. . . i

bennfoglaló prex redukciót végez el. Ha van

és

n

közötti, akkor a

i

rangú processzus kapja a

adatain végzett redukció eredményét. Más szavakkal, a processzusok adatain és a

i

fogadó puerébe tesszük az eredményt.

int MPI_Scan( void *sendbuf, //Küld® puffer void *recvbuf, //Fogadó puffer int count, //Elemek száma a bemen® pufferben MPI_Datatype datatype, //Adatok típusa a bemen® pufferben MPI_Op op, //M¶velet MPI_Comm comm //Kommunikátor )

http://www.open−mpi.org/doc/current/man3/MPI_Scan.3.php

15.2.4. Operátorok A következ® operátorok

op

paraméterként szerepelhetnek a fent említett MPI redukálási

függvényekben.

www.tankonyvtar.hu



297

15.1. táblázat. Az MPI redukálás operátorai maximum minimum szumma szorzás logikai ÉS bináris ÉS logikai VAGY bináris VAGY

DR AF T

MPI_MAX MPI_MIN MPI_SUM MPI_PROD MPI_LAND MPI_BAND MPI_LOR MPI_BOR MPI_LXOR MPI_BXOR MPI_MAXLOC MPI_MINLOC

logikai XOR

bináris XOR

MAX érték és pozíció MIN érték és pozíció

Minimum és maximum pozíció

Létezik két speciális redukálási m¶velet ami dupla értékekkel dolgozik. A a

MPI_MINLOC.

MPI_MAXLOC

és

Az adatpár els® tagját kezeljük úgy, mint amit össze kell hasonlítani a

szétszórt többi adatokkal. A második érték pedig egy index, azaz ez mutatja majd az eredményadat pozícióját. A

MPI_MAXLOC


u v w ? = , i j k

ahol

w = max(u, v),

és

  i min(i, j) k=  j

A

MPI_MINLOC

if if

if

u>v u=v u

w u v ? = , i j k

ahol

w = min(u, v),

és

  i min(i, j) k=  j c Várady Géza, Zaválnij Bogdán, PTE

if if if

uv www.tankonyvtar.hu

298

Bevezetés az MPI programozásba példákon keresztül 15.2. táblázat. Dupla változó típusok

MPI_FLOAT_INT MPI_DOUBLE_INT MPI_LONG_INT MPI_2INT MPI_SHORT_INT MPI_LONG_DOUBLE_INT

float és int double és int long és int int pár short és int long double és int

DR AF T

Speciális dupla adattípusok A fent leírt

MPI_MAXLOC

és

MPI_MINLOC

függvények dupla adattípusokat használnak. A

lenti táblázatban az MPI beépített dupla változó típusait láthatjuk.

Ahhoz, hogy használni tudjuk ®ket, el®ször konstruálni kell egy struktúrát, mint a Dijk-

stra legrövidebb út algoritmusának példájában is tettük. Az

a küldö puer

01 : 02 : 03 : 04 : 05 : 06 : 07 :

p

lesz, a fogadó puer

p_tmp

MPI_Allreduce függvényben

lesz.

struct{

int dd ; int xx ;

} p, tmp_p ;

p.dd=tmp ; p.xx=x ;

MPI_Allreduce(&p,

&tmp_p,

1,

MPI_2INT,

MPI_MINLOC,

MPI_COMM_WORLD) ;

08 : 09 : 10 : 11 :

x=tmp_p.xx ;

D[x]=tmp_p.dd ;

15.3. A kommunikációs topológia dinamikus változtatása

Bizonyos esetekben, mint pl. az FFT példánkban (10.3.2) adott számú processzort szeretnénk használni, vagy adott csoport processzorait szeretnénk használni. Ehhez az MPI egyes csoport és kommunikátor függvényeit használhatjuk, melyekb®l mi a következ®kben leírtakat használtuk.

www.tankonyvtar.hu



299

15.3.1. Egy kommunikátorhoz rendelt csoport lekérdezése Ez a függvény visszaadja a csoportot, ami a

comm

kommunikátorhoz tartozik.

DR AF T

int MPI_Comm_group( MPI_Comm comm, //Kommunikátor MPI_Group *group //A kommunikátorhoz tartozó csoport ) http://www.open−mpi.org/doc/current/man3/MPI_Comm_group.3.php 15.3.2. Új csoport létrehozása kizárással

Ez a függvény egy új csoportot hoz létre (newgroup) a tagokból úgy, hogy

n

darab tar-

tományt (hármas értékek : els® rang, utolsó rang, lépésköz) kizár a meglév® csoportból (group, 15.3.1). A lépésköz (stride ) értékkel lépünk a tartomány kezd® és végpontjai kö-

zött. Más szóval, a processzusok egy új csoportját hozzuk létre úgy, hogy kizárunk párat.

int MPI_Group_range_excl( MPI_Group group, //Csoport int n, //A számhármasok darabszáma int ranges[][3], //Számhármasok tömbje MPI_Group *newgroup //Új csoport )

http://www.open−mpi.org/doc/current/man3/MPI_Group_range_incl.3.php 15.3.3. Kommunikátor létrehozása csoportból

Ez a függvény egy új kommunikátort hoz létre (newcomm) a (group) csoport és a régi kommunikátor (comm) segítségével. A

group

csoportot akár a

MPI_Group_range_excl

függ-

vénnyel is létrehozhatjuk (15.3.2). Ha egy processzus a csoport tagja, az új kommunikátort

(newcomm) kapja visszatérési értéknek, ha nem tagja, akkor ez az érték MPI_COMM_NULL.

int MPI_Comm_create( MPI_Comm comm, //Kommunikátor MPI_Group group, c Várady Géza, Zaválnij Bogdán, PTE

www.tankonyvtar.hu

300


//Csoport, amely a comm alcsoportja MPI_Comm *newcomm //Az új kommunikátor ) http://www.open−mpi.org/doc/current/man3/MPI_Comm_create.3.php

DR AF T

15.4. Vegyes függvények 15.4.1. Inicializálás

Ahhoz, hogy az MPI funkciókat használni tudjuk, el®ször inicializálnunk kell az MPI környezetet az

MPI_Init()

függvénnyel. Az

argc

és

argv

paraméterek a

main()

függvény

paramétereire mutatnak.

int MPI_Init( int *argc, //A main() függvény argc paraméterére mutat char ***argv //A main() függvény argv paraméterére mutat )

http://www.open−mpi.org/doc/current/man3/MPI_Init.3.php 15.4.2. Rang lekérdezése

Minden futó processzusnak (munkásnak) van egy rangja (rank ) a csoportjában, ami a kommunikátorhoz tartozik. Ez a rank rang felhasználható arra, hogy egyedileg azonosítsuk

a processzust a kommunikátorban.

int MPI_Comm_rank( MPI_Comm comm, //Kommunikátor int *rank //A hívó processzus rangja a com kommunikátorban )

http://www.open−mpi.org/doc/current/man3/MPI_Comm_rank.3.php 15.4.3. Méret lekérdezése Az

MPI_Comm_size()

függvény az adott kommunikátorhoz kötött csoport méretét adja

vissza. Ez praktikus információ a csoportunkról, azaz a munkások számáról, akikkel együtt dolgozhatunk.

www.tankonyvtar.hu



301

int MPI_Comm_size( MPI_Comm comm, //Kommunikátor int *size //A comm csoportban lév® processzusok száma ) http://www.open−mpi.org/doc/current/man3/MPI_Comm_size.3.php

DR AF T

15.4.4. Lezárás Az

MPI_Finalize() függvény lezárja az MPI indítási környezetet. Ezek után a processzu-

sok futása nem deniált, nincs róluk az MPI-ban információnk. A legjobb választás ezek után a processzusokat is leállítani, bár lehetséges ®ket tovább futtatni és nem MPI-al kap-

csolatos tevékenységet végeztetni velük. Semmilyen MPI függvényt nem lehet hívni ezen függvény meghívása után.

int MPI_Finalize()

http://www.open−mpi.org/doc/current/man3/MPI_Finalize.3.php 15.4.5. Megszakítás A

comm

kommunikátorhoz tartozó összes processzus futását megszakítja. A függvény nem

ad visszatérési értéket. Ez egy vészleállás, helyette a

MPI_Finalize() használata ajánlott.

int MPI_Abort( MPI_Comm comm //Kommunikátor int errorcode //Hibakód amit a hívó környezet felé adunk vissza ) http://www.open−mpi.org/doc/current/man3/MPI_Abort.3.php 15.4.6. Korlát Az

MPI_Barrier

függvény blokkolja a hívó processzusok további futását amíg mindegyik

processzusunk le nem futtatja ezt a hívást, azaz ehhez a ponthoz nem ér a végrehajtásban.

int MPI_Barrier( MPI_Comm comm //Kommunikátor ) c Várady Géza, Zaválnij Bogdán, PTE

www.tankonyvtar.hu

302

Bevezetés az MPI programozásba példákon keresztül A korlátok (barrier ) használata elterjedt az osztott memóriás környezetekben, mivel a

közös hozzáférés¶ adatok olvasása hibalehet®séget rejthet, ha valamely processzusunk még m¶veletet végez ezzel az adattal. Egy elosztott környezetben a küldés-fogadás függvények szinkronban tartják az egyes processzusokat, így a példáinkban az

MPI_Barrier függvényt

ritkán, ha egyáltalán kell használni. Néha tesztelési céllal használjuk, pl. futási id®k mérése el®tt az adminisztratív tevékenységeket szinkronban tarthatjuk vele és tisztán a számítási id®ket tudjuk mérni.

http://www.niif. hu/en/node/311 címen Miért lassulnak le az MPI programok ? címmel. http://www.open−mpi.org/doc/current/man3/MPI_Barrier.3.php

DR AF T

Érdemes kerülni a függvény használatát. Err®l van egy jó cikk a

15.4.7. Eltelt id® Wall time Az

MPI_WTime egy valamikori múltbéli esemény óta eltelt id®t adja meg másodpercekben.

A processzus futása során ez a valamikor esemény nem változik, így ezt az id®t többször

lekérve és egymásból kivonva az id®lekérések közötti tevékenységeink futásához szükséges id®t kaphatjuk meg.

double MPI_Wtime()

Az eltelt id®t adja meg másodpercekben.

http://www.open−mpi.org/doc/current/man3/MPI_Wtime.3.php

15.5. Adattípusok

A szabványos MPI alap adattípusokat el®re deniál C-ben, mint pl. az int (MPI_INT),

el®jeles long int (MPI_LONG), és a C további alap adattípusai. Ha különböz® adattípu-

sokat szeretnénk küldeni, több lehet®ségünk is van. A legegyszer¶bb lehet®ségünk, hogy a különböz® adattípusokat különböz® üzenetekben küldjük át. Másik lehet®ségünk, hogy az

MPI_Pack

függvénnyel különböz® típusokat egy puerbe helyezzünk és egyszerre elküld-

jük. További lehet®ségünk, hogy az

MPI_BYTE

típust használjuk, és bájtonként küldjük át

az adatunkat. A két utóbbi esetben azonban elveszíthetjük a hordozhatóságot. További

lehet®ségek kapcsán (amikre erre a könyvünkben nem térünk ki)a derived datatypes részt

ajánljuk az MPI szabványból. Ez a haladó technika speciális adatszerkezetek létrehozását teszi lehet®vé futási id®ben. Ezt egy vegyes típusokból álló template -ként is tekinthetjük.

1

Az alap MPI adattípusokat a táblázatban láthatjuk (15.3).

1 Ez

a leírás a 3.0 szabvány szerinti, így lehetséges, hogy szerepelnek benne az olvasó MPI megvalósításában még nem elérhet® adattípusok is. www.tankonyvtar.hu



303

15.3. táblázat. MPI alapvet® adattípusok

MPI_CHAR

char (nyomtatható karakterként kezelve)

signed signed signed signed signed signed

short int int long int long long int long long int char

DR AF T

MPI_SHORT MPI_INT MPI_LONG MPI_LONG_LONG_INT MPI_LONG_LONG (szinonímaként) MPI_SIGNED_CHAR

(egész értékként kezelve)

MPI_UNSIGNED_CHAR

unsigned char

(egész értékként kezelve)

MPI_UNSIGNED_SHORT MPI_UNSIGNED MPI_UNSIGNED_LONG MPI_UNSIGNED_LONG_LONG MPI_FLOAT MPI_DOUBLE MPI_LONG_DOUBLE MPI_WCHAR

unsigned short int unsigned int unsigned long int unsigned long long int float double long double wchar_t

(a <stddef.h>-ban deniálva)

(nyomatatható karakterként kezelve)

MPI_C_BOOL MPI_INT8_T MPI_INT16_T MPI_INT32_T MPI_INT64_T MPI_UINT8_T MPI_UINT16_T MPI_UINT32_T MPI_UINT64_T MPI_C_COMPLEX MPI_C_FLOAT_COMPLEX (szinonímaként) MPI_C_DOUBLE_COMPLEX MPI_C_LONG_DOUBLE_COMPLEX MPI_BYTE MPI_PACKED


_Bool int8_t int16_t int32_t int64_t uint8_t uint16_t uint32_t uint64_t float _Complex float _Complex double _Complex long double _Complex

www.tankonyvtar.hu


DR AF T

304

www.tankonyvtar.hu


Irodalomjegyzék Akl, S.G. Parallel Sorting Algorithms. Academic Press. 1985.

[Braw1989]

Brawer, S. Introduction to Parallel Programming. Academic Press. 1989.

[Brel1979]

Brélaz, D. New Methods to Color the Vertices of a Graph. In : Communica-

DR AF T

[Akl1985]

tions of the ACM. 1979. Volume 22. Number 4. pp. 251257.

[Corm2009] Cormen, T.H., Leiserson, C.E., Rivest, R.L. and Stein, C. Introduction to

Algorithms. 3rd ed. MIT Press and McGraw-Hill. 2009.

[Cool1965]

Cooley, J.W. and Tukey, J.W. An algorithm for the machine calculation of

complex Fourier series. In : Mathematics of Computation. 19. pp. 297-301, 1965.

[Dijk1959]

Dijkstra, E.W. A note on two problems in connexion with graphs. In : Numerische Mathematik 1. pp. 269271. 1959.

[Gram2003] Grama, A., Gupta, A., Karypis, G. and Kumar, V. Introduction to Parallel

Computing. 2nd ed. Addison Wesley. 2003.

[Hilb2013a]

Hilbert, S. FFT Zero Padding. BitWeenie, DSP resource page. 2013.

//www.bitweenie.com/listings/fft−zero−padding/

[Hilb2013b]

Hilbert,

S.

A DFT and FFT TUTORIAL.

Alwayslearn,

http:

SoundAnaly-

Project page. 2013. http://alwayslearn.com/DFT%20and%20FFT% 20Tutorial/DFTandFFT_BasicIdea.html ser

[Ivanyi2013] Iványi P. and Radó J. El®feldolgozás párhuzamos számításokhoz Tankönyvtar, 2013.

[Kan1998]

Kanevsky, S.A.Y. and Rounbehler, A.Z. MPI/RT an emerging standard for

high-performance real-time systems HICSS, pp. 157166. 1998.

[Karn2003]

Karniadakis, G.E. and Kirby, R.M. Parallel Scientic Computing in C++

and MPI. Cambridge UP. 2003. [Lyons2004] Lyons, R.G. Understanding Digital Signal Processing. Second Edition. Prentice Hall. 2004.


www.tankonyvtar.hu

306


[McCo2012] McCool, M., Robison, A.D. and Reinders, J. Structured Parallel Program-

ming. Patterns for Ecient Computation. Elsevier. 2012. [Matt2005]

Mattson, T.G., Sanders, B.A. and Massingill, B.L. Patterns for Parallel

Programming. Addison-Wesly. 2005. [MPI2012]

Message Passing Interface Forum. MPI : A Message-Passing Interface Stan-

dard. Version 3.0. 2012. [Pet2004]

Petersen, W.P. and Arbenz, P. Introduction to Parallel Computing. A prac-

DR AF T

tical Guide with Examples in C. Oxford UP. 2004.

[PovRay]

PovRay

Persistence

of

Vision

Raytracer.

org/documentation

[Sima1997]

http://www.povray.

Sima, D., Fountain, T. and Kacsuk, P. Advanced Computer Architectures : A

Design Space Approach. Addison Wesley. 1997.

[Szab2012a] Szabó S. A Non-Conventional Coloring of the Edges of a Graph. Open Jour-

nal of Discrete Mathematics, 2012, 2, 119-124 doi :10.4236/ojdm.2012.24023 Published Online October 2012. (http ://www.SciRP.org/journal/ojdm)

[Szab2012b] Szabó S. and Zaválnij B. Greedy Algorithms for Triangle Free Coloring. AKCE Int. J. Graphs Comb., 9, No. 2 (2012), pp. 169-186.

[Weisst]

Weisstein, E.W. Discrete Fourier Transform. From MathWorldA Wolfram Web Resource.

http://mathworld.wolfram.com/DiscreteFourierTransform.html

www.tankonyvtar.hu


Bevezetés az MPI programozásba példákon keresztül január 16. DRAFT

Recommend Documents