Algoritmen en Datastructuren III Partim: Parallelle algoritmen - caagt

Algoritmen en Datastructuren III 

Partim: Parallelle algoritmen 

Veerle Fack 

12 november 2008

Inhoudsopgave 

1 Inleiding 1 

1.1 Parallelle algoritmen ontwerpen en analyseren . . . . . . . . . . . . . . . . . . . 2 

1.2 Modellen van parallelle computers . . . . . . . . . . . . . . . . . . . . . . . . . 4 

2 Het gedeelde-geheugenmodel 7 

2.1 Het gedeelde-geheugenmodel . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 

2.2 De Parallel Random-Access Machine (PRAM) . . . . . . . . . . . . . . . . . . 10 

2.2.1 Het PRAM-model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 

2.2.2 Geheugenmodellen voor PRAM . . . . . . . . . . . . . . . . . . . . . . 11 

2.2.3 Semigroep-problemen . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 

2.2.4 Kost-optimaliseren van PRAM-algoritmen . . . . . . . . . . . . . . . . 14 

2.3 Het werk-tijd-paradigma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 

2.3.1 Het WT-presentatieniveau . . . . . . . . . . . . . . . . . . . . . . . . . 15 

2.3.2 Het WT-scheduling-niveau . . . . . . . . . . . . . . . . . . . . . . . . . 16 

3 Het netwerkmodel 19 

3.1 Het netwerkmodel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 

3.2 Circuits en systolische algoritmen . . . . . . . . . . . . . . . . . . . . . . . . . 20 

3.3 Interconnectienetwerken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 

3.3.1 Netwerktopologieën . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 

3.3.2 Rij en ring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 

3.3.3 Rooster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 

3.3.4 Hyperkubus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 

3.4 Communicatie-algoritmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 

i

ii INHOUDSOPGAVE 

3.4.1 One-to-all broadcast . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 

3.4.2 All-to-all broadcast . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 

3.4.3 Single-node scatter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 

3.4.4 Total exchange . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 

3.5 Gedistribueerde algoritmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 

4 Ontwerptechnieken voor parallelle algoritmen 35 

4.1 Pipelining / Sorteren & Priemzeef . . . . . . . . . . . . . . . . . . . . . . . . . 36 

4.1.1 Techniek van pipelining . . . . . . . . . . . . . . . . . . . . . . . . . . 36 

4.1.2 Sorteren via pipelining . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 

4.1.3 Priemzeef via pipeling . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 

4.2 Gebalanceerde bomen / Prefixsommen . . . . . . . . . . . . . . . . . . . . . . . 38 

4.2.1 Techniek van gebalanceerde bomen . . . . . . . . . . . . . . . . . . . . 38 

4.2.2 Wat zijn prefixsommen? . . . . . . . . . . . . . . . . . . . . . . . . . . 38 

4.2.3 Berekenen van prefixsommen in het PRAM-model . . . . . . . . . . . . 39 

4.2.4 Berekenen van prefixsommen op een rooster . . . . . . . . . . . . . . . 41 

4.2.5 Berekenen van prefixsommen op een hyperkubus . . . . . . . . . . . . . 42 

4.3 Partitionering / Merge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 

4.3.1 Techniek van partitioneren . . . . . . . . . . . . . . . . . . . . . . . . . 42 

4.3.2 Een eenvoudig merge-algoritme . . . . . . . . . . . . . . . . . . . . . . 42 

4.3.3 Parallel algoritme voor merge via partitioneren . . . . . . . . . . . . . . 43 

4.4 Accelerated cascading / Maximum bepalen . . . . . . . . . . . . . . . . . . . . 45 

4.4.1 Bepalen van het maximum . . . . . . . . . . . . . . . . . . . . . . . . . 45 

4.4.2 Bepalen van het maximum in constante tijd . . . . . . . . . . . . . . . . 45 

4.4.3 Algoritme voor het maximum in dubbel-logaritmische tijd . . . . . . . . 46 

4.4.4 Het snelle algoritme optimaal maken . . . . . . . . . . . . . . . . . . . 47 

4.4.5 Opmerking: speciaal geval . . . . . . . . . . . . . . . . . . . . . . . . . 48 

5 Parallelle sorteeralgoritmen 49 

5.1 Sorteernetwerken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 

5.1.1 Wat zijn sorteernetwerken? . . . . . . . . . . . . . . . . . . . . . . . . . 50 

5.1.2 Bitonisch sorteren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 

Algoritmen en Datastructuren III Veerle.Fack@UGent.be

INHOUDSOPGAVE iii 

5.1.3 Mergen en sorteren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 

5.1.4 Het nul-een-principe voor sorteernetwerken . . . . . . . . . . . . . . . . 57 

5.2 Sorteren op interconnectienetwerken . . . . . . . . . . . . . . . . . . . . . . . . 60 

5.2.1 Odd-even-transposition sorteren op een rij van processoren . . . . . . . . 60 

5.2.2 Bitonisch sorteren op de hyperkubus . . . . . . . . . . . . . . . . . . . . 60 

5.2.3 Shearsort op een rooster van processoren . . . . . . . . . . . . . . . . . 60 

5.3 PRAM-varianten van klassieke sorteeralgoritmen . . . . . . . . . . . . . . . . . 63 


Hoofdstuk 1 

Inleiding 

In dit gedeelte van de cursus bestuderen we hoe berekeningen kunnen worden versneld door 

meerdere processoren te gebruiken in plaats van één enkele processor. Algoritmen die ontworpen 

werden om uitgevoerd te worden op een netwerk van processoren, worden parallelle of 

gedistribueerde algoritmen genoemd, afhankelijk van de aard van het netwerk. Processoren 

in gedistribueerde netwerken zijn doorgaans onafhankelijker van elkaar dan processoren in een 

parallel netwerk. 

De bedoeling van dit cursusgedeelte is het introduceren van verscheidene modellen van parallelle 

computers en het opstellen van een geschikt raamwerk voor het voorstellen en analyseren van 

parallelle algoritmen. De nadruk ligt op technieken, paradigma’s en methodes, eerder dan op de 

gedetailleerde implementatie voor specifieke toepassingen. 

1

2 Hoofdstuk 1. Inleiding 

1.1 Parallelle algoritmen ontwerpen en analyseren 

Een vraag die zich onmiddellijk stelt is: Hoe kan een algoritme geëvalueerd worden op zijn geschiktheid 

voor parallelliseren? Net zoals in het geval van sequentiële algoritmen zijn er meerdere 

belangrijke criteria, zoals uitvoeringstijd, geheugengebruik en programmeerbaarheid. Maar de 

situatie bij parallelle algoritmen wordt nog ingewikkelder, door de aanwezigheid van bijkomende 

factoren, zoals het aantal processoren, de capaciteit van lokale geheugens van de processoren, de 

communicatieschema tussen processoren, en de gebruikte protocols voor synchronisatie tussen 

processoren. 

Voorbeeld 1.1.1. Veronderstel dat we n exemplaren van een rapport moeten uitprinten en dat het 

printen van één exemplaar één tijdseenheid vereist. Wanneer we slechts één printer ter beschikking 

hebben, duurt het uitprinten van alle rapporten T ∗ (n) = n tijdseenheden. Wanneer we twee 

printers ter beschikking hebben, kan het uitprinten gebeuren in ⌈n/2⌉ tijd, door ⌈n/2⌉ printaanvragen 

naar de ene printer te sturen en ⌊n/2⌋ naar de andere. Algemeen, wanneer we p printers 

hebben, kan het printen gebeuren in Tp(n) = ⌈n/p⌉ tijd. 

Het uitprinten van meerdere exemplaren van een rapport is een voorbeeld van een taak die gemakkelijk 

efficiënt kan worden uitgevoerd door meerdere machines. Verschillende instanties 

van de taak hangen niet van elkaar af, zodat ze eenvoudigweg aan p verschillende machines 

(hier printers) kunnen worden toegekend. Als we evenveel printers ter beschikking hebben als er 

exemplaren te printen zijn, m.a.w. p = n, dan kunnen we het probleem oplossen in parallelle tijd 

Tp(n) = Θ(1), de tijd nodig om één enkel rapport te printen op één enkele printer. Wanneer we de 

uitvoeringstijd van de twee oplossingen vergelijken: T ∗ (n) = n stappen op één printer (voor de 

sequentiële oplossing) en Tp(n) = ⌈n/p⌉ stappen op p printers (voor de parallelle oplossing), dan 

zien we dat de parallelle oplossing een factor p sneller is. Men zegt dat de parallelle oplossing 

een versnelling Sp(n) = p over de sequentiële oplossing heeft. 

We noemen Tp(n) de parallelle uitvoeringstijd van een algoritme op p processoren voor een 

probleem van grootte n. Merk op dat we de sequentiële uitvoeringstijd noteren als T ∗ (n), d.i. 

de uitvoeringstijd van het beste sequentiële algoritme voor het gegeven probleem. 

De versnelling (of speed-up) geeft een maat voor de winst in uitvoeringstijd van het parallelle 

algoritme t.o.v. het sequentiële algoritme, en wordt gedefinieerd als 

Sp(n) = T ∗ (n) 

Tp(n) . 

In dit deel bestuderen we in welke mate computationele problemen kunnen worden versneld 

door meer dan één processor of machine te gebruiken, m.a.w. in welke mate we een gegeven 

taak kunnen parallelliseren. In het bovenstaande voorbeeld, hadden we een sequentieel algoritme 

dat het probleem oploste in f(n) tijd, en een parallel algoritme dat p machines gebruikte en het 

probleem oploste in ⌈ f(n)/p⌉ tijd. We kunnen niet hopen dat p processoren het probleem sneller 

dan dat kunnen oplossen, omdat we anders het sequentiële algoritme zouden kunnen verbeteren 

tot een uitvoeringstijd kleiner dan f(n), nl. door de parallelle processen een na een op één enkele 


1.1. Parallelle algoritmen ontwerpen en analyseren 3 

Algoritme 1.1 Zoeken van het grootste element in een array (sequentieel algoritme) 

Input: array (a1,...,an), lengte n 

Output: de waarde van het grootste element in a 

1: Stel m ← a1 

2: for i from 2 to n do 

3: if ai > m then 

4: Stel m ← ai 

5: return m 

processor te laten lopen. De beste versnelling die we kunnen verwachten bij het gebruik van 

p processoren is dus een factor p. 

Bij het ontwerpen van een parallel algoritme moet een compromis worden gezocht tussen de twee 

resources hardware en uitvoeringstijd. Meer hardware gebruiken kan leiden tot een vermindering 

van de uitvoeringstijd met een factor p, voor p processoren. Wanneer uitvoeringstijd een hoge 

prioriteit heeft en we de middelen voor bijkomende hardware hebben, dan is het nuttig naar 

parallelle algoritmen te zoeken. 

Een mogelijke benadering bij het ontwerpen van een parallel algoritme is te starten met een sequentieel 

algoritme voor het probleem en te onderzoeken of dit algoritme, of gedeelten ervan, kan 

worden geparallelliseerd. In het algemene geval zullen we geen zo’n spectaculaire versnelling 

als bij het printervoorbeeld kunnen bekomen. 

Voorbeeld 1.1.2. Als voorbeeld behandelen we het probleem van het berekenen van het grootste 

element in een array. Een eenvoudig sequentieel algoritme hiervoor wordt gegeven in Algoritme 

1.1. Merk op dat dit algoritme inherent sequentieel is, want elke vergelijking hangt af van 

alle voorafgaande vergelijkingen. 

Veronderstel dat we een onbeperkt aantal processoren ter beschikking hebben. Hoe kan Algoritme 

1.1 worden geparallelliseerd? In stap 1 van het algoritme gebruiken we één processor om het 

maximum van twee elementen te vinden. Gebruik makend van ⌊n/2⌋ processoren kunnen we 

van ⌊n/2⌋ paren van elementen de maxima bepalen. In de volgende stap kunnen we met behulp 

van ⌊n/4⌋ processoren de maxima van ⌊n/4⌋ paren bepalen, enzovoort. 

Hoeveel tijd kost dit parallelle algoritme? In elke stap wordt het aantal elementen waarvan het 

maximum moet worden bepaald, gehalveerd. Het algoritme voert dus ten hoogste ⌈log 2 n⌉ stappen 

uit, hetgeen een substantiële verbetering is tegenover het Θ(n) sequentiële algoritme. Bovendien 

hebben we enkel ⌈n/2⌉ processoren nodig om het algoritme in parallelle tijd O(logn) uit 

te voeren. Op het eerste gezicht ziet het algoritme er goed uit: met een lineair aantal processoren 

kunnen we een probleem dat lineaire sequentiële tijd vereist, oplossen in logaritmische parallelle 

tijd. Maar er is ook duidelijke inefficiëntie in het algoritme: in de eerste stap worden ongeveer 

n/2 processoren effectief gebruikt, in de tweede stap nog slechts ongeveer n/4, in de k-de stap 

nog slechts ongeveer n/2 k . Het overgrote deel van de processoren doet dus geen werk gedurende 

het algoritme. Dit is duidelijk een verspilling van hardware. 

Het bovenstaande voorbeeld geeft aan dat we parallelle algoritmen niet alleen moeten beoordelen 



op basis van hun parallelle uitvoeringstijd en hun versnelling, maar ook op basis van het aantal 

processoren dat ze gebruiken. De kost Cp(n) van een parallel algoritme is het product van het 

aantal processoren p en het aantal stappen dat het algoritme uitvoert, m.a.w. 

Cp(n) = p × Tp(n). 

Merk op dat een parallel algoritme met kost Cp(n) kan omgezet worden in een sequentieel algoritme 

dat Θ(Cp(n)) uitvoeringstijd vraagt. 

Voorbeeld 1.1.3. Het parallelle algoritme uit Voorbeeld 1.1.2 heeft kost Cn(n) = Θ(nlogn), 

hetgeen slechter is dan het sequentiële algoritme dat uitvoeringstijd (en dus kost) T ∗ (n) = Θ(n) 

heeft (aangezien het n stappen uitvoert op 1 processor). In termen van kost is het parallelle 

algoritme dus niet optimaal, omdat er een ander algoritme bestaat dat minder kost vraagt. 

We noemen een algoritme kost-optimaal als Cp(n) = Θ(T ∗ (n)). Zoals we verder zullen zien, 

bestaan er technieken die dikwijls toelaten om parallelle algoritmen kost-optimaal te maken. 

1.2 Modellen van parallelle computers 

Een algemeen aanvaard model voor het ontwerpen en analyseren van sequentiële algoritmen 

bestaat uit een centrale verwerkingseenheid, die verbonden is met een random-access geheugen. 

De typische instructieset voor dit model omvat lezen uit en schrijven naar het geheugen, evenals 

elementaire logische en rekenkundige bewerkingen. Dit model heeft zijn welslagen te danken 

aan zijn eenvoud enerzijds en aan het feit dat het de performantie van sequentiële algoritmen op 

computers van het von Neumann-type adequaat kan inschatten. 

Jammer genoeg is er voor parallelle berekeningen geen dergelijk algemeen aanvaard algoritmisch 

model beschikbaar. Een van de redenen hiervoor is het feit dat de performantie van parallelle 

algoritmen afhankelijk is van een complex geheel van factoren die machine-afhankelijk zijn. 

Deze factoren zijn onder meer de mate waarin berekeningen kunnen geparallelliseerd worden, het 

toewijzen van processoren aan deeltaken, het plannen van taken over verscheidene processoren, 

aspecten van communicatie en synchronisatie. 

In de praktijk worden meerdere verschillende modellen voor parallelle computers gebruikt. 

We kunnen bijvoorbeeld de complexiteit van de gebruikte processoren beperken. Wanneer een 

parallel algoritme op hardware-niveau wordt geïmplementeerd, kan het gebeuren dat we niet aan 

elke processor de algemeenheid van een doorsnee-processor willen geven. Bijvoorbeeld, bij het 

berekenen van het maximum hebben we enkel een kleine gespecialiseerde poort nodig die het 

maximum van twee inputs kan berekenen. Deze poort heeft zelfs geen lokaal geheugen nodig; ze 

moet enkel de grootste van de twee inputs verder doorgeven. Modellen van parallelle computers 

die op dit fijne niveau van parallellisme werken, worden circuits genoemd, naar analogie met 

elektrische circuits. 


1.2. Modellen van parallelle computers 5 

Op een minder fijn niveau van parallellisme kunnen we elke processor zien als een complete computer, 

die elk zijn eigen sequentiële algoritme kan uitvoeren. We spreken dan van parallelle architecturen. 

Op dit niveau wordt het onderscheid tussen de verschillende modellen gemaakt op 

basis van de manier waarop de processoren met elkaar communiceren. In het PRAM-model hebben 

alle processoren een gemeenschappelijk geheugen dat voor communicatie gebruikt wordt. 

Bepaalde taken kunnen goed worden opgelost door speciale types van netwerken, zoals ringen, 

bomen of roosters. 

In sommige gevallen zijn de processoren minder sterk met elkaar gekoppeld. Geheugen kan 

gedistribueerd zijn, eerder dan gedeeld; elke processor heeft zijn eigen lokale geheugen en er 

is geen globaal geheugen. Het kan gebeuren dat de processoren geen gemeenschappelijke klok 

delen, waardoor ze asynchroon moeten werken. Het kan zijn dat we weinig kennis of controle 

hebben over het specifieke netwerk tussen de processoren; denk bijvoorbeeld aan het Internet. 

We spreken dan van gedistribueerde architecturen. Algoritmen voor dergelijke architecturen 

zijn belangrijk in het kader van lokale netwerken en het Internet. 

In de volgende hoofdstukken bespreken we deze modellen in detail. 




Hoofdstuk 2 

Het gedeelde-geheugenmodel 

Het gedeelde-geheugenmodel is een natuurlijke uitbreiding van het basis sequentiële RAMmodel. 

In dit model hebben alle processoren toegang tot een gemeenschappelijk geheugen, 

waardoor ze met elkaar kunnen communiceren. Een speciaal geval is de Parallel Random-Access 

Machine (PRAM). In dit hoofdstuk bespreken we zowel het algemene gedeelde-geheugenmodel 

als het PRAM-model, en gaan we ook in op het analyseren van de complexiteit van PRAMalgoritmen. 

7

8 Hoofdstuk 2. Het gedeelde-geheugenmodel 

2.1 Het gedeelde-geheugenmodel 

In het gedeelde-geheugenmodel hebben meerdere processoren toegang tot één enkele gedeelde 

geheugeneenheid. Meer bepaald bestaat het gedeelde-geheugenmodel uit een aantal processoren, 

die elk hun lokaal geheugen hebben en die elk een lokaal programma kunnen uitvoeren, 

waarbij communicatie tussen de processoren gebeurt door het uitwisselen van gegevens via een 

gedeeld geheugen. Elke processor wordt eenduidig geïdentificeerd door een index, het processornummer 

of processor-id genoemd, die lokaal beschikbaar is en waarnaar in het programma 

van de processor dus kan verwezen worden. Het gedeelde geheugen wordt soms ook het globale 

geheugen genoemd. 

Er zijn twee verschillende manieren van werken in het gedeelde-geheugenmodel. De eerste manier 

wordt synchroon genoemd en hierbij werken alle processoren synchroon, m.a.w. gestuurd 

door een gemeenschappelijke klok. Dit model wordt ook de parallel random-access machine 

(PRAM) genoemd; we bespreken ze verder in de volgende paragraaf. 

De tweede manier wordt asynchroon genoemd en hierbij werken de processoren elk gestuurd 

door hun eigen klok. In dit model is het de verantwoordelijkheid van de programmeur om waar 

nodig voor synchronisatiepunten te zorgen. Meer bepaald, wanneer bepaalde data nodig is voor 

de berekening door een bepaalde processor, dan moet de programmeur er voor zorgen dat de 

correcte waarden beschikbaar zijn – merk immers op dat de waarde van een gedeelde variabele 

dynamisch wordt bepaald tijdens de uitvoering van de programma’s van de verschillende 


Aangezien elke processor zijn eigen lokale programma kan uitvoeren, is het asynchrone gedeeldegeheugenmodel 

van het type multiple instruction multiple data (MIMD). Dit betekent dat elke 

processor een andere instructie kan uitvoeren, of een berekening op andere data kan uitvoeren, 

en dit op elk willekeurig moment in de uitvoering van het programma. Voor een gegeven algoritme, 

geeft de omvang van de gegevens die getransfereerd worden tussen het gedeelde geheugen 

en de lokale geheugens van de processoren, een maat voor de communicatie vereist door het 

