Párhuzamos számítástechnika

Az IBM Blue Gene/P masszívan páthuzamos szuperszámítógépe

A párhuzamos számítástechnika a számítástechnika egy típusa, ahol a számításokat vagy folyamatokat egyidejűleg hajtják végre. A nagy problémákat gyakran fel lehet osztani kisebbekre, amelyeket egyidejűleg lehet megoldani. A párhuzamos számítástechnikának többféle formája létezik: bitszintű, utasításszintű, adat- és feladatpárhuzamosság. A párhuzamosságot már régóta alkalmazzák a nagy teljesítményű számítástechnika területén, de szélesebb körű érdeklődést váltott ki a frekvencia skálázás fizikai korlátai miatt. Mivel a számítógépek energiafogyasztása (és ennek következtében a hőtermelés) az utóbbi években aggodalomra ad okot, a párhuzamos számítástechnika a számítógép-architektúra meghatározó példájává vált, főleg a többmagos processzorok formájában.

A párhuzamos számítástechnika szorosan kapcsolódik az egyidejű számítástechnikához – gyakran használják együtt és gyakran egymással felcserélve, bár a kettő különbözik egymástól: párhuzamosság létezhet egyidejűség nélkül (például bitszintű párhuzamosság), és egyidejűség létezhet párhuzamosság nélkül (például többfeladatosság egy egymagos processzoron az időosztás által). A párhuzamos számítástechnika során a számítási feladat jellemzően több, gyakran sok, nagyon hasonló alfeladatra bontható, amelyeket egymástól függetlenül lehet feldolgozni, és amelyek eredményeit a teljesítés után később egyesítik. Ezzel szemben a egyidejű számítástechnikában a különféle folyamatok gyakran nem foglalkoznak a kapcsolódó feladatokkal; amikor megteszik, amint az az elosztott számítástechnikában jellemző, az egyes feladatok változatos természetűek lehetnek, és a végrehajtás során gyakran bizonyos folyamatok közötti kommunikációt igényelnek.

A párhuzamos számítógépeket nagyjából osztályozni lehet annak a szintnek az alapján, amelyen a hardver a párhuzamosságot támogatja: a többmagos és a többprocesszoros számítógépek esetében egyazon gépen több feldolgozó elem van, míg a fürtök, MPP-k és rácsszámítások több számítógépet használnak ugyanazon feladat elvégzéséhez. Speciális párhuzamos számítógép-architektúrákat alkalmaznak a hagyományos processzorok mellett bizonyos feladatok felgyorsítására.

Bizonyos esetekben a párhuzamosság átlátható a programozó számára, mint például a bitszintű vagy utasításszintű párhuzamosság, de kifejezetten a párhuzamos algoritmusok közül különösen azokat, amelyek egyidejűséget használnak, nehezebb megírni, mint szekvenciális társaikat, mivel az egyidejűség számos új potenciális szoftverhibát rejt, amelyek közül a versenyhelyzetek a leggyakoribbak. A különböző alfeladatok közötti kommunikáció és szinkronizálás általában a legnagyobb akadály az optimális párhuzamos programteljesítmény elérésében.

Egyetlen program gyorsulásának elméleti felső határát a párhuzamosítás eredményeként Amdahl törvénye adja meg.

Háttér

Hagyományosan a számítógépes szoftvereket soros számításra írták. Egy probléma megoldásához egy algoritmust állítanak össze és valósítanak meg soros utasításfolyamként. Ezeket az utasításokat egy számítógép központi feldolgozó egységén hajtják végre. Egyszerre csak egy utasítás hajtható végre – az utasítás befejezése után a következő kerül végrehajtásra.

A párhuzamos számítástechnika viszont több feldolgozási elemet használ egyszerre egy probléma megoldásához. Ezt úgy lehet elérni, hogy a problémát független részekre bontjuk, hogy minden feldolgozási elemet az algoritmus többi részével egyidejűleg lehessen végrehajtani. A feldolgozási elemek változatosak lehetnek, és tartalmazhatnak olyan erőforrásokat, mint egy számítógép több processzorral, több hálózati számítógép, speciális hardver vagy a fentiek bármelyikének kombinációja. A történelem során a párhuzamos számítástechnikát alkalmazták tudományos számításhoz és tudományos problémák szimulálásához, különösen a természettudomány és a műszaki tudományok, például a meteorológia területén. Ez a párhuzamos hardver és szoftver, valamint a nagy teljesítményű számítástechnika megtervezéséhez vezetett.

A frekvencia skálázás volt a meghatározó oka a számítógépes teljesítmény javulásának az 1980-as évek közepétől 2004-ig. A program futási ideje megegyezik az utasítások számával, szorozva az utasításonkénti átlagos idővel. Ha az órajelen kívül minden más állandó, akkor annak növelése csökkenti egy utasítás végrehajtásához szükséges átlagos időt. A frekvencia növelése tehát csökkenti az összes számításhoz kötött program futási idejét. Ugyanakkor a processzor által adott P energiafogyasztást a P = C × V ² × F egyenlet adja, ahol C a kapacitás ciklusonként kapcsolva (arányos azon tranzisztorok számával, amelyek bemenete változik), V a feszültség és F a processzor frekvenciája (másodpercenkénti ciklusok száma). A frekvencia növelése növeli a processzorban felhasznált energiamennyiséget. A processzorok növekvő energiafogyasztása végül az Intel 2004. május 8-i Tejas és Jayhawk processzorainak megszüntetéséhez vezetett, amelyeket általában a frekvencia skálázás végének tekintenek, és az uralkodó számítógép-architektúra példájának neveznek.

Az energiafogyasztás és a túlmelegedés problémájának kezelése érdekében a fő központi feldolgozó egység (CPU vagy processzor) gyártói elkezdték a többmagos energiahatékony processzorok gyártását. A mag a processzor számítási egysége, és a többmagos processzorokban minden mag független, és ugyanahhoz a memóriához egyidejűleg fér hozzá. A többmagos processzorok párhuzamos számítástechnikát hoztak az asztali számítógépekbe. Így a soros programok párhuzamosítása vált a fő programozási feladattá. 2012-ben a négymagos processzorok szabványossá váltak az asztali számítógépekben, míg a szerverek tíz- és tizenkétmagos processzorokkal rendelkeztek. Moore törvénye kimondja, hogy a processzoronkénti magok száma 18–24 hónaponként megduplázódik. Ez azt jelentheti, hogy 2020 után egy tipikus processzor tucatnyi vagy száz maggal rendelkezik.

Az operációs rendszer biztosítja, hogy a különféle feladatok és felhasználói programok párhuzamosan fussanak a rendelkezésre álló magokon. Ahhoz azonban, hogy egy soros szoftver program teljes mértékben kihasználhassa a többmagos architektúrát, a programozónak kell átszerkesztenie és párhuzamosítania a kódot. Az alkalmazásszoftverek futtatásának gyorsítását már nem lehet frekvencia skálázással elérni, hanem a programozóknak párhuzamosítaniuk kell a szoftverkódjukat, hogy kihasználhassák a többmagos architektúrák növekvő számítási teljesítményét.

