Parallele Algorithmen - Lehrstuhl für Informatik der RWTH Aachen

Parallele Algorithmen
Walter Unger, Dirk Bongartz
Lehrstuhl für Informatik I
8. November 2006
Teil I
Motivation
1
Einfaches Sortieren
Einfache Algorithmen
Verbesserte Algorithmen
2
Einführung zum opt. Alg.
Untere Schranke
Batchers Sortieralgorithmus
3
Sortiernetzwerke
4
Algorithmus von Cole
Idee
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Einfache Algorithmen
Sehr einfacher Algorithmus (Idee)
22
33
41
26
59
57
52
61
27
49
67
23
56
14
12
34
0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 1 0 1 0 0 1 0 0 0 0 1 0 0 1
1 1 1 0 1 0 0 1 0 0 0 0 1 0 1 1
0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 1
1 1 1 1 1 0 1 1 0 1 1 0 1 1 1 1
1 1 1 1 1 0 1 1 0 1 0 0 1 1 1 1
1 1 1 0 1 0 1 1 0 0 0 0 1 1 1 1
1 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1
0 1 1 0 1 0 0 0 0 0 0 0 1 0 0 1
1 1 1 0 1 0 0 1 0 0 0 0 1 1 1 1
1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1
0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1
1 1 1 0 1 0 1 1 0 1 0 0 1 1 1 1
0 1 0 0 0 0 0 0 0 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 1 0 1 0 0 1 0 0 0 0 1 0 1 1
34 12 14 56 23 67 49 27 61 52 57 59 26 41 33 22
3
7
9
5
14
13
11
15
6
10
16
4
12
2
1
8
12
14
22
23
26
27
33
34
41
49
52
56
57
59
61
67
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Einfache Algorithmen
Sehr einfacher Algorithmus
Idee: Bestimme die Position jedes Elements.
Vergleiche paarweise und bestimme Anzahl der kleineren Elemente.
Benutze n2 Prozessoren.
Programm: SimpleSort
Eingabe: s1 , · · · , sn .
for all Pi,j where 1 6 i, j 6 n do in parallel
if si > sj then Pi,j (1) → Ri,j else Pi,j (0) → Ri,j
for all i where 1 6 i 6 n do in parallel
for all Pi,j where 1 6 j 6 n do in parallel
Pn
Prozessoren Pi,j bestimmen qi = l=1 Ri,l .
Pi (si ) → Rqi +1 .
Komplexität: T (n) = O(log n) und P(n) = n2 .
Effizienz:
O(n log n)
n2 ·O(log n)
Modell: CREW.
= O( n1 ).
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Verbesserte Algorithmen
Verbesserter Algorithmus für CREW
Arbeite mit P(n) Prozessoren (P(n) 6 n).
Teile in Blöcke der Größe O(n/P(n)) auf. O(1)
Sortiere die Blöcke. O(n/P(n) · log(n/P(n)))
Mische die Blöcke paarweise und parallel.
O(n/P(n) + log n) · O(log P(n))
Laufzeit: T (n) = O(n/P(n) · log n + log2 n).
Effizienz: Eff (n) =
O(n log n)
O(n log n)
=
O(P(n)) · O(n/P(n) · log n + log2 n)
O(n · log n + P(n) · log2 n)
Ist O(1) für P(n) 6 n/ log n.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Verbesserte Algorithmen
Verbesserter Algorithmus für EREW
Tausche einfach Mischverfahren aus.
Erinnerung TMischen(EREW ) (n) = O(n/P(n) + log n · log P(n)).
T (n) =
O(n/P(n) · log(n/P(n)) + O(n/P(n) · log P(n) + log n · log2 P(n))
T (n) = O((n/P(n) + log2 n) · log n)
Effizienz:
O(n log n)
Eff (n) =
O(P(n) · ((n/P(n) + log2 n) · log n))
Ist O(1) falls P(n) < n/log 2 n.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Untere Schranke
Untere Schranke
Theorem:
Für jedes parallele Sortierprogramm Srt mit PSrt (n) = O(n) gilt:
TSrt (n) = Ω(log(n)).
Beweis:
Sequentiell in Θ(n log n).
Man braucht O(n log n) Vergleiche.
In jedem parallelen Schritt sind aber nur o(n) viele Vergleiche
möglich.
Mit weniger Schritten könne man auch schneller sequentiell
sortieren.
Situation bisher:
Ineffizienter Algorithmus mit: T (n) = O(log n) und P(n) = n2 .
Effizienter Algorithmus mit: T (n) = O(log2 n) und P(n) = o(n).
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Batchers Sortieralgorithmus
Grundoperation beim Sortieren
Bestimme Grundoperation.
Annahme: Sortierschlüssel in s1 , · · · , sn .
Programm: compare exchange(i,j)
if si > sj then exchange si ↔ sj
Symbolische Darstellung (Batcher):
x
y
min(x, y )
max(x, y )
Grundbausteinen von Sortiernetzwerken.
Grundlage von Odd-Even Mischen.
Daraus entsteht dann optimaler Algorithmus von Cole.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Batchers Sortieralgorithmus
Odd-even Merge (Definitionen)
Eingabe: Folge S = (s1 , s2 , · · · , sn ). (O.E.d.A. n gerade)
Seien Odd(S) [Even(S)] die Elemente von S mit ungeraden
[geradem] Index.
Sei weitere Folge: S ′ = (s1′ , s2′ , · · · , sn′ ).
Dann gilt: interleave(S, S ′ ) = (s1 , s1′ , s2 , s2′ , · · · , sn , sn′ ).
s1 s2 s3 s4 s1′ s2′ s3′ s4′
Q
A @
Q
A @
Q Q
A
@
U
Q
R
s′′ ′′?
+
?
′′
′′
′′
′′
′′
′′
s1 s 2 s 3 s 4 s5 s6 s 7 s8
Tinterleave (n) = O(1) mit Pinterleave (n) = O(n)
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Batchers Sortieralgorithmus
Odd-even Merge (Definitionen)
Programm: odd even(S)
for all i where 1 < i < n and i even do in parallel
compare exchange(i, i + 1).
s1 s2 s3 s4 s5 s 6 s 7 s 8
?
?
?
?
?
?
?
?
′
′
′
′
′
′
′
s1 s2 s3 s4 s5 s6 s7 s8′
Tcompare
exchange (n)
= O(1) mit Pcompare
exchange (n)
= O(n)
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Batchers Sortieralgorithmus
Odd-even Merge (Definitionen)
Programm: join1(S, S ′ )
odd even(interleave(S, S ′ ))
s1 s2 s3 s4 s1′ s2′ s3′ s4′
Q
A @
Q
A @
Q Q
@
A
Q
? ′′? ′′? ′′? ′′? ′′? ′′? ′′?
s 2 s 3 s 4 s5 s6 s 7 s8
s1′′
Tjoin1 (n) = O(1) mit Pjoin1 (n) = O(n)
Algorithmus von Cole
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Batchers Sortieralgorithmus
Sortieren durch Mischen
Programm: odd even merge(S, S ′ )
if |S| = |S ′ | = 1 then mische mit compare exchange.
Sodd = odd even merge(odd(S), odd(S ′ )).
Seven = odd even merge(even(S), even(S ′ )).
return join1(Sodd , Seven ).
Todd
even merge (n)
= O(log n) mit Podd
even merge (n)
= O(n)
Theorem:
Der Algorithmus odd even merge sortiert zwei vorsortierte Folgen richtig.
Beweis: Folgt.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Sortiernetzwerke
Theorem:
Es gibt ein Sortieralgorithmus mit T (n) = O(log2 n) und P(n) = n.
Beweis: Teile und Herrsche, Mischen der Tiefe O(log n).
Theorem:
Es gibt ein Sortiernetzwerk der Größe O(n log2 n).
Beweis: Alle Aufrufe der compare exchange Operationen hängen nicht
von der Eingabe ab.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Das 0-1 Prinzip
Theorem:
Falls ein Sortiernetzwerk X , bzw. Sortieralgorithmus für alle 0-1 Eingaben
korrekt sortiert, dann auch für jede Eingabe.
Beweis (durch Widerspruch):
Sei f (x) monotone Funktion: f (si ) 6 f (sj ) ⇔ si 6 sj .
Falls X (a1 , a2 , · · · , an ) zu (b1 , b2 , · · · , bn ) sortiert, dann auch
(f (a1 ), f (a2 ), · · · , f (an )) zu (f (b1 ), f (b2 ), · · · , f (bn )).
Falls bi > bi+1 und f (bi ) 6= f (bi+1 ), dann f (bi ) > f (bi+1 ) in der
“sortierten” Folge (f (b1 ), f (b2 ), · · · , f (bn )). D.h. Fehler bleiben
durch f ggf. erhalten.
Wähle f : f (bj ) = 0 für bj < bi und f (bj ) = 1 sonst.
Damit ist (f (b1 ), f (b2 ), · · · , f (bn )) nicht sortiert, denn f (bi ) = 1
und f (bi+1 ) = 0.
Widerspruch zur Annahme.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Korrektheit des Mischens
Theorem:
Der Algorithmus odd even merge sortiert zwei vorsortierte Folgen richtig.
Beweis:
S hat die Form: S = 0p 1m−p für ein 0 6 p 6 m.
′
S ′ hat die Form: S ′ = 0q 1m −q für ein 0 6 q 6 m′ .
Damit hat dann Sodd die Form 0⌈p/2⌉+⌈q/2⌉ 1∗
Und Seven die Form 0⌊p/2⌋+⌊q/2⌋ 1∗ .
Definiere: d = ⌈p/2⌉ + ⌈q/2⌉ − (⌊p/2⌋ + ⌊q/2⌋)
Abhängig von d betrachten wir drei Fälle: d = 0, d = 1 und d = 2.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Korrektheit des Mischens
Falls d = 0: Dann gilt: p und q sind gerade.
Der interleave Schritt von join1 hat die Form:
′
interleave(Sodd , Seven ) = (00)(p+q)/2 1m+m −p−q
Die Sequenz ist bereits sortiert.
Der compare exchange Schritt erhält die Sortierung.
Falls d = 1: Dann gilt: p ist ungerade und q ist gerade.
Der interleave Schritt von join1 hat die Form:
⌊(p+q)/2⌋
interleave(Sodd , Seven ) = (00)
m+m′ −p−q
01
Die Sequenz bleibt analog sortiert.
Falls d = 2: Dann gilt: p und q sind ungerade.
Der interleave Schritt von join1 hat die Form:
′
interleave(Sodd , Seven ) = (00)⌊(p+q)/2⌋ 101m+m −p−q
Der compare exchange Schritt vertauscht die 1 auf
Position 2r mit der 0 auf Position 2r + 1.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Test auf Korrektheit eines Netzwerkes
Korrellar:
Die Korrektheit eines Mischnetzwerks kann in Zeit O(n2 ) getestet
werden.
′
Beweis: Teste alle Eingaben der Form (0p 1m−p , 0q 1m −q ).
Theorem:
Der Korrektheitstest eines Sortiernetzwerks ist NP-vollständig.
Beweis: siehe Literatur.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Situation
Ziel: Schneller optimaler Algorithmus.
Bisher T (n) = log2 n bei P(n) = O(n).
Bisher: Zwei Schleifen: Mischen und Sortieren.
Idee: Beschleunige eine Schleife, also Mischen in O(1).
Problem: Ohne Zusatzinformation Θ(log n) notwendig.
Idee: Bestimme beim Sortieren die Zusatzinformation.
Wähle als Zusatzinformation die Mischpunkte.
D.h. wähle die Punkte, die konstant große zu mischende Blöcke
trennen.
Problem: Wie bestimmt man diese Punkte?
Lösung dieses Problem ist die Grundlage des Algorithmus von Cole.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Idee
Idee
Vor dem Mischen zweier Folgen mische Teilfolgen.
Wähle als Teilfolgen jedes k-te Element.
Diese Teilfolgen dienen dann als Stützstellen.
D.h. diese Teilfolgen dienen als “Vorschau”.
Mit den Stützstellen wird in O(1) Zeit gemischt.
Gesamtzeit dann nur noch O(log n).
Der Mehraufwand muss aber O(1) sein.
Algorithmus von Cole
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Definition
Seien J und K zwei sortierte Folgen.
Beachte: Ohne Zusatzinformation können J und K nicht in O(1)
mit O(n) Prozessoren gemischt werden.
Sei L eine weitere Folge, im folgenden Stützfolge (good sampler) für
J und K .
Informell: |L| < |J| und Elemente von L sind in J gleichverteilt.
Sei a < b, c liegt zwischen a und b falls a < c 6 b.
Der Rang von e in S ist rng (e, S) = |{x ∈ S | x < e}|.
Bezeichnung: RngA,B ist die Funktion RngA,B : A 7→ IN mit
RngA,B (e) = rng (e, B) für alle e ∈ A.
RngA,B wird als Rang zwischen A und B bezeichnet.
RngA,B kann als Array mit |A| Elementen dargestellt werden.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Stützfolge
RngA,B (e) = rng (e, B)
Definition:
Wir sagen L ist Stützfolge (good sampler) von J, falls:
L und J sind sortiert.
zwischen je k + 1 aufeinander folgenden Elemente von
{−∞} ∪ L ∪ {+∞} liegen höchstens 2 · k + 1 viele Elemente in J.
Beispiel:
Sei S sortierte Folge.
Bestehe S1 aus jedem vierten Element von S.
Dann ist S1 Stützfolge von S.
Bestehe S2 aus jedem zweiten Element von S.
Dann ist S1 Stützfolge von S2 .
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Mischen mit Stützfolge
RngA,B (e) = rng (e, B)
Seien J, K und L sortierte Folgen.
Sei L Stützfolge von J und auch von K .
Sei L = (l1 , l2 , · · · , ls ).
Programm: merge with help(J, K , L)
for all i where 1 6 i 6 s do in parallel
Setze Ji = {x ∈ J | li−1 < x 6 li }.
Setze Ki = {x ∈ K | li−1 < x 6 li }.
Setze resi = merge(Ji , Ki ).
return (res1 , res2 , · · · , ress ).
Situation:
L1
L2
l1
K1
L3
l2
K2
L4
l3
K3
L5
l4
K4
L6
l5
K5
L7
l6
K6
L8
l7
K7
L9
l8
K8
K9
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Mischen mit Stützfolge (Beispiel)
RngA,B (e) = rng (e, B)
K = (1, 4, 6, 9, 11, 12, 13, 16, 19, 20)
J = (2, 3, 7, 8, 10, 14, 15, 17, 18, 21)
L = (5, 10, 12, 17)
Dann gilt:
i
1
2
3
4
5
Ki
(1, 4)
(6, 9)
(11, 12)
(13, 16)
(19, 20)
Ji
(2, 3)
(7, 8, 10)
∅
(14, 15, 17)
(18, 21)
merge(Ki , Ji )
(1, 2, 3, 4)
(6, 7, 8, 9, 10)
(11, 12)
(13, 14, 15, 16, 17)
(18, 19, 20, 21)
Ergebnis:
(1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Mischen mit Stützfolge (Laufzeit)
RngA,B (e) = rng (e, B)
Lemma:
Falls L eine Stützfolge für K und J ist. Falls RngL,J , RngL,K , RngK ,L und
RngJ,L bekannt sind, dann gilt:
Tmerge with help(J,K ,L) = O(1) mit Pmerge with help(J,K ,L) = O(|J| + |K |).
Beweis:
Analoges Vorgehen wie bei obigen Mischverfahren.
Jeder Prozessor kennt über RngL,J bzw. RngL,K den zu lesenden
Bereich.
Jeder Prozessor kennt mit RngJ,L und RngK ,L den zu schreibenden
Bereich.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Eigenschaften von Stützfolgen
RngA,B (e) = rng (e, B)
Lemma:
Falls X Stützfolge für X ′ und Y Stützfolge für Y ′ , dann ist merge(X , Y )
eine Stützfolge für X ′ [bzw. Y ′ ].
Beweis:
Betrachte X Stützfolge für X ′ .
Jedes zusätzliche Element macht die Stützfolge nur “besser”.
Beachte: merge(X , Y ) muss nicht Stützfolge von merge(X ′ , Y ′ ) sein.
X = (2, 7) und X ′ = (2, 5, 6, 7).
Y = (1, 8) und Y ′ = (1, 3, 4, 8).
merge(X , Y ) = (1, 2, 7, 8) und
merge(X ′ , Y ′ ) = (1, 2, 3, 4, 5, 6, 7, 8).
Es sind 5 Elemente zwischen 2 und 7.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Eigenschaften von Stützfolgen
RngA,B (e) = rng (e, B)
Lemma:
Sei X Stützfolge für X ′ und Y Stützfolge für Y ′ . Dann sind höchstens
2 · r + 2 Elemente von merge(X ′ , Y ′ ) zwischen r aufeinanderfolgenden
Elementen von merge(X , Y ).
Beweis:
O.E.d.A. enthält X und Y Elemente −∞ und +∞.
Seien (e1 , e2 , · · · , er ) aufeinanderfolgende Elemente von
merge(X , Y ).
O.E.d.A. e1 ∈ X .
Betrachte nun 2 Fälle: er ∈ X und er ∈ Y .
Sei im Folgenden x = |X ∪ {e1 , e2 , · · · , er }| und
y = |Y ∪ {e1 , e2 , · · · , er }|.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Eigenschaften von Stützfolgen
RngA,B (e) = rng (e, B)
x = |X | und y = |Y |
Falls: er ∈ X
Zwischen e1 und er sind höchstens 2(x − 1) + 1
Elemente von X ′ .
Zwischen e1 und er sind höchstens 2(y + 1) + 1
Elemente von Y ′ , denn sie liegen zwischen y + 2
Elementen von Y .
Damit gilt: 2(x − 1) + 1 + 2(y + 1) + 1 = 2 · r + 1
Falls: er ∈ Y
Füge e0 ∈ Y mit e0 < e1 zur Stützfolge hinzu.
Füge er +1 ∈ X mit er < er +1 zur Stützfolge hinzu.
Die Elemente aus X ′ zwischen (e1 , e2 , · · · , er ) liegen
zwischen x + 1 Elementen aus X .
Die Elemente aus Y ′ zwischen (e1 , e2 , · · · , er ) liegen
zwischen y + 1 Elementen aus Y .
Damit gilt: 2x + 1 + 2y + 1 = 2r + 2.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Eigenschaften von Stützfolgen
RngA,B (e) = rng (e, B)
x = |X | und y = |Y |
Definition
Sei reduce(X ) die Operation, die aus X jedes vierte Element auswählt.
Lemma:
Falls X Stützfolge für X ′ und Y Stützfolge für Y ′ , dann ist
reduce(merge(X , Y )) eine Stützfolge für reduce(merge(X ′ , Y ′ )).
Beweis:
Betrachte k + 1 aufeinanderfolgende Elemente (e1 , e2 , · · · , ek+1 )
von reduce(merge(X , Y )).
Höchstens 4k + 1 Elemente von merge(X , Y ) liegen zwischen
e1 , e2 , · · · , ek+1 einschließlich e1 , ek+1 .
Höchstens 8k + 4 Elemente von merge(X ′ , Y ′ ) liegen zwischen
diesen 4k + 1 Elementen.
Höchstens 2k + 1 Elemente von reduce(merge(X ′ , Y ′ )) liegen
zwischen (e1 , e2 , · · · , ek+1 ).
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Überblick zum Algorithmus von Cole
Erste Erklärung mittels eines vollständigen Baumes.
Blätter enthalten die zu sortierenden Elemente.
Innerer Knoten v “verwaltet” so viele Elemente, wie er Blätter unter
sich hat.
Knoten v empfängt von Söhnen Folge von sortierten Folgen.
Die “Länge” der Folgen verdoppeln sich jeweils.
Knoten v empfängt Folgen X1 , X2 , · · · , Xr und Y1 , Y2 , · · · , Yr .
Knoten v sendet zu seinem Vorfahr Folgen Z1 , Z2 , · · · , Zr , Zr +1 .
Knoten v verwaltet eine interne Hilfsfolge valv .
Es gilt: |X1 | = |Y1 | = |Z1 | = 1.
Es gilt: |Xi | = 2 · |Xi−1 |, |Yi | = 2 · |Yi−1 | und |Zi | = 2 · |Zi−1 |.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Grundoperation eines internen Knoten v
Empfängt von Söhnen Folgen X und Y .
Bestimmt: valv = merge with help(X , Y , valv ).
Sendet an Vorfahr: reduce(valv ) bis v alles sortiert hat.
Sendet an Vorfahr jedes 2. Element aus valv , falls v vorher fertig
sortiert hat.
Sendet an Vorfahr valv , falls v vor zwei Schritten fertig sortiert
hatte.
Beispiel:
Schritt
1
2
3
4
5
Links
7
3,7
1,3,4,7
1,3,4,7
1,3,4,7
Rechts
8
5,8
2,5,6,8
2,5,6,8
2,5,6,8
valv
7,8
3,5,7,8
1,2,3,4,5,6,8
1,2,3,4,5,6,8
1,2,3,4,5,6,8
Vorfahr
∅
8
4,8
2,4,6,8
1,2,3,4,5,6,8
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Grundoperation eines internen Knoten v
Empfängt von Söhnen Folgen X und Y .
Bestimmt: valv = merge with help(X , Y , valv ).
Sendet an Vorfahr: reduce(valv ) bis v alles sortiert hat.
Sendet an Vorfahr jedes 2. Element aus valv , falls v vorher fertig
sortiert hat.
Sendet an Vorfahr valv , falls v vor zwei Schritten fertig sortiert
hatte.
Damit ergibt sich folgendes Muster:
X1
X2
X3
Z1
X4
Z2
···
···
Xr
Xr
Xr +1
Xr +2
Falls Knoten x nach t Schritten fertig ist, dann ist der Vorfahr von
x nach t + 3 Schritten fertig.
Damit ergibt sich eine Laufzeit von 3 log n.
Einfaches Sortieren
Einführung zum opt. Alg.
Idee
Invariante
Invariante:
Jedes Xi ist eine Stützfolge von Xi+1 .
Jedes Yi ist eine Stützfolge von Yi+1 .
Jedes Zi ist eine Stützfolge von Zi+1 .
Jedes Xi ist halb so groß wie Xi+1 .
Jedes Yi ist halb so groß wie Yi+1 .
Jedes Zi ist halb so groß wie Zi+1 .
|X1 | = |Y1 | = |Z1 | = 1.
Sortiernetzwerke
Algorithmus von Cole
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Situation
Laufzeit ist in O(log n).
Die inneren Knoten v brauchen |valv | viele Prozessoren.
Prozessorzahl O(n) muss noch beweisen werden.
PRAM Modell muss noch bestimmt werden.
Wichtig: Die Berechnung der Werte RngX ,Y muss noch gezeigt
werden.
Diese Werte werden mit den Folgen mitgeführt und überarbeitet.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Bestimme Ränge
In jedem Schritt wird bestimmt:
merge with help(Xi+1 , Yi+1 , merge(Xi , Yi )).
Wegen obiger Lemma ist merge(Xi , Yi ) Stützfolge von Xi+1 und
Yi+1 .
Sei L = merge(Xi , Yi ), J = Xi+1 und K = Yi+1 .
Zu bestimmen: RngL,J , RngL,K , RngJ,L und RngK ,L .
Invariante:
Sei S1 , S2 , · · · , Sp eine Folge von Folgen am Knoten v .
Dann ist auch bekannt: RngSi+1 ,Si für 1 6 i < p.
Weiter ist für jede Folge S bekannt: RngS,S .
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Ränge bestimmen
Lemma:
Sei S = (b1 , b2 , · · · , bk ) sortierte Folge, dann kann der Rang von a ∈ S
in Zeit O(1) mit k Prozessoren bestimmt werden.
Beweis:
Programm: rng1(a,S)
for all Pi where 1 6 i 6 k do in parallel
if bi < a 6 bi+1 then return i
.
Programm hat keine Schreibkonflikte.
Könnte auch Lesekonflikt-frei gemacht werden.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Ränge bestimmen
Lemma:
Seien S1 , S2 , S sortierte Folgen mit S = merge(S1 , S2 ) und S1 ∩ S2 = ∅.
Dann kann RnkS1 ,S2 und RnkS2 ,S1 in Zeit O(1) mit O(|S|) Prozessoren
bestimmt werden.
Beweis:
Wir kennen RnkS,S , RnkS1 ,S1 und RnkS2 ,S2 .
Weiter gilt: rnk(a, S2 ) = rnk(a, merge(S1 , S2 )) − rnk(a, S1 ).
Damit ergibt sich direkt die Behauptung.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Ränge bestimmen
Lemma:
Sei X Stützfolge von X ′ .
Sei Y Stützfolge von Y ′ .
Sei U = merge(X , Y ).
Sei bekannt RnkX ′ ,X und RnkY ′ ,Y .
Dann kann in Zeit O(1) mit O(|X | + |Y |) Prozessoren RnkX ′ ,U , RnkY ′ ,U ,
RnkU,X ′ und RnkU,X ′ bestimmt werden.
Beweis:
Wir bestimmen im Folgenden erst RnkX ′ ,U und RnkY ′ ,U .
Dann RnkX ,X ′ und RnkY ,Y ′ .
Und zuletzt RnkU,X ′ und RnkU,Y ′ .
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Ränge bestimmen (RnkX ′ ,U )
Sei X = (a1 , a2 , · · · , ak ).
Sei o.E.d.A. a0 = −∞ und ak+1 = +∞.
′
Teile X ′ anhand von Stützfolge X auf in X1′ , X2′ , · · · , Xk′ , Xk+1
.
Beachte: RnkX ′ ,X ist bekannt.
Aufteilung geht in Zeit O(1) mit O(|X |) Prozessoren.
Sei nun Ui die Folge der Elemente von Y die zwischen ai−1 und ai
liegen.
Damit:
Programm: RnkX ′ ,U
for all i where 1 6 i 6 k + 1 do in parallel
for all x ∈ Xi′ do
rnk(x, U) = rnk(ai−1 , U) + rnk(x, Ui )
Pk+1
Laufzeit O(1) mit i=1 |Ui | Prozessoren.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Ränge bestimmen (RnkX ,X ′ )
Sei ai ∈ X .
′
.
Sei a′ minimale Element in Xi+1
Der Rang von ai in X ′ ist der gleiche wie der von a′ in X ′ .
Dieser Rang ist schon bekannt.
Damit kann das in O(1) mit einem Prozessor bestimmt werden.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Ränge bestimmen (RnkU,X ′ )
Beachte: RnkU,X ′ besteht aus RnkX , X ′ und RnkY , X ′ .
RnkX , X ′ ist bereits bekannt.
Noch zu bestimmen: RnkY , X ′ .
RnkY , X kann nach vorhergehenden Lemma bestimmt werden.
Wir bestimmen rnk(a, X ′ ) mit Hilfe von rnk(a, X ) und RnkX ,X ′ .
Damit haben wir RnkU,X ′ mit O(|U|) Prozessoren in O(1) Zeit.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Ränge bestimmen
Betrachte Schritt
merge with help(J = Xi+1 , K = Yi+1 , L = merge(Xi , Yi ):
Bekannt nach Invariante: RnkJ,Xi und RnkK ,Yi .
Mit obigen Überlegungen können bestimmt werden: RnkL,J , RnkL,K ,
RnkJ,L und RnkK ,L .
Noch zu bestimmen: Rnkreduce(merge(Xi+1 ,Yi+1 )),reduce(merge(Xi ,Yi ))
Bekannt: RnkXi+1 ,merge(Xi ,Yi ) und RnkYi+1 ,merge(Xi ,Yi ) .
Einfach zu bestimmen: RnkXi+1 ,reduce(merge(Xi ,Yi )) und
RnkYi+1 ,reduce(merge(Xi ,Yi )) .
Weiter einfach zu bestimmen Rnkmerge(Xi+1 ,Yi+1 ),reduce(merge(Xi ,Yi )) .
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Algorithmus von Cole
Idee
Algorithmus von Cole
Theorem:
Man kann mit O(n) Prozessoren auf CREW PRAM in Zeit O(log n) n
Werte sortieren.
Beweis: siehe oben.
Theorem:
Man kann mit O(n) Prozessoren auf EREW PRAM in Zeit O(log n) n
Werte sortieren.
Beweis: siehe Literatur.
Theorem:
Es gibt ein Sortiernetzwerk mit O(n) Prozessoren und Tiefe O(log n).
Beweis: siehe Literatur.
Einfaches Sortieren
Einführung zum opt. Alg.
Sortiernetzwerke
Idee
Literatur zu diesem Kapitel
Literatur:
A. Gibbons, W. Rytter:
Efficient Parallel Algorithms. Cambridge University Press 1990.
Kapitel 5.
Algorithmus von Cole