algoritme. 

We schrijven parallelle algoritmen in het gedeelde-geheugenmodel zoals we dat voor een sequentieel 

algoritme doen, met als bijkomende bewerkingen: 

• global read(x,y): het inlezen van een gegeven x uit het globale geheugen naar de lokale 

variabele y; 

• global write(u,v): het wegschrijven van de inhoud van de lokale variabele u naar de variabele 

v in het globale geheugen. 

In vele gevallen zullen we echter de volgende verkorte notatie gebruiken: 

stel c ← a+b 

die staat voor: 

global read (a,x); global read (b,y) 


2.1. Het gedeelde-geheugenmodel 9 

Algoritme 2.1 Berekenen van matrix-vector-vermenigvuldiging 

Input: n×n matrix A en vector x; aantal processoren p met r = n/p geheel; processornummer i; 

Output: componenten y (i−1)r+1,...,yir van y = Ax in globale variabele 

1: global read (x, z) 

2: global read (A (i−1)r+1:ir,1:n, B) 

3: Bereken w ← Bz 

4: global write (w, y (i−1)r+1:ir) 

Algoritme 2.2 Berekenen van matrix-vector-vermenigvuldiging (met verkorte notatie) 

Input: n×n matrix A en vector x; aantal processoren p met r = n/p geheel; processornummer i; 

Output: componenten y (i−1)r+1,...,yir van y = Ax in globale variabele 

1: Bereken y (i−1)r+1:ir ← A (i−1)r+1:ir,1:nx 

stel z ← x+y 

global write (z, c) 

met a,b,c gedeelde variabelen, en x,y,z lokale variabelen. 

Voorbeeld 2.1.1 (Matrix-vector-vermenigvuldiging). Beschouw het vermenigvuldigen van een 

n×n matrix A met een vector x van orde n, die beiden in het gedeelde geheugen opgeslagen zijn. 

Veronderstel dat we over p processoren Pi beschikken, met p ≤ n en r = n/p geheel, en dat we 

in het asynchroon model werken. 

Een eenvoudig parallel algoritme bestaat in het opsplitsen van A in p blokken A (i) van r rijen, 

waarbij elke processor Pi de vector x en een blok A (i) uit het gedeeld geheugen leest en het 

product A (i) x berekent. Dit levert r componenten van de resultaatvector. 

Algoritme 2.1 geeft de pseudocode voor processor Pi. Merk op dat alle processoren in stap 1 

tegelijkertijd toegang moeten hebben tot de globale variabele x. Daarentegen zullen twee processoren 

nooit tegelijkertijd naar dezelfde globale geheugenplaats proberen te schrijven. 

Met de eerder vermelde verkorte notatie bekomen we de pseudocode zoals getoond in Algoritme 

2.2. 

De parallelle tijd van dit algoritme is Tp(n) = Θ(n 2 /p). De kost is Cp(n) = pΘ(n 2 /p) = Θ(n 2 ), 

hetgeen precies de tijd van het sequentiële algoritme is. Het algoritme is dus kost-optimaal. 

Een belangrijk aspect van dit algoritme is het feit dat de processoren hun activiteiten niet hoeven 

te synchroniseren – dit is te danken aan de manier waarop de berekeningen gepartitioneerd 

werden. Door de matrix op te splitsen in blokken van rijen zijn de berekeningen die door de 

verschillende processoren gebeuren, onafhankelijk van elkaar. 

Als we daarentegen de matrix zouden opsplitsen in blokken van kolommen, m.a.w. als A = 

(A (1) ,...,A (r) ) en x = (x (1) ,...,x (r) ), dan wordt het product y = Ax gegeven door y = A (1) x (1) + 

···+A (r) x (r) . Elke processor Pi kan dus z (i) = A (i) x (i) berekenen, na het inlezen van A (i) en x (i) 

uit het gedeelde geheugen. Maar geen enkele processor mag beginnen met het berekenen van 



de som z (1) + ···+ z (r) vooraleer gegarandeerd is dat alle processoren de berekening van hun z (i) 

beëindigd hebben. Er is m.a.w. een expliciete synchronisatie nodig: het programma van elke 

processor moet een synchronisatiepunt bevatten na de berekening van z (i) = A (i) x (i) , om ervoor 

te zorgen dat de processoren synchroniseren vooraleer verder te gaan met de uitvoering van het 

programma. 

2.2 De Parallel Random-Access Machine (PRAM) 

In deze paragraaf concentreren we ons op de Parallel Access-Random Machine (PRAM), die 

zowat het standaardmodel voor parallelle algoritmen in het gedeelde-geheugenmodel geworden 

is. Dit model veralgemeent de Random-Access Machine (RAM), het model dat voor sequentiële 

algoritmen gebruikt wordt. We beschrijven beide modellen hier, zonder echter een precieze 

formele definitie te geven. 

2.2.1 Het PRAM-model 

Het RAM-model bestaat uit een centrale verwerkingseenheid (CPU) met een random-accessgeheugen 

eraan verbonden. De CPU kan rekenkundige en logische bewerkingen uitvoeren op 

een set registers, waarvan de inhoud kan worden geladen uit en geschreven naar het geheugen 

via random-access-adressering. Elke bewerking vereist één tijdseenheid. 

Het PRAM-model bestaat uit meerdere RAM-processoren, met één extra gedeeld random-accessgeheugen, 

waartoe alle processoren toegang hebben. De processoren zijn gesynchroniseerd 

door een globale klok, en elke processor voert één stap uit tijdens elke klokcyclus. 

Algoritmen ontwikkeld in het PRAM-model zijn meestal van het type single instruction multiple 

data (SIMD). Dit betekent dat alle processoren hetzelfde programma uitvoeren, zodanig 

dat, op elke tijdseenheid, de actieve processoren dezelfde instructie uitvoeren, doorgaans wel 

op verschillende data. Merk echter op dat deze beperking niet inherent door het PRAM-model 

zelf opgelegd wordt. Het PRAM-model laat toe om verschillende programma’s op verschillende 

processoren uit te voeren, uiteraard op voorwaarde dat de processoren synchroon kunnen werken. 

Aan de pseudocode voegen we nu ook een parallelle lus toe, die zal toelaten om een blok code 

in parallel op meerdere processoren uit te voeren: 

for i from 1 to n pardo 

{Blok code} 

Hierbij wordt het aantal gebruikte processoren niet nader gespecificeerd, en wordt impliciet verondersteld 

dat hun aantal onbeperkt is. De parallelle tijd nodig om deze lus uit te voeren is het 

maximum van de tijd gebruikt in één van de n stappen (in plaats van de som, zoals het op een 

sequentiële machine zou zijn). De kost is het aantal stappen in de lus, maal de kost van één stap. 

Voorbeeld 2.2.1. Beschouw het initialiseren van elk element van een array met een waarde. Gebruik 

makend van p = n processoren kan dit met een factor n worden versneld: 


2.2. De Parallel Random-Access Machine (PRAM) 11 

Algoritme 2.3 Parallel zoeken van een element in een niet-gesorteerde array 

Input: waarde x, array (a1,...,an), lengte n 

Output: true als er een i bestaat waarvoor x = ai, anders false 

1: Stel f ← false 

2: for i from 1 to n pardo 

3: if x = ai then 

4: Stel f ← true 

5: return f 


Stel a[i] ← 0 

De parallelle tijd van dit stuk code is Tn(n) = Θ(1). De kost is Cn(n) = Θ(n), zodat dit stuk code 

kost-optimaal is. 

2.2.2 Geheugenmodellen voor PRAM 

Voorbeeld 2.2.2. Beschouw het parallel zoeken van een element in een niet-gesorteerde array. 

Het sequentiële algoritme neemt tijd Θ(n). Algoritme 2.3 geeft de pseudocode voor het parallelle 

algoritme. Dit algoritme loopt op n processoren in constante parallelle tijd. De kost is Θ(n), 

hetgeen optimaal is. 

Merk op dat het algoritme veronderstelt dat de processoren gelijktijdig toegang tot het geheugen 

hebben. In eerste instantie wordt de vergelijking x = ai op alle processoren gelijktijdig uitgevoerd, 

hetgeen vereist dat alle processoren gelijktijdig toegang moeten hebben tot de variabele x. 

Verder moeten alle processoren waarvoor de vergelijking x = ai als resultaat true geeft, gelijktijdig 

kunnen schrijven naar de variabele f . 

We kunnen er niet zomaar van uitgaan dat gelijktijdige activiteiten zoals in Algoritme 2.3 in de 

praktijk mogelijk zijn. Het implementeren van gelijktijdig lezen en schrijven in hardware is een 

dure aangelegenheid. Bovendien kunnen in het geval van gelijktijdig schrijven ook logische conflicten 

optreden. Immers, wat gebeurt er wanneer meerdere processoren verschillende waarden 

in dezelfde geheugenplaats proberen te schrijven? Om dit soort situaties te modelleren, bestaan 

er meerdere varianten van het PRAM-model: 

• Exclusive Read (ER): de waarde van een variabele kan maar door één processor gelijktijdig 

worden gelezen; 

• Concurrent Read (CR): de waarde van een variabele kan door meerdere processoren 

gelijktijdig worden gelezen; 

• Exclusive Write (EW): de waarde van een variabele kan maar door één processor gelijktijdig 

worden geschreven; 



Algoritme 2.4 Parallel zoeken van de positie van een element in een niet-gesorteerde array 

Input: waarde x, array (a1,...,an), lengte n 

Output: een index ℓ waarvoor x = aℓ indien deze bestaat, anders −1 

1: Stel ℓ ← −1 


3: if x = ai then 

4: Stel ℓ ← i 

5: return ℓ 

• Concurrent Write (CW): meerdere processoren kunnen gelijktijdig een waarde naar een 

variabele schrijven. 

Op die manier bekomen we vier verschillende PRAM-modellen: 

• EREW: het meest restrictieve model; 

• CRCW: het minst restrictieve model; 

• CREW: het meest gebruikte gemengde model; 

• ERCW: een weinig gebruikt gemengd model. 

Voorbeeld 2.2.3. Algoritme 2.3 is een CRCW algoritme. Het is CR omwille van de gelijktijdige 

leestoegang tot x en het is CW omwille van de gelijktijdige schrijftoegang tot f . 

Wanneer we een CW algoritme uitvoeren, kan het gebeuren dat verscheidene processoren verschillende 

waarden naar dezelfde variabele proberen te schrijven. 

Voorbeeld 2.2.4. Veronderstel dat we Algoritme 2.3 willen aanpassen zodanig dat het ook de 

plaats teruggeeft waar x gevonden werd. Algoritme 2.4 geeft de pseudocode voor dit aangepaste 

algoritme. Wanneer x meer dan één keer voorkomt in de array, dan wordt de opdracht ℓ ← i in 

parallel door meerdere processoren uitgevoerd voor verschillende waarden van i. 

We onderscheiden meerdere modellen voor het oplossen van schrijfconflicten: 

• CW in prioriteit: De processoren krijgen verschillende prioriteiten toegekend, en bij conflict 

is het de processor met de hoogste prioriteit waarvan de waarde in de variabele geschreven 

wordt. 

• CW in overeenstemming: Alle processoren die een waarde naar een variabele schrijven, 

moeten dezelfde waarde schrijven, anders faalt de schrijfbewerking. 

• willekeurig CW: Een willekeurige processor van diegene die een waarde naar de variabele 

willen schrijven, schrijft effectief zijn waarde naar de variabele. 


2.2. De Parallel Random-Access Machine (PRAM) 13 

Algoritme 2.5 Probleem van cache-coherentie 

Stel x ← 0 


if i = n then 

Stel x ← 1 

else 

Stel ai ← x 

Voorbeeld 2.2.5. Merk op dat Algoritme 2.3 een algoritme met “CW in overeenstemming” is, 

aangezien elke processor dezelfde waarde naar de variabele probeert te schrijven. Algoritme 2.4 

daarentegen werkt alleen in het model “CW in prioriteit” of “willekeurig CW”, aangezien het 

verschillende waarden naar dezelfde variabele kan proberen schrijven; het werkt in het EWmodel 

wanneer alle elementen in de array verschillend zijn. 

Merk op dat, zelfs wanneer we ons beperken tot het EW-model, er problemen kunnen zijn met 

gelijktijdige leesbewerkingen. 

Voorbeeld 2.2.6. Beschouw de code in Algoritme 2.5. Welke waarden bevat de array a na het 

uitvoeren van deze code? Alhoewel slechts één processor, nl. processor n, naar de variabele x 

schrijft, proberen alle andere processoren wel de waarde van x te lezen. Maar wat is de waarde 

van x? Wanneer de processoren lokale kopieën van x gebruiken, dan zal de array nullen bevatten, 

ook al verandert processor n de waarde van x in het globale geheugen. 

Dit wordt het probleem van cache-coherentie genoemd. Wanneer alle processoren de waarde 

van een variabele x in het globale geheugen gebruiken, dan zal het resultaat afhangen van de 

willekeurige volgorde waarin de processoren toegang krijgen tot x. Met dergelijke problemen 

moet in de praktijk zeker rekening worden gehouden; in deze cursus vermijden we ze door code 

te schrijven die ze vermijdt. 

2.2.3 Semigroep-problemen 

Voorbeeld 2.2.7 (Veralgemeende som van een rij getallen). Hoe snel kunnen we een reeks 

getallen sommeren op een EREW PRAM; m.a.w. gegeven een array a van lengte n, hoe snel 

kunnen we a1 + ···+an berekenen? Dit probleem behoort tot een familie van problemen die 

allemaal van dezelfde gedaante zijn: voor een gegeven binaire associatieve bewerking ⊕ wensen 

we ∑ n i=1 ai te berekenen. Dit probleem is gekend als het semigroep-probleem, aangezien een 

verzameling elementen samen met een associatieve binaire bewerking een semigroep genoemd 

wordt. Andere problemen van deze gedaante zijn het berekenen van het maximum, waarbij 

⊕ = max, of het product, waarbij ⊕ = ×, van een reeks van n getallen. 

Eerder zagen we reeds twee algoritmen voor het bepalen van het maximum, het ene sequentieel 

en het andere parallel. Het sequentiële algoritme had uitvoeringstijd Θ(n); het parallelle 



Algoritme 2.6 Berekenen van de veralgemeende som van een rij getallen (sequentieel algoritme) 


Output: de waarde ∑ n i=1 ai 

1: Stel s ← a1 


3: Stel s ← s ⊕ ai 

4: return s 

Algoritme 2.7 Berekenen van de veralgemeende som van een rij getallen (parallel algoritme) 

Input: array a met n = 2 k getallen, p = n processoren, processornummer i 

Output: som s = ∑ n i=1 ai 

1: Stel bi ← ai 

2: for h from 1 to log 2 n do 

3: if i ≤ n/2 h then 

4: Stel bi ← b2i−1 ⊕ b2i 

5: if i = 1 then 

6: Stel s ← b1 

algoritme had uitvoeringstijd Θ(logn) en kost Θ(nlogn). Beide algoritmen kunnen worden veralgemeend 

voor een willekeurige binaire associatieve bewerking ⊕ die in constante tijd kan 

gebeuren. 

Algoritme 2.6 geeft de pseudocode voor het sequentiële algoritme. Voor het parallelliseren van 

dit algoritme gebruiken we dezelfde strategie als voor het parallelliseren van Algoritme 1.1. 

Veronderstel dat we een PRAM met p = n processoren P1,...,Pn hebben. 

Elke processor berekent de (veralgemeende) som van twee getallen; deze sommen worden weer 

twee aan twee opgeteld, elk door andere processor; dit proces wordt herhaald totdat de totale 

som bekomen is. Algoritme 2.7 geeft de pseudocode voor processor Pi. 

Merk op dat het PRAM-model synchroon werkt, m.a.w. in elke tijdseenheid kan de processor 

ofwel een opdracht uitvoeren, ofwel niets doen. Bijvoorbeeld, de voorwaarde van de if-opdracht 

in lijn 3 van het parallelle algoritme is slechts op een beperkt aantal processoren voldaan, zodat 

de andere processoren niets doen tijdens de tijdseenheid waarop lijn 4 uitgevoerd wordt. 

Dit algoritme heeft parallelle tijd Tp(n) = Θ(logn) en kost Cp(n) = pΘ(logn) = Θ(nlogn). 

Aangezien dit probleem in sequentiële tijd T ∗ (n) = Θ(n) kan opgelost worden, is het parallelle 

algoritme dus niet kost-optimaal. 

2.2.4 Kost-optimaliseren van PRAM-algoritmen 

Voorbeeld 2.2.8 (Veralgemeende som van een rij getallen). Om de kost van Algoritme 2.7 te 

verbeteren moeten we ofwel de parallelle uitvoeringstijd ofwel het aantal processoren verminde- 


2.3. Het werk-tijd-paradigma 15 

ren. Dit laatste houdt in dat we een waarde voor p zoeken waarvoor Cp(n) = Θ(T ∗ (n)), m.a.w. 

waarvoor p × Θ(logn) = Θ(n). Dus p = Θ( n 

logn ). 

In het aangepaste algoritme berekent elke processor dan (sequentieel) de sommatie van Θ(logn) 

elementen, hetgeen parallelle tijd Θ(logn) kost. Vervolgens wordt de som van deze p deelsommen 

in parallel berekend (analoog aan het eerdere algoritme). Dit kost parallelle tijd Θ(log p) = 

Θ(log( n 

logn ))) = Θ(logn). De totale parallelle tijd voor het aangepaste algoritme is dus Tp(n) = 

Θ(logn). 

De kost is Cp(n) = Θ( n 

logn )×Θ(logn) = Θ(n) = Θ(T ∗ (n)), m.a.w. het algoritme is kost-optimaal. 

Merk op dat de optimale Θ(logn) tijd uit het eerdere algoritme behouden blijft. 

2.3 Het werk-tijd-paradigma 

De beschrijving van een parallel algoritme bevat doorgaans talrijke details, waardoor soms de 

essentie van het algoritme minder duidelijk wordt. Het PRAM-model is reeds een manier om 

details bij het het beschrijven van parallelle algoritmen te vereenvoudigen. In deze pararaaf 

bespreken we een paradigma dat hierbij nog meer zal helpen. 

Het werk-tijd-paradigma (WT-paradigma) geeft informele richtlijnen voor een beschrijving 

van parallelle algoritmen in twee niveau’s met een top-down-benadering. Het bovenste niveau 

is een presentatieniveau en vermijdt specifieke details van het algoritme. Het onderste niveau 

volgt een algemeen scheduling-principe en resulteert in een volledige PRAM-beschrijving van 

het algoritme. 

2.3.1 Het WT-presentatieniveau 

Het WT-presentatieniveau levert een abstracte beschrijving van een parallel algoritme als een 

reeks parallelle stappen. Het algoritme bestaat dan uit een een sequentie van tijdseenheden, 

waarbij elke tijdseenheid bestaat uit een willekeurig aantal parallelle bewerkingen. Er worden 

hier geen details gegeven over het aantal processoren, de werkverdeling over de verschillende 

processoren, e.d. In deze beschrijving wordt de eerder vermelde parallelle for-lus gebruikt. 

De complexiteit van een algoritme in WT-presentatie wordt beschreven door de parallelle uitvoeringstijd 

T(n) die het aantal tijdseenheden voorstelt, en het werk W(n) dat bepaald wordt 

door het totale aantal uitgevoerde bewerkingen. 

Merk op dat een parallel algoritme met werk W(n) kan omgezet worden in een sequentieel algoritme 

met uitvoeringstijd Θ(W(n)). We noemen een algoritme werk-optimaal als W(n) = 

Θ(T ∗ (n)). 

Voorbeeld 2.3.1 (Veralgemeende som van een rij getallen). Beschouwen we opnieuw het probleem 

van het sommeren van een rij getallen. Gebruik makend van de parallelle for-lus kan 

Algoritme 2.7 ook beschreven worden met de pseudocode uit Algoritme 2.8. 



Algoritme 2.8 Berekenen van de veralgemeende som van een rij getallen (WT-presentatie) 

Input: array a met n = 2 k getallen 



2: Stel bi ← ai 


4: for i from 1 to n/2 h pardo 

5: Stel bi ← b2i−1 ⊕ b2i 

6: Stel s ← b1 

Het aantal tijdseenheden nodig voor dit algoritme is log 2 n+2, zodat de uitvoeringstijd T(n) = 

Θ(logn). Het werk wordt bepaald door 

Het algoritme is dus werk-optimaal. 

