Het sorteernetwerk

Parallelle 

sorteeralgoritmen 

parallelle varianten van klassieke 

sorteeralgoritmen 

sorteernetwerken / nul-een-principe 

sorteren op interconnectienetwerken 

Cursus Algoritmen en Datastructuren III - Parallelle Algoritmen (2008–2009) – p.1/47

Sorteeralgoritmen 

“Comparison-based” sorteeralgoritmen 

sorteren door herhaaldelijk vergelijken van 

2 elementen en verwisselen indien in 

verkeerde volgorde 

basisbewerking “vergelijk&verwissel” 

(“compare-exchange”, notatie v&v ) 

BubbleSort, InsertionSort, SelectionSort, 

MergeSort, QuickSort 

ondergrens voor sequentiële tijdscomplexiteit 

is Ω(n log n) 


Sorteeralgoritmen (2) 

“Noncomparison-based” sorteeralgoritmen 

gebruiken specifieke gekende eigenschappen 

van te sorteren gegevens (bvb. hun 

bitvoorstelling of hun verdeling) 

BucketSort, RadixSort, CountingSort 

ondergrens voor sequentiële tijdscomplexiteit 

is Ω(n) 


Parallelle variant van 

mergesort 


Verdeel-en-heers techniek 

Techniek: 3 stappen 

input opsplitsen in stukken van ongeveer 

gelijke grootte 

recursief oplossen van elk deelprobleem 

resultaten van deelproblemen samenvoegen 

tot oplossing van oorspronkelijke probleem 

Wanneer is techniek bruikbaar? 

als opsplitsen en samenvoegen efficiënt kan 

gebeuren 

Voorbeelden: mergesort 


MergeSort 

Algoritme MergeSort (sequentieel, recursief) 

Input: rij elementen Aℓ,r = (aℓ,...,ar) 

Output: stijgend gesorteerde rij 

1: if ℓ < r then 

2: stel m ← (ℓ + r)/2 

3: sorteer (aℓ,...,am) recursief 

4: sorteer (am+1,...,ar) recursief 

5: merge deelrijen 

Sequentiële complexiteit 

T(n) = 2T(n/2) + Θ(n) = Θ(n log n) 


MergeSort parallelliseren 

Merk op 

sorteren deelrijen kan in parallel gebeuren 

mergen in parallel? 

Parallelle Merge (zie eerder) 

mergen van k = 2 ℓ elementen 

T(k) = Θ(log k) en W(k) = Θ(k) 


MergeSort parallelliseren 

Merk op 

sorteren deelrijen kan in parallel gebeuren 

mergen in parallel? 

Parallelle Merge (zie eerder) 

mergen van k = 2 ℓ elementen 

T(k) = Θ(log k) en W(k) = Θ(k) 

Complexiteit van parallelle MergeSort 

T(n) = T(n/2) + Θ(log n) = Θ(log 2 n) 

W(n) = 2W(n/2) + Θ(n) = Θ(n log n) 


TwoWayMergeSort 

Algoritme (sequentieel, niet-recursief) 

Input: rij A = (a1,...,an), n = 2 k 


1: for h from 1 to log 2 n − 1 do 

2: for j from 1 to n/2 h − 1 step 2 do 

3: merge (a (j−1)2 h +1,...,a j2 h) en 

(a j2 h +1,...,a (j+1)2 h) 



Algoritme (sequentieel, niet-recursief) 

Input: rij A = (a1,...,an), n = 2 k 



2: for j from 1 to n/2 h − 1 step 2 do 


(a j2 h +1,...,a (j+1)2 h) 

Opmerking 

cfr. techniek van gebalanceerde bomen 



Algoritme (voor PRAM) 


2: for j from 1 to n/2 h − 1 step 2 pardo 


(a j2 h +1,...,a (j+1)2 h) 





2: for j from 1 to n/2 h − 1 step 2 pardo 


(a j2 h +1,...,a (j+1)2 h) 

Complexiteit van parallelle TwoWayMergeSort 

T(n) = Θ( log 2 n−1 

h=1 

W(n) = Θ( log 2 n−1 

h=1 

log 2(2 h )) = Θ(log 2 n) 

n) = Θ(n log n) 


Varianten van bubblesort 