Amdahl törvénye és Gustafson törvénye

Amdahl törvényének grafikus ábrázolása. A program párhuzamosítástól való felgyorsítását korlátozza az, hogy a program mekkora részét lehet párhuzamosítani. Például, ha a program 90%-a párhuzamosítható, akkor az elméleti maximális sebesség a párhuzamos számítás használatával tízszeres lesz, függetlenül attól, hogy hány processzort használunk.

Optimális esetben a párhuzamosítástól való gyorsulás lineáris lenne – a feldolgozási elemek számának megkétszerezésével a futási időt a felére, második alkalommal történő megkétszerezésére pedig a futási idő ismét a felére kellene csökkenteni. Azonban nagyon kevés párhuzamos algoritmus éri el az optimális gyorsulást. Legtöbbjüknél csaknem lineáris sebességgnövekedés tapasztalható kis számú feldolgozó elem esetében, amely állandó értékké válik nagyszámú feldolgozó elem esetében.

Az algoritmus várható gyorsulását egy párhuzamos számítási platformon Amdahl törvénye adja meg:

Tegyük fel, hogy egy feladatnak két független része van: A és B. A B rész a teljes számítás idejének körülbelül 25%-át veszi igénybe. Nagyon kemény munkával előfordulhat, hogy ez a rész ötször gyorsabb lesz, de ez csak kicsit csökkenti a teljes számításhoz szükséges időt. Ezzel szemben lehet, kevesebb munkát kell elvégezni, hogy az A rész kétszer gyorsabb legyen. Ez sokkal gyorsabbá teszi a számítást, mint a B rész optimalizálása, annak ellenére, hogy a B rész gyorsulása aránylag nagyobb (ötszörös a kétszeressel szemben).

$S_{\text{késleltetés}}(s)={\frac {1}{1-p+{\frac {p}{s}}}},$

ahol

• S_{késleltetés} a végrehajtás késleltetésének lehetséges gyorsulása az egész feladat esetében;
• s a végrehajtás késleltetésének lehetséges gyorsulása a feladat párhuzamosítható része esetében;
• p a feladat párhuzamosítható részének végrehajtása a párhuzamosítás előtt a teljes feladat végrehajtási idejének százalékában.

Mivel az S_{késleltetés} < 1/(1 − p), ezért a program egy kis része, amely nem párhuzamosítható, korlátozza a párhuzamosítástól elérhető teljes gyorsulást. Egy nagy matematikai vagy mérnöki feladatot megoldó program általában több párhuzamosítható és több nem párhuzamosítható (soros) részből áll. Ha a program nem párhuzamosítható része a futási idő 10%-át teszi ki (p = 0,9), legfeljebb tízszeres gyorsulást érhetünk el, függetlenül attól, hogy hány processzort adunk hozzá. Ez felső korlátot jelent a párhuzamos végrehajtó egységek hozzáadásának hasznosságára. „Ha egy feladat nem osztható szét egymást követő korlátozások miatt, a nagyobb erőfeszítéseknek nincs hatása az időbeosztásra. A terhesség kilenc hónapig tart, függetlenül attól, hogy hány nőt jelölünk ki.”

Gustafson törvényének grafikus ábrázolása

Amdahl törvénye csak azokra az esetekre vonatkozik, amikor a probléma nagysága rögzítve van. A gyakorlatban, mivel egyre több számítási erőforrás válik elérhetővé, hajlamosak nagyobb problémákhoz (nagyobb adatkészletekhez) szokni, és a párhuzamosítható részben eltöltött idő gyakran sokkal gyorsabban növekszik, mint a benne rejlő sorozatmunka. Ebben az esetben Gustafson törvénye kevésbé pesszimista és reálisabb értékelést ad a párhuzamos teljesítményről:

$S_{\text{késleltetés}}(s)=1-p+sp.$

Mind Amdahl, mind Gustafson törvénye feltételezi, hogy a program soros részének futási ideje független a processzorok számától. Amdahl törvénye azt feltételezi, hogy a teljes probléma rögzített méretű, tehát a párhuzamosan elvégzendő munka független a processzorok számától, míg Gustafson törvénye azt, hogy a párhuzamosan elvégzendő munka lineárisan változik a processzorok számával.

Függőségek

Az adatfüggőség megértése alapvető fontosságú a párhuzamos algoritmusok megvalósításában. Egyik program sem futhat gyorsabban, mint a függő számítások leghosszabb lánca (úgynevezett kritikus út), mivel a számításokat, amelyek függnek a lánc előzetes számításától, sorrendben kell végrehajtani. A legtöbb algoritmus azonban nem csupán egy hosszú függő számítási láncból áll; általában vannak lehetőségek független számítások párhuzamos végrehajtására.

Legyen P_i és P_j két programszegmens. Bernstein feltételei leírják, mikor a kettő független és párhuzamosan végrehajtható. P_i számára legyen I_i az összes bemeneti és O_i az összes kimeneti változó, és ugyanígy a P_j esetében. P_i és P_j függetlenek, ha teljesülnek a következők:

$I_{j}\cap O_{i}=\varnothing ,$

$I_{i}\cap O_{j}=\varnothing ,$

$O_{i}\cap O_{j}=\varnothing .$

Az első feltétel megsértése valódi függőséget eredményez, ahol az első szegmens által adott eredményt a második szegmens felhasznál. A második feltétel keresztfüggőséget képvisel, amikor a második szegmens az első szegmenshez szükséges változót állít elő. A harmadik, egyben utolsó feltétel egy kimeneti függőséget képvisel: amikor két szegmens ír ugyanarra a helyre, akkor az eredmény a logikailag utoljára végrehajtott szegmenstől származik.

Nézzük meg a következő függvényeket, amelyek többféle függőséget mutatnak:

1: function Dep(a, b)
2: c := a * b
3: d := 3 * c
4: end function

Ebben a példában a 3. utasítás nem hajtható végre a 2. utasítás előtt (vagy akár azzal párhuzamosan), mert a 3. utasítás a 2. utasítás eredményét használja. Ez megsérti az 1. feltételt, és így valódi függőséget okoz.

1: function NoDep(a, b)
2: c := a * b
3: d := 3 * b
4: e := a + b
5: end function

Ebben a példában nincs függőség az utasítások között, tehát mindegyik párhuzamosan futtatható.

Bernstein feltételei nem teszik lehetővé a memória megosztását a különböző folyamatok között. Ehhez szükség van a hozzáférések közötti megrendelés érvényesítésének bizonyos módjaira, például szemaforokra, akadályokra vagy más szinkronizálási módszerre.

Versenyhelyzetek, kölcsönös kizárás, szinkronizálás és párhuzamos lelassulás

A párhuzamos programok alfeladatait gyakran szálaknak hívják. Néhány párhuzamos számítógép-architektúrák a szálak kisebb, könnyű verzióit, rostokat, míg mások nagyobb, folyamatoknak nevezett verziókat használnak . A „szálakat” azonban általánosan elfogadják az alfeladatok általános kifejezésének. A szálaknak gyakran szinkronizált hozzáférésre van szükségük egy objektumhoz vagy más erőforráshoz, például amikor frissíteniük kell egy köztük megosztott változót. Szinkronizálás nélkül a két szál közötti utasítások tetszőleges sorrendben összeilleszthetőek. Vegyük például a következő programot:

A szál	B szál
1A: olvassa be az V változót	1B: olvassa be az V változót
2A: adjon hozzá 1-et az V változóhoz	2B: adjon hozzá 1-et az V változóhoz
3A: írja vissza a V változót	3B: írja vissza a V változót

Ha az 1B utasítást az 1A és a 3A között hajtják végre, vagy ha az 1A utasítást az 1B és a 3B között hajtják végre, akkor a program hibás adatokat fog előállítani. Ezt versenyhelyzetnek nevezik. A programozónak zárat kell használnia, hogy a kölcsönös kizárást érvényesítse. A zár egy programozási nyelvi konstrukció, amely lehetővé teszi, hogy az egyik szál átvegye az irányítást egy változó felett, és megakadályozza, hogy más szálak olvassák vagy írják azt, amíg a változó fel nem oldódik. A zárat tartó szál szabadon végrehajthatja annak kritikus szakaszát (egy olyan program szakaszát, amely kizárólagos hozzáférést igényel valamilyen változóhoz) és az adatok feloldását, amikor kész. Ezért a program helyes végrehajtásának garantálása érdekében a fenti program átírható zárak használatához:

A szál	B szál
1A: zárolja a V változót	1B: zárolja a V változót
2A: olvassa be az V változót	2B: olvassa be az V változót
3A: adjon hozzá 1-et az V változóhoz	3B: adjon hozzá 1-et az V változóhoz
4A: írja vissza a V változót	4B: írja vissza a V változót
5A: oldja fel a V változót	5B: oldja fel a V változót

Az egyik szál sikeresen zárolja a V változót, míg a másik szál lezáródik – nem folytatható addig, amíg a V újra fel nem oldódik. Ez garantálja a program helyes végrehajtását. Lehetséges, hogy zárolásokra van szükség a program helyes végrehajtásának biztosításához, amikor a szálaknak sorba kell állniuk az erőforrásokhoz való hozzáféréshez, de ezek használata jelentősen lelassíthatja a programot és befolyásolhatja annak megbízhatóságát.

Több változó lezárása nem atomi zárakkal bevezeti a program holtpontjának lehetőségét. Egy atomi zár több változót zárol le egyszerre. Ha nem tudja lezárni mindet, akkor egyiket sem zárja le. Ha két szálnak ugyanazt a két változót kell zárolnia nem atomi zárral, akkor lehetséges, hogy az egyik szál lezárja egyik, a másik szál pedig a másik változót. Ebben az esetben egyik szál sem fejeződik be, és holtpont lesz az eredmény.

Sok párhuzamos program megköveteli, hogy a részfeladatai szinkronban működjenek. Ehhez akadály használata szükséges. Az akadályokat jellemzően zár vagy szemafor segítségével valósítják meg. Az algoritmusok egyik osztálya, az úgynevezett zárolás és várakozás nélküli algoritmusok összességében elkerülik a zárak és akadályok használatát. Ezt a megközelítést azonban általában nehéz végrehajtani, és helyesen megtervezett adatszerkezeteket igényel.

Nem minden párhuzamosítás eredményez gyorsulást. Általánosságban elmondható, hogy mivel a feladat egyre több szálon oszlik meg, ezek a szálak idejük egyre növekvő részét egymással kommunikálva vagy egymásra várva töltik, hogy hozzáférjenek az erőforrásokhoz. Ha az erőforrásért való konfliktus vagy a kommunikációból származó költségek uralják az egyéb számításra fordított időt, akkor a további párhuzamosítás (azaz a munkaterhelés felosztása még több szálra) növeli, nem pedig csökkenti a befejezéshez szükséges időt. Ez a probléma párhuzamos lelassulás néven ismert, és bizonyos esetekben javítható szoftverelemzéssel és újratervezéssel.

Finomszemű, durva szemű és zavarba ejtő párhuzamosság

Az alkalmazásokat gyakran annak alapján osztályozzák, hogy az alfeladatoknak milyen gyakran kell szinkronizálniuk vagy kommunikálniuk egymással. Az alkalmazás finom szemcsés párhuzamosságot mutat, ha részfeladatainak másodpercenként sokszor kell kommunikálniuk; durva szemcsés párhuzamosságot mutat, ha másodpercenként nem sokszor kommunikálnak, és zavarba ejtő párhuzamosságot mutat, ha ritkán vagy soha nem kell kommunikálniuk. A zavarba ejtő párhuzamos alkalmazásokat lehet a legkönnyebben párhuzamosítani.

Konzisztencia-modellek

A párhuzamos programozási nyelveknek és a párhuzamos számítógépeknek rendelkezniük kell konzisztencia-modellel (más néven memória-modellel). A konzisztencia-modell meghatározza a számítógépes memóriában végrehajtott műveleteket és az eredmények előállításának szabályait.

Az egyik első konzisztencia-modell Leslie Lamport szekvenciális konzisztencia-modellje volt. A szekvenciális konzisztencia egy párhuzamos program olyan tulajdonsága, hogy annak párhuzamos végrehajtása ugyanazokat az eredményeket adja, mint a szekvenciális végrehajtása. Pontosabban, egy program szekvenciálisan konzisztens, ha „bármely végrehajtás eredménye megegyezik, ha az összes processzor műveletei tetszőleges sorrendben kerülnek végrehajtásra, és az egyes processzorok műveletei ebben a sorrendben jelennek meg a program által meghatározott sorrendben”.

A tranzakciós memória a konzisztencia-modell általános típusa. A tranzakciós memória kölcsönveszi az adatbázis elméletből az atomos tranzakciók fogalmát, és alkalmazza azokat a memória elérésekre.

Matematikailag ezek a modellek többféle módon bemutathatóak. Az 1962-ben bevezetett Petri-hálók korai kísérletek voltak a konzisztencia-modellek szabályainak rögzítésére. Az adatáramlás-elmélet később ezekre épült, és az adatfolyam-architektúrákat az adatáramlás-elmélet ötleteinek fizikai megvalósításához hozták létre. Először az 1970-es évek végén a folyamatkalkulusokat, mint például a kommunikációs rendszerek kalkulusát és a szekvenciális folyamatok kommunikálását arra fejlesztették ki, hogy lehetővé tegyék az algebrai érvelést olyan rendszerekről, amelyek egymással kölcsönhatásba lépő komponensekből állnak. A folyamatkalkulusok családjának újabb kiegészítései, mint például a π-kalkulus, képesek voltak megindokolni a dinamikus topológiákat. A logikákat, mint Lamport TLA+ és az olyan matematikai modelleket, mint például a trace és az actor event diagram, szintén kifejlesztették az egyidejű rendszerek viselkedésének leírására.

Flynn-féle osztályozás

Michael J. Flynn létrehozta az egyik legkorábbi osztályozási rendszert a párhuzamos (és szekvenciális) számítógépek és programok számára, amelyet ma Flynn-féle osztályozásnak hívnak. Flynn osztályozta a programokat és a számítógépeket attól függően, hogy egy vagy több utasítást, és hogy ezek az utasítások egy vagy több adatkészletet használnak-e vagy sem.

