Párhuzamos számítástechnika forrásának megtekintése

[[Fájl:IBM_Blue_Gene_P_supercomputer.jpg|jobbra|bélyegkép|300x300px|Az IBM [[IBM Blue Gene|Blue Gene/P]] [[Masszívan párhuzamos feldolgozás|masszívan párhuzamos]] [[szuperszámítógép]]e]]

A '''párhuzamos számítástechnika''' a [[számítástechnika]] egy típusa, ahol a számításokat vagy [[Folyamat (számítástechnika)|folyamatokat]] egyidejűleg hajtják végre.<ref>{{cite book |last=Gottlieb |first=Allan |title=Highly parallel computing |url=http://dl.acm.org/citation.cfm?id=160438 |year=1989 |publisher=Benjamin/Cummings |location=Redwood City, Calif. |isbn=978-0-8053-0177-9 |author2=Almasi, George S.}}</ref> A nagy problémákat gyakran fel lehet osztani kisebbekre, melyeket párhuzamosan lehet megoldani. A párhuzamos számítástechnikának többféle formája létezik: [[Bitszintű párhuzamosság|bitszintű]], [[Utasításszintű párhuzamosság|utasításszintű]], [[Adat-párhuzamosság|adat-]] és [[feladat-pá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 [[frekvenciaskálázás]] fizikai korlátai miatt.<ref>S.V. Adve ''et al.'' (November 2008). [https://graphics.cs.illinois.edu/sites/default/files/upcrc-wp.pdf „Parallel Computing Research at Illinois: The UPCRC Agenda”] {{webarchive |url=https://web.archive.org/web/20180111165735/https://graphics.cs.illinois.edu/sites/default/files/upcrc-wp.pdf |date=2018-01-11}} (PDF). Parallel@Illinois, University of Illinois at Urbana-Champaign. „A teljesítmény előnyeinek fő technikái – a megnövekedett órajel és az intelligensebb, de egyre összetettebb architektúrák – most az úgynevezett erőfalon vannak. A számítógépes ipar elfogadta, hogy a jövőbeli teljesítménynövekedésnek nagyrészt a processzorok (vagy magok) számának növelésén kell alapulnia, ahelyett, hogy egyetlen mag válna gyorsabbá.”</ref> 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,<ref>Asanovic ''et al.'' „Régi [hagyományos bölcsesség]: Az áram ingyenes, de a [[tranzisztor]]ok drágák. Az új [hagyományos bölcsesség] az, hogy az áram drága, de a tranzisztorok »ingyenesek«.”</ref> a párhuzamos számítástechnika a [[számítógép-architektúra]] meghatározó paradigmájává vált, főleg a [[többmagos processzor]]ok formájában.<ref name="View-Power">Asanovic, Krste ''et al.'' (December 18, 2006). [http://www.eecs.berkeley.edu/Pubs/TechRpts/2006/EECS-2006-183.pdf „The Landscape of Parallel Computing Research: A View from Berkeley”] (PDF). University of California, Berkeley. Technical Report No. UCB/EECS-2006-183. „Régi [hagyományos bölcsesség]: A processzor teljesítmény javításának elsődleges módja az órajel növelése. Új [hagyományos bölcsesség]: A növekvő párhuzamosság az elsődleges módszer a processzor teljesítményének javítására… Még az Intel, »a nagyobb órajel jobb« pozícióval társult vállalat képviselői is figyelmeztettek arra, hogy a teljesítmény maximalizálása a hagyományos megközelítésekkel, vagyis az órajel növelésével, elérte a határát.”</ref>

A párhuzamos számítástechnika szorosan kapcsolódik az [[Egyidejű számítástechnika|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).<ref name="waza">„Concurrency is not Parallelism”, ''Waza conference'' Jan 11, 2012, [[Rob Pike]] ([http://talks.golang.org/2012/waza.slide slides] {{Webarchive|url=https://web.archive.org/web/20150730203124/http://talks.golang.org/2012/waza.slide |date=2015-07-30 }}) ([http://vimeo.com/49718712 video])</ref><ref>{{cite web |url=https://wiki.haskell.org/Parallelism_vs._Concurrency |title=Parallelism vs. Concurrency |work=Haskell Wiki}}</ref> 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 az egyidejű számítástechnikában a különféle folyamatok gyakran nem foglalkoznak a kapcsolódó feladatokkal; az [[Elosztott számítások|elosztott számítástechnikában]] 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 processzor|többmagos]] és a [[Szimmetrikus többprocesszoros rendszer|többprocesszoros]] számítógépek esetében egyazon gépen több [[feldolgozóelem]] van, míg a [[Számítógépfürt|fürtök]], [[Masszívan párhuzamos feldolgozás|MPP]]-k és [[rácsszámítás]]ok 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 algoritmus]]ok közül különösen azokat, amelyek egyidejűséget használnak, nehezebb megírni, mint [[Szekvenciális algoritmus|szekvenciális]] társaikat,<ref>{{cite book |last=Hennessy |first=John L. |authorlink=John L. Hennessy |title=Computer organization and design: the hardware/software interface |url=https://archive.org/details/computerorganiz000henn |edition=2. ed., 3rd print. |year=1999 |publisher=Kaufmann |location=San Francisco |isbn=978-1-55860-428-5 |author2=Patterson, David A. |authorlink2=David Patterson (computer scientist) |author3=Larus, James R. |authorlink3=James Larus}}</ref> mivel az egyidejűség számos új potenciális [[Bug (informatika)|szoftverhibát]] rejt, amelyek közül a versenyhelyzetek a leggyakoribbak. A különböző alfeladatok közötti [[Számítógép-hálózat|kommunikáció]] és [[Szinkronizáció (számítástechnika)|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 (számítástechnika)|gyorsulásának]] elméleti [[Felső és alsó határ|felső határát]] a párhuzamosítás eredményeként [[Amdahl-törvény|Amdahl törvénye]] adja meg.

{{TOClimit|limit=4}}

== Háttér ==

Hagyományosan a [[Szoftver|számítógépes szoftvereket]] [[Soros számítógép|soros számításra]] írták. Egy probléma megoldásához egy [[algoritmus]]t állítanak össze és valósítanak meg soros utasításfolyamként. Ezeket az utasításokat egy számítógép [[Central processing unit|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.<ref name="llnltut">{{cite web |url=http://www.llnl.gov/computing/tutorials/parallel_comp/ |title=Introduction to Parallel Computing |accessdate=2007-11-09 |author=Barney, Blaise |publisher=Lawrence Livermore National Laboratory |archiveurl=https://www.webcitation.org/6HkQWt6d4?url=https://computing.llnl.gov/tutorials/parallel_comp/ |archivedate=2013-06-29 }}</ref>

A párhuzamos számítástechnika viszont több feldolgozó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, és mindegyik feldolgozóelem az algoritmus egy részét a többivel egyidejűleg hajtja végre. A feldolgozó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 az előbbiek bármelyikének kombinációi.<ref name="llnltut" /> 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.<ref>{{cite book |author=Thomas Rauber |title=Parallel Programming: for Multicore and Cluster Systems |url=https://archive.org/details/parallelprogramm00raub_703 |year=2013 |publisher=Springer Science & Business Media |isbn=9783642378010 |page=[https://archive.org/details/parallelprogramm00raub_703/page/1 1] |author2=Gudula Rünger}}</ref>

A [[frekvenciaská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 idő (számítástechnika)|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 az 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 [[processzorigényes]] program futási idejét.<ref>{{cite book |last=Hennessy |first=John L. |title=Computer architecture / a quantitative approach. |edition=3rd |year=2002 |publisher=International Thomson |location=San Francisco, Calif. |isbn=978-1-55860-724-8 |page=43 |author2=Patterson, David A.}}</ref> Ugyanakkor a processzor által adott <math>P</math> energiafogyasztást a <math>P=C \cdot U^2 \cdot F</math> egyenlet adja meg, ahol <math>C</math> a [[Elektromos kapacitás|kapacitás]] ciklusonként kapcsolva (arányos azon tranzisztorok számával, amelyek bemenete változik), <math>U</math> a [[Elektromos feszültség|feszültség]] és <math>F</math> a processzor frekvenciája (másodpercenkénti ciklusok száma).<ref>{{cite book |last=Rabaey |first=Jan M. |title=Digital integrated circuits: a design perspective |year=1996 |publisher=Prentice-Hall |location=Upper Saddle River, N.J. |isbn=978-0-13-178609-7 |page=235}}</ref> 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 frekvenciaskálázás végének tekintenek és az uralkodó számítógép-architektúra paradigmájának neveznek.<ref>{{cite news |last=Flynn |first=Laurie J. |title=Intel Halts Development Of 2 New Microprocessors |url=https://www.nytimes.com/2004/05/08/business/08chip.html?ex=1399348800&en=98cc44ca97b1a562&ei=5007 |accessdate=5 June 2012 |newspaper=New York Times |date=8 May 2004}}</ref>

Az energiafogyasztás és a túlmelegedés problémájának kezelése érdekében a processzorgyártók elkezdték a többmagos, energiahatékony processzorok gyártását. A mag a processzor számítási egysége, a többmagos processzorokban minden mag független és ugyanahhoz a memóriához egyidejűleg fér hozzá. A [[többmagos processzor]]ok párhuzamos számítástechnikát hoztak az [[asztali számítógép]]ekbe. Í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 [[szerver]]ek 10 és 12 magos processzorokkal rendelkeztek. [[Moore-törvény|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.<ref>{{cite book |author=Thomas Rauber |title=Parallel Programming: for Multicore and Cluster Systems |url=https://archive.org/details/parallelprogramm00raub_703 |year=2013 |publisher=Springer Science & Business Media |isbn=9783642378010 |page=[https://archive.org/details/parallelprogramm00raub_703/page/2 2] |author2=Gudula Rünger}}</ref>

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 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ások futtatásának gyorsítását már nem lehet frekvenciaskálázással elérni, hanem a programozóknak kell párhuzamosítaniuk a szoftverkódjukat, hogy kihasználhassák a többmagos architektúrák növekvő számítási teljesítményét.<ref>{{cite book |author=Thomas Rauber |title=Parallel Programming: for Multicore and Cluster Systems |url=https://archive.org/details/parallelprogramm00raub_703 |year=2013 |publisher=Springer Science & Business Media |isbn=9783642378010 |page=[https://archive.org/details/parallelprogramm00raub_703/page/3 3] |author2=Gudula Rünger}}</ref>

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

[[Fájl:AmdahlsLaw.svg|jobbra|bélyegkép|300x300px|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.]]

[[Fájl:Optimizing-different-parts.svg|jobbra|bélyegkép|300x300px|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).]]

Optimális esetben a párhuzamosítástól való [[Gyorsulás (számítástechnika)|gyorsulás]] lineáris lenne – a feldolgozó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 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égnövekedés tapasztalható kisszámú feldolgozóelem esetében, amely állandó értékké válik nagyszámú feldolgozóelem esetén.

Az algoritmus várható gyorsulását egy párhuzamos számítási platformon Amdahl törvénye adja meg:<ref>{{cite journal |last=Amdahl |first=Gene M. |title=Validity of the single processor approach to achieving large scale computing capabilities |journal=Proceeding AFIPS '67 (Spring) Proceedings of the April 18–20, 1967, Spring Joint Computer Conference |pages=483–485 |doi=10.1145/1465482.1465560 |url=http://dl.acm.org/citation.cfm?id=160438 |year=1967}}</ref>

: <math>S_\text{latency}(s) = \frac{1}{1 - p + \frac{p}{s}},</math>

ahol

* <math>S_\text{latency}</math> a végrehajtás [[késleltetés]]ének lehetséges gyorsulása az egész feladat esetében;
* <math>s</math> a végrehajtás késleltetésének lehetséges gyorsulása a feladat párhuzamosítható része esetében;
* <math>p</math> a feladat párhuzamosítható részének végrehajtási ideje a párhuzamosítás előtt a teljes feladat végrehajtási idejének százalékában.

Mivel az <math>S_\text{latency}<{1 \over 1-p}</math>, 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 <math>(p=0,9)</math>, legfeljebb tízszeres gyorsulást érhetünk el, függetlenül attól, hogy hány processzort használunk. 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 szekvenciális korlátozások miatt, a feldolgozási teljesítmény növelése nem befolyásolja annak végrehajtási idejét. Az emberi terhesség kilenc hónapig tart, függetlenül attól, hogy hány nőt jelölünk ki.”<ref>{{cite book |last=Brooks |first=Frederick P. |title=The mythical man month essays on software engineering |url=https://archive.org/details/mythicalmonth00broo |edition=Anniversary ed., repr. with corr., 5. [Dr.] |year=1996 |publisher=Addison-Wesley |location=Reading, Mass. [u.a.] |isbn=978-0-201-83595-3}}</ref>

[[Fájl:Gustafson.png|jobbra|bélyegkép|300x300px|[[Gustafson-törvény|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.<ref>{{cite book |title=Structured Parallel Programming: Patterns for Efficient Computation |url=https://archive.org/details/structuredparall0000mcco |year=2013 |publisher=Elsevier |pages=[https://archive.org/details/structuredparall0000mcco/page/n90 61] |author1=Michael McCool |author2=James Reinders |author3=Arch Robison}}</ref> Ebben az esetben [[Gustafson-törvény|Gustafson törvénye]] kevésbé pesszimista és reálisabb értékelést ad a párhuzamos teljesítményről:<ref>{{cite journal |last=Gustafson |first=John L. |title=Reevaluating Amdahl's law |journal=Communications of the ACM |date=May 1988 |volume=31 |issue=5 |pages=532–533 |doi=10.1145/42411.42415 |url=http://www.scl.ameslab.gov/Publications/Gus/AmdahlsLaw/Amdahls.html |url-status=dead |archiveurl=https://web.archive.org/web/20070927040654/http://www.scl.ameslab.gov/Publications/Gus/AmdahlsLaw/Amdahls.html |archivedate=2007-09-27 |citeseerx=10.1.1.509.6892 |s2cid=33937392}}</ref>

: <math>S_\text{latency}(s) = 1 - p + sp.</math>

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 arányosan változik a processzorok számával.

=== Függőségek ===

Az [[adatfüggőség]]ek megértése alapvető fontosságú a [[párhuzamos algoritmus]]ok megvalósításában. Egyik program sem futhat gyorsabban, mint a függő számítások leghosszabb lánca (úgynevezett [[Kritikusút-módszer|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 <math>P_i</math> és <math>P_j</math> két programszegmens. Bernstein feltételei<ref>{{cite journal |last=Bernstein |first=A. J. |title=Analysis of Programs for Parallel Processing |journal=IEEE Transactions on Electronic Computers |date=1 October 1966 |volume=EC-15 |issue=5 |pages=757–763 |doi=10.1109/PGEC.1966.264565}}</ref> leírják, mikor a kettő független és párhuzamosan végrehajtható. <math>P_i</math> számára legyen <math>I_i</math> az összes bemeneti és <math>O_i</math> a kimeneti változó, és ugyanígy a <math>P_j</math> esetében. <math>P_i</math> és <math>P_j</math> függetlenek, ha teljesülnek a következők:

: <math>I_j \cap O_i = \varnothing,</math>
: <math>I_i \cap O_j = \varnothing,</math>
: <math>O_i \cap O_j = \varnothing.</math>

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 hamis fü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.<ref>{{cite book |last=Roosta |first=Seyed H. |title=Parallel processing and parallel algorithms: theory and computation |url=https://archive.org/details/parallelprocessi00roos |year=2000 |publisher=Springer |location=New York, NY [u.a.] |isbn=978-0-387-98716-3 |page=[https://archive.org/details/parallelprocessi00roos/page/n129 114]}}</ref>

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 az utasítás hozzáférések közötti érvényesítésére, például [[Szemafor (programozás)|szemaforokra]], [[Barrier (programozás)|akadályokra]] vagy más [[Szinkronizáció (számítástechnika)|szinkronizálási módszerre]].

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

A párhuzamos programok alfeladatait gyakran [[Szál (programozás)|szálaknak]] hívják. Néhány párhuzamos számítógép-architektúra a szálak kisebb, könnyű verzióit, [[Rost (programozás)|rostokat]], míg mások nagyobb, [[Folyamat (számítástechnika)|folyamatoknak]] nevezett verziókat használnak. A szálakat azonban elfogadják az alfeladatok általános kifejezésének.<ref>{{cite web |url=https://msdn.microsoft.com/en-us/library/windows/desktop/ms684841(v=vs.85).aspx |title=Processes and Threads |last= |first= |date=2018 |website=Microsoft Developer Network |publisher=Microsoft Corp. |access-date=2018-05-10}}</ref> A szálaknak gyakran [[Szinkronizáció (számítástechnika)|szinkronizált]] hozzáférésre van szükségük egy [[Objektum (informatika)|objektumhoz]] vagy más [[Erőforrás-gazdálkodás (számítástechnika)|erőforráshoz]], például amikor frissíteniük kell egy köztük megosztott [[Változó (programozás)|változót]]. Szinkronizálás nélkül a két szál közötti utasítások tetszőleges sorrendben összeilleszthetők. Vegyük például a következő programot:

{| class="wikitable"
|A szál
|B szál
|-
|1A: olvassa be a V változót
|1B: olvassa be a V változót
|-
|2A: adjon hozzá 1-et a V változóhoz
|2B: adjon hozzá 1-et a 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 [[Versenyhelyzet#A_számítástechnikában|versenyhelyzetnek]] nevezik. A programozónak [[Lock (informatika)|zárat]] kell használnia, hogy a [[kölcsönös kizárás]]t é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 programszakaszát, amely kizárólagos hozzáférést igényel valamilyen változóhoz) és az adat 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:

{| class="wikitable"
|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 a V változót
|2B: olvassa be a V változót
|-
|3A: adjon hozzá 1-et a V változóhoz
|3B: adjon hozzá 1-et a 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 [[Software lockout|befejezi a végrehajtást]], és nem folytatja addig, amíg a V változó újra fel nem oldódik. Ez garantálja a program helyes végrehajtását. Lehetséges, hogy zárakra 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 [[Szoftverminőség|megbízhatóságát]].<ref>{{cite web |url=http://www.developforperformance.com/ThreadSafetyForPerformance.html |title=Thread Safety for Performance |last=Krauss |first=Kirk J |date=2018 |website=Develop for Performance |access-date=2018-05-10 |archiveurl=https://web.archive.org/web/20180513081315/http://www.developforperformance.com/ThreadSafetyForPerformance.html |archivedate=2018-05-13 }}</ref>

Több változó lezárása [[atomiság (számítástechnika)|nem atomi]] zárakkal bevezeti a program [[holtpont]]já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 az 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.<ref>{{cite book |last=Tanenbaum |first=Andrew S. |title=Introduction to Operating System Deadlocks |url=http://www.informit.com/articles/article.aspx?p=25193 |date=2002-02-01 |publisher=Pearson Education, Informit |website=Informit |access-date=2018-05-10}}</ref>

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 (programozás)|szemafor]] segítségével valósítják meg.<ref>{{cite web |url=https://www.embedded.com/design/operating-systems/4440752/Synchronization-internals----the-semaphore |title=Synchronization internals – the semaphore |last=Cecil |first=David |date=2015-11-03 |website=Embedded |publisher=AspenCore |access-date=2018-05-10}}</ref> Az algoritmusok egyik osztálya, az úgynevezett [[Nem blokkoló algoritmus|zárolás és várakozás nélküli algoritmusok]] összességében elkerülik a zárak és az akadályok használatát. Ezt a megközelítést azonban általában nehéz végrehajtani, és helyesen megtervezett adatszerkezeteket igényel.<ref>{{cite web |url=http://preshing.com/20120612/an-introduction-to-lock-free-programming/ |title=An Introduction to Lock-Free Programming |last=Preshing |first=Jeff |date=2012-06-08 |website=Preshing on Programming |access-date=2018-05-10}}</ref>

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.<ref>{{cite web |url=https://stackoverflow.com/questions/806569/whats-the-opposite-of-embarrassingly-parallel |title=What's the opposite of “embarrassingly parallel”? |last= |first= |date= |website=StackOverflow |access-date=2018-05-10}}</ref><ref>{{cite web |url=https://stackoverflow.com/questions/1970345/what-is-thread-contention |title=What is thread contention? |last=Schwartz |first=David |date=2011-08-15 |website=StackOverflow |access-date=2018-05-10}}</ref> 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 lassulás]] néven ismert<ref>{{cite web |url=https://software.intel.com/en-us/blogs/2008/03/04/why-a-simple-test-can-get-parallel-slowdown |title=Why a simple test can get parallel slowdown |last=Kukanov |first=Alexey |date=2008-03-04 |website= |access-date=2015-02-15}}</ref> és bizonyos esetekben javítható szoftverelemzéssel és újratervezéssel.<ref>{{cite web |url=http://www.developforperformance.com/ThreadingForPerformance.html |title=Threading for Performance |last=Krauss |first=Kirk J |date=2018 |website=Develop for Performance |access-date=2018-05-10 |archiveurl=https://web.archive.org/web/20180513081501/http://www.developforperformance.com/ThreadingForPerformance.html |archivedate=2018-05-13 }}</ref>

=== Finom felbontású, durva felbontású é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 felbontású párhuzamosságot mutat, ha részfeladatainak másodpercenként sokszor kell kommunikálniuk; durva felbontású párhuzamosságot mutat, ha másodpercenként nem sokszor kommunikálnak, és [[zavarba ejtő párhuzamosság]]ot mutat, ha ritkán vagy soha nem kell kommunikálniuk. A zavarba ejtően párhuzamos alkalmazásokat lehet a legkönnyebben párhuzamosítani.

=== Flynn-féle osztályozás ===

{{bővebben|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, amit ma Flynn-féle osztályozásnak hívnak. Flynn attól függően osztályozta a programokat és a számítógépeket, 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 végezzük el egy nagy adatkészleten. Ezt általában [[Jelfeldolgozás|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 a [[szisztolés tömb]]ök), 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 minta.”<ref>Patterson and Hennessy, p.&nbsp;748.</ref>

== A párhuzamosság típusai ==

=== Bitszintű párhuzamosság ===

[[Fájl:Taiwania 3 Supercomputer.jpg|bélyegkép|Taiwania 3, egy párhuzamos szuperszámítógép, amely csatlakozott a [[Covid19]]-kutatáshoz]]

A [[VLSI]] ''(Very Large Scale Integration)'' számítógépes chipgyá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ó (számítástechnika)|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.<ref>{{cite book |last=Singh |first=David Culler; J.P. |title=Parallel computer architecture |edition=[Nachdr.] |year=1997 |publisher=Morgan Kaufmann Publ. |location=San Francisco |isbn=978-1-55860-343-1 |page=15}}</ref> 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 architektúra|8 bites]] processzornak két [[16 bites architektúra|16 bites]] [[Egész számok|egész számot]] kell összeadnia, akkor a processzornak először össze kell adnia a 8 alacsonyabb rendű bitet mindkettő egészből a szokásos összeadási utasítás felhasználásával, majd össze kell adnia a 8 magasabb rendű bitet egy add-with-carry utasítás segítségével és az [[átvitelbit]]et 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 lenne.

A [[4 bites architektúra|4 bites]] mikroprocesszorokról történelmileg 8, 16, majd 32 bites mikroprocesszorokra váltottak. Ez a tendencia általánosságban véget ért a 32 bites processzorok bevezetésével, amely két évtizede az általános célú 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 architektúra|64 bites]] processzorok köznapivá.

=== Utasításszintű párhuzamosság ===

[[Fájl:Nopipeline.png|jobbra|bélyegkép|300x300px|Szabványos processzor [[Utasítás-futószalag|futószalag]] nélkül. Egy utasítás elvégzéséhez öt ciklus szükséges, és így a processzor szubskalár teljesítményt adhat ({{nowrap|1=IPC = 0,2 < 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 [[Instructions per Cycle|utasítást adhat ki ciklusonként]] ({{nowrap|IPC < 1}}). Ezeket a processzorokat szubskalár processzoroknak nevezzük. Ezek az utasítások [[Mikroarchitektúra#Soron_kívüli_végrehajtás|újrarendelhetők]] és csoportokba rendezhetők, amelyeket 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.<ref>Culler et al. p.&nbsp;15.</ref>

[[Fájl:Fivestagespipeline.png|jobbra|bélyegkép|300x300px|Szabványos processzor ötfokozatú [[Utasítás-futószalag|futószalaggal]]. A legjobb esetben egy utasítás teljesítéséhez egy ciklus szükséges, így a processzor skalár teljesítményt adhat ({{nowrap|1=IPC = 1}}).]]

Minden modern processzor többfokozatú [[utasítás-futószalag]]ot kínál. A futószalag egyes szintjei eltérő műveletnek felelnek meg, amelyet a processzor az adott utasításban hajt végre; egy ''N'' fokozatú futószalaggal rendelkező processzornak legfeljebb ''N'' különféle utasítása lehet a teljesítés különböző szakaszaiban, így ciklusonként egy utasítást adhat ki ({{nowrap|1=IPC = 1}}). Ezek a processzorok skalár processzorok. A futószalagos processzor szabványos példája egy [[Reduced Instruction Set Computing|RISC]]-processzor, amely öt szintből áll: utasításlekérés (IF), utasításdekódolás (ID), végrehajtás (EX), memória-hozzáférés (MEM) és regiszter-visszaírás (WB). A [[Pentium 4]] processzornak 35 fokozatú futószalagja volt.<ref>[[Yale Patt]] (April 2004). [http://users.ece.utexas.edu/~patt/Videos/talk_videos/cmu_04-29-04.wmv The Microprocessor Ten Years From Now: What Are The Challenges, How Do We Meet Them?] {{webarchive |url=https://web.archive.org/web/20080414141000/http://users.ece.utexas.edu/~patt/Videos/talk_videos/cmu_04-29-04.wmv |date=2008-04-14}} (wmv). Distinguished Lecturer talk at [[Carnegie Mellon University]]. Retrieved on November 7, 2007.</ref>

[[Fájl:Superscalarpipeline.svg|jobbra|bélyegkép|300x300px|Szabványos processzor két végrehajtóegységgel és ötfokozatú [[Utasítás-futószalag|futószalaggal]]. A legjobb esetben két utasítás teljesítéhez egy ciklus szükséges, így a processzor szuperskalár teljesítményt adhat ({{nowrap|1=IPC = 2 > 1}}).]]

A legtöbb modern processzornak több [[végrehajtóegység]]e is van. Általában ezt a szolgáltatást kombinálják a futószalaggal, így ciklusonként egynél több utasítást adhatnak ki ({{nowrap|IPC > 1}}). Ezeket a processzorokat [[szuperskalár processzor]]oknak nevezzük. A szuperskalár processzorok abban különböznek a többmagos processzoroktól, hogy a több végrehajtóegység nem teljes processzor (azaz feldolgozóegység). Az utasításokat csak akkor lehet csoportosítani, ha nincs [[adatfüggőség]] közöttük. A [[scoreboarding]] és a [[Tomasulo-algoritmus]] (amely hasonló az scoreboardinghoz, de a [[Regiszterátnevezés|regiszterek átnevezését]] használja) a két leggyakoribb módszer a soron kívüli végrehajtás és az utasításszintű párhuzamosság megvalósításához.

{{anchor|feladat-párhuzamosság}}
=== Feladat-párhuzamosság ===

A feladat-párhuzamosság egy párhuzamos program azon jellemzője, hogy teljesen eltérő számítások végezhetők ugyanazon vagy különböző adatkészleteken.<ref name="Culler124">Culler et al. p.&nbsp;124.</ref> Ez ellentétben áll az adat-párhuzamossággal, amikor ugyanazt a számítást hajtják végre ugyanazon vagy különböző adatkészleteken. A feladat-pá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 feladat-párhuzamosság általában nem egyezik meg a probléma méretével.<ref name="Culler125">Culler et al. p.&nbsp;125.</ref>

=== Szuperszószintű párhuzamosság ===

A szuperszószintű párhuzamosság egy [[Automatikus vektorizálás|vektorizálási]] technika, amely [[cikluskifejtés]]en és alapvető blokkvektorizáláson alapul. Ez abban különbözik a ciklusvektorizációs algoritmusoktól, hogy ki tudja használni a [[Inline code|soros kód]] párhuzamosságát, például a koordináták, a színcsatornák vagy a kézzel kifejtett ciklusok kezelését.<ref>{{cite web |title=Exploiting Superword Level Parallelism with Multimedia Instruction Sets |url=http://groups.csail.mit.edu/cag/slp/SLP-PLDI-2000.pdf |author=Samuel Larsen |author2=Saman Amarasinghe |accessdate=2020-07-07 |archiveurl=https://web.archive.org/web/20170812091312/http://groups.csail.mit.edu/cag/slp/SLP-PLDI-2000.pdf |archivedate=2017-08-12 }}</ref>

== Hardver ==

=== Memória és kommunikáció ===

A párhuzamos számítógép főmemóriája vagy [[Közös memóriahasználat|közös memória]] (az összes feldolgozóelem között megosztva egyetlen [[címtér]]ben), vagy [[Elosztott memóriahasználat|elosztott memória]] (amelyben minden feldolgozóelemnek megvan a saját helyi címtere).<ref name="PH713">Patterson and Hennessy, p.&nbsp;713.</ref> 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 [[osztott közös memória]] és a [[memóriavirtualizá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ép]]ekben az osztott közös memóriaterület a programozási modell segítségével, 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 [[InfiniBand]] segítségével egy külső közösmemória-rendszerhez is csatlakozik. Ezt a külső közösmemória-rendszert [[burst puffer]]nek nevezik, amely általában [[nem felejtő memória]] tömbjeiből épül fel, fizikailag elosztva több bemeneti/kimeneti csomópont között.

[[Fájl:Numa.svg|jobbra|bélyegkép|400x400px|A [[Non-uniform memory access|nem egységes memória-hozzáférésű]] (NUMA) architektúra logikai nézete. Az egyik címtárban lévő processzorok kevesebb késleltetéssel férhetnek hozzá a címtár memóriájához, mint a többi címtár memóriájához.]]

Azokat a számítógép-architektúrákat, amelyekben a főmemória minden eleméhez azonos [[Memóriakésleltetés|késleltetéssel]] és [[sávszélesség]]gel lehet hozzáférni, [[Uniform memory access|egységes memória-hozzáférésű]] (UMA) rendszereknek nevezzük. Általában ezt csak egy [[Közös memóriahasználat|közösmemória]]-rendszerrel lehet elérni, amelyben a memória fizikailag nincs elosztva. Azt a rendszert, amely nem rendelkezik ezzel a tulajdonsággal, [[Non-uniform memory access|nem egységes memória-hozzáférésű]] (NUMA) architektúrának nevezik. Az elosztottmemória-rendszerek nem egységes memória-hozzáféréssel rendelkeznek.

A számítógépes rendszerek [[gyorsítótár]]akat 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|gyorsítótárkoherencia]]-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 [[Bus snooping|buszfigyelé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árkoherencia-rendszerek tervezése nagyon nehéz probléma a számítógép-architektúrában. Ennek eredményeként a közös memória számítógép-architektúrái nem olyan nagy léptékűek, mint az elosztottmemória-rendszerek.<ref name="PH713" />

A processzor–processzor és a processzor–memória kommunikációt sokféle módon megvalósíthatjuk a hardverben, többek között közös (multiportált vagy [[Multiplexelés|multiplexelt]]) memória, [[Crossbar switch|keresztkapcsoló]], megosztott [[Busz (informatika)|busz]] vagy összekapcsolt hálózat révén számos [[Hálózati topológia|topológiával]], beleértve a [[Csillagtopológia|csillagot]], [[Gyűrűtopológia|gyűrűt]], [[Fa (gráfelmélet)|fát]], [[Hiperkockagráf|hiperkockát]], kövér hiperkockát (egy csomóponton egynél több processzort tartalmazó hiperkocka) vagy [[Mesh networking|n dimenziós hálót]].

Az összekapcsolt hálózatokon alapuló párhuzamos számítógépeknek valamilyen [[útválasztás]]sal 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.

=== A 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 rendszerekből álló fürtök viszonylag gyakoriak.

==== Többmagos számítástechnika ====

A többmagos processzor több [[Central processing unit|feldolgozóegységet]] (úgynevezett magokat) foglal magában ugyanazon a chipen. Ezek a processzorok különböznek a [[szuperskalár processzor]]októl, amelyek több [[végrehajtóegység]]et tartalmaznak, és ciklusonként több utasítást adhatnak ki egy utasításfolyamból (szálból); ezzel szemben a többmagos processzorok ciklusonként több utasítást adhatnak ki több utasításfolyamból. Az [[IBM]] [[Cell (mikroprocesszor)|Cell mikroprocesszorát]] a [[Sony Corporation|Sony]] [[PlayStation 3]]-ban való használatra tervezték, egy kiemelkedő többmagos processzorként. A többmagos processzorok minden magja potenciálisan szuperskalár is lehet, azaz ciklusonként minden egyes mag több utasítást adhat ki egy szálból.

A [[szimultán többszálú végrehajtás]] (amelyek közül az Intel [[Hyper-Threading]] a legismertebb) a pseudo-multi-coreism korai formája volt. A szimultán többszálú végrehajtásra képes processzorok több végrehajtóegységet tartalmaznak ugyanabban a feldolgozóegységben – azaz szuperskalár architektúrával rendelkeznek –, és ciklusonként több utasítást adhatnak ki több szálból. Az [[időosztásos többszálú vé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 többprocesszoros rendszer (SMP) több azonos processzorral rendelkezik, amelyek megosztják a memóriát és [[Busz (informatika)|buszon]] keresztül csatlakoznak.<ref name="HP549">Hennessy and Patterson, p.&nbsp;549.</ref> A [[Bus contention|buszviszály]] megakadályozza a buszarchitektúrák méretezését. Ennek eredményeként az SMP-k általában legfeljebb 32 processzort tartalmaznak.<ref>Patterson and Hennessy, p.&nbsp;714.</ref> A processzorok kis mérete és a nagy gyorsítótárak révén a buszsávszélességre vonatkozó követelmények jelentős csökkenése miatt az ilyen szimmetrikus többprocesszoros rendszerek rendkívül költséghatékonyak, feltéve, hogy elegendő mennyiségű memória-sávszélességgel rendelkeznek.<ref name="HP549" />

==== Elosztott számítástechnika ====

{{bővebben|Elosztott számítások}}

Az elosztott számítógép elosztott memóriával rendelkező számítógépes rendszer, amelyben a feldolgozóelemek hálózattal vannak összekötve. Az elosztott számítógépek nagymértékben bővíthetők. 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.<ref>Ghosh (2007), p. 10. Keidar (2008).</ref> Ugyanaz a rendszer jellemezhető párhuzamos és elosztott formában is; egy tipikus elosztott rendszerben a processzorok párhuzamosan futnak.<ref>Lynch (1996), p. xix, 1–2. Peleg (2000), p. 1.</ref>

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

{{bővebben|Számítógépfürt}}

[[Fájl:Beowulf.jpg|jobbra|bélyegkép|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ők.<ref>[http://www.webopedia.com/TERM/c/clustering.html What is clustering?] Webopedia computer dictionary. Retrieved on November 7, 2007.</ref> 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, azonban 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ózat]]hoz csatlakoztatott, több azonos [[Commercial off-the-shelf|kereskedelmi forgalomban kapható]] számítógépen valósul meg.<ref>[https://www.pcmag.com/encyclopedia_term/0,2542,t=Beowulf&i=38548,00.asp Beowulf definition.] {{Wayback|url=https://www.pcmag.com/encyclopedia_term/0%2C2542%2Ct%3DBeowulf%26i%3D38548%2C00.asp |date=20121010215231 }} ''PC Magazine''. Retrieved on November 7, 2007.</ref> A Beowulf technológiát eredetileg [[Thomas Sterling (számítástechnika)|Thomas Sterling]] és [[Donald Becker]] fejlesztette ki. A [[TOP500]] rangsor szuperszámítógépei közül 87% fürt.<ref>{{cite web |url=https://www.top500.org/statistics/list/ |title=List Statistics {{!}} TOP500 Supercomputer Sites |website=www.top500.org |language=en |access-date=2018-08-05}}</ref> A fennmaradók masszívan 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ően 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.<ref>[https://www.nersc.gov/users/computational-systems/hopper/configuration/interconnect/ „Interconnect”] {{webarchive |url=https://web.archive.org/web/20150128133120/https://www.nersc.gov/users/computational-systems/hopper/configuration/interconnect/ |date=2015-01-28}}</ref> 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 =====

[[Fájl:BlueGeneL_cabinet.jpg|jobbra|bélyegkép|Egy szekrény az [[IBM]] [[IBM Blue Gene|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ási 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.<ref>Hennessy and Patterson, p.&nbsp;537.</ref> Egy MPP-ben minden processzor 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.<ref>[https://www.pcmag.com/encyclopedia_term/0,,t=mpp&i=47310,00.asp MPP Definition.] {{Wayback|url=https://www.pcmag.com/encyclopedia_term/0%2C%2Ct%3Dmpp%26i%3D47310%2C00.asp |date=20130511084523 }} ''PC Magazine''. Retrieved on November 7, 2007.</ref>

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

===== Rácsszámítások =====

{{bővebben|Rácsszámítás}}

A rácsszámítás a párhuzamos számítástechnika legelterjedtebb formája. Az [[internet]]en 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ésleltetés miatt az elosztott számítástechnika általában csak zavarba ejtően párhuzamos problémákkal foglalkozik. [[Elosztott számítástechnikai projektek listája|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]].<ref>{{cite journal |last=Kirkpatrick |first=Scott |title=COMPUTER SCIENCE: Rough Times Ahead |journal=Science |volume=299 |issue=5607 |pages=668–669 |doi=10.1126/science.1081623 |year=2003 |pmid=12560537 |s2cid=60622095}}</ref>

A legtöbb rácsszámító alkalmazás [[köztes szoftver]]t 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-specifikus nyelv|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]] egy [[Field-programmable gate array|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ók olyan [[hardverleíró nyelv]]ekkel mint a [[VHDL]]<ref>{{Cite journal|last1=Valueva|first1=Maria|last2=Valuev|first2=Georgii|last3=Semyonova|first3=Nataliya|last4=Lyakhov|first4=Pavel|last5=Chervyakov|first5=Nikolay|last6=Kaplun|first6=Dmitry|last7=Bogaevskiy|first7=Danil|date=2019-06-20|title=Construction of Residue Number System Using Hardware Efficient Diagonal Function|journal=Electronics|language=en|volume=8|issue=6|pages=694|doi=10.3390/electronics8060694|issn=2079-9292|quote=All simulated circuits were described in very high speed integrated circuit (VHSIC) hardware description language (VHDL). Hardware modeling was performed on Xilinx FPGA Artix 7 xc7a200tfbg484-2.|doi-access=free}}</ref> vagy a [[Verilog]].<ref>{{Cite journal|last1=Gupta|first1=Ankit|last2=Suneja|first2=Kriti|date=May 2020|title=Hardware Design of Approximate Matrix Multiplier based on FPGA in Verilog|url=https://ieeexplore.ieee.org/document/9121004|journal=2020 4th International Conference on Intelligent Computing and Control Systems (ICICCS)|location=Madurai, India|publisher=IEEE|pages=496–498|doi=10.1109/ICICCS48265.2020.9121004|isbn=978-1-7281-4876-2|s2cid=219990653}}</ref> Ezeken a nyelveken 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)|C programozási nyelv]] [[C-szintaxis|szintaxisát]] és szemantikáját utánozni, amelyeket a legtöbb programozó ismer. A legismertebb C to HDL nyelvek a [[Mitrionics|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ók.

Az AMD azon döntése, hogy [[HyperTransport]] technológiáját más 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á.<ref name="DAmour">D’Amour, Michael R., Chief Operating Officer, [[DRC Computer Corporation]]. „Standard Reconfigurable Computing”. Invited speaker at the University of Delaware, February 28, 2007.</ref> Michael R. D’Amour, a [[DRC Computer Corporation]] vezérigazgató-helyettese szerint: „amikor először sétáltunk be az AMD-hez »[[Processzorfoglalat|foglalat]]lopóknak« hívtak minket. Most partnereinknek hívnak minket.”<ref name="DAmour" />
{{anchor|GPGPU}}
===== Általános célú számítástechnika grafikus feldolgozóegységeken (GPGPU) =====

[[Fájl:NvidiaTesla.jpg|jobbra|bélyegkép|Az Nvidia [[Nvidia Tesla|Tesla GPGPU kártyája]]]]

Az általános célú számítástechnika [[Graphics processing unit|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.<ref>Boggan, Sha’Kia and Daniel M. Pressel (August 2007). [http://www.arl.army.mil/arlreports/2007/ARL-SR-154.pdf GPUs: An Emerging Platform for General-Purpose Computation] {{webarchive |url=https://web.archive.org/web/20161225073248/http://www.arl.army.mil/arlreports/2007/ARL-SR-154.pdf |date=2016-12-25}} (PDF). ARL-SR-154, U.S. Army Research Lab. Retrieved on November 7, 2007.</ref> 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 algebra]]i [[Mátrix (matematika)|mátrixmű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 [[Advanced Micro Devices|AMD]] által kiadott programozási környezetekkel, 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 [[Nvidia Tesla|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 [[Advanced Micro Devices|AMD]], az [[Apple Inc.|Apple]], az [[Intel]], az [[Nvidia]] és még mások is támogatják az OpenCL-t.

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

{{bővebben|Alkalmazásspecifikus integrált áramkör}}

Számos [[alkalmazásspecifikus integrált áramkör]]i (ASIC) megközelítést dolgoztak ki a párhuzamos alkalmazások kezelésére.<ref>Maslennikov, Oleg (2002). [[doi:10.1007/3-540-48086-2_30|„Systematic Generation of Executing Programs for Processor Elements in Parallel ASIC or FPGA-Based Systems and Their Transformation into VHDL-Descriptions of Processor Element Control Units”]] ''Lecture Notes in Computer Science'', '''2328/2002:''' p.&nbsp;272.</ref><ref>{{cite journal |last=Shimokawa |first=Y. |author2=Fuwa, Y. |author3=Aramaki, N. |title=A parallel ASIC VLSI neurocomputer for a large number of neurons and billion connections per second speed |journal=International Joint Conference on Neural Networks |date=18–21 November 1991 |volume=3 |pages=2162–2167 |doi=10.1109/IJCNN.1991.170708 |isbn=978-0-7803-0227-3 |s2cid=61094111}}</ref><ref>{{cite journal |last=Acken |first=Kevin P. |author2=Irwin, Mary Jane |author3=Owens, Robert M. |title=A Parallel ASIC Architecture for Efficient Fractal Image Coding |journal=The Journal of VLSI Signal Processing |date=July 1998 |volume=19 |issue=2 |pages=97–113 |doi=10.1023/A:1008005616596 |s2cid=2976028}}</ref>

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 [[Fotolitográfia|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.<ref>Kahng, Andrew B. (June 21, 2004) [http://www.future-fab.com/documents.asp?grID=353&d_ID=2596 Scoping the Problem of DFM in the Semiconductor Industry] {{webarchive |url=https://web.archive.org/web/20080131221732/http://www.future-fab.com/documents.asp?grID=353&d_ID=2596 |date=2008-01-31}} University of California, San Diego. „A gyártás jövőbeli tervezésének (DFM) csökkentenie kell a tervezési költséget [nem megtérülő költség], és közvetlenül foglalkoznia kell a gyártás – a maszkkészlet és a szondakártya – költségeivel [nem megtérülő költségek], amely jóval meghaladja az egymillió dollárt 90 nm esetén és jelentős gátat szab a félvezető-alapú innovációnak.”</ref> (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ény|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.<ref name="DAmour" /> A magas kezdeti költség és a Moore törvénye által vezérelt általános célú számítástechnika túllépésének tendenciája az ASIC-eket a legtöbb párhuzamos számítástechnikai alkalmazás számára megvalósíthatatlanná tette. Néhányat azonban építettek. Példa erre a PFLOPS [[RIKEN MDGRAPE-3]] gépe, amely egyedi ASIC-eket használ [[molekuláris dinamika]]i szimulációhoz.

===== Vektorprocesszorok =====

{{bővebben|Vektorprocesszor}}

[[Fájl:Cray_1_IMG_9126.jpg|jobbra|bélyegkép|A [[Cray-1]] vektorprocesszor]]

A vektorprocesszor egy processzor 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 <math>A=B \cdot C</math>, ahol <math>A</math>, <math>B</math> és <math>C</math> mindegyike 64 bites [[Lebegőpontos számábrázolás|lebegőpontos számok]] 64 elemű vektorja.<ref name="PH751">Patterson and Hennessy, p.&nbsp;751.</ref> Ezek szorosan kapcsolódnak Flynn SIMD besorolásához.<ref name="PH751" />

A [[Cray]] számítógépek az 1970-es és 1980-as években váltak híressé vektorfeldolgozó számítógépeikkel. Ugyanakkor a vektorprocesszorok – mind processzorként, mind pedig teljes számítógépes rendszerként – általánosságban eltűntek. A modern [[Utasításkészlet|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ű és párhuzamos programozási nyelvek listája|Egyidejű programozási nyelvek]], [[Programkönyvtár|könyvtárak]], [[Alkalmazásprogramozási felület|API]]-k és [[párhuzamos programozási modell]]ek (például [[Algorithmic skeleton|algoritmikus vázlatok]]) 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óriaarchitektúrára vonatkozó feltételezések alapján – közös memória, elosztott memória vagy osztott közös memória. A közös memória programozási nyelvei a közös memória változóinak manipulálásával kommunikálnak. Az elosztott memória az [[üzenettovábbítás]]t használja. A [[POSIX Threads]] és az [[OpenMP]] a legszélesebb körben használt közös memória API-k, míg a [[Message Passing Interface]] (MPI) a legszélesebb körben használt üzenettovábbító rendszer API.<ref>The [http://awards.computer.org/ana/award/viewPastRecipients.action?id=16 Sidney Fernbach Award given to MPI inventor Bill Gropp] {{webarchive |url=https://web.archive.org/web/20110725191103/http://awards.computer.org/ana/award/viewPastRecipients.action?id=16 |date=2011-07-25}} refers to MPI as „the dominant HPC communications interface”</ref> A párhuzamos programok programozásában alkalmazott egyik koncepció a [[Future (számítástechnika)|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 [[Hybrid multi-core parallel programming|hibrid többmagos párhuzamos programozási]] (HMPP) irányelveket [[OpenHMPP]] néven hozzák létre. Az OpenHMPP irányelvalapú programozási modell szintaxist kínál a számítások hatékony eltávolításához a hardveres gyorsítókon, é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ás]]t (RPC) írnak le egy gyorsítóeszközön (pl. GPU) vagy általánosságban egy magkészletnél. Az irányelvek [[C (programozási nyelv)|C]] vagy [[Fortran]] kódot használnak a funkcionalitások két csoportjának leírására: az eljárások (codeletek) távoli eszközre történő letöltése, és az adatátvitel optimalizálása a processzor főmemóriája és a gyorsítómemória között.

A fogyasztói GPU-k növekedése a [[compute kernel]]ek támogatásához vezetett, akár a grafikai API-kban (más néven [[compute shader]]ek), 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óprogram|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.<ref>{{cite book |last=Shen |first=John Paul |title=Modern processor design: fundamentals of superscalar processors |edition=1st |year=2004 |publisher=McGraw-Hill |location=Dubuque, Iowa |isbn=978-0-07-057064-1 |page=561 |quote=Ezen kutatás »szent gráljának« – a soros programok automatizált párhuzamosításának – még nincs megvalósulása. Noha bizonyították az algoritmusok bizonyos osztályainak automatikus párhuzamosítását, az ilyen siker nagyrészt a kiszámítható áramlásszabályozással (például beágyazott ciklusszerkezetek statikusan meghatározott iterációs számlálással) és statikusan analizálható memória-hozzáférési mintákkal korlátozódott tudományos és numerikus alkalmazásokon (például végigmenni lebegőpontos adatok nagy, többdimenziós tömbjein). |author2=Mikko H. Lipasti}}</ref>

A gyakori párhuzamos programozási nyelvek [[Kifejezett párhuzamosság|kifejezetten párhuzamosak]] vagy (legjobb esetben) részben [[Rejtett párhuzamosság|rejtetten párhuzamosak]] maradnak, amelyben a programozó megadja a fordító [[Irányelv (programozás)|irányelveit]] a párhuzamosításhoz. Néhány teljesen rejtett párhuzamos programozási nyelv létezik – [[SISAL]], Parallel [[Haskell (programozási nyelv)|Haskell]], [[SequenceL]], [[SystemC]] ([[Field-programmable gate array|FPGA]]-k számára), [[Mitrionics|Mitrion-C]], [[VHDL]] és [[Verilog]].

=== Ellenőrzőpont-képzés alkalmazásokban ===

Ahogy egy számítógépes rendszer bonyolultabbá válik, a [[MTBF|hibák közötti átlagos idő]] általában csökken. Az [[Ellenőrzőpont-képzés alkalmazásokban|ellenőrzőpont-képzés]] egy olyan módszer, amellyel a számítógépes rendszer az alkalmazás „pillanatfelvételét” készíti el – az összes aktuális erőforrás-elosztásról és a változó állapotokról, hasonlóan a [[memóriakép]]hez –; ezek az információk felhasználhatók a program visszaállítására, ha a számítógép meghibásodik. Az ellenőrzőpont-képzés azt jelenti, hogy a programnak a kezdeti helyett csak az utolsó ellenőrzési pontról kell újraindulnia. Noha az ellenőrzőpont-képzés a különféle helyzetekben előnyöket nyújt, különösen hasznos a [[Nagy teljesítményű számítástechnika|nagy teljesítményű számítástechnikában]], ahol a masszívan párhuzamos rendszerek nagyszámú processzort használnak.<ref>''Encyclopedia of Parallel Computing, Volume 4'' by David Padua 2011 {{ISBN|0387097651}} page 265</ref>

== 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érjehajtogatás]] és [[szekvenciaelemzé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:<ref>Asanovic, Krste, et al. (December 18, 2006). [http://www.eecs.berkeley.edu/Pubs/TechRpts/2006/EECS-2006-183.pdf „The Landscape of Parallel Computing Research: A View from Berkeley”] (PDF). University of California, Berkeley. Technical Report No. UCB/EECS-2006-183. See table on pages 17–19.</ref>

* [[sűrű lineáris algebra]], (lásd még: [[lineáris algebra]])
* [[ritka lineáris algebra]],
* spektrális módszerek (például [[Cooley–Tukey-algoritmus]]),
* [[N-test probléma|{{mvar|n}}-test probléma]] (például [[Barnes–Hut-algoritmus]]),
* [[szabályos rács|szabályosrács]]-problémák (például [[Lattice-Boltzmann-módszer]]ek),
* [[szabálytalan rács|szabálytalanrács]]-problémák (például [[végeselemes módszer]]ek),
* [[Monte-Carlo-módszer]],
* [[kombinációs hálózat]] (például [[Brute force-támadás|brute force kriptográfiai technikák]]),
* [[gráfbejárás]] (például [[Rendezés (programozás)|rendezési algoritmusok]]),
* [[dinamikus programozás]],
* [[elágazás és korlátozás]] módszerek,
* [[grafikus modell]]ek (például [[rejtett Markov-modell]]ek észlelése és [[Bayes-háló]]k építése),
* [[végállapotú gép]]ek szimulációja.

== Hibatűrés ==

A párhuzamos számítástechnika alkalmazható [[Hibatűrés|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 (számítástechnika)|lockstep]]-rendszerek segítségével. Ez [[Redundancia|redundanciát]] biztosít az egyik összetevő meghibásodása esetén, és lehetővé teszi az automatikus [[Hibajavítás|hibaészlelést]] és [[hibajavítás]]t, ha az eredmények eltérnek. Ezek a módszerek felhasználhatók az átmeneti hibák által okozott egyszeri események megelőzésére.<ref>Dobel, B., Hartig, H., & Engel, M. (2012) „Operating system support for redundant multithreading”. ''Proceedings of the Tenth ACM International Conference on Embedded Software'', 83–92. {{doi|10.1145/2380356.2380375}}</ref> 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.

== Előzmények ==

[[Fájl:ILLIAC_4_parallel_computer.jpg|jobbra|bélyegkép|[[ILLIAC IV]], „a szuperszámítógépek leghírhedtebbike”<ref name="infamous" />]]

Az igazi (MIMD) párhuzamosság eredete visszamegy [[Luigi Federico Menabrea]] és a ''Sketch of the [[Analitikus gép|Analytical Engine]] Invented by [[Charles Babbage]]'' (Charles Babbage által feltalált analitikus gép vázlata) című könyvéhez.<ref>[[Luigi Federico Menabrea|Menabrea, L. F.]] (1842). [http://www.fourmilab.ch/babbage/sketch.html ''Sketch of the Analytic Engine Invented by Charles Babbage'']. Bibliothèque Universelle de Genève. Retrieved on November 7, 2007. idézet: „amikor azonos számítások hosszú sorát kell elvégezni, például a szorzótáblák kialakításához szükségeseket, akkor a gépet el lehet indítani úgy, hogy több eredményt adjon egyszerre, ami nagymértékben csökkenti a folyamatok mennyiségét.”</ref><ref name="PH753">Patterson and Hennessy, p.&nbsp;753.</ref><ref>R.W. Hockney, C.R. Jesshope. [https://books.google.com/books?id=6HcBQ67-Fb4C ''Parallel Computers 2: Architecture, Programming and Algorithms, Volume 2'']. 1988. p. 8 idézet: „Úgy gondolják, hogy a számítógépes tervezésben a párhuzamosság legkorábbi hivatkozása O. F. Menabrea tábornok 1842-ben kiadott kiadványában található, melynek címe: ''Sketch of the Analytical Engine Invented by Charles Babbage''.”</ref>

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.<ref>„Parallel Programming”, S. Gill, ''The Computer Journal'' Vol. 1 #1, pp2-10, British Computer Society, April 1958.</ref> 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.<ref name="G_Wilson">{{cite web |url=http://ei.cs.vt.edu/~history/Parallel.html |title=The History of the Development of Parallel Computing |accessdate=2008-01-08 |first=Gregory V. |last=Wilson |year=1994 |publisher=Virginia Tech/Norfolk State University, Interactive Learning with a Digital Library in Computer Science}}</ref> A [[Burroughs Corporation]] 1962-ben mutatta be a D825-öt, egy négyprocesszoros számítógépet, amely [[Crossbar switch|keresztkapcsolón]] keresztül akár 16 memóriamodult is elérhet.<ref>{{cite web |url=http://www.computerworld.com/action/article.do?command=viewArticleBasic&articleId=65878 |title=The Power of Parallelism |author=Anthes, Gry |accessdate=2008-01-08 |date=November 19, 2001 |work=[[Computerworld]] |url-status=dead |archiveurl=https://web.archive.org/web/20080131205427/http://www.computerworld.com/action/article.do?command=viewArticleBasic&articleId=65878 |archivedate=January 31, 2008}}</ref> 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.<ref name="G_Wilson" /> E vita során fogalmazta meg [[Amdahl-törvény|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 többprocesszoros rendszert, amely képes akár nyolc processzor párhuzamos futtatására.<ref name="G_Wilson" /> A [[C.mmp]] a 70-es években a [[Carnegie Mellon University|Carnegie Mellon Egyetemen]] működő többprocesszoros projekt egyike volt az első többprocesszoros rendszernek, több mint néhány processzorral. Az első busszal kapcsolt többprocesszoros rendszer figyelt gyorsítótárakkal a [[Synapse N+1]] volt 1984-ben.<ref name="PH753" />

A SIMD párhuzamos számítógépek az 1970-es évekre vezethetők vissza. A korai SIMD számítógépek mögött a motiváció az volt, hogy a processzor [[vezérlőegység]]ének [[Terjedési késés|kapukésését]] több utasítás felett csökkentsék.<ref>Patterson and Hennessy, p.&nbsp;749.</ref> 1964-ben Slotnick javaslatot tett egy masszívan párhuzamos számítógép felépítésére a [[Lawrence Livermore National Laboratory|Lawrence Livermore Nemzeti Laboratórium]] számára.<ref name="G_Wilson" /> Tervezését az [[Az Amerikai Egyesült Államok Légiereje|amerikai légierő]] támogatta, amely a legkorábbi SIMD párhuzamos számítástechnikai erőfeszítés volt, [[ILLIAC IV]] néven.<ref name="G_Wilson" /> A tervezés kulcsa egy meglehetősen nagy párhuzamosság volt, akár 256 processzorral, amely lehetővé tette a gép számára, hogy nagy adatkészleteken dolgozzon, amit később [[Vektorprocesszor|vektorfeldolgozásnak]] neveznek. Az ILLIAC IV-et azonban a szuperszámítógépek leghírhedtebbikének 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.<ref name="infamous">Patterson and Hennessy, pp.&nbsp;749–50: „Noha az ILLIAC IV sikeresen alkalmazta a későbbi projektekben hasznos technológiákat, az ILLIAC IV számítógépes hibaként jelent meg. A költségek az 1966-ban becsült 8 millió dollárról 1972-re 31 millió dollárra növekedtek, annak ellenére, hogy a tervezett gép mindössze egynegyedét építették meg. Ez talán a szuperszámítógépek leghírhedtebbike volt. A projekt 1965-ben indult, és első valódi alkalmazását 1976-ban futatta.”</ref> 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últák.

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

Az 1970-es években, az [[MIT Computer Science and Artificial Intelligence Laboratory|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 feldolgozás|masszívan párhuzamos számítógép]] látja. Minsky 1986-ban publikálta a ''The Society of Mind'' című könyvét, amely azt állítja, hogy az elme sok kis ágensből áll, amelyek önmagukban értelmetlenek.<ref>{{cite book |last=Minsky |first=Marvin |title=The Society of Mind |url=https://archive.org/details/societyofmind00marv/page/17 |date=1986 |publisher=Simon & Schuster |location=New York |isbn=978-0-671-60740-1 |pages=[https://archive.org/details/societyofmind00marv/page/17 17]}}</ref> Az elmélet megkísérli megmagyarázni, hogy amit intelligenciának nevezünk, miként lehet 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 robotkar, videókamera és számítógép segítségével építkezik építőkockákból.<ref>{{cite book |last=Minsky |first=Marvin |title=The Society of Mind |url=https://archive.org/details/societyofmind00marv/page/29 |date=1986 |publisher=Simon & Schuster |location=New York |isbn=978-0-671-60740-1 |pages=[https://archive.org/details/societyofmind00marv/page/29 29]}}</ref>

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

* Thomas R. Blakeslee,<ref>{{cite book |last=Blakeslee |first=Thomas |authorlink=Thomas R. Blakeslee |title=Beyond the Conscious Mind. Unlocking the Secrets of the Self |url=https://archive.org/details/beyondconsciousm00blak |date=1996 |pages=[https://archive.org/details/beyondconsciousm00blak/page/6 6–7] |url-access=registration}}</ref>
* [[Michael S. Gazzaniga]],<ref>{{cite book |title=The Integrated Mind |url=https://archive.org/details/integratedmind00gazz |date=1978 |pages=[https://archive.org/details/integratedmind00gazz/page/n137 132]–161 |last1=Gazzaniga |first1=Michael |authorlink1=Michael S. Gazzaniga |last2=LeDoux |first2=Joseph |authorlink2=Joseph E. LeDoux}}</ref><ref>{{cite book |last=Gazzaniga |first=Michael |authorlink=Michael S. Gazzaniga |title=The Social Brain. Discovering the Networks of the Mind |url=https://archive.org/details/socialbraindisco0000gazz |date=1985 |pages=[https://archive.org/details/socialbraindisco0000gazz/page/77 77–79] |url-access=registration}}</ref>
* [[Robert E. Ornstein]],<ref>{{cite book |last=Ornstein |first=Robert |authorlink=Robert Ornstein |title=Evolution of Consciousness: The Origins of the Way We Think |url=https://archive.org/details/evolutionofconsc0000orns |date=1992 |pages=[https://archive.org/details/evolutionofconsc0000orns/page/2 2] |url-access=registration}}</ref>
* [[Ernest Hilgard]],<ref>{{cite book |last=Hilgard |first=Ernest |authorlink=Ernest Ropiequet „Jack” Hilgard |title=Divided consciousness: multiple controls in human thought and action |url=https://archive.org/details/dividedconscious0000hilg |date=1977 |publisher=Wiley |location=New York |isbn=978-0-471-39602-4}}</ref><ref>{{cite book |last=Hilgard |first=Ernest |authorlink=Ernest Ropiequet „Jack” Hilgard |title=Divided consciousness: multiple controls in human thought and action (expanded edition) |url=https://archive.org/details/dividedconscious0000hilg_c0z9 |date=1986 |publisher=Wiley |location=New York |isbn=978-0-471-80572-4}}</ref>
* [[Michio Kaku]],<ref>{{cite book |last=Kaku |first=Michio |authorlink=Michio Kaku |title=The Future of the Mind |date=2014 |title-link=The Future of the Mind}}</ref>
* [[G. I. Gurdjieff|George Ivanovich Gurdjieff]],<ref>{{cite book |last=Ouspenskii |first=Pyotr |authorlink=Pyotr Demianovich Ouspenskii |title=In Search of the Miraculous. Fragments of an Unknown Teaching |date=1992 |pages=72–83 |chapter=Chapter 3}}</ref>
* Neurocluster Brain Model.<ref>{{cite web |url=http://neuroclusterbrain.com |title=Official Neurocluster Brain Model site |access-date=July 22, 2017}}</ref>

== Jegyzetek ==
{{jegyzetek}}

== Fordítás ==
* {{fordítás|en|Parallel computing|oldid=1041057095}}

== További információk ==
* {{cite journal |last1=Rodriguez |first1=C. |last2=Villagra |first2=M. |last3=Baran |first3=B. |title=Asynchronous team algorithms for Boolean Satisfiability |journal=Bio-Inspired Models of Network, Information and Computing Systems, 2007. Bionetics 2007. 2nd |date=29 August 2008 |pages=66–69 |doi=10.1109/BIMNICS.2007.4610083 |s2cid=15185219}}
* Sechin, A.; Parallel Computing in Photogrammetry. GIM International. #1, 2016, pp.&nbsp;21–23.

== Külső hivatkozások ==
* [http://www.nd.edu/~dbalsara/Numerical-PDE-Course Instructional videos on CAF in the Fortran Standard by John Reid (see Appendix B)]
* [http://www.llnl.gov/computing/tutorials/parallel_comp/ Lawrence Livermore National Laboratory: Introduction to Parallel Computing]
* [http://www-unix.mcs.anl.gov/dbpp/ Designing and Building Parallel Programs, by Ian Foster]
* [https://web.archive.org/web/20021012122919/http://wotug.ukc.ac.uk/parallel/ Internet Parallel Computing Archive]
* [https://web.archive.org/web/20110928211245/http://dsonline.computer.org/portal/site/dsonline/index.jsp?pageID=dso_level1_home&path=dsonline%2Ftopics%2Fparallel&file=index.xml&xsl=generic.xsl Parallel processing topic area at IEEE Distributed Computing Online]
* [http://www.new-npac.org/projects/cdroms/cewes-1998-05/copywrite/pcw/book.html Parallel Computing Works Free On-line Book] {{Wayback|url=http://www.new-npac.org/projects/cdroms/cewes-1998-05/copywrite/pcw/book.html |date=20110727120355 }}
* [http://ark.cdlib.org/ark:/13030/ft0f59n73z/ Frontiers of Supercomputing Free On-line Book Covering topics like algorithms and industrial applications]
* [https://web.archive.org/web/20081020052247/http://www.upcrc.illinois.edu/ Universal Parallel Computing Research Center]
* [https://web.archive.org/web/20100122110043/http://ppppcourse.ning.com/ Course in Parallel Programming at Columbia University (in collaboration with IBM T.J. Watson X10 project)]
* [https://arxiv.org/PS_cache/arxiv/pdf/1008/1008.0011v1.pdf Parallel and distributed Gröbner bases computation in JAS]
* [https://web.archive.org/web/20110826190010/http://sbel.wisc.edu/Courses/ME964/2011/index.htm Course in Parallel Computing at University of Wisconsin-Madison]
* [http://research.microsoft.com/en-us/collaboration/parlab/contents.aspx Berkeley Par Lab: progress in the parallel computing landscape], Editors: David Patterson, Dennis Gannon, and Michael Wrinn, August 23, 2013
* [https://spectrum.ieee.org/computing/software/the-trouble-with-multicore The trouble with multicore], by David Patterson, posted 30 Jun 2010
* [https://www.techsevi.com/supercomputer/ Parallel Computing : A View From Techsevi]
* [https://computing.llnl.gov/tutorials/parallel_comp/ Introduction to Parallel Computing]{{Wayback|url=https://computing.llnl.gov/tutorials/parallel_comp/ |date=20130610122229 }}
* [https://www.coursera.org/learn/parprog1 Coursera: Parallel Programming]
* [https://www.gyangrih.in/ Parallel Computing : A View From Gyan Grih]

== Kapcsolódó szócikkek ==
* [[Többfeladatosság]]
* [[Transputer]]
* [[Vektorprocesszor]]

{{Párhuzamos számítástechnika}}

{{portál|informatika|i }}

{{DEFAULTSORT:Párhuzamosszámítástechnika}}
[[Kategória:Párhuzamos számítástechnika| ]]