log 2n W(n) = n+ 

∑ 

h=1 

2.3.2 Het WT-scheduling-niveau 

n 

+ 1 = Θ(n). 

2h In het WT-scheduling-niveau wordt de volledige PRAM-specificatie van een algoritme (in WTpresentatie) 

uitgewerkt, tot alle implementatiedetails met p processoren. 

Door gebruik te maken van een algemeen scheduling-principe bekomt men voor een algoritme 

in WT-specificatie met T(n) tijdseenheden en W(n) werk doorgaans een p-PRAM-algoritme met 

parallelle uitvoeringstijd Tp(n) ≤ ⌊ W(n) 

p ⌋+T(n) en kost Cp(n) = p×Tp(n) = O(W(n)+ pT(n)). 

Noteren we daartoe door Wi(n) het aantal bewerkingen in tijdseenheid i, voor 1 ≤ i ≤ T(n). 

Deze Wi(n) bewerkingen worden in ≤ ⌈ Wi(n) 

p ⌉ parallelle stappen gesimuleerd op p processoren, 

voor alle 1 ≤ i ≤ T(n). Dit geeft een p-PRAM-algoritme waarbij het aantal parallelle stappen 

≤ ∑i⌈ Wi(n) Wi(n) 

p ⌉ ≤ ∑i(⌊ p ⌋+1) ≤ ⌊W(n) 

p ⌋+T(n). 

Om deze algemene werkwijze te implementeren moeten eerst en vooral de Wi(n), ∀i, berekend 

worden, hetgeen meestal triviaal is. Vervolgens moeten de bewerkingen toegekend worden aan 

processoren, m.a.w. voor elke parallelle stap en voor elke processor Pk moet nagegaan worden of 

de processor actief is, en zo ja, welke bewerkingen hij moet uitvoeren 

Voorbeeld 2.3.2 (Veralgemeende som van een rij getallen). We beschouwen de WT-scheduling 

van Algoritme 2.8. Onderstel dat we beschikken over een PRAM met p = 2 q ≤ n = 2 k processoren 

P1,...,Pp, en zij ℓ = n/p = 2 k−q . De rij a wordt verdeeld in p deelrijen van elk ℓ elementen, 

waarbij processor Pr deelrij a ℓ(r−1)+1,...,aℓr behandelt. 

Voor elke waarde van h wordt de berekening van de elementen bi zo gelijkmatig mogelijk verdeeld 

over de p processoren. Merk op dat het aantal mogelijke parallelle bewerkingen gegeven 


2.3. Het werk-tijd-paradigma 17 

Algoritme 2.9 Berekenen van de veralgemeende som van een rij getallen (WT-scheduling) 

Input: array a met n = 2 k getallen; p = 2 q ≤ n processoren; ℓ = n/p; processornummer r 


1: for j = 1 to ℓ do 

2: Stel b ℓ(r−1)+ j ← a ℓ(r−1)+ j 


4: if k − h − q ≥ 0 then 

5: for j from 2 k−h−q (r − 1)+1 to 2 k−h−q r do 

6: Stel b j ← b2 j−1 ⊕ b2 j 

7: else if r ≤ 2 k−h then 

8: Stel br ← b2r−1 ⊕ b2r 

9: if r = 1 then 

10: Stel s ← b1 

wordt door n/2 h = 2 k−h . Als 2 k−h ≥ p = 2 q , dus als k − h − q ≥ 0, dan kunnen de bewerkingen 

gelijkmatig verdeeld worden over p processoren. Anders worden ze verdeeld over de 2 k−h 

“eerste” processoren. Algoritme 2.9 geeft de pseudocode voor dit PRAM-algoritme. 

De parallelle uitvoeringstijd van dit algoritme wordt gegeven door 

 

n 

Tp(n) = O 

p + 

log 2n ⌈ n 

2hp ⌉ 

 

n 

= O + logn . 

p 

∑ 

h=1 

 

W(n) 

Merk op dat Tp(n) = O p + T(n) , zoals voorspeld door het WT-scheduling-principe. De 

kost van dit algoritme is Cp(n) = p × Tp(n) = O(n+ plogn). 

In het vervolg zullen we PRAM-algoritmen doorgaans enkel in hun WT-presentatie bespreken. 

Het weglaten van de details van het WT-scheduling niveau wordt gemotiveerd door het feit dat 

deze uitwerking doorgaans geen nieuwe ideeën vereist, maar eerder bestaat uit programmeerdetails 

die de beschrijving van het algoritme veel ingewikkelder maken. 




Hoofdstuk 3 

Het netwerkmodel 

In dit hoofdstuk bespreken we parallelle computers die kunnen gemodelleerd worden als een 

netwerk. We behandelen zowel de circuits, die bestaan uit processoren met zeer beperkte mogelijkheden, 

als de meer algemene interconnectienetwerken. We zien welke netwerktopologieën 

interessant kunnen zijn voor het parallel oplossen van problemen. Bovendien bestuderen we ook 

enkele standaard communicatiepatronen in de veelgebruikte interconnectienetwerken. 

19

20 Hoofdstuk 3. Het netwerkmodel 

3.1 Het netwerkmodel 

Een netwerk kan beschouwd worden als een graaf G = (V,E), waarbij elke top vi ∈ V een 

processor Pi voorstelt, en elke boog (vi,vj) ∈ E een communicatielink tussen Pi en Pj voorstelt. 

Elke processor heeft zijn eigen lokale geheugen, en er is geen gemeenschappelijk geheugen 

beschikbaar. 

Communicatie tussen de processoren gebeurt via de beschikbare communicatielinks. In de pseudocode 

gebruiken we dan ook volgende bijkomende opdrachten voor het aangeven van communicatie: 

• send(X,i): De processor zendt een kopie van data X naar processor Pi en gaat daarna 

onmiddellijk verder met het uitvoeren van de volgende instructie. 

• receive(Y , j): De processor schort de uitvoering van zijn programma op totdat data van 

processor Pj ontvangen is. Daarna slaat hij deze data op in een variabele Y en gaat dan 

verder met de uitvoering van zijn programma. 

Ook in het netwerkmodel beschouwen we twee verschillende manieren van werken, nl. synchroon 

en asynchroon. Meest gebruikt is echter het asynchrone netwerkmodel. 

De processoren in een asynchroon netwerk coördineren hun activiteiten door boodschappen uit 

te wisselen; dit schema wordt het message-passing model genoemd. 

Merk echter op dat twee communicerende processoren niet noodzakelijk rechtstreeks verbonden 

zijn. Het proces van het bezorgen van een bericht van de afzender naar de bestemmeling wordt 

routing genoemd. 

3.2 Circuits en systolische algoritmen 

Een voorbeeld van parallelle algoritmen in het synchrone netwerkmodel zijn de zgn. systolische 

algoritmen die werken op circuits. 

Circuits bestaan uit processoren met beperkte mogelijkheden. Dergelijke processor wordt een 

poort genoemd. Een poort heeft inputkanalen, waarop een eenvoudige bewerking gebeurt, waarvan 

het resultaat naar de outputkanalen gestuurd wordt. Voorbeelden van circuits zijn de sorteernetwerken 

die we in Hoofdstuk 5 zullen bespreken, en de systolische netwerken, waarvan we 

hier een toepassing behandelen. 

In een systolisch algoritme werken de processoren volledig synchroon. Per tijdseenheid ontvangt 

elke processor gegevens van bepaalde buren, op deze gegevens doet hij een lokale berekening, 

en vervolgens stuurt hij gegevens door naar bepaalde buren. 

Voorbeeld 3.2.1 (Matrixvermenigvuldiging). We beschouwen het berekenen van het product 

C = AB van twee n×n matrices A en B. Veronderstel dat we een tweedimensionaal n×n rooster 


3.3. Interconnectienetwerken 21 

van poorten ter beschikking hebben. Elke processor Pi, j heeft twee inputkanalen, komende van 

zijn linkerbuur Pi−1, j en van zijn bovenbuur Pi, j−1. Verder heeft Pi, j twee outputkanalen, gaande 

naar zijn rechterbuur Pi+1, j en zijn onderbuur Pi, j+1. 

Een mogelijk systolisch algoritme bestaat erin de rijen van A synchroon, maar met een verschuiving, 

van links naar rechts door de rijen van het rooster te sturen, terwijl de kolommen van B 

synchroon, en ook met verschuiving, van boven naar onder door de kolommen van het rooster 

gestuurd worden. Wanneer processor Pi, j de inputwaarden Ai,ℓ en Bℓ, j ontvangen heeft, dan berekent 

hij Ci, j ← Ci, j +Ai,ℓBℓ, j, en stuurt vervolgens de inputwaarde Ai,ℓ door naar zijn rechterbuur 

en de inputwaarde Bℓ, j naar zijn onderbuur. Na O(n) dergelijke stappen bevat elke processor Pi, j 

het correcte matrixelement Ci, j van het matrixproduct C = AB. 

Het aantal processoren is p = n 2 . De parallelle uitvoeringstijd van dit algoritme is Tp(n) = Θ(n). 

De kost van dit algoritme is Cp(n) = Θ(n 3 ). 

3.3 Interconnectienetwerken 

3.3.1 Netwerktopologieën 

Een verzameling processoren met voorgeschreven statische communicatiekanalen wordt een interconnectienetwerk 

genoemd. Zoals reeds vermeld kunnen we de communicatiekanalen voorstellen 

als bogen in een graaf waarvan de toppen de processoren zijn. We spreken van netwerktopologieën 

om bepaalde families van grafen aan te duiden. 

Voor het evalueren van netwerktopologieën worden een aantal parameters gebruikt. De grootste 

afstand tussen twee processoren in het netwerk noemen we de diameter van het netwerk. 

Een kleine diameter in het netwerk betekent doorgaans snelle communicatie. De graad van 

een processor is het aantal communicatiekanalen van de processoren; de grootste graad van een 

processor in het netwerk wordt ook wel de graad van het netwerk genoemd. De connectiviteit 

van het netwerk is het kleinste aantal toppen of bogen waarvan de verwijdering het netwerk 

niet-samenhangend maakt. 

Bijvoorbeeld, we kunnen de processoren verbinden in de stertopologie, waarbij alle processoren 

verbonden zijn met één centrale processor. In de stertopologie is elke processor hoogstens twee 

stappen verwijderd van elke andere processor. De stertopologie heeft diameter 2. Bovendien 

gebruikt de stertopologie slechts n communicatiekanalen om n + 1 processoren te verbinden, 

hetgeen het minimum is. 

Een negatief punt is dat de stertopologie een zeer lage connectiviteit heeft: het uitvallen van één 

enkele processor (nl. de centrale processor) verbreekt het ganse netwerk en maakt communicatie 

tussen alle andere processoren onmogelijk. Dergelijk gedrag is in vele situaties ontoelaatbaar; 

denk bijvoorbeeld aan het uitvallen van het Internet door het uitvallen van één enkele machine. 

Een ander probleem ontstaat wanneer teveel processoren terzelfdertijd proberen te communiceren. 

Aangezien alle communicatie door de centrale processor moet gebeuren, is de snelheid 



van deze ene processor een bottleneck voor het ganse netwerk. M.a.w. toppen van grote graad 

(processoren met veel incidente communicatiekanalen) kan ook een nadeel zijn. 

Als we de connectiviteit willen verbeteren, moeten we communicatiekanalen toevoegen. Wanneer 

we alle mogelijke verbindingen toevoegen, dan bekomen we een topologie die correspondeert 

met de complete graaf Kn. 

Een voordeel van Kn is zijn kleine diameter van 1 en dus het ontbreken van enige bottleneck 

in de communicatie tussen processoren. We betalen echter een hoge prijs voor dit netwerk: we 

gebruiken n(n − 1)/2 communicatiekanalen om n processoren te verbinden. 

Het is dus nuttig om naar intermediaire architecturen te kijken, zoals bomen, rijen, roosters en 

hyperkubussen. 

De stertopologie is een voorbeeld van een boom, en netwerken worden soms op natuurlijke wijze 

op bomen gebaseerd. Denk bijvoorbeeld aan de manier waarop we het maximum berekenden 

door gebruik te maken van een binaire boom. 

Bomen zijn samenhangend met een minimum aan bogen, hetgeen betekent dat het verwijderen 

van een top of een boog hen onmiddellijk niet-samenhangend maakt. 

Positief aan bomen is dat er bomen bestaan met toppen van kleine graad en met kleine diameter. 

Bijvoorbeeld, een binaire boom, waar elke top hoogstens graad 3 heeft, laat toe om n toppen te 

verbinden met een diameter van 2log 2 n. 

3.3.2 Rij en ring 

Een andere manier om n processoren te verbinden met een klein aantal verbindingen, is de rij 

van processoren, en de variant van de ring van processoren. Beiden komen in de praktijk voor; 

bijvoorbeeld een Ethernet is een rijtopologie, terwijl een ‘token ring’ een ringtopologie is. 

Een rij van processoren bestaat uit p processoren P1,...,Pp die in een lineaire rij verbonden 

zijn, m.a.w. Pi is verbonden met de voorgaande processor Pi−1 en met de volgende processor Pi+1 

(wanneer die bestaan). De diameter van dergelijke rij is p − 1 en zijn maximumgraad is 2. 

Een ring van processoren is een lineaire rij van processoren waarbij de eerste processor P1 ook 

met de laatste processor Pp rechtstreeks verbonden is. De diameter van de ring is ⌊p/2⌋ en zijn 

maximumgraad is 2. 

De connectiviteit van de ringtopologie is lichtjes hoger dan die van de stertopologie en de rijtopologie. 

Na het uitvallen van een processor in een ring, is het netwerk nog steeds samenhangend, 

m.a.w. elke processor kan communiceren met elke andere processor. Wanneer echter twee nietnaburige 

processoren uitvallen, dan is het netwerk niet meer samenhangend. 

Een nadeel van zowel rij als ring is het feit dat hun diameter Θ(n) is, waardoor ze enkel bruikbaar 

zijn voor kleine waarden van n, zoals in ‘local area’ netwerken (LAN). 

Voorbeeld 3.3.1 (Matrix-vector-vermenigvuldiging). Zij gegeven een n × n matrix A en een 

vector x van orde n. We behandelen het berekenen van het matrix-vector-product y = Ax op een 

ring van p processoren, waarbij p ≤ n. Onderstel dat p een deler van n is, en stel r = n/p. 



Algoritme 3.1 Berekenen van matrix-vector-vermenigvuldiging op ring 

Input: processornummer i; aantal processoren p; r = n/p geheel; deelmatrix B = A (i) = 

A 1:n,(i−1)r+1:ir; deelvector w = x (i) = x (i−1)r+1:ir 

Output: Pi berekent A (1) x (1) + ··· + A (i) x (i) , en geeft dit resultaat naar rechts door; na afloop 

bevat P1 het resultaat Ax 

1: Bereken z ← Bw 


3: Stel y ← 0 

4: else 

5: receive (y, links) 

6: Stel y ← y+z 

7: send (y, rechts) 


9: receive (y, links) 

We splitsen A op in p blokken A (i) van grootte n × r, en x in p stukken x (i) van lengte r. Elke 

processor Pi berekent z (i) = A (i) x (i) , voor 1 ≤ i ≤ p. Vervolgens bepalen we de som z (1) + ···+ 

z (p) , door de partiële sommen in wijzerzin doorheen de ring te laten circuleren. Algoritme 3.1 

geeft de pseudocode voor processor Pi. 

Elke processor begint met het berekenen van zijn stuk van de matrix-vector-vermenigvuldiging 

en slaat het resultaat op in een lokale variabele z (stap 1). In stap 2 initialiseert processor P1 de 

vector y op 0, terwijl alle andere processoren de uitvoering van hun programma opschorten en 

wachten tot ze data van hun linkerbuur ontvangen. Processor P1 stelt y ← A (1) x (1) en stuurt dit 

resultaat door naar zijn rechterbuur (lijn 6 en 7). Op dat moment ontvangt P2 de waarde A (1) x (1) 

en gaat verder met de uitvoering van zijn programma door de waarde y ← A (1) x (1) + A (2) x (2) 

te berekenen en door te sturen naar zijn rechterbuur (lijn 6 en 7). Op die manier berekent elke 

processor Pi gaandeweg zijn partieelsom y ← A (1) x (1) + ···+A (i) x (i) . Uiteindelijk berekent Pp 

het gewenste resultaat y ← Ax en stuurt dit door naar zijn rechterbuur P1. Dit verklaart de laatste 

if-opdracht, waar P1 nog het resultaat van zijn linkerbuur Pp moet ontvangen. 

Bespreken we de performantie van dit algoritme. De parallelle tijd nodig voor de berekeningen 

is Θ(n 2 /p). Bij de communicatie tussen twee processoren moet telkens een vector van orde n 

doorgestuurd worden. Verder moet P1 wachten tot wanneer Pp de som A (1) x (1) + ···+A (p) x (p) 

berekend heeft, vooraleer hij zijn laatste bewerking kan uitvoeren; deze accumulatie van de som 

vraagt p stappen. De totale tijd nodig voor de communicatie is dus Θ(np). M.a.w. de totale 

parallelle uitvoeringstijd van het algoritme is 

Tp(n) = Θ(n 2 /p+np). 

Gelet op de sequentiële uitvoeringstijd T ∗ (n) = Θ(n2 ) voor dit probleem, levert dit dus een 

versnelling 

Θ(n 

Sp(n) = 

2 ) 

Θ(n2 p 

= Θ( 

/p+np) 1+ p2 /n ). 



De kost van het algoritme is 

(a) Q0 (b) Q1 (c) Q2 (d) Q3 Q4 

Figuur 3.1: De hyperkubussen t.e.m. dimensie 4 

Cp(n) = pΘ(n 2 /p+np) = Θ(n 2 + np 2 ), 

zodat het algoritme kost-optimaal is voor p = Θ( √ n). 

3.3.3 Rooster 

Een veralgemening van de rijtopologie is het rooster (of mesh), dat p = m 2 processoren in een 

m×m tweedimensionale loodrechte roosterstructuur plaatst, waarbij elke processor verbonden is 

met zijn onmiddellijke buren (boven, onder, links en rechts), m.a.w. Pi, j is verbonden met Pi±1, j 

en Pi, j±1 (waar die bestaan). Net zoals bij de rijtopologie, kan het rooster gesloten worden tot 

een torus (of rooster met wrap-around), door de bovenste processor van elke kolom te verbinden 

met de onderste, en de laatste processor van elke rij te verbinden met de eerste. In de jaren 1980 

ontwierp Inmos een chip met 4 links, transputer genoemd, die dus perfect geschikt was voor het 

bouwen van een rooster- of torustopologie. 

De diameter van een rooster met p = m 2 processoren is 2 √ p − 2, dus Θ( √ p). De maximale 

graad van elke processor is 4. Het aantal verbindingen is 2m(m − 1) = Θ(p). De connectiviteit 

is 2. 

Deze topologie heeft verscheidene eigenschappen die haar aantrekkelijk maken. Ze is eenvoudig, 

regulier en uitbreidbaar. Bovendien zijn er verscheidene toepassingen waarbij de berekeningen 

op natuurlijke wijze in een roosterstructuur gebeuren. Maar gelet op de grote diameter, zal een 

berekening met niet-triviale communicatiestappen doorgaans Ω( √ p) parallelle stappen vereisen. 

3.3.4 Hyperkubus 

Een andere populaire topologie is de hyperkubus. Een nuldimensionale hyperkubus is één enkele 

processor. Een d-dimensionale hyperkubus Qd, met d > 0, bestaat uit twee kopieën van 

een (d − 1)-dimensionale hyperkubus Qd−1, waarbij de corresponderende toppen uit elke kopie 

verbonden worden. Figuur 3.1 toont alle hyperkubussen t.e.m. dimensie 4. 

De toppen in een d-dimensionale hyperkubus kunnen gelabeld worden met een binaire string van 

d bits, op de volgende manier. De twee toppen van de eendimensionale hyperkubus worden met 0 



010 

110 111 

100 

011 

000 001 

Figuur 3.2: Labeling van de hyperkubus van dimensie 3 

101 

0 1 0 1 0 1 0 0 1 0 

1 1 0 1 0 1 1 0 1 0 

1 1 1 1 0 1 1 1 1 0 

1 1 1 0 0 1 1 1 1 1 

1 1 1 0 1 

Figuur 3.3: Het verzenden op een hyperkubus 

en 1 gelabeld. De labels voor de d-dimensionale hyperkubus worden dan recursief opgesteld. 