Az „egy utasítás-, egy adatfolyam” (SISD) osztályozás egyenértékű egy teljesen szekvenciális programmal. Az „egy utasítás-, több adatfolyam” (SIMD) osztályozás megegyezik azzal, hogy ugyanazt a műveletet ismételten elvégezzük egy nagy adatkészleten. Ezt általában jelfeldolgozó alkalmazásokban használják. A „több utasítás-, egy adatfolyam” (MISD) egy ritkán használt osztályozás. Miközben kidolgozták az ennek kezelésére szolgáló számítógép-architektúrákat (például systolic array), kevés ilyen, ebbe az osztályba tartozó alkalmazás valósult meg. A „több utasítás-, több adatfolyam” (MIMD) programok messze a leggyakoribb típusai a párhuzamos programoknak.

David A. Patterson és John L. Hennessy szerint „Néhány gép természetesen ezeknek a kategóriáknak a hibridjei (keverékei), de ez a klasszikus modell fennmaradt, mert egyszerű, könnyen érthető, és jó első megközelítést ad. Ugyancsak – talán érthetősége miatt – a legszélesebb körben alkalmazott séma.”

A párhuzamosság típusai

Bitszintű párhuzamosság

A nagyon nagy méretű integráció (VLSI) számítógépes chip gyártási technológiának az 1970-es években történő megjelenéséig, mintegy 1986-ig, a számítógép-architektúra felgyorsítását a számítógépes szó méretének megduplázása vezette – az az információmennyiség, amelyet a processzor ciklusonként módosíthat. A szóméret növelése csökkenti a processzor által végrehajtott műveletek számát olyan változók módosításakor, amelyek mérete meghaladja a szó hosszát. Például ha egy 8 bites processzornak két 16 bites egész számot kell összeadnia, akkor a processzornak először hozzá kell adnia 8 alacsonyabb rendű bitet minden egyes egészből a szokásos összeadási utasítás felhasználásával, majd hozzá kell adnia 8 magasabb rendű bitet egy add-with-carry utasítás segítségével és a szállító bitet az alacsonyabb rendű összeadásból; így egy 8 bites processzornak két utasításra van szüksége egyetlen művelet végrehajtásához, amire egy 16 bites processzor egyetlen utasítással is képes lett volna.

A 4 bites mikroprocesszorokról történelmileg 8, 16, majd 32 bites mikroprocesszorokra váltottak. Ez a tendencia általában véget ért a 32 bites processzorok bevezetésével, amely két évtizede a szokásos számítástechnika szabványa. Csak a 2000-es évek elején, az x86-64-es architektúrák megjelenésével váltak a 64 bites processzorok hétköznapivá.

Utasításszintű párhuzamosság

Szabványos processzor csővezeték nélkül. Egy utasítás elvégzéséhez öt ciklus szükséges, és így a processzor szubkaláris teljesítményt adhat (IPC = 0,2 < 1).

Szabványos processzor ötfokozatú csővezetékkel. A legjobb esetben egy utasítás teljesítéséhez egy ciklus szükséges, így a processzor skaláris teljesítményt adhat (IPC = 1).

A számítógépes program lényegében egy processzor által végrehajtott utasítások folyamja. Utasításszintű párhuzamosság nélkül a processzor csak egynél kevesebb utasítást adhat ki ciklusonként (IPC < 1). Ezeket a processzorokat szubkaláris processzoroknak nevezzük. Ezek az utasítások újrarendelhetőek és csoportokba kombinálhatóak, melyeket ezután párhuzamosan hajtanak végre a program eredményének megváltoztatása nélkül. Ezt úgy hívják, hogy utasításszintű párhuzamosság. Az utasításszintű párhuzamosság előretörése az 1980-as évek közepétől az 1990-es évek közepéig uralta a számítógép-architektúrát.

Minden modern processzor többfokozatú utasítás csővezetékeket kínál. A csővezeték egyes szakaszai eltérő műveletnek felelnek meg, amelyet a processzor az adott utasításban hajt végre; egy N-fokozatú csővezetékkel rendelkező processzornak legfeljebb N különféle utasítása lehet a teljesítés különböző szakaszaiban, és így ciklusonként egy utasítást adhat ki (IPC = 1). Ezek a processzorok skaláris processzorok. A csővezetékes processzor szabványos példája egy RISC processzor, amely öt szakaszból áll: utasítás lekérés (IF), utasítás dekódolás (ID), végrehajtás (EX), memóriahozzáférés (MEM) és regiszter visszaírás (WB). A Pentium 4 processzornak 35 fokozatú csővezetéke volt.

Szabványos szuperskaláris processzor ötfokozatú csővezetékkel. A legjobb esetben két utasítás teljesítéhez egy ciklus szükséges, és így a processzor szuperskaláris teljesítményt adhat (IPC = 2 > 1).

A legtöbb modern processzornak több végrehajtó egysége is van. Általában ezt a szolgáltatást kombinálják a csővezetékkel, és így ciklusonként egynél több utasítást adhatnak ki (IPC > 1). Ezeket a processzorokat szuperskaláris processzoroknak nevezzük. Az utasításokat csak akkor lehet csoportosítani, ha nincs adatfüggőség közöttük. Az eredménytábla-módszer és a Tomasulo-algoritmus (amely hasonló az eredménytábla-módszerhez, de a regiszterek átnevezését használja) a két leggyakoribb módszer a megrendelésen kívüli végrehajtás és az utasításszintű párhuzamosság megvalósításához.

Feladatpárhuzamosság

A feladatpárhuzamosság egy párhuzamos program azon jellemzője, hogy „teljesen eltérő számítások végezhetőek ugyanazon vagy különböző adatkészleteken”. Ez ellentétben áll az adatpárhuzamossággal, amikor ugyanazt a számítást hajtják végre ugyanazon vagy különböző adatkészleteken. A feladatpárhuzamosság magában foglalja egy feladat alfeladatokra bontását, majd az egyes alfeladatok kiosztását egy processzor számára végrehajtás céljából. A processzorok ezután ezeket az alfeladatokat egyidejűleg és gyakran együttműködve hajtják végre. A feladatpárhuzamosság általában nem egyezik meg a probléma méretével.

Szuperszó-szintű párhuzamosság

Szuperszó-szintű párhuzamosság egy vektorizálási technika, amely hurok lazítás és alapvető blokk vektorizáláson alapul. Ez abban különbözik a hurokvektorizációs algoritmusoktól, hogy ki tudja használni a beillesztett kód párhuzamosságát, például a koordináták, a színcsatornák vagy a kézzel lazított hurkok kezelését.

Hardver

Memória és kommunikáció