BubbleSort 

Algoritme (sequentieel) 

Input: rij (a1,a2,...,an) 


1: for i from n − 1 to 1 do 

2: for j from 1 to i do 

3: v&v aj en aj+1 

Complexiteit 

T(n) = Θ(n 2 ) 


Parallelle BubbleSort 

Parallelliseren van BubbleSort 

elke fase (lus over j) is inherent sequentieel 

algoritme te parallelliseren via pipelining 


Parallelle BubbleSort 

Parallelliseren van BubbleSort 

elke fase (lus over j) is inherent sequentieel 

algoritme te parallelliseren via pipelining 

Complexiteit 

T(n) = Θ(n) 

W(n) = Θ(n 2 ) 


Variant van BubbleSort 

OddEvenTranspositionSort 

werkt in twee fasen: even en oneven 

(on)even fase: vergelijk&verwissel tussen 

elementen op (on)even plaatsen met hun 

rechterbuur 



Algoritme (sequentieel) 

1: for i from 1 to n do 

2: if i is oneven then 

3: for j from 0 to n/2 − 1 do 

4: v&v a2j+1 en a2j+2 

5: else 

6: for j from 1 to n/2 − 1 do 

7: v&v a2j en a2j+1 

Complexiteit: 

T(n) = Θ(n 2 ) 






3: for j from 0 to n/2 − 1 pardo 

4: v&v a2j+1 en a2j+2 

5: else 









4: v&v a2j+1 en a2j+2 

5: else 



Complexiteit 

T(n) = Θ(n) en W(n) = Θ(n 2 ) 

niet optimaal, T ∗ (n) = Θ(n log n) 


Algoritme optimaliseren 

OddEvenTranspositionSort optimaliseren 

n stappen van elk Θ(n) werk 

→ in totaal Θ(n 2 ) werk 

proberen herleiden naar log 2 n stappen 

→ parallel algoritme uitvoeren op p = log 2 n 

“elementen” 


Algoritme optimaliseren 

OddEvenTranspositionSort optimaliseren 

n stappen van elk Θ(n) werk 

→ in totaal Θ(n 2 ) werk 

proberen herleiden naar log 2 n stappen 

→ parallel algoritme uitvoeren op p = log 2 n 

“elementen” 

“elementen” zijn deelrijen van lengte n/p die 

sequentieel gesorteerd worden 

“vergelijk&verwissel” wordt “merge&splits” 

(“compare-split”) van 2 deelrijen 


Optimaal algoritme 

OddEvenTranpositionSort (voor PRAM) 

Input: rij (a1,a2,...,an), n = 2 p , r = n/p 

1: for i from 1 to p pardo 

2: sorteer Ai = (a (i−1)r+1,...,air) seq. 

3: for i from 1 to p do 


5: for j from 0 to p/2 − 1 pardo 

6: merge&splits A2j+1 en A2j+2 

7: else 

8: for j from 1 to p/2 − 1 pardo 

9: merge&splits A2j en A2j+1 


Complexiteit 

Stel 

p = log 2 n en r = n/p 

Uitvoeringstijd 

Werk 

T(n) = Θ(r log r + p × r) = Θ(n) 

W(n) = Θ(p × r log r + p × p × r) = Θ(n log n) 


Sorteernetwerken 


Comparatoren 

Wat zijn sorteernetwerken? 

netwerk bestaande uit speciale poorten 

vergelijkende poort of comparator 


Comparatoren 

Wat zijn sorteernetwerken? 

netwerk bestaande uit speciale poorten 

vergelijkende poort of comparator 

Vergelijkende poort of comparator 

device met 2 inputs x,y en 2 outputs x ′ ,y ′ 

stijgende comparator ⊕ 

x ′ = min{x,y} en y ′ = max{x,y} 

dalende comparator ⊖ 

x ′ = max{x,y} en y ′ = min{x,y} 



Sorteernetwerk 

circuit van vergelijkende poorten dat zijn input 

in stijgende volgorde sorteert 






Voorstelling 

verzameling lijnen, 1 lijn per input 

poorten tussen lijnen getekend 






Voorstelling 

verzameling lijnen, 1 lijn per input 

poorten tussen lijnen getekend 

Merk op 