Veronderstel dat we reeds elke top van de (d −1)-dimensionale hyperkubus gelabeld hebben met 

string van d − 1 bits. De d-dimensionale hyperkubus bestaat uit twee kopieën van de (d − 1)dimensionale 

hyperkubus; geef de ene kopie label 0 en de andere label 1. Het label van een 

top in de d-dimensionale hyperkubus bestaat uit de concatenatie van 0 of 1 (afhankelijk van de 

deelkubus waartoe hij behoort) en zijn label in de deelkubus. Figuur 3.2 toont de labeling van 

de driedimensionale hyperkubus. Merk op dat twee processoren die in precies één coördinaat 

verschillen, rechtstreeks verbonden zijn door een communicatiekanaal. 

Aangezien verschillende labels corresponderen met verschillende toppen, kunnen we hieruit afleiden 

dat de d-dimensionale hyperkubus p = 2 d toppen bevat. De graad van elke top is d; de 

hyperkubus is dus een reguliere graaf van graad d. 

De diameter van de hyperkubus is d = log 2 p, hetgeen impliceert dat we een boodschap van elke 

top naar om het even welke andere top kunnen sturen in hoogstens d stappen. 

Voorbeeld 3.3.2. Een eenvoudig routing-algoritme is gebaseerd op het feit dat twee processoren 

die in precies één coördinaat verschillen, rechtstreeks verbonden zijn door een communicatiekanaal. 

Hierdoor kunnen we een boodschap van processor Pi naar processor Pj sturen door het 

label i bit per bit in het label j te veranderen. Bijvoorbeeld, om in de vijfdimensionale hyperkubus 

een boodschap van 01010 naar 11101 te sturen, kunnen we dit routen over 01010, 11010, 

11110, 11100, 11101. 

Dit eenvoudige routing-algoritme kan echter tot problemen leiden, wanneer meerdere boodschappen 

tegelijkertijd onderweg zijn. Bijvoorbeeld, beschouw het versturen van een boodschap 

van 01010 naar 11101 en een boodschap van 10010 naar 11110. Figuur 3.3 illustreert het verzen- 



dingsproces. Hieruit blijkt dat er in de tweede stap twee boodschappen op 11010 zijn, die over 

dezelfde boog moeten verdergestuurd worden. Wanneer we zoals gebruikelijk veronderstellen 

dat slechts één boodschap tegelijk over een kanaal kan verstuurd worden, wordt een van de boodschappen 

hier vertraagd. Meer geavanceerde algoritmen zijn nodig om dergelijke problemen te 

verhelpen. 

De hyperkubus is een populaire topologie omwille van zijn regulariteit, zijn kleine diameter, zijn 

verscheidene interessante graaf-theoretische eigenschappen, en het feit dat vele berekeningen 

snel en eenvoudig op een hyperkubus kunnen worden uitgevoerd. 

Een bijkomende reden is het feit dat andere netwerken er eenvoudig kunnen op gesimuleerd worden. 

Bepaalde netwerken, zoals rijen, kunnen ingebed worden als deelgrafen van de hyperkubus. 

Andere netwerken, zoals bomen, kunnen efficiënt gesimuleerd worden op de hyperkubus, als 

we toelaten dat bogen ‘verwijd’ worden en dat toppen van de hyperkubus meerdere toppen uit 

het oorspronkelijke netwerk simuleren. Algoritmen voor de hyperkubus kunnen dus dikwijls 

aangepast worden om ook op andere architecturen te werken. 

Een nadeel van het hyperkubusnetwerk is dat het duur is om het uit te breiden, omdat nieuwe 

connecties aan elke processor moeten worden toegevoegd wanneer we de dimensie van de hyperkubus 

verhogen. Hyperkubussen worden dus op hun beurt ingebed in netwerken die eenvoudiger 

in hardware te realiseren zijn. 

In de onderstaande voorbeelden ontwerpen we synchrone algoritmen voor enkele eenvoudige 

problemen op de hyperkubus. 

Voorbeeld 3.3.3 (Sommeren van een rij op de hyperkubus). Zij gegeven een rij (a0,...,an−1) 

met n = 2d elementen, waarbij elke ai opgeslagen is in het lokale geheugen van processor Pi van 

een (synchrone) d-dimensionale hyperkubus Qd. Gevraagd is de som s = ∑ n−1 

i=0 ai te berekenen 

en op te slaan op processor P0. 

Het algoritme voor de berekening van s is rechtlijnig. Het bestaat uit d iteraties. De eerste iteratie 

berekent de sommen van paren elementen tussen processoren waarvan de indices in de meest 

significante bitpositie verschillen. Deze sommen worden opgeslagen in de (d − 1)-dimensionale 

deelhyperkubus waarvan de meest significante adresbit gelijk aan 0 is. De andere iteraties gebeuren 

op gelijkaardige wijze. 

Algoritme 3.2 geeft de pseudocode voor processor Pi. Daarbij noteren we door i (ℓ) de index 

i waarbij van bit ℓ het complement genomen werd. De instructie ai ← ai + a i (ℓ) vereist twee 

deelstappen. In de eerste deelstap kopieert processor Pi de waarde a i (ℓ) van processor P i (ℓ) via de 

link tussen Pi en P i (ℓ). In de tweede deelstap berekent processor Pi de waarde ai + a i (ℓ) en slaat 

het resultaat op in ai. 

Dit algoritme vereist d = log 2 n parallelle stappen. 

Voorbeeld 3.3.4 (Broadcast op de hyperkubus). Beschouw het probleem van het doorsturen 

van een item x van processor P0 naar alle andere processoren Pi van een hyperkubus met p processoren, 

waarbij p = 2 d . 


3.4. Communicatie-algoritmen 27 

Algoritme 3.2 Sommeren van een rij op een synchrone hyperkubus 