A párhuzamos számítógép főmemóriája vagy megosztott memória (az összes feldolgozó elem között megosztva egyetlen címtérben), vagy elosztott memória (amelyben minden feldolgozó elemnek megvan a saját helyi címtere). Az elosztott memória arra a tényre utal, hogy a memória logikailag van elosztva, de gyakran azt jelenti, hogy fizikailag is eloszlik. Az elosztott megosztott memória és a memória virtualizáció kombinálja a két megközelítést, ahol a feldolgozó elemnek saját helyi memóriája van, és a memóriahoz nem helyi processzorok férhetnek hozzá. A helyi memória elérése általában gyorsabb, mint a nem helyi memória elérése. A szuperszámítógépeken az elosztott megosztott memóriaterület a programozási modell, például osztott globális címtér használatával valósítható meg. Ez a modell lehetővé teszi az egyik számítási csomóponton lévő folyamatok számára, hogy átlátható módon hozzáférjenek egy másik számítási csomópont távoli memóriájához. Az összes számítási csomópont nagy sebességű összeköttetésen keresztül, például az InfiniBand segítségével, egy külső megosztott memória rendszerhez is csatlakozik. Ezt a külső megosztott memória rendszert burst puffernek nevezik, amely általában nem felejtő memória tömbjeiből épül fel, fizikailag elosztva több I/O csomópont között.

A nem egységes memóriahozzáférésű (NUMA) architektúra logikai nézete. Az egyik könyvtárban lévő processzorok kevesebb késleltetéssel férhetnek hozzá a könyvtár memóriájához, mint a másik könyvtár memóriájához.

Azokat a számítógép-architektúrákat, amelyekben a főmemória minden eleméhez azonos késési idővel és sávszélességgel lehet hozzáférni egységes memóriahozzáférésű (UMA) rendszereknek nevezzük. Általában ezt csak egy megosztott memória rendszerrel lehet elérni, amelyben a memória fizikailag nincs elosztva. Azt a rendszert, amely nem rendelkezik ezzel a tulajdonsággal, nem egységes memóriahozzáférésű (NUMA) architektúrának nevezik. Az elosztott memória rendszerek nem egyenletesen férnek hozzá memóriához.

A számítógépes rendszerek gyorsítótárakat használnak – a processzor közelében található kis és gyors memóriákat, amelyek ideiglenes memóriaértékeket tárolnak (fizikai és logikai értelemben is egyaránt közel vannak). A párhuzamos számítógépes rendszereknek nehézségeik vannak olyan gyorsítótárakkal, amelyek ugyanazt az értéket egynél több helyen tárolhatják, a program helytelen végrehajtásának lehetőségével. Ezeknek a számítógépeknek gyorsítótár-koherencia rendszerre van szükségük, amely nyomon követi a gyorsítótárazott értékeket és stratégiailag megtisztítja azokat, garantálva ezzel a program helyes végrehajtását. A busz szippantás az egyik leggyakoribb módszer annak nyomon követésére, hogy mely értékekhez férnek hozzá (és ezért meg kell tisztítani). Nagy teljesítményű gyorsítótár-koherencia rendszerek tervezése nagyon nehéz probléma a számítógép-architektúrában. Ennek eredményeként a megosztott memória számítógép-architektúrái nem olyan nagy léptékűek, mint az elosztott memória rendszerek.

A processzor–processzor és processzor–memória kommunikációt sokféle módon megvalósíthatjuk a hardverben, többek között megosztott (multiportált vagy multiplexelt) memória, keresztirányú kapcsoló, megosztott busz vagy összekapcsolt hálózat révén számos topológiával, beleértve a csillagot, gyűrűt, fát, hiperkockát, kövér hiperkockát (egy csomóponton egynél több processzort tartalmazó hiperkocka) vagy n-dimenziós hálót.

Az összekapcsolt hálózatokon alapuló párhuzamos számítógépeknek valamilyen útválasztással kell rendelkezniük, hogy lehetővé tegyék az üzenetek továbbítását a közvetlenül nem csatlakozó csomópontok között. A processzorok közötti kommunikációhoz használt közeg valószínűleg hierarchikus lesz a nagy többprocesszoros gépekben.

Párhuzamos számítógépek osztályai

A párhuzamos számítógépeket nagyjából osztályozhatjuk azon szint alapján, amelyen a hardver a párhuzamosságot támogatja. Ez a besorolás nagyjából hasonló az alapvető számítási csomópontok közötti távolsággal. Ezek nem zárják ki egymást; például a szimmetrikus többprocesszoros fürtök viszonylag gyakoriak.

Többmagos számítástechnika

A többmagos processzor olyan processzor, amely több feldolgozó egységet (úgynevezett „magokat”) foglal magában ugyanazon a chipen. Ez a processzor különbözik a szuperskaláris processzoroktól, amelyek több végrehajtó egységet tartalmaznak, és ciklusonként több utasítást adhatnak ki egy utasításfolyamból (szálból); ezzel szemben egy többmagos processzor több utasítást ad ki ciklusonként több utasításfolyamból. Az IBM Cell mikroprocesszorát a Sony PlayStation 3-ban való használatra tervezték, egy kiemelkedő többmagos processzorként. A többmagos processzorok minden magja potenciálisan szuperskaláris is lehet, azaz minden ciklusonként minden egyes mag több utasítást adhat ki egy szálból.

Az egyidejű többszálú utasításvégrehajtás (amelyek közül az Intel Hyper-threading a legismertebb) a pseudo-multi-coreism korai formája volt. Az egyidejű többszálú utasításvégrehajtásra képes processzor több végrehajtó egységet tartalmaz ugyanabban a feldolgozó egységben – azaz szuperskaláris architektúrával rendelkezik –, és ciklusonként több utasítást adhat ki több szálból. Az időszakos többszálú utasításvégrehajtás ugyanakkor egyetlen végrehajtó egységet foglal magában ugyanabban a feldolgozó egységben, és egyszerre egy utasítást adhat ki több szálból.

Szimmetrikus többprocesszoros feldolgozás

A szimmetrikus multiprocesszor (SMP) olyan rendszer, amely több azonos processzorral rendelkezik, melyek megosztják a memóriát és buszon keresztül csatlakoznak. A buszviszály megakadályozza a busz-architektúrák méretezését. Ennek eredményeként az SMP-k általában legfeljebb 32 processzort tartalmaznak. A processzorok kis mérete és a nagy gyorsítótárak révén a busz-sávszélességre vonatkozó követelmények jelentős csökkenése miatt az ilyen szimmetrikus multiprocesszorok rendkívül költséghatékonyak, feltéve, hogy elegendő mennyiségű memória-sávszélességgel rendelkeznek.

Elosztott számítások

Az elosztott számítógép egy elosztott memóriával rendelkező számítógép rendszer, amelyben a feldolgozó elemek hálózattal vannak összekötve. Az elosztott számítógépek nagyon méretezhetőek. Az „egyidejű számítástechnika”, a „párhuzamos számítástechnika” és az „elosztott számítástechnika” kifejezések nagymértékben átfedik egymást, és közöttük nincs világos különbségtétel. Ugyanaz a rendszer jellemezhető „párhuzamos” és „elosztott” formában is; egy tipikus elosztott rendszerben a processzorok párhuzamosan futnak.

Számítógépfürtök

Egy Beowulf cluster