poort reageert pas wanneer alle inputs 

beschikbaar 


Visualisatie sorteernetwerk 

Merk op 

poorten waarvan lijnen niet overlappen, 

kunnen in parallel werken 



Merk op 



Visualisatie 

groeperen poorten die parallel werken 

vormen laag van netwerk 



Merk op 



Visualisatie 

groeperen poorten die parallel werken 

vormen laag van netwerk 

Merk op 

laag vereist 1 tijdseenheid voor uitvoering 


Parameters sorteernetwerk 

Diepte van netwerk = aantal lagen 

d.i. aantal stappen nodig opdat elke poort zijn 

vergelijking uitgevoerd heeft 

bepaalt snelheid van sorteernetwerk 







Grootte van netwerk = aantal poorten 

bepaalt werk van sorteernetwerk 







Grootte van netwerk = aantal poorten 

bepaalt werk van sorteernetwerk 

Merk op 

sorteernetwerk omzetbaar naar sequentieel 

sorteeralgoritme 


Odd-even-tranposition 

sorteernetwerk 


Een ‘maximum’-netwerk 

Bepalen van maximum via ‘sorteernetwerk’ 

vergelijk eerste twee inputs 

telkens vorige resultaat vergelijken met 

volgende input 

totdat alle inputs verwerkt 


Een ‘maximum’-netwerk 

Bepalen van maximum via ‘sorteernetwerk’ 

vergelijk eerste twee inputs 

telkens vorige resultaat vergelijken met 

volgende input 

totdat alle inputs verwerkt 

Complexiteit (n inputs) 

diepte = grootte = n − 1 

tijd en werk Θ(n) 


Odd-even-transposition netwerk 

Merk op: maximum-netwerk 

n − 1 comparatoren op diagonaal 

⇒ grootste element naar laatste lijn 






Idee (cfr. bubblesort) 

gebruik meerdere dergelijke diagonalen 






Idee (cfr. bubblesort) 

gebruik meerdere dergelijke diagonalen 

Werkwijze (n inputs) 

twee soorten koppelingen tussen lijnen 

eerste soort: koppelt even lijn met vorige lijn 

tweede soort: koppelt even lijn met volgende 


Complexiteit 


diepte n, dus tijd Θ(n) 

sneller dan beste sequentieel sorteeralgo. 


Complexiteit 


Werk 



grootte n(n − 1)/2, dus werk Θ(n 2 ) 

niet werk-optimaal 


Complexiteit 


Werk 





Kan dit beter? 

PRAM-versie van mergesort 

tijd Θ(log n) en werk Θ(n log n) 


Complexiteit 


Werk 





Kan dit beter? 

PRAM-versie van mergesort 

tijd Θ(log n) en werk Θ(n log n) 

met sorteernetwerk? Cursus Algoritmen en Datastructuren III - Parallelle Algoritmen (2008–2009) – p.27/47

Betere sorteernetwerken? 

Conjectuur Knuth 

grenzen niet te halen met sorteernetwerk 





Sorteernetwerk van Ajtai, e.a. (1983) 

diepte Θ(log n) en grootte Θ(n log n) 





Sorteernetwerk van Ajtai, e.a. (1983) 

diepte Θ(log n) en grootte Θ(n log n) 

Sorteernetwerk van Batcher (1968) 

diepte Θ(log 2 n) en grootte Θ(n log 2 n) 

gebaseerd op verdeel-en-heers strategie 


Sorteernetwerk van Batcher 

Idee: verdeel-en-heers, mergesort 

splits inputrij in twee helften 

sorteer elke helft recursief 

merge twee gesorteerde deelrijen 







Probleem 

efficiënt mergen in sorteernetwerken? 







Probleem 

efficiënt mergen in sorteernetwerken? 

Werkwijze 

construeren eerst sorteernetwerk voor 

speciale rijen, zgn. bitonische rijen 

daaruit algemeen sorteernetwerk construeren 


Bitonisch sorteernetwerk 


Cyclisch stijgende rij 

Onderstelling: n = 2 k 

Cyclisch stijgende rij: (a0,...,an−1) 

rotatie van gesorteerde rij 

∃i zodat (ai,...,an−1,a0,...,ai−1) stijgend 