Input: rij (a0,...,an−1; n = 2d ; elke ai is opgesplagen op processor Pi van een synchrone hyperkubus 

Qd 

Output: som s = ∑ n−1 

i=0 ai op P0 

1: for ℓ from d − 1 to 0 do 

2: if 0 ≤ i ≤ 2ℓ − 1 then 

3: Stel ai ← ai + ai (ℓ) 

Algoritme 3.3 Broadcast op een synchrone hyperkubus 

Input: synchrone hyperkubus Qd met p = 2 d processoren; processor P0 heeft een item x in zijn 

register d0 

Output: elke processor Pi heeft een kopie van item x in zijn register di 

1: for ℓ from 0 to d − 1 do 

2: if 0 ≤ i ≤ 2 ℓ − 1 then 

3: Stel d i (ℓ) ← di 

Een eenvoudige strategie kan gevolgd worden om dit probleem op te lossen. We werken opwaarts 

vanaf de laagste dimensie naar de hoogste dimensie in de hyperkubus, in d iteraties, als volgt. 

Tijdens de eerste iteratie zendt P0 een kopie van x naar P1. Tijdens de tweede iteratie zenden P0 

en P1 kopies van x naar P2 en P3 respectievelijk, gebruik makend van de links tussen P0 en P2 en 

tussen P1 en P3. 

Algoritme 3.3 geeft de pseudocode voor dit algoritme. Net zoals in Algoritme 3.2 heeft de 

instructie d i (ℓ) ← di twee deelstappen. In de eerste deelstap wordt een kopie van het register di 

van processor Pi naar processor P i (ℓ) gekopieerd via de link tussen Pi en P i (ℓ). In de tweede 

deelstap ontvangt processor P i (ℓ) de kopie en slaat ze op in zijn register d i (ℓ). 

Ook dit algoritme vereist d = log 2 p parallelle stappen. 

Bovenstaande algoritmen voor de hyperkubus behoren tot de klasse van genormaliseerde algoritmen. 

De hyperkubusalgoritmen in deze klasse gebruiken in elke tijdseenheid één dimensie 

van de hyperkubus, zodanig dat opeenvolgende dimensies in opeenvolgende tijdseenheden gebruikt 

worden. Bovenstaande algoritmen behoren zelfs tot de meer gespecialiseerde klassen van 

volledig genormaliseerde algoritmen, dit zijn genormaliseerde algoritmen met de bijkomende 

voorwaarde dat elk van de d dimensies van de hyperkubus in sequentie gebruikt wordt (ofwel in 

stijgende volgorde, zoals bij het voorbeeld van broadcasting, ofwel in dalende volgorde, zoals 

bij het voorbeeld van het sommeren van een rij). 

3.4 Communicatie-algoritmen 

Zoals reeds vermeld wisselen processoren in het netwerkmodel gegevens uit door onderlinge 

communicatie via verbindingen. Deze communicatie heeft een grote invloed op de efficiëntie van 



parallelle algoritmen in het netwerkmodel, omdat bij de gegevensuitwisseling communicatievertragingen 

kunnen ontstaan. Er zijn enkele veelvoorkomende basispatronen van interprocessorcommunicatie, 

die gebruikt worden als bouwstenen voor een veelheid van parallelle algoritmen. 

In deze paragraaf introduceren we enkele standaard communicatiepatronen en bespreken hun efficiënte 

implementatie op standaard netwerktopologieën (zoals ring, rooster met wrap-around en 

hyperkubus). 

We noteren door p het aantal processoren en door m de lengte van de uit te wisselen gegevens. 

We veronderstellen dat de verbindingen tussen de processoren bidirectioneel zijn, m.a.w. dat 

twee rechtstreeks verbonden processoren tegelijkertijd boodschappen van grootte m naar elkaar 

kunnen sturen. Verder veronderstellen we dat een processor slechts op een van zijn verbindingen 

tegelijk een boodschap kan sturen. Analoog kan een processor maar op een van zijn verbindingen 

tegelijk een boodschap ontvangen. Maar een processor kan wel tegelijkertijd op een van van zijn 

verbindingen een boodschap sturen en op een andere verbinding een boodschap ontvangen. 

Voor veel van de hier beschreven bewerkingen bestaan duale en andere aanverwante bewerkingen 

die zeer analoog aan de oorspronkelijke bewerkingen kunnen worden uitgevoerd. De duale van 

een communicatiebewerking is het tegenovergestelde van de oorspronkelijke bewerking en kan 

uitgevoerd worden door de richting en de volgorde van de boodschappen in de oorspronkelijke 

bewerking om te keren. Waar toepasselijk zullen we dergelijke bewerkingen vermelden. 

3.4.1 One-to-all broadcast 

In een one-to-all-broadcast of single-node-broadcast stuurt één processor een identieke boodschap 

naar elke andere processor. Aanvankelijk heeft enkel de bronprocessor de boodschap van 

grootte m; na de broadcast zijn er p kopieën van de boodschap, nl. een kopie op elke processor. 

De duale bewerking hiervan is een single-node accumulation. Hierbij heeft elke processor 

aanvankelijk een boodschap van grootte m. Eén van de processoren (de bronprocessor) verzamelt 

deze informatie van alle andere processoren en bundelt die tot één boodschap van grootte m (via 

een associatieve operator). Merk op dat de samengevoegde informatie na de bewerking grootte m 

heeft. Dit betekent dat single-node accumulation kan worden gebruikt om de som, het product, 

het maximum of het minimum van een rij getallen, of elke andere paarsgewijze bewerking op 

een rij elementen uit te voeren. 

Deze communicatiepatronen worden o.m. gebruikt in parallelle algoritmen voor matrix-vectorvermenigvuldiging, 

Gauss-eliminatie, het bepalen van kortste paden, het inproduct van vectoren. 

One-to-all broadcast op een ring 

De bronprocessor stuurt zijn boodschap naar zijn twee buren, in twee opeenvolgende stappen. 

Elke processor ontvangt een boodschap op een van zijn verbindingen en stuurt deze door naar 

zijn buur op de andere verbinding. Dit proces wordt herhaald totdat alle processoren een kopie 

van de boodschap ontvangen hebben. 



Dit ganse proces vereist ⌈p/2⌉ stappen en de totale communicatietijd is Θ(mp). 

One-to-all broadcast op een rooster met wraparound 

Elke rij en kolom van een vierkant rooster met p processoren kan beschouwd worden als een 

ring met √ p processoren. Verscheidene communicatie-algoritmen voor een rooster zijn dan ook 

eenvoudige uitbreidingen van hun tegenhangers op een ring. Typisch bestaat dergelijk algoritme 

uit twee fasen. In de eerste fase gebeurt de communicatie op een of meerdere rijen, die als ring 

beschouwd worden. Dit wordt een rijrotatie genoemd. In de tweede fase worden de kolommen 

op dezelfde manier behandeld. Dit wordt een kolomrotatie genoemd. 

Concreet is ook het algoritme voor one-to-all broadcast op een rooster met √ p rijen en √ p 

kolommen gebaseerd op het bovenstaande algoritme voor one-to-all braodcast op een ring. In 

fase 1 stuurt de bronprocessor de boodschap naar de andere ( √ p − 1) processoren op zijn rij, 

via een one-to-all broadcast. In fase 2 verspreidt elk van deze processoren de boodschap via een 

one-to-all broadcast over zijn kolom. Op het einde van fase 2 heeft elke processor een kopie van 

de oorspronkelijke boodschap. 

De communicatietijd van de rijrotatie op de rij van de bronprocessor is Θ(m √ p), nl. de tijd nodig 

voor een one-to-all broadcast op een ring van √ p processoren. In de tweede fase gebeuren alle 

kolomrotaties in parallel, zodat deze fase precies evenveel tijd neemt als de eerste fase. De totale 

communicatietijd van deze one-to-all broadcast is dus Θ(m √ p). 

Merk op dat dit algoritme kan veralgemeend worden naar een meerdimensionaal rooster. Bijvoorbeeld, 

in een driedimensionaal rooster worden de 3√ p processoren van elke dimensie als 

ringen beschouwd. Door de procedure voor een ring in drie fasen toe te passen, eenmaal in elke 

dimensie, bekomen we een algoritme voor one-to-all broadcast op een drie-dimensionaal rooster 

met communicatietijd Θ(m 3√ p). 

One-to-all broadcast op een hyperkubus 

In het bijzonder is een hyperkubus van dimensie d te beschouwen als een d-dimensionaal rooster 

met twee processoren in elke dimensie. Het algoritme voor een rooster kan dus worden uitgebreid 

naar een hyperkubus, waarbij het proces in d fasen gebeurt, eenmaal in elke dimensie van de 

hyperkubus. Elke stap is een one-to-all broadcast op een ring met twee processoren, hetgeen 

uiteindelijk een eenvoudige uitwisseling van boodschappen tussen twee rechtstreeks verbonden 

processoren is. 

Merk op dat de volgorde waarin de verschillende fases de dimensies doorlopen, onbelangrijk 

is. Een mogelijke volgorde bestaat erin te starten met de uitwisseling in de hoogste dimensie, 

m.a.w. een uitwisseling tussen twee processoren waarvan de label in hun meest significante bit 

verschillen, en in opeenvolgende lagere dimensies te werken in de volgende stappen. 

Het aantal stappen is Θ(log p), met p = 2 d . De totale communicatietijd is Θ(mlog p). 



3.4.2 All-to-all broadcast 

Een all-to-all broadcast of multinode broadcast is een veralgemening van de one-to-all broadcast, 

waarbij elke processor gelijktijdig een one-to-all broadcast uitvoert. Een processor stuurt 

dezelfde boodschap van grootte m naar alle andere processoren, maar verschillende processoren 

sturen verschillende boodschappen. De duale bewerking is multinode accumulation, waarbij 

elke processor de bestemming is van een single-node accumulation. 

Deze communicatiepatronen worden o.m. gebruikt bij parallelle algoritmen voor matrixbewerkingen, 

zoals matrixvermenigvuldiging, en bij reductie en het bepalen van prefixsommen. 

Een eenvoudige manier om een all-to-all broadcast uit te voeren bestaat in het uitvoeren van 

p one-to-all broadcasts, één die in elke processor start. Wanneer dit eenvoudigweg rechtlijnig 

geïmplementeerd wordt, leidt deze benadering op sommige architecturen tot een communicatietijd 

van p maal de tijd voor een one-to-all broadcast. Maar dikwijls is het mogelijk om de 

communicatieverbindingen van het netwerk efficiënter te gebruiken en de one-to-all broadcasts 

gelijktijdig te laten uitvoeren. Daarbij probeert men ook om boodschappen die over hetzelfde 

pad gestuurd worden, samen te voegen tot één enkele boodschap (met als grootte de som van 

groottes van de individuele boodschappen) en dus tegelijkertijd te sturen. 

All-to-all broadcast op een ring 

In het eerder geziene algoritme voor one-to-all broadcast op een ring zijn slechts twee communicatieverbindingen 

terzelfdertijd actief tijdens elke stap. Bij all-to-all broadcast kunnen alle 

verbindingen de ganse tijd actief gehouden worden, omdat we er voor kunnen zorgen dat elke 

processor op elk moment informatie heeft die hij kan doorgeven. Dit werkt als volgt. 

In de eerste stap stuurt elke processor Pi zijn eigen boodschap door naar zijn buur Pi+1. In de 

volgende stappen stuurt processor Pi alle binnenkomende boodschappen van zijn andere buur 

Pi−1 door naar Pi+1. Dit duurt totdat alle boodschappen overal verspreid zijn. Dit algoritme is te 

beschouwen als een soort pipelining van meerdere one-to-all broadcasts. 

Doordat de communicatie circulair in één richting verloopt, ontvangt elke processor de p − 1 

vereiste boodschappen van de andere processoren in p − 1 stappen. De totale communicatietijd 

is dus Θ(mp). 

All-to-all broadcast op een rooster met wraparound 

Ook hier is het algoritme gebaseerd op het algoritme voor all-to-all broadcast op een ring en 

werkt het in twee fasen. 

In fase 1 doet elke processor Pi, j een all-to-all broadcast van zijn eigen boodschap op rij i. Op 

die manier verzamelt elke processor de √ p boodschappen van grootte m van zijn eigen rij. Vervolgens 

worden op elke processor de binnengekomen boodschappen samengesteld tot een boodschap 

van m √ p lang. In fase 2 doet elke processor Pi, j dan een all-to-all broadcast van zijn 



samengestelde boodschap op kolom j. Hierdoor verzamelt elke processor alle p boodschappen 

die zich oorspronkelijk elk op hun eigen processor bevonden. 

Het aantal stappen in fase 1 is Θ( √ p) en de totale communicatietijd van fase 1 is Θ(m √ p). Ook 

in fase 2 is het aantal stappen Θ( √ p), maar aangezien de boodschappen nu grootte m √ p hebben, 

is de totale communicatietijd van fase 2 Θ(m √ p × √ p). De totale communicatietijd van beide 

fasen samen is dus Θ(mp). 

Merk op dat het algoritme ook te veralgemenen is voor een d-dimensionaal rooster of voor een 

hyperkubus (als oefening). 

3.4.3 Single-node scatter 

In een one-to-all personalized communication of single-node scatter zendt één enkele processor 

een gepersonaliseerde boodschap van grootte m naar elke andere processor. Deze bewerking 

verschilt van een one-to-all broadcast in de zin dat de bronprocessor hier aanvankelijk p verschillende 

boodschappen heeft, nl. een unieke boodschap bestemd voor elke processor. Bovendien 

wordt bij single-node scatter geen data gedupliceerd. 

De duale bewerking is single-node gather, waarbij één enkele processor een unieke boodschap 

van elke andere processor ontvangt. Voor elke netwerktopologie kan de procedure voor singlenode 

gather bekomen worden uit die voor single-node scatter door de richting en de volgorde 

van de boodschappen om te keren. Merk ook op dat een gather-bewerking verschilt van een 

accumulation-bewerking doordat ze de ontvangen data niet combineert of reduceert. 

De complexiteit van single-node scatter op de verschillende topologieën is gelijkaardig aan die 

van all-to-all broadcast. In all-to-all broadcast ontvangt elke processor een boodschap van m(p− 

1), terwijl in single-node scatter de bronprocessor p−1 boodschappen van grootte m doorstuurt. 

Omwille van deze grote gelijkenis tussen we single-node scatter en all-to-all broadcast bespreken 

we hier enkel een algoritme voor een hyperkubus, en laten de algoritmen voor een ring en een 

rooster met wraparound als oefening. 

Single-node scatter op een hyperkubus 

Het achterliggende idee van het algoritme is als volgt. Oorspronkelijk heeft de bronprocessor 

alle p boodschappen. In de eerste communicatiestap stuurt de bronprocessor de helft van zijn 

boodschappen door naar een van zijn buren. In de volgende communicatiestappen stuurt elke 

processor die reeds gegevens heeft, de helft ervan door naar een van zijn buren. 

Merk op dat de links in een hyperkubus met p processoren in een zekere dimensie twee deelhyperkubussen 

met p/2 processoren verbinden. In elke communicatiestap beweegt data van de ene 

deelhyperkubus naar de andere. De gegevens die een processor heeft vooraleer de communicatie 

in een zekere dimensie te starten, bestaan voor de helft uit gegevens die bedoeld zijn voor een 

processor uit de andere deelhyperkubus. In elke stap houdt een communicerende processor de 



helft van zijn gegevens, nl. degene die bedoeld zijn voor een processor in zijn eigen deelhyperkubus 

moeten blijven; de andere helft stuurt hij naar zijn buur in de andere deelhyperkubus. 

Er zijn log 2p communicatiestappen, elk corresponderend met een van de dimensies van de hyperkubus. 

In elke stap wordt de grootte van de doorgestuurde samengestelde boodschap gehalveerd. 

De totale communicatietijd is dus gegeven door Θ(∑ log 2 p p 

i=1 2i m), of dus Θ(mp). Merk op dat dit 

hetzelfde is als de totale communicatietijd van een all-to-all broadcast in een hyperkubus van 

dezelfde dimensie. 

3.4.4 Total exchange 

In een all-to-all personalized communication of total exchange stuurt elke processor een verschillende 

boodschap van grootte m naar elke andere processor. Anders dan in een all-to-all 

broadcast stuurt elke processor verschillende boodschappen naar verschillende processoren. 

Deze bewerking wordt o.m. gebruikt in parallelle algoritmen voor matrixtranspositie. 

Total exchange op een ring 

In stap 1 zendt elke processor Pi al zijn boodschappen, als een samengestelde boodschap met 

lengte m(p − 1), naar Pi+1. Voor elke processor Pi is één van de boodschappen uit de ontvangen 

samengestelde boodschap bestemd voor Pi; deze heeft dus reeds zijn doel bereikt en kan uit de 

samengestelde boodschap verwijderd worden. In stap 2 stuurt elke Pi de rest van de ontvangen 

samengestelde boodschap, die nu lengte m(p − 2) heeft, door naar Pi+1. Na p − 1 dergelijke 

stappen zijn alle boodschappen op hun bestemming. 

De totale communicatietijd wordt gegeven door Θ(∑ p−1 

i=1 m(p − i)) = Θ(mp2 ). 

Total exchange op een hyperkubus 

Zoals bij eerdere communicatie-algoritmen op een hyperkubus, wordt in log p stappen telkens 

data uitgewisseld in een andere dimensie van de hyperkubus. In elke stap heeft elke processor 

p boodschappen van lengte m elk; de helft daarvan wordt doorgestuurd naar een buur, en 

vervangen door de helft van die buur. 

De totale communicatietijd is Θ(mplog p). 

3.5 Gedistribueerde algoritmen 

Begin 1999 ontcijferde een netwerk van zowat 100 000 PCs op het Internet een in DES gecodeerde 

boodschap in minder dan een dag, wat het lot bezegelde van een 25 jaar oude regeringsstandaard 

voor encryptie. DES is de afkorting van “Data Encryption Standard”, het is nu vervangen 


3.5. Gedistribueerde algoritmen 33 

door AES, de “Advanced Encryption Standard”. De aanval was niet gebaseerd op gesofisticeerde 

wiskundige eigenschappen van het DES-coderingsschema, maar wel op brute kracht. DES 

gebruikt een sleutel van 56 bits, m.a.w. er zijn slechts 2 56 mogelijke sleutels om te controleren. 

Een typische PC op dat moment kon zo’n 2 miljoen sleutels in één seconde uitproberen, zodat 

één PC ongeveer 2 56 /(2 × 10 2 ) seconden, of ongeveer 1000 jaar, nodig zou gehad hebben om 

alle sleutels te proberen. Wanneer 100 000 PCs in parallel op dit probleem werken, wordt deze 

tijd gereduceerd tot ongeveer 4 dagen. 

Gelijkaardige gedistribueerde projecten zijn inmiddels opgezet voor taken zoals het factoriseren 

van grote getallen (een andere bezigheid die interessant is voor crypto-analysten), het zoeken 

van grote priemtweelingen, en zelfs voor het zoeken naar buitenaardse intelligentie (het SETI 

project). 

Al deze projecten vertonen een typische eigenschap van gedistribueerde berekening: de taak die 

moet uitgevoerd worden, parallelliseert goed. De taak is op te breken in zeer onafhankelijke 

deeltaken, waarbij weinig communicatie tussen de deeltaken nodig is. Bijvoorbeeld, in het DESproject 

werden de sleutels opgesplitst in grote blokken, die uitgedeeld werden aan verschillende 


De belangrijkste vraag in gedistribueerde berekeningen is niet zozeer of, en hoe, een probleem 

parallelliseert, maar wel hoe de grote hoeveelheid processoren een gedistribueerde berekening 

kan opzetten en handhaven in een onbetrouwbare en soms zelfs vijandige omgeving. Wat moet 

er gebeuren wanneer een PC die gewerkt heeft op een bepaald blok sleutels, geen resultaat teruggeeft? 

Is de communicatie verloren gegaan of is de computer afgesloten? Geven we het blok 

sleutels aan een andere processor, of wachten we? Wat wanneer één van de PCs gekraakt werd 

en nu opzettelijk verkeerde resultaten teruggeeft? Kunnen we herkennen wanneer dit gebeurt? 

En wie is “we”? 

In alle voorbeelden die we tot nu toe vermeld hebben, is er één centrale processor die de taken 

uitbesteedt (ook “farming” genoemd) aan beschikbare werkers en die de ganse berekening beheert. 

In het algemeen willen we echter niet veronderstellen dat er noodzakelijk een aangestelde 

leider is. Bijvoorbeeld, ARPANET, de voorganger van het Internet, was door het US Department 

of Defense in 1969 opgericht als een gedecentraliseerd communicatienetwerk tegen mogelijke 

nucleaire aanvallen. Zelfs wanneer sommige servers in het Internet uitvallen, is er nog steeds 

communicatie mogelijk. Wanneer de hoofdcomputer in een gecentraliseerd netwerk uitvalt, stort 

het hele netwerk in elkaar. 

We zien dus dat de studie van gedistribueerde algoritmen gestuurd wordt door vragen die betrekking 

hebben op basiscommunicatie tussen de processoren die het gedistribueerde netwerk 

vormen. 

Er zijn meerdere modellen van gedistribueerd berekenen. Meestal wordt verondersteld dat de 

processoren slechts losweg gekoppeld (“loosely coupled”) zijn, m.a.w. er is informatie over kanalen 

tussen paren processoren, maar verder wordt geen informatie gedeeld. In het bijzonder is 

er geen sprake van een globale toestand, zoals in een gecentraliseerd algoritme. Occasioneel kan 

het echter zinvol zijn om te veronderstellen dat alle processoren synchroon kunnen werken, via 



toegang tot een globale klok. Zulke netwerken worden synchroon genoemd. Wanneer we niet 

veronderstellen dat er een globale klok is, dan noemen we het netwerk asynchroon. 


Hoofdstuk 4 

Ontwerptechnieken voor parallelle 

algoritmen 

De taak van het ontwerpen van parallelle algoritmen levert uitdagingen die heel wat moeilijker 

zijn dan in het geval van sequentiële algoritmen. Het ontbreken van één welbepaalde methodologie 

wordt gecompenseerd door een verzameling technieken en paradigma’s die effectief gebleken 

zijn bij het behandelen van een breede waaier aan problemen. In dit hoofdstuk introduceren we 

enkele van deze technieken en passen ze toe op een reeks combinatorische problemen, die vaak 

op zichzelf reeds interessant zijn en die daarnaast ook optreden als deelproblemen in tal van andere 

berekeningen. Het is belangrijk op te merken dat de hier besproken technieken eerder als 

algemene richtlijnen voor het ontwerpen van parallelle algoritmen dienen te worden gezien, en 

niet zozeer als een handleiding van pasklare recepten. 

35

36 Hoofdstuk 4. Ontwerptechnieken voor parallelle algoritmen 

4.1 Pipelining / Sorteren & Priemzeef 

4.1.1 Techniek van pipelining 

Bij de techniek van pipelining wordt een taak T opgebroken in een sequentie van deeltaken 

t1,...,tm die na mekaar uit te voeren zijn, op zodanige manier dat, wanneer deeltaak t1 afgewerkt 

is, er kan begonnen worden met de sequentie voor een nieuwe taak T ′ , die aan hetzelfde tempo 

verdergaat. De deeltaken worden door verschillende processoren (of processen) uitgevoerd. Dit 

proces is gelijkaardig aan de werking van een lopende band in een productiesysteem. 

De techniek van pipelining is bruikbaar in o.m. de volgende situaties: 

• wanneer meer dan één instantie van het volledige probleem moet worden opgelost; 

• wanneer er een reeks gegevens te verwerken is, en elk gegeven meerdere bewerkingen 

vereist; 

• wanneer de informatie voor het starten van het volgende proces voorwaarts kan worden 

doorgegeven alvorens het proces al zijn interne bewerkingen afgewerkt heeft. 

Merk op dat systolische algoritmen, waarvan we in Paragraaf 3.2 een voorbeeld zagen, ook 

dikwijls steunen op het principe van pipelining. We illustreren de techniek van pipelining nog 

aan de hand van twee bijkomende voorbeelden. 

4.1.2 Sorteren via pipelining 

Zij gegeven een rij van n getallen, evenals een rij van n processoren Pi (“slaves”) en één aparte 

processor P0 (“master”) die verbonden is met P1. 

Het algoritme werkt als volgt. Processor P0 stuurt gegevens naar processor P1. Elke processor Pi 

ontvangt telkens een getal van processor Pi−1, houdt de kleinste van alle ontvangen getallen bij, 

en stuurt de andere getallen door naar processor Pi+1. Wanneer alle getallen doorgestuurd zijn, 

bevat elke processor het correcte getal uit de gesorteerde rij. 

Om de gesorteerde rij terug samen te stellen, stuurt elke processor zijn getal naar zijn linkerbuur, 

en vervolgens stuurt hij alle getallen die van de rechterbuur binnenkomen door naar de linkerbuur. 

Algoritme 4.1 geeft de pseudocode van dit algoritme voor processor Pi. 

Met p = n+1, heeft dit algoritme parallelle uitvoeringstijd Tp(n) = Θ(n) en kost Cp(n) = Θ(n 2 ). 

Merk op dat dit algoritme een parallelle versie van sorteren door tussenvoegen is. 


4.1. Pipelining / Sorteren & Priemzeef 37 

Algoritme 4.1 Sorteren via pipelining 

Input: rij van n processoren P1,...,Pn en een master P0; processornummer i > 0; rij van n getallen 

op P0 

Output: de gesorteerde rij op master P0 

1: receive (x, Pi−1) 

2: for j from 2 to n − i do 

3: receive (y, Pi−1) 

4: if y < x then 

5: send (x, Pi+1) 

6: Stel x ← y 

7: else 

8: send (y, Pi+1) 

9: send (x, Pi−1) 

10: for j from 2 to n − i do 

11: receive (y, Pi+1) 

12: send (y, Pi−1) 

Algoritme 4.2 Priemzeef van Eratosthenes (sequentieel algoritme) 

Input: een positief geheel getal n 

Output: (p2,..., pn) met pi true als i priem, anders false 


2: Stel pi ← true 

3: for i from 2 to √ n do 

4: if pi then 

5: for j from i 2 to n step i do 

6: Stel pi ← false 

4.1.3 Priemzeef via pipeling 

De priemzeef van Eratosthenes voor het bepalen van alle priemgetallen kleiner dan of gelijk aan n 

start met de rij 2,...,n. Eerst worden alle echte veelvouden van 2 geschrapt, vervolgens alle echte 

veelvouden van 3, van 5, enz. voor alle overblijvende getallen, tot aan √ n. Algoritme 4.2 geeft 

de pseudocode voor een sequentiële uitwerking van dit idee. De sequentiële uitvoeringstijd is 

T(n) = O(n 2 ). 

Merk op dat het schrappen van de veelvouden iets is wat in parallel kan gebeuren, meer bepaald 

via pipelining. Het algoritme via pipelining werkt als volgt. Elke processor houdt het eerste 

binnenkomende getal bij, verwijdert de veelvouden hiervan uit de doorkomende rij en stuurt de 

niet-veelvouden door naar zijn rechterbuur. 

Anders dan bij het sorteerprobleem weten we nu niet op voorhand hoeveel getallen elke processor 

zal ontvangen. Dit kunnen we oplossen door een speciaal getal (“terminator”) aan het einde van 

de rij toe te voegen, dat aangeeft dat de rij ten einde is. 



Algoritme 4.3 Priemzeef van Eratosthenes (parallel algoritme met pipelining) 

Input: rij van n processoren P1,...,Pn en een master P0; processornummer i > 0; rij getallen 

(2,...,n,−1) op P0 

Output: processor Pi bevat het i-de priemgetal 

1: receive (x, Pi−1) 

2: for j from 1 to n do 

3: receive (y, Pi−1) 

4: if y = −1 then 

5: break 

6: if ymod x = 0 then 

7: send (y, Pi+1) 

Algoritme 4.3 geeft de pseudocode voor het algoritme voor processor Pi. 

4.2 Gebalanceerde bomen / Prefixsommen 

4.2.1 Techniek van gebalanceerde bomen 

Het eerder geziene PRAM-algoritme voor het berekenen van de som van n getallen (Algoritme 

2.7) is gebaseerd op een gebalanceerde binaire boom, waarvan de bladeren de gegeven n getallen 

bevatten en waarvan de interne toppen optellingen voorstellen. Dit algoritme is een voorbeeld 

van de algemene ontwerpstrategie van het opbouwen van een gebalanceerde binaire boom 

op de inputelementen en het voorwaarts en achterwaarts doorlopen van deze boom van en naar 

de wortel. Een interne top u houdt doorgaans informatie bij omtrent de gegevens die opgeslagen 

zijn in de bladeren van de deelboom met wortel u. Het welslagen van deze strategie hangt gedeeltelijk 

af van het bestaan van een snelle manier om de informatie opgeslagen in een interne top te 

bepalen uit de informatie opgeslagen in zijn bladeren. Als tweede voorbeeld van het gebruik van 

deze ontwerpstrategie bespreken we hier het probleem van het bepalen van de prefixsommen van 

n getallen. 

4.2.2 Wat zijn prefixsommen? 

Veronderstel dat we de prijzen op de financiële markt analyseren en dat we de hoogste waardering 

van een bepaald aandeel wensen op te volgen. Gegeven is een lijst met dagelijkse afsluitwaarden 

van het aandeel. Voor elke dag willen we de hoogste waarden kennen die het aandeel tot die 

dag reeds bereikt heeft. We kunnen Algoritme 2.7 gebruiken om het maximum voor elke dag 

te berekenen, maar aangezien we het algoritme apart zouden uitvoeren voor elke dag, is deze 

manier van werken inefficiënt. 

We kunnen ook andere problemen bedenken waarbij, in plaats van één finaal resultaat, ook de 

deelresultaten tot op elk punt gevraagd zijn. Voorbeelden hiervan zijn de partiële deelsommen 


4.2. Gebalanceerde bomen / Prefixsommen 39 

Algoritme 4.4 Sequentieel algoritme voor het berekenen van de prefixsommen 


Output: de waarde sk = ∑ k i=1 ai, voor 1 ≤ k ≤ n 

1: Stel s1 = a1 


3: Stel si ← si−1 ⊕ ai 

bij het berekenen van gemiddelden, of de voorafberekening van de overdrachten bij het optellen 

van twee getallen. 

Zoals in het geval van de semigroep-algoritmen, hebben we ook bij dit soort problemen een 

binaire associatieve operator ⊕ op een vaste set. Het probleem van de parallelle prefixsommen 

bestaat erin alle waarden sk = ∑ k i=1 ai te berekenen voor 1 ≤ k ≤ n, waarbij sk de k-de prefix 

genoemd wordt. 

Wanneer de berekening van ⊕ van twee elementen efficiënt kan gebeuren (hetgeen het geval is 

voor de meeste praktische toepassingen), dan kunnen de prefixen in O(n) sequentiële tijd worden 

berekend, door te steunen op de eigenschap si = si−1 ⊕ ai, voor 2 ≤ i ≤ n. Algoritme 4.4 geeft 

de pseudocode. Merk op dat dit algoritme inherent sequentieel is. 

4.2.3 Berekenen van prefixsommen in het PRAM-model 

Gebruik makend van een gebalanceerde binaire boom kunnen we een snel parallel algoritme 

voor het berekenen van de prefixsommen opstellen. Elke interne top staat voor het uitvoeren van 

de bewerking ⊕ op zijn kinderen tijdens het voorwaarts doorlopen van de boom. Dit betekent 

dat elke top v de som bevat van de getallen opgeslagen in de bladeren van de deelboom met 

wortel v. Tijdens het achterwaarts doorlopen van de boom worden de prefixsommen berekend 

van de toppen op gegeven hoogte in de boom. 

Een recursieve formulering van het algoritme wordt gegeven in Algoritme 4.5. 

Voor inputs van grootte n = 2 k vereist het algoritme 2k + 1 tijdseenheden: tijdens de eerste 

k tijdseenheden beweegt de berekening van de bladeren van de boom (die a1,...,an bevatten) 

naar de wortel; tijdens de laatste k tijdseenheden doorlopen we de boom in omgekeerde volgorde 

en berekenen de prefixsommen door gebruik te maken van de data die in de eerste k tijdseenheden 

werd berekend. Merk op dat het ganse algoritme in-place kan worden uitgevoerd en dat we de 

extra variabelen enkel invoeren voor de duidelijkheid. 

Volgende stelling bewijst de correctheid en de complexiteit van het algoritme in WT-presentatie. 

Stelling 4.2.1. Algoritme 4.5 is een EREW PRAM-algoritme dat de prefixsommen van n getallen 

berekent in parallelle tijd T(n) = Θ(logn) en W(n) = Θ(n) bewerkingen. 

Bewijs: Geen enkele stap in het algoritme vereist de mogelijkheid voor concurrent read of concurrent 

write, zodat het algoritme dus werkt in het EREW PRAM-model. 



Algoritme 4.5 Berekening van prefixsommen op PRAM (recursieve formulering) 

Input: rij (a1,...,an) met n = 2 ℓ , p = n processoren 

Output: sk = ∑ k i=1 ai, voor 1 ≤ k ≤ n 

1: if n = 1 then 

2: Stel s1 ← a1 

3: return 

4: for i from 1 to n/2 pardo 

5: Stel bi ← a2i−1 ⊕ a2i 

6: Bereken recursief prefixsommen (c1...,c n/2) van (b1,...,b n/2) 


8: case i = 1: Stel s1 ← a1 

9: case i even: Stel si ← c i/2 

10: case i oneven: Stel si ← c (i−1)/2 ⊕ ai 

We bewijzen de correctheid van het algoritme door inductie, waarbij we veronderstellen dat de 

inputgrootte n = 2 ℓ is. Het basisgeval k = 0 wordt correct behandeld door de eerste if-opdracht 

van het algoritme. Onderstel nu dat het algoritme correct werkt voor alle rijen van lengte 2 k met 

k > 0. We bewijzen dat het algoritme correct werkt voor alle rijen van lengte n = 2 k+1 . 

Wegens de inductiehypothese bevatten de variabelen (c1...,c n/2), berekend in de recursieve 

stap van het algoritme, de prefixsommen van de rij (b1,...,b n/2), waarbij bi ← a2i−1 ⊕ a2i, voor 

1 ≤ i ≤ n/2. Meer bepaald is c j = c1 ⊕ c2 ⊕ ··· ⊕ c j, en dus c j = a1 ⊕ a2 ⊕ ··· ⊕ a2 j−1 ⊕ a2 j. 

M.a.w. c j bevat precies de prefixsommen s2 j, voor 1 ≤ j ≤ n/2. Dus, voor i even, zij i = 2 j, 

hebben we dat si = c i/2. 

Anders is ofwel i = 1, ofwel i = 2 j+ 1, voor zekere 1 ≤ j ≤ n/2 − 1. Het geval i = 1 is triviaal. 

Voor het geval i = 2 j+ 1, hebben we dat si = s2 j+1 = s2 j ⊕ a2 j+1 = c (i−1)/2 ⊕ ai. 

M.a.w. alle gevallen worden correct afgehandeld in de case-opdracht van het algoritme. Hieruit 

volgt dat het algoritme correct werkt. 

Vervolgens bespreken we de complexiteit van het algoritme. De if-opdracht en de twee parallelle 

for-lussen nemen elk Θ(1) parallelle tijd en vragen Θ(n) bewerkingen. De parallelle uitvoeringstijd 

T(n) en het werk W(n) van het algoritme worden dus bepaald voor de volgende recurrente 

betrekkingen: 

T(n) = T(n/2)+Θ(1) 

W(n) = W(n/2)+Θ(n) 

De oplossingen van deze recurrente betrekkingen zijn: 

Het algoritme is dus werk-optimaal. 

T(n) = Θ(logn) 

W(n) = Θ(n) 


4.2. Gebalanceerde bomen / Prefixsommen 41 

Algoritme 4.6 Berekening van prefixsommen op PRAM (niet-recursieve formulering) 

Input: rij (a1,...,an) met n = 2 ℓ 

Output: tabel C: c0,k = sk = ∑ k j=1 a j (1 ≤ k ≤ n) 


2: Stel b0,i ← ai 


4: for j from 1 to n/2 h pardo 

5: Stel bh, j ← bh−1,2 j ⊕ bh−1,2 j+1 

6: for h from log 2 n to 0 do 

7: for j from 1 to n/2 h pardo 

8: case j = 1: Stel ch,0 ← bh,0 

9: case j even: Stel ch, j ← c h+1, j/2 

10: case j oneven: Stel ch, j ← c h+1,( j−1)/2 ⊕ bh, j 

Tot slot bespreken we een niet-recursieve versie van Algoritme 4.5. Daarbij gebruiken we twee 

hulpvariabelen voor het bijhouden van de gebalanceerde boom. De tabel (bh, j), met 0 ≤ h ≤ 

log 2 n en 1 ≤ j ≤ n/2 h , wordt opgebouwd tijdens het voorwaarts doorlopen van de boom. De 

tabel (ch, j) met 0 ≤ h ≤ log 2 n en 1 ≤ j < n/2 h , wordt opgebouwd tijdens het achterwaarts 

doorlopen van de boom. Merk op dat deze hulpvariabelen niet echt nodig zijn en dat het algoritme 

in-place kan worden uitgevoerd. 

4.2.4 Berekenen van prefixsommen op een rooster 

We veronderstellen dat de rij getallen verdeeld is over de rijen van het rooster. Dan kunnen de 

prefixsommen als volgt berekend worden. Elke rij van het rooster doet een rijrotatie; hierdoor 

bevat elke rechtse processor van een rij de som van de getallen op zijn rij. Vervolgens doet de 

rechterkolom van het rooster een kolomrotatie, hetgeen ervoor zorgt dat deze processoren de 

correcte prefixsom bevatten. Dan stuurt elke rechtse processor van een rij zijn prefixsom naar 

zijn onderbuur. Tot slot doet elke rij (behalve de eerste) weer een rijrotatie. Hierdoor bevat 

uiteindelijk elke processor de correcte prefixsom. 

Beschouwen we de performantie van dit algoritme. Zij p = n. De parallelle uitvoeringstijd is 

Tp(n) = Θ( √ p) = Θ( √ n). De kost is Cp(n) = Θ(p 3/2 ) = Θ(n 3/2 ). M.a.w. het algoritme is niet 

kost-optimaal. 

Om het algoritme te optimaliseren bepalen we de waarde van p waarvoor p 3/2 = n, of m.a.w. 

p = n 2/3 . Dan hebben we een rooster van n 1/3 × n 1/3 processoren, en elke processor verwerkt 

n 1/3 elementen sequentieel. De parallelle uitvoeringstijd van dit aangepaste algoritme is Tp(n) = 

Θ( √ p+n 1/3 ) = Θ(n 1/3 ). De kost is Cp(n) = Θ(p × n 1/3 ) = Θ(n), en het aangepaste algoritme 

is dus kost-optimaal. 



4.2.5 Berekenen van prefixsommen op een hyperkubus 

Zij gegeven een rij (a0,...,an−1) met n = 2 d elementen, waarbij elke ak opgeslagen is in het 

lokale geheugen van processor Pk van een hyperkubus Qd. Gevraagd is de prefixsom sk = ∑ k i=0 ai 

te berekenen en op te slaan in Pk, voor alle 0 ≤ k < n. 

Het algoritme volgt de gebruikelijke werkwijze op de hyperkubus, nl. via communicatie in elke 

dimensie, gaande van de laagste naar de hoogste dimensie. Elke processor Pk houdt twee waarden 

xk en yk bij. Initieel krijgen xk en yk beiden de waarde ak. Beschouwen we nu stap i uit het 

algoritme. Zij processoren Pk en Pℓ buren in dimensie i, k < ℓ. Dan wisselen Pk en Pℓ hun 

waarden yk en yℓ uit. Processor Pk houdt zijn oorspronkelijke waarde van xk en vervangt yk door 

yk ⊕yℓ. Processor Pℓ vervangt zijn waarde van xℓ door xℓ ⊕yk en vervangt ook yℓ door yk ⊕yℓ. Na 

d = log 2 n stappen, een in elke dimensie, bevat elke xk uiteindelijk de gevraagde prefixsom sk. 

4.3 Partitionering / Merge 

4.3.1 Techniek van partitioneren 

De techniek van partitioneren bestaat in 

(1) het opsplitsen van het gegeven probleem in p onafhankelijke deelproblemen die ongeveer 

even groot zijn, waarbij p het aantal beschikbare processoren is, en 

(2) het oplossen in parallel van deze deelproblemen. 

In zijn eenvoudigste vorm bestaat deze strategie in het opsplitsen van de inputgegevens in p nietoverlappende 

stukken, gevolgd door het in parallel oplossen van de deelproblemen geassocieerd 

met deze p stukken. In de meeste gevallen zal het opsplitsen van het probleem in onafhankelijke 

deelproblemen echter niet zo eenvoudig zijn. 

We illustreren deze techniek bij het mergen van twee gesorteerde rijen. Zij A = (a1,...,an) 

en B = (b1,...,bn) twee niet-dalende rijen van elementen uit een geordend universum S. We 

beschouwen het probleem van het samenvoegen van deze twee rijen tot één enkele gesorteerde 

rij C = (c1,...,c2n). Er zijn eenvoudige sequentiële algoritmen voor dit probleem die lineaire 

tijd vereisen. Onze bedoeling hier is het opstellen van een parallelle oplossing die gebaseerd is 

op het partitioneren van rijen A en B in meerdere paren van deelrijen op zodanige manier dat we 

de gesorteerde rij C kunnen bekomen door in parallel de paren van deelrijen te mergen. 

4.3.2 Een eenvoudig merge-algoritme 

We beginnen met enkele definities. Zij X = (x1,...,xn) een rij elementen uit het universum S. 

Zij x ∈ S. De rank van x in X, genoteerd als rank(x : X) is het aantal elementen van X dat 


4.3. Partitionering / Merge 43 

kleiner dan of gelijk is aan x. Zij Y = (y1,...,yk) een willekeurige rij van elementen uit S. Het 

ranken van Y in X is het probleem van het bepalen van de rij rank(Y : X) = (r1,...,rk), waarbij 

ri = rank(yi : X). 

Zonder verlies van algemeenheid kunnen we veronderstellen dat alle elementen die in de gegeven 

rijen A en B optreden, verschillend zijn. Meer bepaald komt geen enkele element van A voor in B. 

Het probleem van mergen kan worden beschouwd als het bepalen van de rank van elk element x 

uit A en B in de rij A ∪ B. Als rank(x : A ∪ B) = i, dan is ci = x, waarbij ci het i-de element van 

de gewenste gesorteerde rij is. Aangezien rank(x : A ∪ B) = rank(x : A)+rank(x : B), kunnen 

we het probleem van mergen oplossen door de twee gehele rijen rank(A : B) en rank(B : A) te 

bepalen. 

We beschrijven nu een algoritme om rank(B : A) te bepalen. Hetzelfde algoritme kan gebruikt 

worden om rank(A : B) te bepalen. Zijn bi een willekeurig element van B. Aangezien A gesorteerd 

is, kunnen we de rank van bi in A vinden door gebruik te maken van de binaire zoekmethode. 

We vergelijken bi met het middelste element van A. Afhankelijk van de uitkomst van 

deze vergelijking kunnen we het zoeken beperken tot de onderste of de bovenste helft van A. Dit 

proces wordt herhaald totdat bi geïsoleerd is tussen twee opeenvolgende elementen van A, m.a.w. 

a j(i) < bi < a j(i)+1, waarbij rank(bi : A) = j(i). Merk op dat we hier gebruik maken van het feit 

dat de elementen van A en B allemaal verschillend zijn. 

Dit algoritme bepaalt de rank van een willekeurig element van B in A in sequentiële tijd Θ(logn). 

Het is onmiddellijk duidelijk dat we deze methode in parallel kunnen uitvoeren voor alle elementen 

van B. Dit levert een parallel algoritme voor het bepalen van rank(B : A) met parallelle uitvoeringstijd 

Θ(logn). Dit impliceert een parallel algoritme met uitvoeringstijd Θ(logn) voor het 

mergen van twee rijen van lengte n. Het totaal aantal bewerkingen gebruikt door dit algoritme is 

echter W(n) = Θ(nlogn), zodat het algoritme dus niet werk-optimaal is (aangezien sequentiële 

algoritmen met lineaire uitvoeringstijd bestaan). 

4.3.3 Parallel algoritme voor merge via partitioneren 

Een werk-optimaal parallel algoritme kan als volgt bekomen worden. Kies ongeveer n/log 2 n 

elementen elk uit A en B die A en B partitioneren in blokken van ongeveer gelijke grootte. Pas 

de binaire zoekmethode toe om elk van de gekozen elementen te ranken in de andere rij. Deze 

stap reduceert het probleem tot het mergen van een aantal paren van deelrijen, die elk Θ(logn) 

elementen hebben. Dan kunnen we een optimaal sequentieel algoritme gebruiken om elk paar 

deelrijen te mergen tot een gesorteerde deelrij, die deel uitmaakt van van de uiteindelijk gewenste 

gesorteerde rij. 

Bij het uitwerken van de details beperken we ons voor de eenvoud tot een lichtjes ander algoritme. 

Algoritme 4.7 geeft de pseudocode voor het partitioneringsalgoritme, dat de belangrijkste 

component van het gehele merge-algoritme zal uitmaken. In deze beschrijving veronderstellen 

we niet dat de lengte van de twee deelrijen noodzakelijk gelijk zal zijn. 

Volgende stelling bewijst de correctheid en de complexiteit van dit algoritme. 



Algoritme 4.7 Partitioneringsalgoritme 

Input: A = (a1,...,an) en B = (b1,...,bm) stijgend, log 2 m en k = m/log 2 m geheel 

Output: k paren deelrijen (Ai,Bi), zodat |Bi| = log 2 m, en elk element van Ai en Bi groter dan 

elk element van Ai−1 en Bi−1, voor elke 1 ≤ i < k 

1: Stel j0 ← 0; jk ← n 

2: for i from 1 to k − 1 pardo 

3: Bepaal rank(bilog 2 m : A) via de binaire zoekmethode 

4: Stel ji ← rank(bilog 2 m : A) 

5: for i from 0 to k − 1 pardo 

6: Stel Bi ← (bilog 2 m+1,...,b (i+1)log 2 m) 

7: Stel Ai ← (a ji+1,...,aji+1 ) 

Stelling 4.3.1. Zij C de gesorteerde rij bekomen door het mergen van de twee gesorteerde rijen 

A en B, met lengte resp. n en m. Algoritme 4.7 partitioneert A en B in paren deelrijen (Ai,Bi) 

zodanig dat |Bi| = Θ(log 2 m), ∑i |Ai| = n en C = (C0,C1,...), waarbij Ci de gesorteerde deelrij 

is die bekomen werd door Ai en Bi te mergen. Het algoritme heeft parallelle uitvoeringstijd 

T(n) = Θ(logn) en vereist W(n) = O(n+m) bewerkingen. 

Bewijs: We bewijzen eerst dat elk element in de deelrijen Ai en Bi groter is dan elk element in 

Ai−1 en Bi−1, voor elke 1 ≤ i < k. De twee kleinste elementen van Ai en Bi zijn resp. a j(i)+1 en 

bilog 2 m+1. De tweede grootste elementen van Ai−1 en Bi−1 zijn resp. a j(i) en bilog 2 m. Aangezien 

rank(bilog 2 m : A) = j(i), weten we dat a j(i) < bilog 2 m < a j(i)+1. Hieruit volgt dat bilog 2 m+1 > 

bilog 2 m > a j(i) en ook dat a j(i) > bilog 2 m. M.a.w. elk van de elementen uit Ai en Bi is groter dan 

elk van de elementen uit Ai−1 en Bi−1. Hieruit volgt de correctheid van het algoritme. 

De complexiteitsanalyse gebeurt als volgt. Stap 1 neemt Θ(1) sequentiële tijd. De eerste parallelle 

for-lus vereist Θ(logn) parallelle tijd, aangezien de binaire zoekmethode op alle gewenste 

elementen in parallel uitgevoerd wordt. Het aantal bewerkingen in deze lus is gegeven 

door Θ(logn×(m/logm))=O(n+m), aangezien (mlog 2 n/log 2 m) < (mlog 2 (n+m)/log 2 m) < 

n+m, voor m ≥ 4. De laatste parallelle for-lus vereist Θ(1) tijd en een lineair aantal bewerkingen. 

Het totale algoritme vereist dus T(n) = Θ(logn) parallelle uitvoeringstijd en W(n) = O(n+m) 

bewerkingen. 

Wanneer we Algoritme 4.7 toepassen op het merge-probleem (waarbij we twee rijen van gelijke 

lengte n hebben), dan levert dat een stel onafhankelijke merge-deelproblemen. Dit is de essentie 

van de partitioneringsstrategie. 

Nu wensen we elk merge-deelprobleem op te lossen in Θ(logn) tijd, zodanig dat het totaal aantal 

gebruikte bewerkingen proportioneel is met de grootte van de deelproblemen. Deze uitvoeringstijd 

kunnen we als volgt bekomen. 

Beschouw het merge-deelprobleem voor een willekeurig paar (Ai,Bi). Merk op dat |Bi| = log 2 n 

voor alle i. Als |Ai| = O(logn), dan kunnen we (Ai,Bi) mergen in Θ(logn) sequentiële tijd door 

een optimaal sequentieel algoritme te gebruiken. Anders gebruiken we Algoritme 4.7 om Ai te 

partitioneren in blokken die elk O(logn) groot zijn (in dit geval speelt Ai de rol van B en Bi speelt 


4.4. Accelerated cascading / Maximum bepalen 45 

de rol van A). Deze stap kost Θ(loglogn) tijd en O(|Ai|) bewerkingen. We kunnen er dus voor 

zorgen dat elke deelrij lengte Θ(logn) heeft, zonder de asymptotische complexiteit te verhogen. 

Dit leidt tot de volgende stelling: 

Stelling 4.3.2. Zij A en B twee gesorteerde rijen, elk van lengte n. Dan kunnen A en B via merge 

samengevoegd worden in T(n) = Θ(logn) tijd en W(n) = Θ(n) bewerkingen. 

Merk op dat Algoritme 4.7 de binaire zoekmethode gebruikt om tegelijkertijd meerdere elementen 

van B in A te ranken. M.a.w. de mogelijkheid van concurrent read moet bestaan. Maar 

concurrent write is voor dit algoritme niet nodig. Het algoritme werkt dus in het CREW PRAMmodel. 

4.4 Accelerated cascading / Maximum bepalen 

4.4.1 Bepalen van het maximum 

Zoals reeds eerder gezien bestaat er een parallel algoritme voor het bepalen van het grootste 

element uit een rij X = (x1,...,xn), dat gebruik maakt van de techniek van gebalanceerde bomen. 

De parallelle uitvoeringstijd van dit algoritme is T(n)=Θ(logn) en het totale aantal bewerkingen 

is W(n) = Θ(n). Dit algoritme is werk-optimaal, want het optimale sequentiële algoritme voor 

dit probleem heeft lineaire uitvoeringstijd. 

Dit probleem is een interessant voorbeeld van de strategie van accelerated cascading. Deze 

techniek bestaat uit het combineren van een traag maar optimaal algoritme met een snel maar 

niet-optimaal algoritme, tot een snel en optimaal algoritme. 

We bekijken nu hoe we een sneller parallel algoritme voor het bepalen van het maximum kunnen 

bekomen. Daartoe gebruiken we, in plaats van een gebalanceerde binaire boom (die logaritmische 

diepte heeft), een boom van dubbel-logaritmische diepte. We construeren een gebalanceerde 

boom met als bladeren de waarden xi, zodanig dat het aantal kinderen van een top gelijk 

is aan ⌈ √ nv⌉, waarbij nv het aantal bladeren in een deelboom met wortel v voorstelt. Elke interne 

top wordt gebruikt om het grootste element van zijn deelboom bij te houden. Voorwaarden op 

het aantal kinderen van een top zullen er voor zorgen dat de boom dubbel-logaritmische diepte 

heeft. Het welslagen van deze strategie hangt af van het bestaan van een parallel algoritme met 

constante uitvoeringstijd voor het uitvoeren van de bewerking voorgesteld door een interne top, 

m.a.w. het bepalen van het grootste van een willekeurig aantal elementen. We bespreken dus 

eerst het ontwerpen van dergelijk algoritme. 

4.4.2 Bepalen van het maximum in constante tijd 

Zij A een rij van p elementen, waarvan we het grootste moeten bepalen. In Algoritme 4.8 gebeurt 

een vergelijking tussen elk paar elementen van A. Het grootste element kan geïdentificeerd 



Algoritme 4.8 Bepalen van het maximum in constante tijd 

Input: array A = (a1,...,ap) met p verschillende getallen 

Output: boolean array M = (m1,...,mp) met mi = true als en slechts als ai het maximum van A 

is 

1: for 1 ≤ i, j ≤ p pardo 

2: if ai ≥ a j then 

3: Stel bi, j ← true 

4: else 

5: Stel bi, j ← false 

6: for 1 ≤ i ≤ p pardo 

7: mi ← bi,1 ∧ bi,2 ∧...bi,p 

worden als het element dat in al zijn vergelijkingen de “winnaar” is. Daartoe houdt het algoritme 

een tweedimensionale boolean array B = (bi, j) bij, die het resultaat van elke vergelijking 

opslaat. Vervolgens wordt een array M opgebouwd. Wanneer het algoritme eindigt, heeft arrayelement 

mi de waarde true als en slechts als element ai het grootste element uit A is. 

Merk op dat dit algoritme concurrent read nodig heeft. Bovendien kan de tweede parallelle forlus 

uitgevoerd worden in constante tijd, als we concurrent write toelaten. Dit algoritme werkt dus 

in het CRCW PRAM-model in Θ(1) tijd en gebruikt Θ(p 2 ) bewerkingen. Dit levert de volgende 

stelling. 

Stelling 4.4.1. Het grootste van p elementen kan op CRCW PRAM bepaald worden in Θ(1) 

parallelle tijd en Θ(p 2 ) bewerkingen. 

4.4.3 Algoritme voor het maximum in dubbel-logaritmische tijd 

In een gewortelde boom is het niveau van een top v bepaald door het aantal bogen op het pad 

van de wortel naar v. De wortel heeft dus niveau 0. We definiëren nu de boom van dubbellogaritmische 

diepte met n bladeren. Voor de eenvoud veronderstellen we dat n = 22k voor zekere 

k geheel. 

De wortel van de boom heeft √ n = 22k−1 kinderen, elk van die kinderen heeft op zijn beurt 22k−2 kinderen, enz. Algemeen, een top op niveau i heeft 22k−i−1 kinderen, voor 0 ≤ i ≤ k−1. Tenslotte 

heeft elke top op niveau k nog 2 bladeren als kinderen. 

Volgende eigenschappen zijn eenvoudig (evt. met behulp van inductie) te bewijzen: 

(1) Het aantal toppen op niveau i is gegeven door n/2 2k−i 

(2) Het aantal toppen op niveau k is gegeven door n/2 = 22k−1. (3) De diepte van de boom is k+ 1 = log 2 log 2 n+1 

= 2 2k −2 k−i 

, voor 0 ≤ i < k. 


4.4. Accelerated cascading / Maximum bepalen 47 

Deze boom met dubbel-logaritmische diepte kan gebruikt worden voor het bepalen van het grootste 

van n elementen. Elke interne top houdt het grootste van de elementen in zijn deelboom bij. 

Het algoritme gaat niveau per niveau vooruit, van onder naar boven, startend met de bladeren. 

Gebruik makend van Algoritme 4.8 kan het grootste in elke top bepaald worden in constante 

tijd. Hieruit volgt dat het algoritme het grootste van n element berekent in parallelle tijd 

T(n) = Θ(loglogn), hetgeen exponentieel sneller is dan het eerder geziene Θ(logn) algoritme. 

Vervolgens proberen we het aantal bewerkingen van dit algoritme in te schatten. Het werk Wti (n) 

per top ti op niveau i wordt gegeven door 

Dit levert als totaal werk Wi(n) voor niveau i: 

Wti (n) = Θ((22k−i−1) 

2 ) = Θ(2 2k−i 

). 

Wi(n) = Θ(2 2k−i 

Het totale werk van het algoritme wordt bepaald door 

W(n) = 

k 

∑ 

i=0 

M.a.w. het algoritme is niet werk-optimaal. 

× 2 2k −2 k−i 

) = Θ(2 2k 

) = Θ(n). 

Wi(n) = Θ(nloglogn). 

4.4.4 Het snelle algoritme optimaal maken 

We hebben nu twee algoritmen voor het bepalen van het grootste van een rij elementen. Het 

eerste, gebaseerd op een binaire boom (met logaritmische diepte), is optimaal en vereist logaritmische 

tijd. Het tweede, gebaseerd op de boom met dubbel-logaritmische diepte, is niet optimaal, 

maar is “zeer snel” (dubbel-logaritmische tijd). In dergelijke gevallen kunnen we proberen de 

strategie van accelerated cascading te gebruiken om de twee algoritmen te combineren tot een 

optimaal en zeer snel algoritme. In algemene termen werkt de techniek als volgt: 

1. Voer het optimale algoritme uit, totdat de probleemgrootte gereduceerd is tot een zekere 

drempelwaarde. 

2. Werk dan verder met het zeer snelle maar niet-optimale algoritme. 

We bekijken nu hoe we deze strategie kunnen gebruiken bij het bepalen van het maximum van 

n elementen. 

In fase 1 voeren we het algoritme met de binaire boom uit, startend vanaf de bladeren, verderwerkend 

voor ⌈log 2 log 2 log 2 n⌉ niveau’s. Aangezien het aantal kandidaten in elk niveau gehalveerd 

wordt, weten we dat het maximum zich bevindt tussen de n ′ = O(n/loglogn) overblijvende 

elementen op het einde van deze fase. Het totale aantal tot nu toe gebruikte bewerkingen is 

W1(n) = O(n) en de corresponderende tijd is T1(n) = O(logloglogn). 



In fase 2 gebruiken we de dubbel-logaritmische boom op de n ′ overblijvende elementen. Deze 

fase vereist tijd T2(n) = Θ(loglogn ′ ) = Θ(loglogn) en werk W2(n) = Θ(n ′ loglogn ′ ) = O(n). 

Het totale algoritme is dus optimaal en vereist Θ(loglogn) parallelle tijd. 

Stelling 4.4.2. Het grootste van een rij van n elementen kan optimaal bepaald worden in Θ(loglogn) 

tijd op een CRCW PRAM. 

4.4.5 Opmerking: speciaal geval 

Een belangrijk speciaal geval van de techniek van accelerated cascading bestaat in het gebruik 

van een optimaal sequentieel algoritme in fase 1. Ook bij het probleem van het bepalen van het 

maximum kan op die manier een optimaal algoritme met uitvoeringstijd Θ(loglogn) bekomen 

worden. 

Daartoe partitioneren we de input in n/log 2 log 2 n blokken Bi, met elk ongeveer log 2 log 2 n elementen. 

Via het sequentiële algoritme bepalen we dan het maximum van elk blok; dit kan voor 

de verschillende blokken in parallel gebeuren. Vervolgens werken we verder via de boom van 

dubbel-logaritmische diepte om het maximum te bepalen. 


Hoofdstuk 5 

Parallelle sorteeralgoritmen 

Sorteren is een belangrijk probleem met vele toepassingen. Het ligt dan ook voor de hand om 

parallelle sorteeralgoritmen te ontwikkelen. In het sequentiële geval maakt men doorgaans onderscheid 

tussen twee klassen sorteeralgoritmen. 

Sorteeralgoritmen gebaseerd op vergelijkingen sorteren door herhaaldelijk twee elementen te 

vergelijken en ze te verwisselen indien ze in de verkeerde volgorde staan. Voorbeelden hiervan 

zijn bubblesort, mergesort en quicksort. Deze sorteeralgoritmen hebben een theoretische 

ondergrens Ω(nlogn) voor de (sequentiële) complexiteit. 

Sorteeralgoritmen die niet gebaseerd zijn op vergelijkingen gebruiken specifieke gekende eigenschappen 

van de te sorteren gegevens (zoals hun bitvoorstelling of hun verdeling). De theoretische 

ondergrens voor de (sequentiële) complexiteit is hier Ω(n). Voorbeelden zijn countingsort, 

bucketsort en radixsort. 

In dit hoofdstuk bespreken we parallelle varianten van enkele van deze klassieke sorteeralgoritmen. 

Daarnaast bestuderen we ook hoe specifieke circuits voor het sorteren van data, de zgn. 

sorteernetwerken, kunnen geconstrueerd worden. 

49

50 Hoofdstuk 5. Parallelle sorteeralgoritmen 

5.1 Sorteernetwerken 

x 

y 

min(x,y) 

max(x,y) 

Figuur 5.1: Een vergelijkende poort 

5.1.1 Wat zijn sorteernetwerken? 

Sorteernetwerken zijn circuits die opgebouwd zijn uit één enkel type poort, nl. de vergelijkende 

poort (of comparator gate). Deze poort krijgt als input twee getallen en ze geeft als output deze 

getallen in volgorde terug. We tekenen een comparator als een boog tussen de twee lijnen die 

worden vergeleken (zie Figuur 5.1). 

Een sorteernetwerk is een circuit van vergelijkende poorten dat zijn input in stijgende volgorde 

teruggeeft. We tekenen een sorteernetwerk als een verzameling lijnen, één voor elke input, met 

de vergelijkende poorten toegevoegd tussen de lijnen. Vooraleer een poort kan reageren, moet ze 

wachten tot al haar inputs beschikbaar zijn. Vergelijkende poorten waarvan de lijnen niet overlappen, 

kunnen in parallel werken. Wanneer we een sorteernetwerk visualiseren, dan groeperen 

we de comparatoren die in parallel kunnen werken. Ze vormen een laag van het netwerk. Elke 

laag vereist één tijdseenheid om uitgevoerd te worden, aangezien alle poorten van een laag in 

parallel kunnen werken. Het aantal poorten in de netwerk wordt de grootte van het netwerk 

genoemd. De diepte van het netwerk is het aantal stappen dat nodig is opdat elke poort zijn 

vergelijking uitgevoerd heeft. 

Voorbeeld 5.1.1. Beschouw het netwerk uit Figuur 5.2(a). Dit heeft 5 poorten en sorteert 4 getallen 

in 3 stappen. Het bestaat uit 3 lagen: de eerste en de tweede laag bestaan elk uit 2 vergelijkende 

poorten, terwijl de derde laag uit 1 vergelijkende poort bestaat. Dit sorteernetwerk 

heeft dus grootte 5 en diepte 3, hetgeen betekent dat de input na 3 stappen gesorteerd is. In 

Figuur 5.2(b) wordt het sorteren van de getallen 17, 42, 23, 7 getoond. 

Hoe kunnen we nu het probleem van het sorteren van n getallen algemeen oplossen? We bekijken 

eerst een eenvoudiger probleem, nl. het bepalen van het grootste element van de inputs. 

Daartoe vergelijken we eerst de eerste twee inputs, daarna het grootste hiervan met de derde 

input, enzovoort, telkens het vorige resultaat vergelijkend met de volgende input, totdat we de 

laatste lijn bereikt hebben. Voor 8 elementen bekomen we het netwerk van grootte en diepte 7 

uit Figuur 5.3. 

De 7 comparatoren op de diagonalen garanderen dat het grootste inputelement zijn weg vindt 

naar de laatste lijn, waar het moet terechtkomen. Het idee achter het odd-even-transposition 

netwerk is om vele dergelijke diagonalen te gebruiken. 

Voorbeeld 5.1.2. Figuur 5.4 toont het odd-even-transposition netwerk voor n = 10. Dit netwerk 

heeft diepte 10 en grootte 45. 


5.1. Sorteernetwerken 51 

(a) Een sorteernetwerk (b) Werking op de getallen 17, 42, 23, 7 

Figuur 5.2: Een sorteernetwerk en zijn werking 

Figuur 5.3: Een netwerk voor het bepalen van het grootste element 

Figuur 5.4: Het odd-even-transposition netwerk voor n = 10 lijnen. 

Algoritmen en Datastructuren III Veerle.Fack@UGent.be 

17 

42 

23 

7 

17 

42 

7 

23 

23 

17 

7 

17 

23 

42


Een odd-even-transposition netwerk op n lijnen is gebouwd uit twee soorten koppelingen van de 

lijnen. Wanneer we de lijnen nummeren van 1 tot n, dan worden in de eerste soort koppeling 

vergelijkingen tussen lijnen 1 en 2, 3 en 4, 5 en 6, enz. aangebracht. In de tweede soort koppeling 

worden vergelijkingen tussen lijnen 2 en 3, 4 en 5, enz. aangebracht. We alterneren deze 

koppelingen n − 2 keer, hetgeen een netwerk van diepte n oplevert. 

Stelling 5.1.3. Het odd-even-transposition netwerk sorteert n getallen in n stappen met Θ(n 2 ) 

poorten. 

(Bewijs als oefening) 

Het odd-even-transposition netwerk is sneller dan de beste sequentiële algoritmen, maar de versnelling 

met factor O(logn) is bekomen ten koste van Θ(n 2 ) poorten. De vraag is of we het 

netwerk kunnen verbeteren, zowel in diepte als in grootte. Dit blijkt een moeilijk probleem te 

zijn. 

In het PRAM-model bestaat er een gecompliceerde parallelle versie van het mergesort-algoritme 

dat sorteert in O(logn) parallelle tijd en O(nlogn) werk (een algoritme dat we hier niet bespreken). 

Voor lange tijd bestond er een conjectuur (o.a. door Knuth) dat deze grenzen niet met 

een sorteernetwerk konden worden bereikt. In 1983 echter construeerden Ajtai, Komlós en Szemerédi 

een sorteernetwerk van diepte O(logn) en grootte O(nlogn). Hun constructie is echter 

zeer ingewikkeld en van weinig praktisch belang. 

Onze bedoeling in dit hoofdstuk is het bespreken van een sorteernetwerk, geconstrueerd door 

Batcher, dat diepte O(log 2 n) en grootte O(nlog 2 n) heeft. Batcher gebruikte een verdeel-enheers 

strategie voor het sorteren: een inputrij wordt in twee helften gesplitst, recursief gesorteerd, 

en dan worden de helften samengevoegd (gemerged). De taak van het efficiënt mergen van twee 

gesorteerde rijen tot één gesorteerde rij blijkt moeilijker te zijn op sorteernetwerken dan voor 

algemene algoritmen. Om dit probleem op te lossen, bekijken we eerst hoe een sorteernetwerk 

voor speciale rijen, nl. de bitonische rijen, kan worden geconstrueerd. Daarna passen we dit 

sorteernetwerk toe om twee gesorteerde rijen te mergen en vervolgens gebruiken we dat netwerk 

om een algemeen sorteernetwerk te construeren. 

5.1.2 Bitonisch sorteren 

We benaderen het sorteerprobleem door het eerst op te lossen voor eenvoudige inputrijen. De 

meest eenvoudige inputrij is een rij die reeds in stijgende volgorde gesorteerd is, want daar is er 

geen werk te doen. In een volgende stap beschouwen we rijen die rotaties van gesorteerde rijen 

zijn. We noemen een dergelijke rij (a0,...,an−1) cyclisch stijgend als er een index i bestaat zodanig 

dat (ai,...,an−1,a0,...,ai−1) stijgend is. Merk op dat dit voor i = 0 betekent dat de rij zelf 

stijgend is. Bijvoorbeeld, de rijen (92,78,92) en (12,23,31,4,7) zijn cyclisch stijgend, terwijl 

de rijen (1,3,1,3) en (12,3,2) dit niet zijn. Een cyclisch stijgende rij kan worden gevisualiseerd 

door zijn getallen op de omtrek van een cirkel te schrijven en het eerste element in de rij door 

een pijl te laten aanwijzen. 



Figuur 5.5: Het netwerk D16. 

Voor de eenvoud van de presentatie veronderstellen we voor de rest van deze paragraaf dat n een 

macht van 2 is. 

We bouwen een netwerk Dn dat zijn input beschouwt als bestaande uit twee helften en dat elke 

element van de eerste helft vergelijkt met een element uit de tweede helft. Meer precies wordt 

elk element ai vergeleken met a i+n/2, waarbij 0 ≤ i < n/2. Algemeen heeft Dn grootte n/2 en 

diepte 1 (aangezien alle vergelijkende poorten in parallel kunnen werken). Figuur 5.5 toont D16. 

Voorbeeld 5.1.4. Wanneer we D8 de inputrij (4,5,6,7,8,9,12,3) geven, dan geeft het als output 

(4,5,6,3,8,9,12,7). Voor inputrij (5,6,7,8,9,12,3,4) geeft het (5,6,3,4,9,12,7,8). Voor 

(6,7,8,9,12,3,4,5) geeft het (6,3,4,5,12,7,8,9). 

Beschouwen we de twee helften van de outputrijen in bovenstaande voorbeelden. Merk op dat 

D8 een cyclisch stijgende rij opsplitst in twee cyclisch stijgende deelrijen, waarbij alle elementen 

uit de eerste deelrij kleiner zijn dan de elementen in de tweede deelrij. 

Lemma 5.1.5. Wanneer de input voor Dn een cyclisch stijgende rij is, dan bestaat de output 

(b0,...,bn−1) uit twee cyclisch stijgende rijen (b0,...,b n/2−1) en (b n/2,...,bn−1), zodanig dat 

bi ≤ b j voor 0 ≤ i < n/2 ≤ j < n, m.a.w. elk element van (b0,...,b n/2−1) is kleiner dan (of gelijk 

aan) elk element van (b n/2,...,bn−1). 

Bewijs. Aangezien a cyclisch stijgend is, weten we dat er een index m bestaat, zodanig dat 

am,...,an−1,a0,...,am−1 stijgend is; mogelijks is m = 0. Beschouw de rij voorgesteld op een 

cirkel, met een lijn door het centrum die het grootste en het kleinste element scheidt. Deze lijn 

splitst de cirkel in twee helften en we merken op dat elk element in de helft die het kleinste 

element bevat hoogstens zo groot is als elk element in de helft die het grootste element bevat, 

aangezien de elementen groter worden wanneer we in wijzerzin van het kleinste naar het grootste 

element bewegen. 

Het netwerk Dn berekent 

bi = min(ai,a i+n/2) en b i+n/2 = max(ai,a i+n/2). 

Gevisualiseerd op een cirkel betekent dit bijvoorbeeld dat b0 de kleinste en b n/2 de grootste is van 

de twee elementen aan beide uiteinden van de pijl. Hetzelfde geldt voor bi en b i+n/2, wanneer we 



Figuur 5.6: Het netwerk B16 

de pijl in wijzerzin roteren over i posities. We kunnen de berekening van de output dus bekijken 

als het roteren van de pijl, stap voor stap voor n/2 − 1 keer, vanaf zijn beginpositie. 

Merk op dat de uiteinden van de pijl steeds in tegenovergestelde helften van de cirkel liggen. 

Aangezien alle elementen in de ene helft hoogstens zo groot zijn als alle elementen in de andere 

helft, betekent dit dat bi = min(ai,a i+n/2) steeds genomen wordt uit de helft met het minimum, 

terwijl b i+n/2 = max(ai,a i+n/2) steeds genomen wordt uit de helft met het maximum. Dit impliceert 

dat alle elementen van (b0,...,b n/2−1) kleiner (of gelijk) zijn dan alle elementen van 

(b n/2,...,bn−1). Bovendien zijn beide deelrijen cyclisch stijgend, omdat ze elk een rotatie van 

een deelrij van de oorspronkelijke rij zijn. 

Samenvattend, het netwerk Dn verdeelt een cyclisch stijgende rij van lengte n in twee cyclisch 

stijgende deelrijen van lengte n/2, zodanig dat elk element in de eerste deelrij kleiner is dan 

elk element in de tweede deelrij. We kunnen nu D n/2 op elke deelrij gebruiken om de deelrijen 

verder te verwerken. Wanneer we dit proces recursief verderzetten, bekomen we een netwerk Bn 

dat cyclisch stijgende rijen sorteert. Figuur 5.6 geeft B16. 

Lemma 5.1.6. Het netwerk Bn is een sorteernetwerk voor cyclisch stijgende rijen. Het heeft 

diepte log 2 n en grootte nlog 2 n. 

Bewijs. We bewijzen de correctheid door inductie op n. Het gestelde geldt voor n = 1, want B1 

is een lijn zonder comparatoren. Zij nu n een eigenlijke macht van 2. Door de inductiehypothese 

kunnen we veronderstellen dat B n/2 cyclisch stijgende rijen van lengte n/2 correct sorteert. Beschouw 

een cyclisch stijgende rij als input voor Bn. Wegens Lemma 5.1.5 verdeelt Dn deze rij in 

twee cyclisch stijgende rijen, waarbij elk element van de eerste deelrij kleiner is dan elk element 

van de tweede rij. Dus, aangezien beide deelrijen correct worden gesorteerd door B n/2, wordt de 

ganse rij correct gesorteerd. 

Merk op dat Bn meer doet dan enkel cyclisch stijgende rijen sorteren; het sorteert ook zgn. 

bitonische rijen correct. Een bitonische rij is een rij die een rotatie is van een rij die eerst 

stijgend is en dan dalend. Meer formeel: (a0,...,an−1) is bitonisch wanneer er een m en een c 



bestaan zodanig dat 

am ≤ ... ≤ a (m+c)modn en a (m+c)modn ≥ a (m+c+1)mod n ≥ ... ≥ am−1. 

Voorbeeld 5.1.7. De rij (1,2,3,2,1) is bitonisch met m = 0 en c = 2; (5,12,34,56,49,8,6,3,4) 

is bitonisch met m = 7 en c = 5, want 3 ≤ 4 ≤ 5 ≤ 12 ≤ 34 ≤ 56 en 56 ≥ 49 ≥ 8 ≥ 6. Daarentegen 

is de rij (12,6,8,4) niet bitonisch. 

We kunnen Lemma 5.1.6 herformuleren voor bitonische rijen. 

Lemma 5.1.8. Wanneer de input voor Dn een bitonische rij is, dan bestaat de output (b0,...,bn−1) 

uit twee bitonische rijen (b0,...,b n/2−1) en (b n/2,...,bn), zodanig dat bi ≤ b j voor 0 ≤ i < n/2 ≤ 

j < n. M.a.w. alle elementen van (b0,...,b n/2−1) zijn kleiner dan of gelijk aan alle elementen 

van (b n/2,...,bn). 

(Bewijs als oefening) 

Steunend op dit lemma kunnen we nu aantonen dat Bn bitonische rijen correct sorteert. Het 

bewijs hiervan is analoog aan het bewijs van Lemma 5.1.6. 

Stelling 5.1.9. Bn is een sorteernetwerk voor bitonische rijen met diepte log 2 n en grootte O(nlogn). 

5.1.3 Mergen en sorteren 

Hoe kan het sorteren van bitonische rijen ons nu dichter brengen bij het construeren van een 

algemeen sorteernetwerk? Het antwoord, op het eerste zicht verrassend, is dat het ons helpt 

om twee gesorteerde rijen te mergen. We herinneren er aan dat mergesort werkt door de rij in 

twee helften te splitsen, vervolgens elke deelrij recursief te sorteren en tenslotte de gesorteerde 

deelrijen te mergen. 

Het nut van het bitonische sorteernetwerk Bn wordt duidelijk wanneer we opmerken dat twee gesorteerde 

rijen die ruggelings aan elkaar worden geschakeld, een bitonische rij vormen. M.a.w. 

zijn (a0,...,a n/2−1) en (b0,...,b n/2−1) twee stijgende rijen, dan is (a0,...,a n/2−1,b n/2−1,...,b0) 

een bitonische rij van lengte n. Dus wanneer Bn deze rij als input krijgt, dan is het resultaat een 

gesorteerde rij. 

Op deze manier kunnen we Bn gebruiken om een merging netwerk Mn te bouwen dat een merge 

van twee stijgende rijen uitvoert. Het enige wat we moeten doen, is de volgorde in de tweede 

deelrij omkeren. Figuur 5.7 toont de structuur van M8 en Figuur 5.8 toont nog meer expliciet hoe 

M4 eruitziet. 

Voorbeeld 5.1.10. We beschouwen het mergen door M8 van de rijen (12,18,23,34) en (7,14,29,81). 

Door het omkeren van de tweede rij wordt de bitonische rij (12,18,23,34,81,29,14,7) bekomen. 

Deze rij wordt als input aan B8 gegeven. Deze voert D8 uit, hetgeen de rij (12,18,14,7,81,29,23,34) 

oplevert. Vervolgens worden twee D4 uitgevoerd, om (12,7,14,18) en (23,29,81,34) te bekomen. 

Tenslotte worden vier D2 uitgevoerd, hetgeen uiteindelijk de rij (7,12,14,18,23,29,34,81) 

oplevert. 



Figuur 5.7: De structuur van het merging netwerk M8 

Figuur 5.8: Het netwerk M4, links met en rechts zonder snijdende lijnen 

Stelling 5.1.11. We kunnen een netwerk van diepte log 2 n en grootte nlog 2 n/2 construeren voor 

het mergen van twee gesorteerde rijen. 

Gebruik makende van de merging netwerken kunnen we nu een sorteernetwerk Sn bouwen dat 

voor algemene rijen werkt. Hiertoe gebruiken we het idee van mergesort. Zij S1 een enkele lijn. 

Uit S1 bouwen we S2 door M2 op de twee lijnen toe te passen. Aangezien een enkele input een 

gesorteerde rij is, sorteert S2 rijen van lengte 2 correct. Analoog bouwen we S4 door twee kopies 

van S2 te nemen om de twee helften van de input te sorteren, en vervolgens de gesorteerde helften 

te mergen met M4 (zie Figuur 5.9). Figuur 5.10 illustreert de werking van S4 op de voorbeeldrij 

(4,1,3,2). 

Algemeen bouwen we op dezelfde manier uit twee S n/2 en één Mn een sorteernetwerk Sn. Figuur 

5.11 toont het sorteernetwerk S8. 

Stelling 5.1.12. Het netwerk Sn is een sorteernetwerk van diepte Θ(log 2 n) en grootte Θ(nlog 2 n) 

dat een gegeven rij van lengte n correct sorteert. 

Bewijs. We bewijzen de stelling door inductie op n. S1 is correct, aangezien het maar 1 input 

heeft. Zij n een eigenlijke macht van 2. Als inductiehypothese veronderstellen we dat S n/2 een 

inputrij van lengte n/2 correct sorteert. Dan sorteert Sn eerst elke helft van zijn inputrij met 

behulp van S n/2, hetgeen wegens de inductiehypothese correct gebeurt. Vervolgens voegt Sn de 

twee gesorteerde deelrijen samen tot een gesorteerde rij met behulp van een (correct werkend) 

merging netwerk Mn. Dit levert een gesorteerde rij van lengte n. 

De diepte van Sn is de som van de dieptes van Mn,M n/2,M n/4,...,M1, d.i. log 2 n+log 2 (n/2)+ 

log 2 (n/4)+··· = Θ(log 2 n). Zij sn de grootte van Sn, dan is sn gegeven door de grootte van Mn 


B8


S2 

S2 

Figuur 5.9: De structuur van het sorteernetwerk S4 

M4 

4 1 1 

1 

3 

2 

4 

2 

3 

Figuur 5.10: Werking van S4 bij het sorteren van (4,1,3,2) 

plus 2s n/2. Aangezien Mn grootte nlog 2 n/2 heeft, krijgen we de volgende recurrente betrekking 

voor sn: 

sn = nlog 2 n/2+2s n/2. 

Daaruit kunnen we gemakkelijk afleiden dat sn = Θ(nlog 2 n). 

5.1.4 Het nul-een-principe voor sorteernetwerken 

Om het achterliggende idee achter de constructie van sorteernetwerken te benadrukken, hebben 

we de correctheid van de geziene sorteernetwerken tot nu toe rechtstreeks bewezen. In deze paragraaf 

bespreken we een een tool die dergelijke bewijzen dikwijls vereenvoudigt, het zogenaamde 

nul-een-principe. 

Stelling 5.1.13. Als een sorteernetwerk correct werkt op alle mogelijke inputs bestaande uit 

enkel nullen en enen, dan werkt het ook correct voor willekeurige inputs. 

Deze stelling laat ons toe om sorteernetwerken te verifiëren door ze enkel op rijen van nullen en 

enen te testen. Voor een netwerk met n inputs, betekent dit dat we hoogstens 2 n inputs moeten 

testen, in tegenstelling tot oneindig veel. 

Bewijs. Veronderstel dat er een sorteernetwerk is dat alle rijen van nullen en enen correct sorteert, 

maar dat een zekere rij van getallen (a0,...,an−1) niet correct sorteert. 

Zij (b0,...,bn−1) de output die het sorteernetwerk geeft wanneer het de rij (a0,...,an−1) als 

input krijgt. Aangezien de output niet correct gesorteerd is, moet er een s < t bestaan waarvoor 


2 

4 

3 

1 

2 

3 

4


Figuur 5.11: Het sorteernetwerk S8 

bs > bt. We associëren een rij van nullen en enen met (a0,...,an−1), als volgt. Label elke ai die 

kleiner is dan bs met een nul, en alle andere ai met een één. 

We bewijzen zo meteen dat, wanneer we de rij (a0,...,an−1) en de rij van zijn labels gelijktijdig 

door het sorteernetwerk laten verwerken, elke ai zijn label behoudt. Dit impliceert dat bs met 

een 1 gelabeld is, en bt met een 0. Aangezien s < t, sorteert het netwerk dus de rij van labels niet 

correct, hetgeen een strijdigheid oplevert, aangezien de labels nullen en enen zijn. 

Blijft nog te bewijzen dat de labels van de inputelementen dezelfde blijven. Beschouw een 

vergelijkende poort. Als zijn inputs allebei nul of allebei één zijn, dan geldt dit ook voor de 

output. In het geval waarbij de inputs a < a ′ hebben, en a met 0 en a ′ met 1 gelabeld zijn, 

verandert de vergelijkende poort niets aan a en a ′ , noch aan de labels. De andere mogelijkheid 

is dat we inputs a > a ′ hebben, en dat a met een 1 en a ′ met een 1 gelabeld is – in dit geval 

verwisselt de vergelijkende poort zowel de inputs a en a ′ als de labels, en ook hier blijven de 

labels bij de oorspronkelijke elementen. 

We kunnen nu het nul-een-principe gebruiken om aan te tonen dat het odd-even-transposition 

netwerk dat we eerder introduceerden, correct werkt. 

Stelling 5.1.14. Het odd-even-transposition netwerk sorteert rijen van lengte n in diepte n en 

grootte Θ(n 2 ). 

Bewijs. Neem n vast en beschouw het odd-even-transposition netwerk voor rijen van lengte n. 

Wegens stelling 5.1.13 moeten we enkel aantonen dat het netwerk alle binaire inputrijen correct 

sorteert. 

We beschouwen een zekere willekeurige inputrij (a0,...,an−1) van lengte n. Zij ai de eerste nul 

in deze rij, m.a.w. ai = 0 en ak = 1 voor alle k < i. 

Als i even is, dan wordt ai vergeleken met ai+1 in de eerste laag van het netwerk, en er gebeurt 

niets. Echter, in de tweede laag wordt ai vergeleken met ai−1 = 1, en de twee elementen worden 

verwisseld. Aangezien alle elementen voor ai één zijn, zal ai vanaf dat punt naar voren bewegen 

tot het de eerste lijn bereikt heeft. Als i oneven is, zal ai onmiddellijk beginnen aan zijn beweging 

naar de eerste lijn, tot het die bereikt. Beide situaties worden geïllustreerd in Figuur 5.12. 



1 1 

1 

1 

0 

1 

0 

1 

0 

1 

0 0 

1 

1 1 

(a) Eerste 0 beweegt naar lijn 1 (b) Vertraging van 1 stap 

Figuur 5.12: Het nul-een-principe voor het odd-even-transposition netwerk 

1 1 

1 

0 

1 

0 

0 

1 

0 

1 

0 

0 

1 

0 

1 

0 

1 

0 

1 

0 

1 

1 

1 

0 

0 1 1 1 

Figuur 5.13: Sorteren van (1,1,0,1,0,0) met het odd-even-tranposition netwerk 

Algemeen kunnen we drie toestanden voor elke 0 in de rij onderscheiden: “geblokkeerd”, “in 

beweging” en “aangekomen”. Er zijn twee gevallen van blokkeringen die een 0 beletten om naar 

zijn plaats te bewegen: ofwel in verkeerde fase zitten (zoals de eerste nul op een even lijn in 

Figuur 5.12), ofwel worden opgehouden door een voorafgaande 0 die nog niet beweegt. 

Door inductie kunnen we aantonen dat de k-de nul in de rij ten laatste in de (k+1)-de laag begint 

te bewegen, totdat ze haar positie bereikt heeft. Immers, zoals reeds eerder uitgelegd, begint de 

eerste 0 te bewegen in de eerste of tweede laag, en dan beweegt ze onmiddellijk verder naar haar 

uiteindelijke positie (aangezien er geen blokkerende nullen vooraf kunnen gaan). De tweede 

nul kan enkel door de eerste nul worden geblokkeerd, wanneer de eerste nul nog niet aan het 

bewegen is. Dus begint de tweede nul ofwel in de tweede ofwel in de derde laag te bewegen, 

m.a.w. ten laatste in de derde laag. Algemeen kan de k-de nul enkel worden geblokkeerd door 

de voorafgaande nullen, die allemaal ten laatste in de k-de laag beginnen te bewegen. Dus, 

afhankelijk van de fase, zal de k-de nul beginnen bewegen in de k-de of in de (k+ 1)-de laag. 

De k-de nul kan hoogstens n − k posities van zijn uiteindelijk positie verwijderd zijn. Aangezien 

ze ten laatste in de (k+ 1)-de laag begint te bewegen, zijn er dan nog n − k lagen over waarin ze 

naar haar uiteindelijke positie kan bewegen. 

Voorbeeld 5.1.15. We bekijken het sorteren van de rij (1,1,0,1,0,0) op het odd-even-transposition 

netwerk. Figuur 5.13 toont de werking van het netwerk. 


0 

1 

0 

1 

0 

0 

0 

1 

1 

0 

0 

0 

1 

1 

1 

1 

1 

1 

1 

0 

1 

1 

1 

0 

1 

0 

0 

1


5.2 Sorteren op interconnectienetwerken 

In deze paragraaf bespreken we mogelijke sorteeralgoritmen op netwerktopologieën, zoals de rij, 

het rooster en de hyperkubus. 

5.2.1 Odd-even-transpositionsorteren op een rij van processoren 

Op een rij processoren kunnen we het odd-even-transposition sorteeralgoritme dat we eerder 

zagen, implementeren. Elke processor houdt een teller bij om te weten of het system zich 

momenteel in een even of oneven fase bevindt. Om een vergelijkende poort te implementeren 

moeten twee processoren samenwerken en mogelijks hun elementen uitwisselen. In een even 

fase werken de even processoren samen met hun rechterburen, m.a.w. de paren (0,1), (2,3), (4,5) 

enzovoort, en de even processoren ontvangen het kleinste element. In een oneven fase werken 

de even processoren samen met hun linkerburen, m.a.w. de paren (1,2), (3,4), (5,6), enzovoort. 

Na n stappen stoppen alle processoren. Op dat moment hebben ze de n fasen van het odd-eventransposition 

netwerk gesimuleerd. 

De correctheid van dit algoritme volgt onmiddellijk uit de correctheid van het odd-even-transposition 

netwerk, bewezen in Stelling 5.1.3. 

Stelling 5.2.1. We kunnen n getallen op een rij van n processoren sorteren in lineaire tijd m.b.v. 

het odd-even-transposition sorteeralgoritme. 

5.2.2 Bitonisch sorteren op de hyperkubus 

Wanneer we de inputlijnen van een bitonisch sorteernetwerk met n = 2 d inputlijnen labelen met 

de d-bitstrings 0...0 t.e.m. 1...1, dan bekomen we een rechtstreekse mapping tussen de inputlijnen 

van het sorteernetwerk en de processoren in een hyperkubus van dimensie d. Merk op dat 

de vergelijkingen tussen elementen die het bitonisch sorteernetwerk uitvoert, telkens gebeuren 

tussen inputlijnen waarvan het label in slechts één bitpositie verschilt. M.a.w. deze vergelijkingen 

gebeuren tussen processoren die in de hyperkubus rechtstreeks verbonden zijn, en er is geen 

extra communicatie-overhead voor routing nodig. 

5.2.3 Shearsort op een rooster van processoren 

Vervolgens bekijken we een sorteeralgoritme op het rooster. Het algoritme wordt shearsort genoemd 

en het sorteert in twee fasen die ⌈log 2 n⌉+1 keer herhaald worden. In de rijsorteerfase 

worden alle rijen van het rooster gesorteerd met behulp van het odd-even-transposition sorteeralgoritme 

voor rijen van processoren. De rijen worden afwisselend in stijgende en dalende volgorde 

gesorteerd. In de kolomsorteerfase sorteren we alle kolommen in stijgende volgorde. Na 

hoogstens ⌈log 2 n⌉+1 herhalingen van deze fasen zijn de elementen in het rooster gesorteerd, 


5.2. Sorteren op interconnectienetwerken 61 

stap 1 

stap 2 

stap 3 

rijen sorteren (fase 1) kolommen sorteren (fase 2) 

15 4 10 6 → 

1 5 7 11 ← 

12 14 13 8 → 

9 16 2 3 ← 

4 6 3 1 → 

8 7 5 2 ← 

11 9 10 14 → 

16 12 13 15 ← 

1 3 4 2 → 

8 7 5 6 ← 

9 10 11 12 → 

16 15 13 14 ← 

4 6 10 15 

11 7 5 1 

8 12 13 14 

16 9 3 2 

1 3 4 6 

8 7 5 2 

9 10 11 14 

16 15 13 12 

1 2 3 4 

8 7 6 5 

9 10 11 12 

16 15 14 13 

Figuur 5.14: De rij (15,4,10,6,1,5,7,11,12,14,13,8,9,16,2,3) sorteren op 

een rooster van processoren met het shearsort algoritme 

in een soort ‘ploegvoren’-volgorde (m.a.w. afwisselend in stijgende en dalende volgorde in de 

rijen). 

Voorbeeld 5.2.2. We gebruiken shearsort om de rij (15,4,10,6,1,5,7,11,12,14,13,8,9,16,2,3) te 

sorteren. We kennen de getallen rij per rij aan de processoren van het rooster toe. Figuur 5.14 

illustreert de verschillende stappen in het algoritme. 

Om de correctheid van het shearsort algoritme te bewijzen, willen we het nul-een-principe gebruiken, 

dat we in Paragraaf 5.1.4 invoerden. Het nul-een-principe werd weliswaar geformuleerd 

voor sorteernetwerken, en niet voor algemene algoritmen (het is ook zo dat het niet werkt voor 

algemene algoritmen). Maar shearsort is een zeer beperkt soort algoritme. Ten eerste is het een 

vergelijk-en-verwissel algoritme, dat kan geïmplementeerd worden door enkel gebruik te maken 

van vergelijkende poorten. Ten tweede is het ‘vergeetachtig’, in die zin dat het resultaat van 

een vergelijking geen invloed heeft op de vergelijkingen die later gemaakt worden. Een dergelijk 

algoritme kan als een sorteernetwerk geïmplementeerd worden, waardoor het nul-een-principe 

ervoor geldt. 

Stelling 5.2.3. Shearsort sorteert n 2 elementen in 2n(⌈log 2 n⌉+1) stappen op een n × n rooster. 

Bewijs. We passen het nul-een-principe toe en controleren dat het algoritme werkt voor binaire 

inputrijen. 

Beschouwen we twee rijen 2i en 2i+1 na de rijsorteerfase. Aangezien rij 2i in stijgende volgorde 

gesorteerd werd, start ze met een blok nullen en eindigt ze met een blok enen. Analoog 



begint rij 2i + 1 met een blok enen en eindigt met een blok nullen. Als het aantal enen in de 

twee rijen minstens n is, dan zullen de twee rijen resulteren in tenminste één rij vol enen na de 

kolomsorteerfase. Analoog, als het aantal nullen in de twee rijen tenminste n is, dan krijgen we 

een rij vol nullen na de kolomsorteerfase. 

Aangezien een paar rijen ofwel minstens n nullen ofwel minstens n enen moet bevatten, weten 

we dat elk paar rijen bij de komende kolomsorteerfase zal aanleiding geven tot ten minste één 

rij met enkel nullen of enkel enen. Deze rijen worden niet meer beïnvloed door verdere rij- of 

kolomsorteerfasen; we kunnen ze dus verder negeren. 

Dit betekent dat het uitvoeren van een rijen kolomsorteerfase zorgt voor het halveren van het 

aantal rijen met elementen die hun uiteindelijke positie nog niet bereikt hebben. Na ⌈log 2 n⌉+ 

1 stappen hebben dus alle elementen hun uiteindelijke positie bereikt. Aangezien de rijen 

kolomsorteerfase elk n stappen nemen, is de totale uitvoeringstijd 2n(⌈log 2 n⌉+1). 

Voorbeeld 5.2.4. We bekijken wat er gebeurt voor de volgende input: 

0 1 0 0 1 0 0 1 → 

0 1 1 1 0 1 1 1 ← 

0 0 1 0 1 0 0 1 → 

1 0 0 1 0 0 1 0 ← 

1 1 1 0 1 0 1 0 → 

0 0 0 0 1 1 0 1 ← 

0 0 1 1 1 1 0 1 → 

1 1 0 0 1 1 1 1 ← 

Na de rijsorteerfase zien de eerste twee rijen er als volgt uit: 

0 0 0 0 0 1 1 1 → 

1 1 1 1 1 1 0 0 ← 

De blokken met enen overlappen, dus na de komende kolomsorteerfase zullen deze twee rijen 

zorgen voor een volledige rij enen. 

In rij 3 en 4 zijn er meer nullen dan enen, zodat deze zullen zorgen voor een volledige rij nullen 

na de kolomsorteerfase: 

0 0 0 0 0 1 1 1 → 

1 1 1 0 0 0 0 0 ← 

Rij 5 en 6 hebben samen precies 8 nullen en 8 enen, zodat ze zullen zorgen voor een rij met 

nullen en een rij met enen, na de kolomsorteerfase: 

0 0 0 1 1 1 1 1 → 

1 1 1 0 0 0 0 0 ← 


5.3. PRAM-varianten van klassieke sorteeralgoritmen 63 

De laatste twee rijen hebben een meerderheid aan enen en zullen dus resulteren in een rij enen. 

Samengenomen hebben we minstens 4 rijen met ofwel alles nullen ofwel alles enen (in feite 

hebben we er hier zelfs 5, door rij 5 en 6). Het resultaat van de kolomsorteerfase is: 

0 0 0 0 0 0 0 0 → 

0 0 0 0 0 0 0 0 ← 

0 0 0 0 0 1 0 0 → 

0 0 0 0 0 1 0 0 ← 

1 1 1 1 1 1 1 1 → 

1 1 1 1 1 1 1 1 ← 

1 1 1 1 1 1 1 1 → 

1 1 1 1 1 1 1 1 ← 

Na nog een rijen kolomsorteerfase bekomen we: 

0 0 0 0 0 0 0 0 → 

0 0 0 0 0 0 0 0 ← 

0 0 0 0 0 0 0 0 → 

1 0 0 0 0 0 0 1 ← 

1 1 1 1 1 1 1 1 → 

1 1 1 1 1 1 1 1 ← 

1 1 1 1 1 1 1 1 → 

1 1 1 1 1 1 1 1 ← 

Nog een rijsorteerfase levert een gesorteerde rij. 

5.3 PRAM-varianten van klassieke sorteeralgoritmen

Algoritmen en Datastructuren III Partim: Parallelle algoritmen - caagt

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?