A fürt lazán kapcsolt számítógépek olyan csoportja, amelyek szorosan együttműködnek egymással, így bizonyos szempontból egyetlen számítógépnek tekinthetőek. A fürtök több önálló gépből állnak, amelyeket egy hálózat csatlakoztat. A fürtökben lévő gépeknek nem kell szimmetrikusnak lenniük, a terheléselosztás sokkal nehezebb, ha nem azok. A leggyakoribb fürttípus a Beowulf cluster, amely egy TCP/IP Ethernet helyi hálózathoz csatlakoztatott, több azonos kereskedelmi forgalomban kapható számítógépen valósul meg. A Beowulf technológiát eredetileg Thomas Sterling és Donald Becker fejlesztették ki. Az összes TOP500 szuperszámítógép 87%-a fürt. A fennmaradóak nagymértékben párhuzamos processzorok, amelyeket az alábbiakban ismertetünk.

Mivel a rácsszámítási rendszerek (alább leírtak) könnyen kezelhetik a zavarba ejtő párhuzamos problémákat, a modern fürtöket általában a nehezebb problémák kezelésére tervezték – olyan problémák, amelyek megkövetelik a csomópontoknak, hogy gyakrabban osszák meg a közbenső eredményeket. Ehhez nagy sávszélességre van szükség, és ami még fontosabb, egy alacsony késleltetésű összekapcsolási hálózatra. Számos történelmi és jelenlegi szuperszámítógép, például a Cray Gemini hálózat, kifejezetten a fürtszámításhoz tervezett, nagy teljesítményű hálózati hardvert használ. 2014-től a legtöbb jelenlegi szuperszámítógép néhány szabványos hálózati hardvert használ, gyakran Myrinet, InfiniBand vagy Gigabit Ethernet eszközt.

Masszívan párhuzamos számítástechnika

Egy szekrény az IBM Blue Gene/L masszívan párhuzamos szuperszámítógépéből

A masszívan párhuzamos processzor (MPP) egyetlen számítógép, sok hálózati processzorral. Az MPP-k ugyanolyan tulajdonságokkal rendelkeznek mint a fürtök, de speciális összekapcsoló hálózatokkal rendelkeznek (míg a fürtök kereskedelmi forgalomban kapható hardvert használnak a hálózathoz). Az MPP-k általában nagyobbak is, mint a fürtök, jellemzően „sokkal több”, mint 100 processzor. Egy MPP-ben „minden CPU tartalmazza a saját memóriáját, valamint az operációs rendszer és az alkalmazás másolatát. Minden alrendszer nagysebességű összeköttetésen keresztül kommunikál a többiekkel”.

Az IBM Blue Gene/L a TOP500-as rangsor szerint az ötödik leggyorsabb szuperszámítógép volt a világon 2009 júniusában, egy MPP.

Rácsszámítás

A rácsszámítás a párhuzamos számítástechnika legelterjedtebb formája. Az interneten keresztül kommunikáló számítógépeket használ egy adott probléma megoldására. Az interneten elérhető alacsony sávszélesség és rendkívül magas késés miatt az elosztott számítástechnika általában csak zavarba ejtő párhuzamos problémákkal foglalkozik. Számos elosztott számítástechnikai alkalmazást hoztak létre, amelyek közül a legismertebbek a SETI@home és a Folding@home.

A legtöbb rácsszámító alkalmazás köztes szoftvert használ (olyan szoftvert, amely az operációs rendszer és az alkalmazás között helyezkedik el a hálózati erőforrások kezelésére és a szoftver interfészének szabványosítására). A leggyakoribb elosztott számítástechnikai köztes szoftver a Berkeley Open Infrastructure for Network Computing (BOINC). Az elosztott számítástechnikai szoftverek gyakran „tartalék ciklusokat” használnak, és számításokat végeznek olyankor, amikor a számítógép tétlen.

Speciális párhuzamos számítógépek

A párhuzamos számítástechnikán belül vannak olyan speciális párhuzamos eszközök, amelyek továbbra is érdekes területeken maradnak. Noha nem szakterület-specifikusak, hajlamosak a párhuzamos problémák csak néhány osztályára alkalmazni.

Újrakonfigurálható számítás a felhasználás helyén programozható logikai kapumátrixokkal

Az újrakonfigurálható számítás a felhasználás helyén programozható logikai kapumátrix (FPGA) felhasználása mint egy általános célú számítógép társprocesszora. Az FPGA lényegében egy számítógépes chip, amely képes újratervezni magát egy adott feladatra.

Az FPGA-k programozhatóak olyan hardverleíró nyelvekkel, mint a VHDL vagy a Verilog. Ezen a nyelven történő programozás azonban unalmas lehet. Számos gyártó hozott létre C to HDL nyelveket, amelyek megkísérelik a C programozási nyelv szintaxisát és szemantikáját utánozni, amelyeket a legtöbb programozó ismeri. A legismertebb C to HDL nyelvek a Mitrion-C, az Impulse C, a DIME-C és a Handel-C. Erre a célra a SystemC C++ alapú meghatározott részhalmazai is használhatóak.

Az AMD azon döntése, hogy HyperTransport technológiáját harmadik felű gyártók számára megnyitja, vált a nagy teljesítményű, újrakonfigurálható számítástechnikát lehetővé tévő technológiává. Michael R. D'Amour, a DRC Computer Corporation vezérigazgató-helyettese szerint: „amikor először sétáltunk be az AMD-hez »foglalat lopóknak« hívtak minket. Most partnereinknek hívnak minket.”

Általános célú számítástechnika grafikus feldolgozó egységeken (GPGPU)

Az Nvidia Tesla GPGPU kártyája

Az általános célú számítástechnika grafikus feldolgozó egységeken (GPGPU) meglehetősen új tendencia a számítógépes mérnöki kutatásokban. A GPU-k olyan társprocesszorok, amelyeket erősen optimalizáltak a számítógépes grafika feldolgozására. A számítógépes grafikus feldolgozás olyan terület, amelyben az adatpárhuzamos műveletek dominálnak – különösen a lineáris algebrai mátrix műveletek.

A kezdeti napokban a GPGPU programok a szokásos grafikus API-kat használták a programok végrehajtására. Ugyanakkor számos új programozási nyelv és platform épült általános célú számítások elvégzéséhez GPU-n mind az Nvidia, mind az AMD kiadott programozási környezeteket a CUDA és a Stream SDK segítségével. Egyéb GPU programozási nyelvek a BrookGPU, a PeakStream és a RapidMind. Az Nvidia a Tesla sorozatban is kiadott speciális termékeket számításhoz. A Khronos Group technológiai konzorcium kiadta az OpenCL specifikációt, amely keretrendszer olyan programok írására, amelyeket CPU-kból és GPU-kból álló platformon keresztül hajtanak végre. Az AMD, az Apple, az Intel, az Nvidia és még mások is támogatják az OpenCL-t.

Alkalmazásspecifikus integrált áramkörök

Számos alkalmazásspecifikus integrált áramköri (ASIC) megközelítést dolgoztak ki a párhuzamos alkalmazások kezelésére.