visualiseren op cirkel of in diagram 


Cyclisch stijgende rij 

Onderstelling: n = 2 k 

Cyclisch stijgende rij: (a0,...,an−1) 

rotatie van gesorteerde rij 

∃i zodat (ai,...,an−1,a0,...,ai−1) stijgend 

visualiseren op cirkel of in diagram 

Netwerk Dn 

vergelijkt ai met a i+n/2, ∀0 ≤ i < n/2 

grootte n/2 en diepte 1 


Netwerk Dn 

Stelling 

als input voor Dn cyclisch stijgende rij 

zij (b0,...,bn−1) output van Dn 

dan zijn (b0,...,b n/2−1) en (b n/2,...,bn−1) 

cyclisch stijgend 

zodanig dat bi ≤ bj voor 0 ≤ i < n/2 ≤ j < n 


Netwerk Dn 

Stelling 

als input voor Dn cyclisch stijgende rij 

zij (b0,...,bn−1) output van Dn 

dan zijn (b0,...,b n/2−1) en (b n/2,...,bn−1) 

cyclisch stijgend 

zodanig dat bi ≤ bj voor 0 ≤ i < n/2 ≤ j < n 

Betekenis 

Dn splitst cyclisch stijgende rij in twee 

cyclisch stijgende deelrijen, die ’onafhankelijk’ 

zijn 


Netwerk Bn 

Werkwijze 

gebruik Dn om rij op te splitsen 

gebruik D n/2 om deelrijen verder te verwerken 

enzovoort 


Netwerk Bn 

Werkwijze 

gebruik Dn om rij op te splitsen 

gebruik D n/2 om deelrijen verder te verwerken 

enzovoort 

Stelling 

Bn sorteert cyclisch stijgende rijen 

diepte is log 2 n en grootte is n log 2 n 


Bitonisch sorteren 

Bitonische rij 

rotatie van rij die eerst stijgt en dan daalt 

(a0,...,an−1) bitonisch a.s.a. ∃m,c zodat 

am ≤ ... ≤ a(m+c) mod n 

a (m+c) mod n ≥ a (m+c+1) mod n ≥ ... ≥ am−1 


Bitonisch sorteren 

Bitonische rij 

rotatie van rij die eerst stijgt en dan daalt 

(a0,...,an−1) bitonisch a.s.a. ∃m,c zodat 

Stelling 

am ≤ ... ≤ a(m+c) mod n 

a (m+c) mod n ≥ a (m+c+1) mod n ≥ ... ≥ am−1 

Bn sorteert bitonische rijen 

in tijd Θ(log n) en werk Θ(n log n) 


Mergen met Bn 

Merk op 

twee gesorteerde rijen ‘ruggelings’ aan elkaar 

schakelen levert bitonische rij 


Mergen met Bn 

Merk op 

twee gesorteerde rijen ‘ruggelings’ aan elkaar 

schakelen levert bitonische rij 

Merging netwerk Mn 

input: twee stijgende rijen van lengte n/2 

volgorde van tweede deelrij omkeren 

gebruik Bn om rij te sorteren 


Het sorteernetwerk Sn 

Werkwijze 

input: een rij van lengte n 

sorteer eerste helft met een S n/2 

sorteer tweede helft met een S n/2 

merge deze stijgende deelrijen met een Mn 


Complexiteit van Sn 

Diepte dn 

dn = d n/2 + log 2 n 

⇒ dn = Θ(log 2 n) 


Complexiteit van Sn 

Diepte dn 

dn = d n/2 + log 2 n 

⇒ dn = Θ(log 2 n) 

Grootte sn 

sn = 2s n/2 + n log 2 n 

⇒ dn = Θ(n log 2 n) 


Nul-een-principe 

voor sorteernetwerken 



Stelling 

als sorteernetwerk correct werkt op alle 

mogelijke 0-1-inputs, dan werkt het ook 

correct op alle mogelijke inputs 



Stelling 

als sorteernetwerk correct werkt op alle 

mogelijke 0-1-inputs, dan werkt het ook 

correct op alle mogelijke inputs 

Gevolg 

sorteernetwerken verifiëren door enkel 

0-1-inputs te testen 

dus hoogstens 2 n i.p.v. oneindig veel 


