Bevezetés a párhuzamos programozás OpenMP c Intel® szoftver
Nem titok, hogy a „megahertz faj”, amely sok éven át maradt a fő módja, hogy javítsa a processzor teljesítményét váltotta a tendenciája a magok száma. Nagyjából elmondható, hogy a processzor gyártók megtanulták, hogy egyetlen lapkán több processzor. Most szinte minden számítógép rendelkezik egy multi-core processzor. Még belépő szintű asztali rendszerek két mag - mondanom sem kell, hogy a megközelítés négy- és nyolcmagos rendszert. Ha Moore törvénye nem veszíti érvényét, 5 évig, az átlagos számítógép lesz 16, vagy akár 32 magot a chip.
A probléma az, hogy a szoftver-ipar még nem lépést tartani a hardver, és csak egy része az alkalmazás képes hatékonyan felhasználni a forrásokat a többmagos processzorok. Minden program egy fő végrehajtási szál - egy sor utasítást, amelyek végre egymás után. Természetesen ebben az esetben is részt vesz egy processzor magot. A programozónak kell gondoskodni a rakodási művelet a többi magok, más szóval, meg kell győződnie arról, hogy egyes utasításokat nem vitték végig következetesen, és ugyanabban az időben - párhuzamosan.
Érdemes megjegyezni, hogy a teljesítmény nem lineárisan nő a magok száma. Ez a bevonása a négy mag nem garantálja a megnövekedett termelékenység négyszeresére. Növekedés azonban, és ez erősebb lesz minden évben - nem lesz több optimalizálva többmagos processzorok programokat.
Hogyan programozók áramlását kontrollálják, hogy valamennyi CPU? Hogyan lehet, hogy az alkalmazás futtatásához, amilyen gyorsan csak lehetséges, skála a magok száma, és írni egy ilyen kérelmet nem volt a rémálom programozó? Az egyik lehetőség - manuálisan létrehozni szálak a kódot, nekik feladatot kell végrehajtani, majd törli azokat. De ebben az esetben van szükség, hogy vigyázzon egy nagyon fontos dolog - a szinkronizálás. Ha problémája adatokat kér számítanak a másik feladatot, a helyzet bonyolultabb. Nehéz megérteni, hogy mi történik, ha különböző szálak egyszerre próbál változtatni az értékeket megosztott változók. Igen, és nem akarom, hogy manuálisan létrehozni szálak, és bizonyos feladatokat nekik. Ahhoz, hogy a támogatás a különböző könyvtárak és szabványok párhuzamos programozás. Nézzük a leggyakoribb szabvány párhuzamosítás programok C, C ++, Fortran - OpenMP.
OpenMP - API, amelynek célja a programozás többszálú alkalmazások többprocesszoros rendszerekben megosztott memóriát. Kidolgozása az OpenMP leírásban több nagy gyártó a számítógépes hardver és szoftver. OpenMP által támogatott főbb fordító.
Az OpenMP, akkor „nem látja” folyamok a kódot. Ehelyett akkor mondja a fordító segítségével #pragma irányelvek kódblokkot lehet párhuzamosított. Ezen információk birtokában, a fordító képes generálni egy alkalmazást, amely egy fő áramlás, amely megteremti számos más áramok párhuzamos kód blokk. Ezek az áramok szinkronizálva végén a párhuzamos kód blokk, és újra itt vagyunk az egyik fő patak.
használata OpenMP
Mivel OpenMP vezérli #pragma, a C ++ kódot helyesen lefordítani bármilyen C ++ fordító, mert nem támogatott #pragma figyelmen kívül kell hagyni. Azonban az OpenMP API is tartalmaz számos funkciót, és használja őket, akkor tartalmaznia kell a header fájlt. A legegyszerűbb módja annak megállapítására, hogy a fordító támogatja OpenMP - próbáljon meg csatlakozni omp.h file: #include
Ha OpenMP támogatás, meg kell, hogy kapcsolja be a speciális fordítóprogram-jelzők:
OpenMP irányelvek kezdődik #pragma omp.
Ez az irányelv létrehoz egy csoportot N patakok. N meghatározva futási időben, általában egy a processzormagok száma, de lehet állítani kézzel N. Mind a folyamok a csoport végzi a következő irányelv parancsot (vagy utasítás blokk, meghatározott <>-zárójelben). A végrehajtás után folyik „merge” egy.
Példa megjeleníti a „Helló!” Egy sor ahányszor áramlás jött létre a csoportban. Kétmagos rendszerek, a szöveg kétszer lesz kinyomtatva. (Megjegyzés: valami hasonló „HeHlellolo” is megjelenik, mivel a kimenet zajlik párhuzamosan.)
Ha megnézzük, hogyan működik, azt látjuk, hogy a GCC létrehoz egy speciális funkciót, és mozgatja a készüléket kódot ezt a funkciót, hogy minden változót a blokk lokális változó a függvény (illetve a lokális változók az egyes stream). Másrészt, ICC által használt mechanizmust hasonlító fork (), és létrehoz egy speciális funkciót. Mindkét megvalósítások természetesen helyes és szemantikailag azonos.
Párhuzamosság feltétele, hogy használja a kifejezést, ha:
Ebben az esetben, ha parallelism_enabled nullával egyenlő, a hurok által feldolgozott csak egy (fő) patak.
Irányelv megoszlik a jelenlegi ciklus egy csoportja menet úgy, hogy minden szál egy csoportban kezeli egy részét a ciklus.
Ez a hurok megjeleníti a számok 0-9, minden pontosan egyszer. Az eljárást azonban azok visszavonására ismeretlen. Ez lehet, például, a következők szerint:
0 5 6 7 1 8 2 3 4 9.
Ezt a kódot kell átalakítani valamit, mint egy fordító:
Így minden egyes folyam kezeli maga részéről a ciklus párhuzamosan a másik folyam.
Fontos, hogy a #pragma OMP irányelv csak átruházhatja részeit a ciklus, hogy különböző szálak az aktuális szál csoport. Abban az időben a program megkezdése csoport egyetlen (fő) patak. Ahhoz, hogy hozzon létre egy új szál csoport, akkor kell használni a kulcsszó párhuzamosan:
Írhat röviden:
Mindkét rögzíti ekvivalens.
Annak beállításához, a szálak számát a csoportban, akkor a paraméter num_threads:
Az OpenMP 2.5, egy iteratív hurkot változó típusú legyen alá. Az OpenMP 3.0. ez is lehet a típus előjel nélküli egész, lehet egy pointer vagy állandó idejű elérésű bejáró. Az utóbbi esetben, std :: távolság () fogják használni, hogy hány ciklusiteráció.
Egy rövid összefoglaló: párhuzamos, a csoportos és adatfolyamok
Ismét figyelmét a különbség egy párhuzamos, egymással párhuzamosan, és:
- Menet csoport - e szálakat, amelyek jelenleg is fut.
- Amikor a program elindul, az együttes tartalmaz egy szál.
- Párhuzamos irányelv osztja az aktuális téma, hogy az új szál csoport, amíg el nem éri a végén a következő kifejezések / kifejezések blokk, majd egy csoport patakok beleolvadnak egy patak.
- megosztott a ciklus egymástól, és így minden egyes része az áramlás a jelenlegi csoportban. Ez az irányelv nem hoz létre új témát, csak megosztja a munkát az áramlás az aktuális csoport.
- párhuzamosan - gyors- és a két csapat: párhuzamos és. Párhuzamos áramlás létrehoz egy új csoportot, majd elosztja az egyes áramok a csoportban a hurok.
Ha a program nem tartalmaz párhuzamos direktívát, csak akkor kerül végrehajtásra patak.
ütemezés (tervezés)
A programozó szabályozhatja, milyen módon fog működni patakok terhelést a feldolgozás során. Számos módja van.
statikus az alapértelmezett beállítás. Mielőtt a hurok, minden szál „tudja” melyik részét a ciklus feldolgozni.
A második lehetőség - ez a kulcsszó dinamikus:
Ebben az esetben lehetetlen megjósolni, hogy milyen sorrendben iteráció a hurok lesz rendelve a szálakat. Minden szál elvégzi a meghatározott számú iteráció. Ha ez a szám nincs megadva, az alapértelmezett 1. Amikor a menet befejezése végrehajtását meghatározott ismétléseket, akkor megy a következő sor ismétléseket. Ez addig folytatódik, amíg elvégezte az összes ismétléseket. Az utolsó sor ismétléseket lehet kisebb, mint az eredetileg meghatározott. Ez a lehetőség akkor hasznos, ha egy másik ciklusiteráció számít az időben. Azt is megadhatja az ismétlések számát, majd egy patak, amely „kérni” -tól OpeMP következő:
Ebben a példában minden szál végez három iteráció, majd a „felveszi” három, és így tovább. Az utóbbi természetesen a mérete lehet kisebb, mint három.
Ott van még a lehetőség vezetve. Ez hasonló a dinamikus. tétel méretét, de exponenciálisan csökken. Ha megad egy irányelv #pragma OMP az ütemezés (dinamikus, 15), a ciklus ismétlések 100 végezhetjük négy sorozatát az alábbiak szerint:
De mi lehet az eredménye ugyanabban a ciklusban négy szál, ha az irányelv #pragma OMP menetrendes kerül meghatározásra (irányított, 15):
Dinamikusan vezérelt ütemezés, és jól alkalmazható, ha minden egyes iteráció végzik különböző mennyiségű munka, vagy ha néhány processzorok hatékonyabbak, mint mások. Amikor a statikai tervezés nincs mód, amely lehetővé teszi a teher ellensúlyozására különböző szálak. A dinamikus és ellenőrzött tervezését a terhelés eloszlik automatikusan - ez a lényege ezeknek a módszereknek. Jellemző, hogy amikor menedzselt kód tervezési gyorsabb, mint a dinamikus, az alacsonyabb tervezési költségek.
rendelési (szekvenálás)
A sorrend, amelyben kerülnek feldolgozásra iteráció a hurok, általában kiszámíthatatlan. Mindazonáltal lehetséges, hogy „erőt» OpenMP elvégzésére kifejezést a hurok érdekében. Erre a célra van egy kulcsszó rendelhető:
A ciklus „összenyomja” 100 fájl párhuzamos, de a „Levél” őket szigorú sorrendben. Ha például az áramlás „préselt” a hetedik fájlt, de hat fájl ezen a ponton még nem „küldött”, az áramlás vár „küldő” hat fájlokat. Minden fájl „sűrített” és a „küldött” egyszer, de „tömörítés” lehet párhuzamosan zajlik. Ez lehetővé tette, hogy csak egy blokk ciklusonként rendelt.