Mivel az ASIC (definíció szerint) egy adott alkalmazásra jellemző, ezért teljes mértékben optimalizálható az adott alkalmazás számára. Ennek eredményeként egy adott alkalmazás esetén az ASIC általában jobb, mint egy általános célú számítógép. Az ASIC-eket azonban UV fotolitográfia hozza létre. Ehhez a folyamathoz maszkkészlet szükséges, amely rendkívül költséges lehet. Egy maszkkészlet több mint egymillió dollárba kerülhet. (Minél kisebbek a chiphez szükséges tranzisztorok, annál drágább lesz a maszk.) Eközben az általános célú számítástechnika teljesítményének növekedése az idő múlásával (ahogyan azt Moore törvénye leírja) hajlamos arra, hogy ezeket az előnyöket csak egy vagy két chipgeneráció alatt törölje el. A magas kezdeti költségek és a Moore törvénye által vezérelt általános célú számítástechnika túllépésének az a tendenciája, hogy az ASIC-ek lehetetlenné válnak a legtöbb párhuzamos számítástechnikai alkalmazás számára. Néhányat azonban építettek. Példa erre a PFLOPS RIKEN MDGRAPE-3 gépe, amely egyedi ASIC-eket használ molekuláris dinamikai szimulációhoz.

Vektorprocesszorok

A Cray-1 vektorprocesszor

A vektorprocesszor egy CPU vagy számítógépes rendszer, amely ugyanazt az utasítást képes végrehajtani nagy adatsorokon. A vektorprocesszorok magas szintű műveleteket végeznek, amelyek számok vagy vektorok lineáris tömbjein működnek. Példa vektorműveletre az A = B × C, ahol A, B és C mindegyike 64 bites lebegőpontos számok 64 elemű vektorja. Ezek szorosan kapcsolódnak Flynn SIMD besorolásához.

A Cray számítógépek a 1970-es és 1980-as években váltak híressé vektor feldolgozó számítógépeikkel. Ugyanakkor a vektorprocesszorok – mind CPU, mind pedig teljes számítógépes rendszerekként – általában eltűntek. A modern processzor utasításkészletek tartalmaznak néhány vektorfeldolgozási utasítást, például a Freescale Semiconductor AltiVec és az Intel Streaming SIMD Extensions (SSE).

Szoftver

Párhuzamos programozási nyelvek

Egyidejű programozási nyelvek, könyvtárak, API-k és párhuzamos programozási modellek (például algoritmikus vázak) készültek a párhuzamos számítógépek programozására. Ezeket általában osztályokra lehet bontani az alapul szolgáló memória-architektúrára vonatkozó feltételezések alapján – megosztott memória, elosztott memória vagy megosztott elosztott memória. A megosztott memória programozási nyelvei a megosztott memória változóinak manipulálásával kommunikálnak. Az elosztott memória az üzenettovábbítást használja. A POSIX Threads és az OpenMP a legszélesebb körben használt megosztott memória API-k, míg a Message Passing Interface (MPI) a legszélesebb körben használt üzenettovábbító rendszer API. A párhuzamos programok programozásában alkalmazott egyik koncepció a jövőbeli koncepció, ahol a program egyik része ígéretet tesz arra, hogy a szükséges adatot egy későbbi időpontban a program egy másik részéhez továbbítja.

A CAPS entreprise és a Pathscale szintén összehangolják azon törekvéseiket, hogy a hibrid többmagos párhuzamos programozási (HMPP) irányelveket OpenHMPP néven hozzák létre. Az OpenHMPP irányelv alapú programozási modell szintaxist kínál a számítások hatékony eltávolításához a hardveres gyorsítókról, és optimalizálja az adatok mozgását a hardveres memóriából/memóriába. Az OpenHMPP irányelvek távoli eljáráshívást (RPC) írnak le egy gyorsító eszközön (pl. GPU) vagy általánosságban egy magkészletnél. Az irányelvek C vagy Fortran kódot használnak a funkcionalitások két csoportjának leírására: az eljárások (jelölt kódolók) távoli eszközre történő letöltése és az adatátvitel optimalizálása a CPU főmemóriája és a gyorsító memória között.

A fogyasztói GPU-k növekedése a számítási kernelek támogatásához vezetett, akár grafikai API-kban (számítási shader-eknek nevezik), dedikált API-kban (például OpenCL) vagy más nyelvbővítményekben.

Automatikus párhuzamosítás

Egy szekvenciális program automatikus párhuzamosítása egy fordító által a párhuzamos számítástechnika „szent grálja”, különösen a processzor frekvenciájának fent említett korlátja mellett. A kutatók évtizedes munkája ellenére az automatikus párhuzamosítás csak korlátozott sikerrel járt.

A gyakori párhuzamos programozási nyelvek kifejezetten párhuzamosak vagy (legjobb esetben) részben rejtetten párhuzamosak maradnak, amelyben a programozó megadja a fordító irányelveit a párhuzamosításhoz. Néhány teljesen rejtett párhuzamos programozási nyelv létezik – SISAL, Parallel Haskell, SequenceL, SystemC (FPGA-khoz), Mitrion-C, VHDL és Verilog.

Alkalmazás ellernőrzőpontok

Ahogy egy számítógépes rendszer bonyolultabbá válik, a hibák közötti átlagos idő általában csökken. Az alkalmazás ellenőrzőpontok egy olyan módszer, amellyel a számítógépes rendszer az alkalmazás „pillanatfelvételét” készíti – az összes aktuális erőforrás-eloszlásról és változó állapotok rekordját, hasonlóan a core dump-hoz –; ezek az információk felhasználhatóak a program visszaállítására, ha a számítógép meghibásodik. Az alkalmazás ellenőrzőpontok azt jelenti, hogy a programnak a kezdeti helyett csak az utolsó ellenőrzési pontról kell újraindulnia. Noha az ellenőrzés a különféle helyzetekben előnyöket nyújt, ez különösen hasznos masszívan párhuzamos rendszerekben, ahol nagyszámú processzort használnak a nagy teljesítményű számítástechnikához.

Algoritmikus módszerek

Ahogy a párhuzamos számítógépek egyre nagyobbá és gyorsabbá válnak, most már képesek vagyunk megoldani azokat a problémákat, amelyek futása korábban túl sokáig tartott. Az olyan változatos területek, mint a bioinformatika (fehérje hajtogatás és szekvencia elemzés) és a közgazdaságtan (a pénzügyi matematika szempontjából) kihasználták a párhuzamos számítástechnika lehetőségeit. A párhuzamos számítástechnikai alkalmazások általános problémái a következők:

• Sűrű lineáris algebra
• Ritka lineáris algebra
• Spektrális módszerek (például Cooley–Tukey-algoritmus)
• N-test probléma (például Barnes–Hut-algoritmus)
• Szabályos rácsproblémák (például Lattice-Boltzmann-módszerek)
• Szabálytalan rácsproblémák (például végeselemes módszerek)
• Monte-Carlo-módszer
• Kombinációs hálózat (például brute force kriptográfiai technikák)
• Gráfbejárás (például rendezési algoritmusok)
• Dinamikus programozás
• Elágazás és korlátozás módszerek
• Grafikus modellek (például rejtett Markov-modellek észlelése és Bayes-i hálózatok építése)
• Végállapotú gépek szimulációja