Bewijs nul-een-principe 

ond. netwerk sorteert alle 0-1-rijen correct 

ond. (a0,...,an−1) niet correct gesorteerd 





zij (b0,...,bn−1) output van sorteernetwerk 

dan ∃s < t zodat bs > bt 







labels ℓi = 0 als ai < bs; ℓi = 1 anders 








er geldt: netwerk (ai) en (ℓi) gelijktijdig laten 

sorteren ⇒ elke ai behoudt zijn label 










dus: bs heeft label 1 en bt label 0, met s < t 










dus: bs heeft label 1 en bt label 0, met s < t 

m.a.w. rij labels niet correct gesorteerd 

(strijdigheid) 


Correctheid odd-even-transposition 

Stelling 

odd-even-transposition sorteernetwerk 

sorteert n inputs in diepte n en grootte Θ(n 2 ) 



Stelling 



Bewijs 

beschouw willekeurige 0-1-rij (a0,...,an−1) 

zij ai eerste nul: ai = 0, en ak = 1, voor k < i 



Stelling 



Bewijs 



als i oneven, ai begint aan beweging naar 

eerste lijn totdat die bereikt 



Stelling 



Bewijs 



als i oneven, ai begint aan beweging naar 

eerste lijn totdat die bereikt 

als i even, in eerste laag blijft ai, vanaf 

tweede laag beweging naar eerste lijn 


Bewijs (vervolg) 

3 mogelijke toestanden voor 0 in rij 

aangekomen / in beweging 

geblokkeerd 

ofwel in verkeerde fase 

ofwel opgehouden door eerdere 0 





geblokkeerd 



er geldt: k-de 0 in rij begint ten laatste in laag 

k + 1 te bewegen (bewijs door inductie) 





geblokkeerd 



er geldt: k-de 0 in rij begint ten laatste in laag 

k + 1 te bewegen (bewijs door inductie) 

er geldt: k-de 0 is hoogstens n − k posities 

verwijderd van uiteindelijke positie 

⇒ voldoende lagen beschikbaar 


Sorteren op 

interconnectienetwerken 


Sorteren op rij processoren 

Cfr. odd-even-transposition sorteernetwerk 

“comparator” = tussen naburige processoren 

Odd-even-transposition sorteeralgoritme 

elke processor heeft vlag: even/oneven fase 

even fase: werkt samen met rechterbuur 

oneven fase: werkt samen met linkerbuur 

Complexiteit 

sorteert n getallen in lineaire tijd op rij van 

n processoren 


Bitonisch sorteren op hyperkubus 

Werkwijze 

label inputlijnen van bitonisch sorteernetwerk 

met 00. . . 0 t.e.m. 11. . . 1 

Opmerking 

mappen inputlijnen op processoren van 

hyperkubus 

→ vergelijk&verwissel over verbindingen in 

hyperkubus 

m.a.w. geen extra communicatie-overhead 

voor routing 


Shearsort op rooster 

Shearsort 

twee fasen, telkens herhaald 

rijsorteerfase: 

sorteren rijen met odd-even-transposition, 

afwisselend stijgend en dalend 



Shearsort 





kolomsorteerfase: 

sorteren kolommen met odd-even-transp., 

in stijgende volgorde 



Shearsort 





kolomsorteerfase: 

sorteren kolommen met odd-even-transp., 

in stijgende volgorde 

na ⌈log 2 n⌉ + 1 herhalingen is rij gesorteerd 

(‘ploegvoren’) 


Correctheid shearsort 

Stelling 

shearsort sorteert n 2 inputs in Θ(n log n) 

stappen op n × n rooster 

Bewijs (0-1-principe sorteernetwerken) 



Stelling 




beschouwen enkel 0-1-inputs 



Stelling 





beschouw rijen 2i en 2i + 1 na rijsorteerfase 



Stelling 






geven minstens 1 rij vol 0 of 1 na 

kolomsorteerfase, verder niet meer beïnvloed 



Stelling 






geven minstens 1 rij vol 0 of 1 na 

kolomsorteerfase, verder niet meer beïnvloed 

elke fase halveert # “niet-gesorteerde” rijen

Het sorteernetwerk

Create successful ePaper yourself

Delete template?

Save as template?