Parallel computergebruik

* Definitie: Een computertype waarbij meerdere processors of kernen binnen een enkele machine aanwezig zijn tegelijkertijd aan verschillende delen van hetzelfde probleem werken. De focus ligt op het verminderen van de tijd die nodig is om een ​​probleem op te lossen door de werklast te verdelen.

* Belangrijkste kenmerken:

* Gedeeld geheugen (meestal): Parallelle systemen maken vaak gebruik van gedeeld geheugen, wat betekent dat alle processors toegang hebben tot dezelfde geheugenruimte. Dit maakt het eenvoudig delen van gegevens en communicatie tussen processors mogelijk. Gedeeld geheugen kan echter een knelpunt zijn.

* Strakke koppeling: Processoren zijn nauw met elkaar verbonden, wat betekent dat ze vaak communiceren en een lage latentie hebben.

* Homogene omgeving (meestal): De processors zijn vaak vergelijkbaar of identiek qua architectuur en mogelijkheden.

* Enkel besturingssysteem: Wordt doorgaans uitgevoerd op één exemplaar van een besturingssysteem.

* Locatie: Fysiek dicht bij elkaar geplaatst, vaak binnen dezelfde computer of rack.

* Voorbeelden:

* Multicore-processors in uw desktopcomputer.

* GPU's (Graphics Processing Units) voor wetenschappelijke simulaties of machinaal leren.

* Multiprocessorservers met gedeeld geheugen.

Gedistribueerd computergebruik

* Definitie: Een type computergebruik waarbij meerdere onafhankelijke computers (knooppunten of machines) samenwerken aan een gemeenschappelijke taak of reeks taken. Deze machines zijn fysiek gescheiden en communiceren via een netwerk.

* Belangrijkste kenmerken:

* Gedistribueerd geheugen: Elke computer (knooppunt) heeft zijn eigen privégeheugenruimte. Gegevens moeten expliciet tussen knooppunten worden overgedragen via het doorgeven van berichten.

* Losse koppeling: Knooppunten zijn losjes gekoppeld, wat betekent dat ze minder vaak communiceren en een hogere latentie hebben in vergelijking met parallelle systemen.

* Heterogene omgeving (vaak): Knooppunten kunnen divers zijn wat betreft hardware, besturingssystemen en netwerkconnectiviteit.

* Meerdere besturingssystemen: Elk knooppunt voert doorgaans zijn eigen exemplaar van een besturingssysteem uit.

* Locatie: Geografisch verspreid, kan het over een kamer, een gebouw of zelfs over de hele wereld gaan.

* Voorbeelden:

* Cloud computing-platforms (AWS, Azure, Google Cloud).

* Cluster computing (groepen van netwerkcomputers die samenwerken).

* Grid computing (geografisch verspreide bronnen).

* Peer-to-peer-netwerken.

Belangrijkste verschillen samengevat:

| Kenmerk | Parallel computergebruik | Gedistribueerde computers |

|-------------------|---------------------------------|----------------------------------------|

| Verwerkers | Meerdere cores binnen één machine | Meerdere onafhankelijke machines (knooppunten) |

| Geheugen | Gedeeld geheugen (meestal) | Gedistribueerd geheugen (elk knooppunt heeft zijn eigen) |

| Koppeling | Strakke koppeling | Losse koppeling |

| Locatie | Nabijheid | Geografisch verspreid |

| Communicatie | Gedeelde geheugentoegang of het doorgeven van berichten | Bericht doorgeven (netwerkcommunicatie) |

| Homogeniteit | Meestal homogeen | Vaak heterogeen |

| Besturingssysteem | Eén exemplaar | Meerdere exemplaren |

Impact op schaalbaarheid

* Schaalbaarheid van parallelle computers:

* Beperkt door het aantal kernen/processors in een enkele machine: Je wordt uiteindelijk beperkt door de fysieke beperkingen van de machine. Bij opschalen gaat het meestal om het kopen van krachtigere hardware met meer kernen, wat erg duur kan worden.

* Knelpunt in gedeeld geheugen: Naarmate het aantal processors toeneemt, kan de strijd om gedeeld geheugen een aanzienlijk knelpunt worden, waardoor de schaalbaarheid wordt beperkt. Technieken als caching en NUMA (Non-Uniform Memory Access) kunnen dit helpen verzachten.

* De wet van Amdahl: De wet van Amdahl stelt dat de snelheid van een programma dat meerdere processors gebruikt, wordt beperkt door het deel van het programma dat kan worden geparalleliseerd. Als een aanzienlijk deel van het programma inherent sequentieel is, zal het toevoegen van meer processors een afnemend rendement opleveren.

* Goed voor: Rekeningintensieve taken die gemakkelijk kunnen worden opgesplitst in kleinere, onafhankelijke taken en die zeer geschikt zijn voor gedeelde geheugenarchitecturen.

* Gedistribueerde computerschaalbaarheid:

* Horizontaal schaalbaar: U kunt eenvoudig meer knooppunten aan het systeem toevoegen om de verwerkingskracht te vergroten. Dit wordt vaak 'uitschalen' genoemd.

* Fouttolerantie: Als één knooppunt uitvalt, kan het systeem blijven functioneren, op voorwaarde dat de werklast kan worden herverdeeld naar andere knooppunten.

* Verwerkt grote datasets: Zeer geschikt voor het verwerken en opslaan van enorme datasets die onpraktisch zouden zijn om op één enkele machine te verwerken.

* Netwerklatentie: Communicatie tussen knooppunten via het netwerk introduceert latentie, wat de prestaties kan beperken, vooral voor toepassingen die frequente gegevensuitwisseling vereisen. Strategieën zoals datalokaliteit (gegevens verwerken dichtbij de plek waar deze zijn opgeslagen) zijn cruciaal.

* Complexiteit: Gedistribueerde systemen zijn complexer om te ontwerpen, implementeren en beheren vanwege problemen als gegevensconsistentie, fouttolerantie en beveiliging.

* Goed voor: Applicaties die kunnen worden onderverdeeld in onafhankelijke taken die op verschillende machines kunnen worden uitgevoerd, zoals webservers, pijplijnen voor gegevensverwerking en grootschalige simulaties.

In een notendop:

* Parallel computing geeft prioriteit aan snelheid en efficiëntie binnen één enkele machine. De schaalbaarheid wordt beperkt door hardwarebeperkingen en gedeelde geheugenknelpunten.

* Gedistribueerd computergebruik geeft prioriteit aan schaalvergroting om grotere werklasten en datavolumes aan te kunnen, met inherente fouttolerantie. De schaalbaarheid ervan wordt beperkt door netwerklatentie en de complexiteit van het beheer van een gedistribueerd systeem.

De keuze tussen parallelle en gedistribueerde computing hangt sterk af van het specifieke probleem dat u probeert op te lossen, de beschikbare bronnen en het vereiste niveau van schaalbaarheid en fouttolerantie. Vaak worden hybride benaderingen gebruikt, waarbij parallelle verwerking binnen elk knooppunt van een gedistribueerd systeem wordt gecombineerd.