Hibatűrés

A párhuzamos számítástechnika alkalmazható hibatűrő számítógépes rendszerek tervezésére is, különösen az azonos műveletet párhuzamosan végrehajtó lockstep rendszerek segítségével. Ez redundanciát biztosít az egyik összetevő meghibásodása esetén, és lehetővé teszi az automatikus hiba észlelést és a hibajavítást, ha az eredmények eltérnek. Ezek a módszerek felhasználhatóak az átmeneti hibák által okozott egyszeri események megelőzésére. Bár kiegészítő intézkedésekre lehet szükség a beágyazott vagy speciális rendszerekben, ez a módszer költséghatékony megközelítést jelenthet az n-moduláris redundancia elérése érdekében a kereskedelemben kapható rendszerekben.

Történelem

ILLIAC IV, „a leghírhedtebb szuperszámítógépek”

Az igazi (MIMD) párhuzamosság eredete visszamegy Luigi Federico Menabrea és a Sketch of the Analytical Engine Invented by Charles Babbage könyvéhez.

1958 áprilisában Stanley Gill (Ferranti) megvitatta a párhuzamos programozást, valamint az elágazás és a várakozás szükségességét. 1958-ban az IBM kutatói, John Cocke és Daniel Slotnick is először tárgyalták a párhuzamosság alkalmazását a numerikus számításokban. A Burroughs Corporation 1962-ben mutatta be a D825-öt, egy négyprocesszoros számítógépet, amely keresztirányú kapcsolón keresztül akár 16 memóriamodult is elérhet. 1967-ben Amdahl és Slotnick vitát tett közzé a párhuzamos feldolgozás megvalósíthatóságáról az Információs Feldolgozó Társaságok Amerikai Szövetsége konferencián. E vita során fogalmazta meg Amdahl törvényét, hogy meghatározza a párhuzamosság miatti sebességhatárt.

1969-ben a Honeywell bemutatta első Multics rendszerét, egy szimmetrikus multiprocesszoros rendszert, amely képes akár nyolc processzor párhuzamos futtatására. A C.mmp a 70-es években a Carnegie Mellon Egyetemen működő multiprocesszoros projekt egyike volt az első multiprocesszornak, több mint néhány processzorral. Az első busszal kapcsolt multiprocesszor szippantó gyorsítótárakkal a Synapse N+1 volt 1984-ben.

A SIMD párhuzamos számítógépek az 1970-es évekre vezethetőek vissza. A korai SIMD számítógépek mögött a motívum az volt, hogy a processzor vezérlőegységének kapukésleltetését több utasítás alapján csökkentsék. 1964-ben Slotnick javaslatot tett egy masszívan párhuzamos számítógép felépítésére a Lawrence Livermore Nemzeti Laboratórium számára. Tervezését az amerikai légierő támogatta, amely a legkorábbi SIMD párhuzamos számítástechnikai erőfeszítés az ILLIAC IV volt . A tervezés kulcsa egy meglehetősen magas párhuzamosság volt, akár 256 processzorral, amely lehetővé tette a gép számára, hogy nagy adatkészleteken dolgozzon, amelyeket később vektorfeldolgozásnak neveznek. Az ILLIAC IV-et azonban „a leghírhedtebb szuperszámítógépeknek” nevezték, mivel a projekt csak egynegyede fejeződött be, de 11 évig tartott, és az eredeti becslés majdnem négyszeresébe került. Amikor 1976-ban végre készen állt az első valódi alkalmazás futtatására, azt a meglévő kereskedelmi szuperszámítógépek, mint például a Cray-1 felülmúlta.

Biológiai agy, mint masszívan párhuzamos számítógép

Az 1970-es években, az MIT Számítástudományi és Mesterséges Intelligencia Laboratóriumban Marvin Minsky és Seymour Papert fejlődésnek indította a Society of Mind elméletet, amely a biológiai agyat, mint masszívan párhuzamos számítógép látja. Minsky 1986-ban publikálta a The Society of Mind című könyvet, amely azt állítja, hogy „az elme sok kis ügynökből áll, amelyek önmagukban értelmetlenek”. Az elmélet megkísérli megmagyarázni, hogy amit intelligenciának nevezünk, miként lehet a nem intelligens részek kölcsönhatásának a terméke. Minsky elmondja, hogy az elmélettel kapcsolatos ötletek legnagyobb forrása az a munkája volt, hogy megpróbált olyan gépet létrehozni, amely robotkarral, videokamerával és számítógéppel építkezik építőkockákból.

Hasonló modelleket (amelyek ugyancsak a biológiai agyat masszívan párhuzamos számítógépnek tekintik, azaz az agy független vagy félig független ügynökökből áll) írnak le:

• Thomas R. Blakeslee,
• Michael S. Gazzaniga,
• Robert E. Ornstein,
• Ernest Hilgard,
• Michio Kaku,
• George Ivanovich Gurdjieff,
• Neurocluster Brain Model.

Fordítás

• Ez a szócikk részben vagy egészben a Parallel computing című angol Wikipédia-szócikk ezen változatának fordításán alapul. Az eredeti cikk szerkesztőit annak laptörténete sorolja fel. Ez a jelzés csupán a megfogalmazás eredetét és a szerzői jogokat jelzi, nem szolgál a cikkben szereplő információk forrásmegjelöléseként.

További információk

• Rodriguez, C. (2008. augusztus 29.). „Asynchronous team algorithms for Boolean Satisfiability”. Bio-Inspired Models of Network, Information and Computing Systems, 2007. Bionetics 2007. 2nd, 66–69. o. DOI:10.1109/BIMNICS.2007.4610083.  
• Sechin, A.; Parallel Computing in Photogrammetry. GIM International. #1, 2016, pp. 21–23.

Kapcsolódó oldalak

• Instructional videos on CAF in the Fortran Standard by John Reid (see Appendix B)
• Lawrence Livermore National Laboratory: Introduction to Parallel Computing
• Designing and Building Parallel Programs, by Ian Foster
• Internet Parallel Computing Archive
• Parallel processing topic area at IEEE Distributed Computing Online
• Parallel Computing Works Free On-line Book
• Frontiers of Supercomputing Free On-line Book Covering topics like algorithms and industrial applications
• Universal Parallel Computing Research Center
• Course in Parallel Programming at Columbia University (in collaboration with IBM T.J. Watson X10 project)
• Parallel and distributed Gröbner bases computation in JAS, see also Gröbner basis
• Course in Parallel Computing at University of Wisconsin-Madison
• Berkeley Par Lab: progress in the parallel computing landscape, Editors: David Patterson, Dennis Gannon, and Michael Wrinn, August 23, 2013
• The trouble with multicore, by David Patterson, posted 30 Jun 2010
• The Landscape of Parallel Computing Research: A View From Berkeley (one too many dead link at this site)
• Introduction to Parallel Computing
• Coursera: Parallel Programming

Kapcsolódó szócikkek

• Többfeladatosság
• Transputer
• Vektorprocesszor