N - stinfwww - Universität Leipzig

Parallele AlgorithmenMartin MiddendorfUniversität LeipzigStand: 18. Dezember 2006

Literatur:1. S. G. Akl: The Design and Analysis of Parallel Algorithms,Prentice-Hall, 19892. J. JáJá: An Introduction to Parallel Algorithms,Addison-Wesly, 19923. Skripten:B. Monien, J. Schulze, Universität-GH Paderborn;H. Schmeck, Universität Karlsruhe;T. Thierauf,Universität UlmHinweis: Ein Großteil des Skripts für dieses Semesterist übernommen aus einem Skript vonH. Schmeck (Uni Karlsruhe).

1. EinleitungEntwurf und Analyse von Algorithmen werden starkbeeinflußt durch die zugrundeliegende RechnerstrukturUnterscheidung:sequentielle AlgorithmenRandom Access MachineTuring Machineverteilte AlgorithmenWorkstation-ClusterHypercomputingGrid Computingparallele Algorithmenparallele RechnerstrukturenPRAM, Feldrechner, BSP, LogPHardware-Algorithmenhöchstintegrierte SchaltkreiseSpezialhardware

Hauptziel paralleler Algorithmen:Zeitgewinn (Beschleunigung) gegenüber sequentiellenAlgorithmenMöglichkeiten dafür hängen von der Aufteilbarkeiteiner Berechnung in unabhängige Teilberechnungen abZeitgewinn wird u.U. gemindert durch zusätzlichenKommunikations- und VerwaltungsaufwandFragestellungen der VorlesungWelches ist der beste Algorithmus zur Lösung einesvorgegebenen Problems auf einer verfügbaren Rechnerstruktur?Wie beeinflußt die zugrundeliegende Rechnerstruktur(bzw. das Berechnungsmodell) die Beurteilung derQualität von Algorithmen?Welches ist die beste Rechnerstruktur zur Lösung einesvorgegebenen Problems?Welche allgemeinen Prinzipien existieren für den Entwurfeffizienter Algorithmen?Welche Grenzen für eine effiziente parallele Ausführungeines vorgegebenen Problems gibt es?

Anwendungen paralleler AlgorithmenGrundsätzlich sind parallele Algorithmen sehr wichtigfür die Simulation komplexer Systeme sowie fürrechenaufwendige Realzeit-Anwendungen.Beispiele:Simulation komplexer technischer Vorgänge:Crash-TestsSimulation komplexer biologischer Vorgänge:Whole-Cell-SimulationBildverarbeitung in der Medizin, z.B. bei OperationenWettervorhersageGenanalyse in der BioinformatikOnline-Banking

2. Berechnungsstrukturen und -modell:- vollständig verbundene Parallelrechnera) Busb) Leitungsnetz- linear verbundenes Feld (Ring)...

- HypercubeDimension 0:Dimension 1:Dimension 2:Dimension 3:Dimension 4:

- Baumstrukturen:a) binärer Baumb) Fat Treec) Stern- Schmetterlingsnetzwerk (butterfly network)000001010011100101110111000001010011100101110111

allgemeine Regel:kk... ...2k- rekonfigurierbare Bussystemeviele weitere Strukturen

Organisation paralleler Berechnungen:- asynchron• Kooperierende Prozesse, Verteilte Systeme• Austausch von Botschaften• Kommunikationsprotokolle- synchron• Ausführung eines Berechnungsschritts synchron inallen Prozessoren• globaler Takt- zentral gesteuert• ein Steuerwerk• viele Rechenwerke- lokal gesteuert• viele Steuerwerke• viele Rechenwerke

2.1 Berechnungsmodell:Klassifizierungsschema (Flynn 1972)- Anzahl der Steuerwerke (Befehlsströme)- Anzahl der Speicherbereiche (Datenströme)CPMC. . .C C CP P . . . PVerbindungsnetzMCP P . . . PVerbindungsnetzM M . . . MC. . .C C CP P . . . PVerbindungsnetzM M . . . M

a) SISD- Single Instruction Stream Single Data Streamvon Neumann-Rechner, Random Access Machineübliche Ein-Prozessor-Rechnerb) SIMD- Single Instruction Stream Multiple Data Stream• pro Takt (Schritt) ein Befehl verteilt an alleProzessoren (broadcast)• Teilmenge der Prozessoren führt Befehl aus,die anderen nur NOOPc) MISD- Multiple Instruction Stream Single Data Streamvorwiegend für SpezialanwendungenBeispiele:• Primzahltest: jeder Prozessor prüft Teilbarkeit füreinen festen Divisor• Analyse von Sensordaten: jeder Prozessor untersuchtdie Daten auf bestimmte Musterd) MIMD- Multiple Instruction Stream Multiple Data StreamMehrprozessoranlage aus SISD-Rechnern⇒ vielseitigste Form der Parallelverarbeitung

Abstraktes Berechnungsmodell für parallele Algorithmen:PRAM Parallel Random Access Machine— hat eine MIMD-Struktur (kann jedoch auch alsSIMD Machine betrachtet werden)mit gemeinsamem Speicher ( ”shared memory“):. . .M M MP P . . . PVerbindungsnetzgem. Speichermit verteiltem Speicher ( “distributed memory“):. . .M M MP P . . . PVerbindungsnetzPRAM ermöglicht allgemeine Untersuchungen derMöglichkeiten paralleler Berechnungen

Arbeitsweise der Prozessoren:jeweils pro Takt:• Lesen einer beliebigen Zelle des gemeinsamenSpeichers und in beliebigen Zellen des lokalen(eigenen) Speichers.• Ausführen einer Rechenoperation(2-stellige arithmetisch/logische Operation)• Schreiben in eine beliebige Zelle des gemeinsamenSpeichers und in beliebige Zellen des lokalen(eigenen) Speichers.Häufige Variante: Mehrere arithmetisch/logischeOperationen pro Takt zugelassen (z.B. Auswerteneines ”einfachen“ arithmetischen Ausdrucks, oderAuswertung einer bedingten Anweisung)

Zugriff auf Speichermodule:- gemeinsamer Speicher (shared memory machine):Jeder Prozessor kann auf beliebige Zelle des gemeinsamenSpeichers zugreifen- verteilter Speicher ( distributed memory machine ):Jeder Prozessor hat eigenen Speicher. Auf Speicherzellenanderer Prozessoren kann nur über Kommunikationzwischen Prozessoren zugegriffen werden,entsprechend der Verbindungsstruktur (viele Variationenmöglich)Auch:- verteilter gemeinsamer Speicher- virtueller gemeinsamer Speicher

Kommunikation zwischen Prozessoren ist teuer undkann zum Engpaß von Berechnungen werden.Betrachte SM-PRAM:. . .M M MP P . . . PVerbindungsnetzgem. SpeicherSatz 2.1 Jedes Kommunikations- bzw. Verbindungsnetz,das n Prozessoren den getrennten, gleichzeitigenZugriff auf n Speicherbereiche in jeder beliebigenZuordnung erlaubt, benötigt mindestens (Ω(n log n))” Schalter“.Beweis:• n! mögliche Zuordnungen• s Schalter ⇒ 2 s verschiedene Zustände• s ∈ Ω(log n!) = Ω(n log n)q.e.d.

Unterscheidung zwischen- exklusivem Zugriff (Lesen, Schreiben)- gemeinsamem Zugriff (Lesen, Schreiben)Exclusive ReadConcurrent Readz.B.:Exclusive WriteConcurrent Write• EREW - SM - SIMD - PRAM• CREW - SM - MIMD - PRAM• CRCW - SM - MIMD - PRAMmehrfaches Lesen: in der Regel unproblematischmehrfaches Schreiben: Schreibkonflikte müssenaufgelöst werden• PRIORITY: Prozessor mit höchster Priorität darfschreiben• COMMON: Schreiben nur zulässig, wenn alle Proszessorendas gleiche schreiben• ARBITRARY: beliebiger Prozessor darf schreiben• SUM: die Summe der Einzelwerte wird geschrieben(diese Regel ist allerdings unrealistisch, da sieeine beliebigstellige Operation in konstanter Zeitermöglicht)

Suchproblem: Stelle fest, ob ein Datum x in einersehr großen Datei mit n Einträgen enthalten ist.Sequentielle Lösung: (auf SISD-Rechner)Vergleiche x mit allen Einträgen, da binäre Suchewegen fehlender Sortierung nicht möglich.⇒- im schlechtesten Fall n Vergleiche- im Mittel n/2 VergleicheParallele Lösung: N Prozessoren P 1 , ..., P N1) Sende x an alle Prozessoren.2) Teile die Datei in N Blöcke B 1 , . . . , B N mit jeweilsmaximal ⌈ n N ⌉ Elementen.3) Für alle i ∈ N suche P i in B i nach x. Sobald P i xfindet, schreibe i in ”Antwortspeicherzelle“.genauer:

Schritt 1: Broadcast (sende x an alle P 1 , . . . , P N )bei CR: 1 Schritt (Takt)bei ER: recursive doubling1) P 1 liest x in Zelle 1 des gemeinsamen Speichers undschreibt x in Zelle 2.2) P 2 und P 3 lesen x in Zellen 1 und 2 und schreibenx in Zellen 3 und 4.3) P 4 , . . . , P 7 lesen x in Zellen 1 bis 4 und schreiben xin Zellen 5, . . . , 8.u.s.w.allgemein: (Ann.: N = 2 r , SIMD-PRAM)FOR k := 0 TO r − 1 DOFOR i := 2 k TO 2 k+1 − 1 PARDOP i liest aus Zelle i − 2 k + 1P i schreibt x in Zelle i + 1PARENDEND;P N liest x aus Zelle N⇒ log N + 1 TakteDie Schreibweise ”PARDO ... PAREND“bedeutet, dass der Schleifenrumpf für alle Werteder Laufvariablen gleichzeitig ausgeführt wird.

Schritt 2:a) Sende an alle Prozessoren die Werte n und N.b) For i = 1 TO N PARDOP i bestimme aus i, n und N die Grenzendes Blocks B i .PAREND⇒ 2 log N + 2 Takte für (a) bei ER-PRAM1 Takt für (b)(Annahme: Auswertung eines arithmetischenAusdrucks erfordert nur einen Takt;andernfalls 3 Takte)Schritt 3:FOR i := 1 TO N PARDOa) P i durchsuche B i nach x.b) Falls x gefunden, schreibe i in Zelle 0PAREND(b) setzt CW voraus, sofern x in mehreren B i´s seinkönnte. Andernfalls würde maximal ein Prozessor in 0schreiben, d.h. EW würde reichen.⇒ maximal 3 log N + ⌈ n N⌉ + 4 Takte (bei EREW)Mit CREW frühere Terminierung möglich, wenn alle P inach jedem Suchschritt Zelle 0 überprüfen.⇒ auf CREW nur ≤ ⌈ n N ⌉ + 4 Takte

Wie simuliert man CR oder CW auf EREW-SIMD?a) jeweils N gleichzeitige Zugriffe:mehrfaches Lesen:Simulation mittels Broadcast (s.o.)→ log N + 1 Taktemehrfaches Schreiben:Annahme: COMMON-Strategie,Speicherzellen R 0 , . . . , R Nin CRCW-PRAM: P i schreibe x i in Zelle R 0 .Dabei sei x i eine lokale Variable von P i .In R 0 steht also nur dann anschließend ein definierterWert, wenn alle x i den gleichen Wert haben.Simulation auf EREW-PRAM durch Überprüfung derGleichheit und ”inversen Broadcast“:1) FOR i := 1 TO N PARDOP i schreibe x i in R i ;PAREND;

2) FOR i := 1 TO N PARDOP i lese y i in R imodN+1 ;P i schreibe b i := (x i = y i ) in R iPAREND;3) FOR k := 1 TO log N − 1 DOFOR i := 1 TO N/2k PARDOP i lese t i in R i+N/2 k;P i schreibe b i := t i ∧ b i in R iPAREND;END;P 1 lese t 1 in R 2 ;P 1 schreibe x 1 in R 0 , falls t 1 = b 1 = TRUE.Ist N keine Zweierpotenz, müßte der Algorithmus leichtmodifiziert werden.Analyse:Nach Schritt 2 steht genau dann ein FALSE in einemR i , wenn x i ≠ x i−1 ist.Durch Schritt 3 werden die Werte der R i” geundet“,d.h. nach log N + 1 Takten weiß P 1 , ob alle P i dengleichen Wert schreiben wollen, und kann die entsprechendeAktion ausführen.⇒ Pro Schreibschritt in CW Verzögerung vonO(log N) Takten.

) beliebige Mehrfach-Zugriffe:vorher nicht feststellbar, wo ein Broadcast oder inverserBroadcast ausgeführt werden muß.R 1RnnLösung:Vergrößere den Speicher: pro Speicherzelle ein Baummit 2N − 2 weiteren Zellen, d.h. mit N Blätternmehrfaches Lesen:• Schreibe Lesewunsch von P i in Blatt i des derentsprechenden Zelle zugeordneten Baumes.• Bewege Lesewünsche zur Wurzel und transportiereden gelesenen Wert zu den Blättern.⇒nach O(log N) Takten hat P i den gewünschten Wert.

mehrfaches Schreiben:• Schreibe Schreibwunsch von P i (d.h. das zuschreibende Datum) in Blatt i des Baumesder entsprechenden Zelle.• Bewege Schreibwünsche entsprechend derSchreibregel (COMMON, PRIORITY oderARBITRARY) zur Wurzel und führe dortden resultierenden Schreibbefehl aus.⇒ O(log N) Takte für mehrfaches Schreiben und Lesenaber (2N − 1)-mal so viele Speicherzellen!

DM-PRAM (verteilter Speicher). . .M M MP P . . . PVerbindungsnetz• Jeder Prozessor verwaltet eigenen Speicherbereich.• Zugriff von anderem Prozessor nur möglich überdirekte Verbindungsleitungen / Kommunikationsregisterentsprechend der Verbindungsstruktur.⇒ Kommunikationszeit beeinflußt durch- den Durchmesser des Verbindungsnetzes, d.h. denmaximalen kürzesten Weg zwischen zwei Knoten- die Weite des Verbindungsnetzes, d.h. minimaleZahl von Kanten, die bei einer gleichmäßigen Aufteilung(Schnitt) durchtrennt werden, (englischbisection width“). Eine Aufteilung heißt”gleichmäßig, wenn die Anzahl der Knoten in beidenTeilen sich höchstens um eins unterscheidet.Je größer der Durchmesser, desto länger die Zeit füreinen Datenaustausch (im schlechtesten Fall).Je kleiner die Weite, desto größer der Engpaß für dieKommunikation zwischen Teilen des Netzes.

Beispiele: (jeweils N Prozessoren)Durchmesser Weitelineares Feld N − 1 12-dim. Feld 2 √ √N − 2 Nbinärer Baum 2 log(N + 1) − 2 1Hypercube log N n/2⇒• Hypercube verbindet kleinen Durchmesser mitgroßer Weite.• 2-dim. Feld hat Durchmesser und Weite etwagleicher Größe.• binärer Baum leidet unter dem starkem Engpaß nureiner Leitung zwischen zwei benachbartenTeilbäumen.⇒Kommunikationsengpässe durch großen Durchmesseroder kleine Weite können zu erheblichem Overhead beiparallelen Algorithmen führen.Deshalb:• schnelle Algorithmen zum Transport vonNachrichten in Verbindungsnetzen erforderlich(Routing-Verfahren, werden in dieser Vorlesungnicht behandelt).• Kommunikationszeiten verstecken“ ( communicationhiding“) durch nebenläufige Ausführung von” ”Berechnungs- und Datentransportprozessen.

2.2 BewertungskriterienSei A ein Algorithmus auf einer PRAM M.Parallelitätsgrad von A:p A (n) := maximale Zahl von Prozessoren, die währendder Ausführung von A gleichzeitig aktiv sind, wennProbleme der Größe n bearbeitet werden.A wird auch als p A (n)-paralleler Algorithmus bezeichnet.Falls p A (n) beliebig groß sein kann, heißt A auch∞-parallel, andernfalls beschränkt parallel.Zeitkomplexität von A:T A,k (n) := maximale Anzahl der Schritte von A fürEingaben der Größe n bei einer k-parallelen Ausführung• häufig Aufteilung in Rechen- und Transportschritte:T A,k (n) := t c A,k(n) + t r A,k(n)(c für compute, r für route)Manchmal wird abkürzend statt T A,k (n) auch T k (n)oder T A (n) geschrieben.

Beispiel: SuchproblemDer bereits vorgestellte Algorithmus ist N-parallel, dap(n) = N.ZeitkomplexitätT N (n) ={3 log N + ⌈nN ⌉ + 4 EREW-PRAM≤ ⌈ n N ⌉ + 4 CREW-PRAMManchmal (insbesondere für k = 1) bezeichnet T k (n)auch die Zeit des optimalen k-parallelen Algorithmuszur Lösung eines vorgegebenen Problems.Kosten:C A,k (n) := T A,k (n) · kBeachte: Nicht jeder der n Prozessoren muß währendder gesamten Zeit aktiv gewesen sein.⇒ Dieses Maß ist eine obere Schranke, für die Anzahlder tasächlichen für A ausgeführten Prozessorschritte.

Weitere Bewertungskriterien:Zeitgewinn (Speed-up): (auch Beschleunigung)S A,k (n) :=T 1(n)T A,k (n)Dabei ist sei T 1 (n) die Zeit des optimalen sequentiellenAlgorithmus.(In manchen Analysen wird allerdings nicht einoptimaler sequentieller Algorithmus herangezogensondern T A,1 (n), d.h. der Zeitgewinn wird dannüberschätzt)Effizienz (mittlerer Auslastungsgrad der Prozessoren)E A,k (n) :=T 1(n)k · T A,k (n) =T (1(n)C A,k (n) = = S )A,k(n)k

Beispiel: Skalarprodukt(a 1 , . . . , a n ) · (b 1 , . . . , b n ) = ∑ ni=1 a i · b iAlgorithmus SP :⇒T SP,n (n) = ⌈log n⌉ + 1,p SP (n) = nS SP,n (n) = 2n − 1⌈log n⌉ + 1 ∈ O( nlog n )1E SP (n) ∈ O(log n )Satz 2.2 Der Zeitgewinn ist stets kleiner oder gleichdem Parallelitätsgrad.Beweis:Ann.: ∃ paralleler Alg. A mit S A,p(n) > p A (n)Konstruiere sequentiellen Algorithmus A ′ , dernacheinander die Operationen der PRAM-Prozessoren

unter A simuliert.⇒ A ′ schneller als der optimale sequentielle (Wid.!)q.e.d.Folgerung 2.3Die Effizienz ist stets kleiner oder gleich 1.Beispiel: Skalarprodukt: E SP (n) ∈ O( 1log n )⇒ schlechte Ausnutzung, bedingt durch großes fan-inbei Berechnung des Skalarproduktes.

Algorithmus SP’:Wie SP, aber verwende nur ⌈ nlog n ⌉ Prozessoren.⇒ Jeder Prozessor berechnet zunächst Teilbaum mit2 · log n Blättern, gefolgt von einem großen fan-in.⇒ ≤ 3 · log n Schritte⇒ E SP ′ ,⌈log nn ⌉ (n) ≥ 2 3⇒ Zu viele Prozessoren können häufig nicht mehreffizient arbeiten.Durch Verwendung weniger Prozessoren läßt sich dieEffizienz erhöhen, ohne den Zeitbedarf wesentlich zuverändern.(hierzu liefert der Satz von Brent (Abschnitt 2.8) eineallgemeine Aussage)

Grenzen der Effizienz paralleler Berechnungen:Algorithmus A enthalte für Problemgröße n• s Operationen, die sequentiell ausgeführt werdenmüssen• c Operationen, die gleichzeitig ausführbar sind.Ferner sei t := s + c und σ := s/t⇒ T A,1 (n) = t = s + cT A,p (n) = s + c/p⇒S A,p (n) = s + cs + c p=1σ + (1 − σ)/pE A,p (n) =s + cp · s + c = 1p · σ + (1 − σ) = 11 + (p − 1) · σAmdahls Gesetz: Der sequentielle Programmanteilverhindert einen hohen Zeitgewinn bzw. eine effizienteAusnutzung parallel arbeitender Prozessoren.Beispiel: Wie erreicht man bei 1000 Prozessoren eineEffizienz von 50%?999σ = 1 ⇒ σ = 1/999aber: Dieser Effekt bezieht sich auf gleichbleibendensequentiellen Anteil bei wachsender Problemgröße undwachsendem Parallelitätsgrad.⇒ Amdahl’s Gesetz ist nicht ganz realistisch.

Skalierbarkeit: Wie verändert sich die Leistung einesRechners / das Verhalten eines Programms, wenn sichdie Anzahl der Prozessoren oder die Problemgrößeändern?a) Größenskalierbarkeit:• Wunsch: k-fache Größe bringt k-fache Leistung• Probleme:– k-fache Zahl von Prozessoren führt zuentsprechend höheren Anforderungen an dieI/O-Bandbreite1 Teraflop (10 12 Gleitpunktoperationen/sec) undca. 1 Datenbit/flop⇒ I/O-Anforderungen von ca. 125 GByte/secoder 1.250 Platten mit 100MByte/sec– nicht jedes Verbindungsnetz läßt sichbeliebig vergrößernBeispiele: Kreuzschienenverteiler, Gitterb) Technologie-Skalierbarkeit (auchGenerationsskalierbarkeit):• Wunsch: Einsatz neuer Hardware-Generation(Proz., ca. alle 3 Jahre!) erhöht die Leistungohne neuen Programmierungsaufwand.• Probleme: neue Proz. erfordern in der Regel

– höhere I/O-Bandbreiten,– schnellere Verbindungsnetze,-schalter– kürzeren Speicherzyklusc) Problemskalierbarkeit:• Wunsch: gegebene Granularität eines Parallelrechners(d.h. Leistung pro Prozessor /Parallelitätsgrad)kann stets optimal effizient genutzt werden.• Probleme:– Amdahl’s Gesetz : Effizienz sinkt (bei konstantemsequentiellen Anteil) zwangsläufig mit Erhöhungdes Parallelitätsgrads– feinkörnige Parallelität erfordert häufig zu hohenKommunikationsaufwandFolgerung: Abschätzungen des zu erwartendenZeitgewinns durch Einsatz von Parallelrechnernsowie Entwurf und Analyse paralleler Algorithmenmüssen Vielzahl von Faktoren berücksichtigen, u.a.:• Größenskalierbarkeit• Generationsskalierbarkeit• Problemskalierbarkeit• Verhältnis von Rechenleistung zuKommunikationsleistung• Verbindungsstrukturen• ...

Erwünschte Eigenschaften paralleler Algorithmen1) Parallelitätsgrad sollte kleiner als n sein:Realistische Annahme ist, dass nicht beliebigviele Prozessoren zur Verfügung stehen, aberbeliebig große Probleme zu lösen sind.⇒ es sollte gelten p A (n) ≤ n x mit 0 < x < 12) Algorithmus sollte adaptiv sein:Er sollte sich einfach an variierende Prozessorzahlenanpassen lassen.3) Algorithmus sollte signifikanten Zeitgewinnerzielen:Die Zeit sollte zumindest deutlich kleiner als die Zeitsequentieller Algorithmen sein.4) Algorithmus sollte skalierbar sein:Ein höherer Parallelitätsgrad sollte generell zukleinerer Zeit führen, zumindest innerhalb gewisserGrenzen.

2.3 SelektionProblem:Gegeben sei Folge S = (s 1 , . . . , s n ) mit Elementenaus einer geordneten Menge und eine Zahl k ∈ [n].Bestimme das k-t kleinste Element (oder Elementmit Rang k), genannt s(k).Naiver sequentieller Algorithmus:1) Sortiere die Folge, d.h. berechneS ′ = (s (1) , s (2) , . . . , s (n) )2) Gib s (k) aus.⇒ Zeit Ω(n log n)Kluger sequentieller Algorithmus:Selektiere rekursiv, wende Strategiedivide-and-conquer“ an:”Sei q eine kleine Zahl aus N , die noch genauerbestimmt wird.

Algorithmus Select (S, k):1) Falls |S| ≤ q, bestimme s(k) direkt.Anderenfalls teile S in r = ⌈|S|/q⌉ Teilfolgen mitjeweils höchstens q Elementen.2) Bestimme die Mediane der Teilfolgen m 1 , . . . , m r .3) m :=Select((m 1 , . . . , m r ), ⌈ r 2 ⌉)4) Erzeuge drei Teilfolgen S 1 , S 2 , S 3 der Elemente vonS, die als m sind.5) Fall 1) |S 1 | ≥= k ⇒ s (k) := Select(S 1 , k)Fall 2) |S 1 | < k ∧ |S 1 | + |S 2 | ≥ k ⇒ s(k) := mFall 3) |S 1 | + |S 2 | < k⇒ s(k) := Select(S 3 , k − |S1| − |S2|)für q = 5:m 1m 2m n/10 m n/10+1 mn/5

Analyse von Select1) Aufwand ≤ c 1 · n (für das Aufteilen der Liste)2) r = ⌈ n q⌉ Teilfolgen mit maximal jeweils q Elementen⇒ Gesamtaufwand ≤ c 2 · n3) Aufwand T Select ( n q )4) Aufwand c 3 · n für die Konstruktion von S 1 , S 2 , S 35) Nach Definition sind ⌈ r 2 ⌉ der m i größer oder gleichm sowie jeweils ⌈ q 2⌉ der Teillistenelemente größer odergleich ihrem Median m i .⇒ ≥ n 4Elemente von S größer oder gleich m⇒ |S 1 | ≤ 3 4 nanalog |S 3 | ≤ 3 4 n⇒ Aufwand ≤ T Select ( 3 4 n)⇒ T Select (n) ≤ c 4 · n + T Select ( n q ) + T Select( 3 4 n)Wähle q so, daß n q + 3 4 n < n⇒ insgesamt immer kleinere Restfolgen für q ≥ 5.

Sei q = 5.Es gilt T Select (n) ∈ O(n), falls ein c 5 existiert, sodass für genügend großes n gilt T Select (n) ≤ c 5 · n.Für ein derartiges c 5 muss geltenT Select (n) ≤ c 4 · n + c 5 · n5 + c 5 · 34 n= c 4 · n + c 5 · 1920 n ≤ c 5 · nFür c 5 ≥ 20c 4 ist dies erfüllt.⇒ T Select (n) ∈ O(n)

Select offensichtlich guter Kandidat fürParallelisierung:Idee: bei N Prozessoren Aufteilung inN Teilfolgen der Größe ⌈ n N ⌉⇒ Schritt 2: sofort parallel ausführbarSchritt 3: wie bisher rekursivSchritt 1: Aufteilung möglich, wenn jedem P in bekannt.⇒ BROADCASTSchritt 4: nichttrivialIdee: P i teilt eigene Liste auf, schreibt eigeneTeiliste an geeignete Stelle im Speicher.⇒ Berechnung dieser Stelle z.B. mittels ProzedurALLSUMS (s.u.)Schritt 5: Von jedem P i ausführbar, sofern |S 1 |und |S 2 | bekannt. (BROADCAST)⇒ Parallel Select benötigt BROADCAST undfolgendes Verfahren ALLSUMS:

Sei S = (s 1 , . . . , s n ) mit s i ∈ N 0Aufgabe:Berechne für alle i ∈ [n] den Wert S i := ∑ ij=1 s jIdee: 1) Berechne die Summen der jeweilsbenachbarten“ Werte”2) Addiere die jeweils übernächsten Werte bzw.Zwischensumme)3) u.s.w.

allgemein:Algorithmus ALLSUMS (s 1 , . . . , s n )FOR j := 0 TO log n − 1 DOFOR i := 2 j + 1 TO n PARDOP i liest s i−2 j im gem. Speicher (in R i−2 j),berechnet s i := s i−2 j + s i ,schreibt s i in den gemeinsamen Speicher (in R i ).PAREND (*of FOR i *)END (* of FOR j *)nach Schritt j enthält R i den Wert ∑ min(i−1,2 j −1)k=0s i−kd.h. der Algorithmus ist korrekt.Laufzeit: T ALLSUMS,n (n) ∈ O(log n)Bemerkung:• Verfahren ALLSUMS nutzbar für beliebige parallelePräfixberechnungen (d.h. für eine große Klasse vonFunktionen, später)• Andere Berechnungsmuster möglich, die auch nurO(log n) Schritte benötigen.(z.B. über rekursive Formulierung.)Frage: Wie geht es auf anderen Rechnerstrukturen?

Voraussetzungen für ParallelSelect:1) Gegeben:• S = (s 1 , . . . , s n ), k ∈ [n]• EREW-PRAM mit N Prozessoren, N

PROCEDURE ParallelSelect(S, k);Schritt 1) IF |S| ≤ 4THEN P 1 bestimme k-tes ElementELSE Teile S in r = ⌊|S| 1−x ⌋ Teilfolgen S imit jeweils höchstens ⌈|S| x ⌉ ElementenSchritt 2) FOR i := 1 TO r PARDOP i berechne m i =Select(S i , ⌊|S|/2⌋)P i schreibe m i in R iPARENDSchritt 3) m :=ParallelSelect(R, ⌈|R|/2⌉)Schritt 4) Teile S in TeilfolgenL = alle s i mit s i < mE = alle s i mit s i = mG = alle s i mit s i > mSchritt 5) IF |L| ≥ kTHEN RETURN ParallelSelect(L, k)ELSIF |L| + |E| ≥ kTHEN RETURN mELSE RETURN ParallelSelect(G, k−|L|−|E|)END

Analyse:Schritt 1) Jeder P i benötigtAnfangsadresse A von Ssowie |S|⇒ Aufwand O(log |S| 1−x )Berechnung der Anfangsadresse von S i in konstanterZeit: A + (i − 1)⌈|S| x ⌉, . . . , A + i⌈|S| x ⌉ − 1Schritt 2) Aufwand O(|S i |) = O(|S| x )Schritt 3) T ParallelSelect,r 1−x(r)(durch Sortieren mit r Prozessoren in Zeit O(log 2 r)ausführbar!)Schritt 4) genauer:a) Verteile m an alle r Prozessoren: O(log r)b) FOR i := 1 TO r PARDOP i teilt S i in L i , E i , G iPAREND⇒ Aufwand O(|S i |) = O(|S| x )c) Verschmelze alle L i zu L, E i zu E und G i zu Gunter Verwendung von ALLSUMS:Berechne Anfangsposition von L i in LSchreibe L i an diese Position(analog für E i , G i ).⇒ Aufwand O(log r) + O(|S| x )⇒ insgesamt Zeit O(|S| x ) in Schritt 4.

Schritt 5) |L| und |E| bekannt aus Schritt 4rekursive Aufrufe: ≤ T P arallelSelect,(34|S|) 1−x ( 3 4 |S|))⇒ (abgekürzt):T P S (n) = c 1 log n + c 2 n x + c · log 2 n 1−x + c 3 n x +T P S ( 3 4 n)⇒ T P S (n) ∈ O(n x )⇒ S P S (n) ∈ Ω(n 1−x ), E P S (n) ∈ Ω(1)!Algorithmus Parallel Select hat alle gewünschtenEigenschaften, insbesondere stellt er sich auf jede nichtzu große Zahl von Prozessoren vernünftig ein.Bemerkung:• Man beachte, dass x zu Beginn bestimmt wird undin rekursiven Aufrufen nicht verändert wird!• Optimaler paralleler Algorithmus wurde gefunden,ausgehend von optimalem sequentiellenAlgorithmus. Dies ist häufig nicht möglich!

2.4 MergingProblem:Gegeben: Folgen A = (a 1 , . . . , a r ) und B =(b 1 , . . . , b s ) nichtfallend sortiert.Gesucht: Sortierte Folge C = (c 1 , . . . , c r+s ), die durchVerschmelzen von A und B entsteht.Sequentielle Lösung: ”Reissverschlussverfahren“i := j := k := 1;REPEATWHILE ((j = s + 1) OR (a i ≤ b j )) AND (i ≤ r)DOc k := a i ;i := i + 1; k := k + 1END;WHILE ((i = r + 1) OR (b j ≤ a i )) AND (j ≤ s)DOc k := b j ;j := j + 1; k := k + 1END;UNTIL k > r + s;Aufwand: O(r + s)→ optimal, da jedes Element mindestens einmalverglichen werden muss.

Parallele Lösungena) Odd-Even Merge:Annahme: n = 2k, r = s = nFür n = 1 triviales Verfahren:(if a 1 = b 1 then (a 1 , b 1 ) else (b 1 , a 1 ))Schritt 1) ( ”odd“)(d 1 , . . . , d n ) := Odd-Even Merge((a 1 , a 3 , a 5 , . . . , a n−1 ),(b 1 , b 3 , b 5 , . . . , b n−1 ))Schritt 2) ( ”even“)(e 1 , . . . , e n ) :=Odd-Even Merge((a 2 , a 4 , . . . , a n ),(b 2 , b 4 , . . . , b n ))Schritt 3) FOR i := 1 TO n − 1 PARDOc 2i := min(d i+1 , e i );c 2i+1 := max(d i+1 , e i )PARENDc 1 := d 1 ; c 2n := e nVergleichernetz ( ”Datenflussgraph“) für n = 4

Korrektheit von Odd-Even Merge:Betrachte Folgen aus Nullen und Einsen: A enthalte2a oder 2a + 1 Einsen, B 2b oder 2b + 1 Einsen⇒ schlechtester Fall für Schritt 3:. . . d i−2 e i−2 d i−1 e i − 1 d i . . .. . . 0 1 0 1 1 . . .⇒ Vergleich von e i−2 und d i−1 in Schritt 3 reicht aus.⇒ 0-1-Folgen werden richtig sortiert bzw.verschmolzen.0-1-Prinzip: Sortiert (bzw. verschmilzt) ein nur aufVergleichen basierender Algorithmus alle Folgen vonNullen und Einsen, so sortiert (bzw. verschmilzt) erauch jede beliebige Folge von Elementen einergeordneten Menge.(Beweis siehe Vorlesung Zellularautomaten oder Knuth, The Artof Computer Programming, Vol.III)⇒ Odd-Even Merge ist korrekt.

Aufwand:p OEM (n) = nT OEM,n (n) = T OEM,n/2 (n/2) + 2da Schritt 1 und Schritt 2 parallel ausführbarT OEM,1 (1) = 1⇒ T OEM,n (n) ∈ O(log n)⇒ S EM,n (n) ∈ O(n/ log n)E OEM,n (n) ∈ O(1/ log n) ⇒ nicht optimalBemerkungen: i) Transformiert man dasVergleichernetz direkt in Hardware (also in ein Netzaus Vergleicherbausteinen, siehe Kapitel 2), so erhältman einen Hardware-Algorithmus aus O(n log n) Vergleichern,der aber log n+1 ”Verschmelzungsvorgänge“gleichzeitig ausführen kann (bzw. im Pipelining-Verfahren).ii) Da jeder Vergleich eines Vergleichernetzes auchdurch eine ”merge-split“-Operation auf sortiertenBlöcken ersetzt werden kann, lässt sich derAlgorithmus an jede kleinere Zahl von Prozessorenanpassen. Bei k Prozessoren erhält man also O(log k)” merge-split“-Stufen.

) CREW-Merge (auf CREW-PRAM)N Prozessoren mit N

3) Jeder Prozessor verschmelze zwei Teilfolgen(eine von A und eine von B) wie folgt:a) Berechne für jeden Prozessor P i (i ∈ [N]) ein PaarS(i) = (x, y) von ”Startpositionen“ x in A und y inB: S(1) := (1, 1) d.h. P 1 beginnt ganz links.Für Berechnung von S(2) betrachte v 2 :Falls v 2 = (a ′ k , k, A), beginne P 2 in Liste A mit a ′ k ,d.h. an Position k · ⌈ n N ⌉ .Startposition in B sei das kleinste j mit b j > a ′ k (daalle anderen Elemente von B (also b i mit i < j) linksvon a ′ k stehen).Falls v 2 = (b ′ k, k, B), verfahre analog, d.h.S(2) = (j, k · ⌈ n N ).Berechne analog für i = 3, . . . , N S(i) mit Bezug aufv 2i−2 .b) Für alle i = 1, . . . , N verfahre P i wie folgt:Sei S(i) = (x, y), S(i + 1) = (x ′ , y ′ ).Dann verschmelze P i sequentiell die Folgen(a x , . . . , a x ′ −1) und (b y , . . . , b y ′ −1)und schreibe ”seine“ Teilliste an die richtige Positionin der Gesamtliste (d.h. ab Position x + y − 1).

Beispiel: N = 4, n = 12 (⇒ ⌈ n N ⌉ = 3)A : (2, 3, 4, 6, 11, 12, 13, 15, 16, 20, 22, 24)B : (1, 5, 7, 8, 9, 10, 14, 17, 18, 19, 21, 23)Schritt 1: A ′ = (4, 12, 16)B ′ = (7, 10, 18)Schritt 2: Suche für jedes i das kleinste j, so dassa ′ i < b′ jSetze v i+j−1 := (a ′ i , i, A), analog für B′ .⇒ A ′ : v 1+1−1 = v 1 = (4, 1, A)v 2+3−1 = v4 = (12, 2, A)v 3+3−1 = v5 = (16, 3, A)B ′ : v 1+2−1 = v2 = (7, 1, B)v 2+2−1 = v3 = (10, 2, B)v 3+4−1 = v6 = (18, 3, B)⇒ V = ((4, 1, A), (7, 1, B), (10, 2, B),(12, 2, A), (16, 3, A), (18, 3, B))Schritt 3: S(1) = (1, 1)S(2) = (5, 3)S(3) = (6, 7)S(4) = (10, 9)⇒ P 1 verschmilzt (2, 3, 4, 6) (1, 5)P 2 verschmilzt (11) (7, 8, 9, 10)P 3 verschmilzt (12, 13, 15, 16) (14, 17)P 4 verschmilzt (20, 22, 24) (18, 19, 21, 23)

Analyse:Schritt 1 konstante Zeit, da Concurrent Read: c 1Schritt 2N − 1 binäre Suchen auf B ′ : c 2 · log NN − 1 binäre Suchen auf A ′ : c 3 · log NSchritt 3:a) N − 1 binäre Suchen auf B oder A: c 4 · log nb) Länge der zu verschmelzenden Teilfolgen≤ 2 · ⌈ n N ⌉ + 1:c 5 · nN⇒ insgesamt O( n N+ log n)⇒ für N ≤nlog n optimal:S CREW −Merge,N (n) ∈ Ω(N)E CREW −Merge,N (n) ∈ Ω(1)außerdem: alle erwünschten Eigenschaften !Bem.:i) Bei Ausführung auf EREW-PRAM Änderungen inallen drei Schritten (Übg.).ii) Der optimale sequentielle Algorithmus führt indiesem Fall nicht direkt zu einem gutem parallelenAlgorithmus.

2.5 SortierenProblem:Gegeben: Folge S = (s 1 , s 2 , . . . , s n )Gesucht: Folge S ′ = (s ′ 1, s ′ 2, . . . , s ′ n) (nicht fallend)sortiert, d.h. S ′ ist eine geeignete Permutation von S.Sequentielle Lösung: z.B. QuicksortPROCEDURE Quicksort(S)IF |S| = 2 AND s 2 < s 1THEN vertausche(s 1 , s 2 )ELSIF |S| > 2THEN Bestimme Pivotelement x in S.Partitioniere S in 2 Teilfolgen:S 1 := {s i | s i ≤ x}; S 2 := {s i | s i > x};ENDENDQuicksort(S 1 ); Quicksort(S 2 );bekannt:T Quicksort (n) = O(n 2 )TQuicksort av (n) = O(n log n)Falls Pivotelement x =Median(S), so gilt sogarT Quicksort (n) = O(n log n)allerdings mit schlechtem konstanten Faktor.

Parallele Lösungen:a) Sortieren mit n 2 Prozessoren:Idee: Bestimme für jedes s i die Anzahl c i ders j (j ∈ [n]) kleiner oder gleich s i .⇒ c i ist die Position von s i in der sortierten FolgeBeispiel:s i 7 12 3 2 6 13 1 4c i 6 7 3 2 5 8 1 4Berechnungsmodell: CRCW-SM-SIMD-PRAMSchreibregel: SUM, d.h. es wird stets die Summe derWerte geschrieben (unrealistisch !)Numeriere die n 2 Prozessoren durch 2 Indizes:P 1,1 P 1,2 . . . P 1,nP 2,1.P 2,2 P 2,n.P n,1 P n,2 . . . P n,nProzessoren P i,1 , P i,2 , . . . , P i,n berechnen c i .

genauer: Algorithmus ParSortFOR i := 1 TO n PARDOFOR j := 1 TO n PARDOIF (s i > s j ) OR (s i = s j AND i > j)THEN P i,j schreibt 1 nach iELSE P i,j schreibt 0 nach iENDPARENDPARENDFOR i := 1 TO n PARDOP i,1 liest c i in i und schreibt s i in Zelle 1 + c i .PARENDAnalyse:p ParSort (n) = n 2T ParSort (n) = O(1)S ParSort (n) =T 1 (n)T ParSort (n)=O(n log n)O(1)= O(n log n)E ParSort (n) = S ParSort (n)p ParSort (n)=O(n log n)O(n 2 )= O( log nn )Bem.: Nachteile des Verfahrens– unrealistische Schreibregel– alle Prozessoren ausgelastet, aber nicht effizient, daZeitgewinn zu gering!– zu viele Prozessoren

) Odd-Even Merge Sort:Berechnungsmodell: EREW-SM-SIMD-PRAMAnalyse: in Stufe i:n/2i-mal Odd-Even Merge auf Folgen der Länge2i − 1 mit jeweils 2i − 1 Prozessoren⇒ Zeit für Stufe i mit n/2 Prozessoren : O(i)⇒T OEMS (n) =log∑ni=1O(i) = O(log 2 n)⇒ Zeitgewinn:S OEMS (n) =Ω(n log n)O(log 2 n) = Ω( nlog n )Effizienz:E OEMS (n) =Ω(n/ log n)O(n/2)1= Ω(log n )

⇒mit Faktor 2n weniger Prozessoren erreicht OEMS eineum den Faktor n/log 2 n höhere Effizienz als ParSort.

c) Cole-Sort (1986): Zeit O(log n) auf EREW-PRAMIdee : O(log n) Merge-Stufen mit konstanter Zeit proStufe:Vorgehensweise erläutert an binärem Baum der Tiefek mit n = 2 k :Knoten v heißt fertig ⇔ S v enthält alle s i im Teilbaummit Wurzel v.v heißt aktiv ⇔ v ist Vorgänger (im Baum) einesfertigen KnotenAnfangs bis auf Blätter alle L v und S v leerREPEAT 3k TIMESFOR EACH v PARDOv aktiv oder 1. Mal fertig: L v := (S v (4), S v (8), S v (12), . . .);v 2. Mal fertig : L v := (S v (2), S v (4), S v (6), . . .);v 3. Mal fertig : L v := S v ;Für direkte Nachfolger x, y von v, verschmelze L x undL y zu S v .

Analyse:Schicht i + 1 wird 3 Schritte nach Schicht i fertig⇒ 3 log n Schritte reichen ausVerwendet man 2m Prozessoren für das Verschmelzenzweier Listen der Länge m, so werden in jedem SchrittO(n) Prozessoren benötigt.Jeder (Verschmelzungs-)Schritt ist in Zeit O(1)ausführbar:Idee: Nutze beim Verschmelzen von L x und L y Kenntnisvon S v⇒ zeit-optimales Sortierverfahren, aber nicht adaptiv

Beweisideen zur Analyse: (vollständige Beweise siehez.B. Gibbons, Rytter)In jedem Knoten v mit direkten Nachfolgern x und ywerden L v,i und S v,i+1 folgendermaßen berechnet:Fallsv aktiv oder 1. Mal fertig:L vi := (S v,i (4), S v,i (8), . . .)v 2. Mal fertig: L v,i := (S v,i (2), S v,i (4), . . .)v 3. Mal fertig: L v,i := S v,iS v,i+1 := mergewithhelp(L x,i , L y,i , S v,i )Dabei berechnet mergewithhelp die Folge S v,i+1 nichtnur auf Basis L x,i und L y,i sondern unter Zuhilfenahmevon Informationen wo sich Elemente von S v,i in L x,iund L y,i befinden.Definition: L ist eine gute Auswahl für L ′ , wennzwischen k + 1 benachbarten Elementen von {−∞} ∪L ∪ {∞} höchstens 2k + 1 Elemente von L ′ stehen,für alle natürlichen k.Invariante:i) Falls L x,i−1 eine gute Auswahl für L x,i ist und L y,i−1eine gute Auswahl für L y,i ist, dann ist auch L v,i−1eine gute Auswahl für L v,i .

ii) |L x,i | = 2|L x,i−1 | für i ∈ [2 : r] und |L x,1 | = 1|L y,i | = 2|L y,i−1 | für i ∈ [2 : r] und |L y,1 | = 1|L v,i | = 2|L v,i−1 | für i ∈ [2 : r + 1] und |L v,1 | = 1Bew: i) (in der Vorlesung)Definition: Für je zwei Folgen L, L ′ vonElementen einer geordneten Menge heißt R[L, L ′ ] =(r 1 , r 2 , . . . , r |L| ) der Rang von L in L ′ , dabei ist r i derRang von a i in L ′ und a i das i-te Element von L.Lemma: mergewithhelp(L x,i , L y,i , S v,i ) lässt sich inkonstanter Zeit mit |S v,i | Prozessoren berechnen, fallsfolgende Werte bekannt sind:R[S v,i , L x,i ], R[S v,i L y,i ]Lemma: Es seien R[L x,i , L x,i−1 ] und R[L y,i , L y,i−1 ]gegeben. Dann lassen sich die folgenden Werte inkonstanter Zeit mit |S v,i | Prozessoren berechnen:R[S v,i , L x,i ], R[S v,i L y,i ], R[L v,i , L v,i−1 ]△

anderes zeitoptimales Verfahren:(Ajtai, Komlos, Szemeredi 1983):” AKS-Sortierer“• Netz aus O(log n) Stufen mit jeweils O(n) parallelenVergleichen• Folge der Vergleiche unabhängig von der zu sortierendenFolge• dies war der erste Sortierer mit Zeit O(log n) undEffizienz (1)• nur theoretisch interessant, da zu große Konstanten

d) Sortieren mit verteiltem Speicher:abhängig von Verbindungsstruktur(I) lineares FeldSortiere S = (s 1 , . . . , s n ) auf linearem Feld der Längen.Annahme: Zu Beginn enthalte P i das Element s i .Sortieren nur möglich durch Folge lokaler Operationen(Vergleichen, Vertauschen)⇒ ähnlich wie Bubble Sort (sequentiell sehr schlechtesVerfahren, da O(n 2 ) Vergleiche)Idee: Vergleiche und vertausche Daten zwischenbenachbarten Prozessoren, bis die Folge nichtfallendsortiert ist.⇒ Elementare Operation: CompEx(a, b)(a, b aus benachbarten Prozessoren)oderIF a > b THEN vertausche(a, b)a := min(a, b)b := max(a, b)

Odd-Even Transposition Sort: (OETS)Sortiere abwechselnd ungerade und gerade Paare vonDaten:FOR j := 1 TO n DOFOR i := 1 TO ⌊n/2⌋ PARDOIF odd(j)THEN CompEx(s 2i−1 , s 2i )ELSE CompEx(s 2i , s 2i+1 )(* Ann.: s n+1 = ∞ *)END (*if*)ENDPARENDAnalyse:T OETS (n) = n , p OETS (n) = nS ETS (n) = O(log n) , E OETS (n) = O( log nn )⇒ geringer Zeitgewinn, schlechte Effizienzaber auf linearem Feld mit n Prozessoren geht es nichtbesser: im schlechtesten Fall müssen P 1 und P n ihreDaten vertauschen⇒ untere Schranke Ω(n)

⇒ OETS optimal für lineare FelderKorrektheit von OETS:Beh.: nach n Odd/Even Schritten ist die Folge sortiert,ebenso nach n Even/Odd Schritten.Bew.: (durch Induktion über n)n = 1 trivialn = 2 Ein Odd- und ein Even-Schritt reichen immeraus, egal in welcher Reihenfolgen → n + 1Betrachte den ”Weg des maximalen Datums“ durchdas lineare Feld der Länge n+1 (im ”Raum-Zeit-Diagramm“, bzw. im zugehörigen Vergleichernetz)⇒ maximal n + 1 Schritte, bis das Maximum seinenPlatz (also P n+1 ) erreicht hat.Eliminiere den ”Weg des maximalen Datums“.

⇒ alle Vergleiche mit dem Maximum fallen weg(höchstens ein Vergleich pro parallelem Schritt)alle übrigen Vergleiche werden nicht beeinflusst.Die übrigen Vergleiche entsprechen den Vergleichen,die von OETS auf Folgen der Länge n in n Odd/EvenSchritten ausgeführt werden.⇒ nach Induktionsannahme wird die restliche Folgesortiert.⇒ die gesamte Folge wird in n + 1 Schritten sortiert.q.e.d.Abwandlungen:(i) Annahme: lange Folge, wenig Prozessoren, d.h. nDaten, k Prozessoren mit k

(ii) Annahmen:– Die Folge S muss von außen in das Feld eingegebenwerden.– Nur P1 hat externe Ein-/Ausgabemöglichkeit.mögliches Verfahren:Up-Down Sort (auch Zero-Time Sort)Idee:– Schiebe die Folge von links nach rechts in dasFeld und anschließend von rechts nach links wiederheraus.– Bewege dabei nur ”größere“ Daten nach rechts undnur ”kleinere“ nach links.Prozessor P i verwende Register x i .Register x 0 sei das externe Eingabe- und Ausgaberegister.(*Eingabephase*)FOR j := 1 TO n DOFOR i := 1 TO j PARDOx i := x i−1 ;IF odd(i) AND i < jTHEN CompEx(x i , x i+1 ) (*)ENDPAREND

END(* Ausgabephase *)FOR j := 1 TO n DOFOR i := 0 TO n − j PARDOx i := x i+1 ;IF odd(i) AND i < n − jTHEN CompEx(x i , x i+1 ) (**)ENDPARENDENDAnalyse:2n Takte für Eingabe und Vergleiche2n Takte für Ausgabe und Vergleiche4n Takte insgesamt.Sofern Zuweisung und CompEx jeweils in einemSchritt (Takt) ausführbar, werden nur 2n Taktebenötigt, d.h. die zur Ein-/Ausgabe erforderliche Zeit,und 0 Takte für die Berechnung !⇒ Bezeichnung Zero-Time SortKorrektheit von Up-Down Sort:Beh.: Am Ende von (*) bzw. (**) befindet sich in x 1stets das kleinste Element der im Feld gespeichertenFolge.Beweis: (leicht durch Induktion)

⇒ In der Ausgabephase wird die Folge in nichtfallenderReihenfolge sortiert ausgegeben.Bemerkungen:i) Auch Up-Down Sort kann auf Blöcke angewandtwerden, indem CompEx durch MergeSplit ersetzt wird.Dies könnte vor allem auch dann sinnvoll sein, wennder Austausch von Blöcken nicht wesentlich mehr Zeitkostet als der Austausch einzelner Daten.ii) Falls auch P n mit externem I/O verbunden wäre,könnten 2 Sortiervorgänge überlagert werden (2-WaySort).(II) 2-dimensionales FeldN = n 2 Prozessoren ein Datum pro Prozessorsortiere zeilenweise oder sortiere zeilenweise inSchlangenlinienMIMD sei erlaubt⇒ einfache untere Schranke:Datenaustausch zwischen P 1 und P N benötigtmindestens 2n − 2 = 2 √ N − 2 lokaleVertauschungen.

LS 3 -Sort (Lang, Schimmler, Schmeck, Schröder)(viele andere Verfahren zum Sortieren auf Gittern)Annahme: Sortiere zeilenweise in Schlangenlinien.1) Verschmelzen:Sei n = 2r.Verschmelze vier sortierte Felder mit n 2 /4 Prozessoren:Algorithmus Merge(n)(i) Perfect Shuffle in jeder Zeile des Feldes.(a 1 , . . . , a n/2 )(b 1 , . . . , b n/2 ) → (a 1 , b 1 , . . . , a n/2 , b n/2 )(ii) Sortiere jede Doppelspalte in Schlangenlinien (mitOETS).(iii) Wende 2n Schritte von OETS auf die gesamteMatrix als Schlangenlinie an.Ablauf von Merge:

Analyse:Schritt 1) Perfect Shuffle n/2 − 1 TakteSchritt 2) OETS auf Folgen der Länge 2n ⇒ 2n TakteSchritt 3) nach Definition 2n Takteinsgesamt 4.5n − 1 TakteKorrektheit von Merge:Ausgangssituation:e := a + b + c + d⇒ Nach Schritt 2:e gerade:e/2 volle Zeilen mit 1, maximal 2 Zeilen mit 0 und 1,restliche Zeilen nur mit 0⇒ maximal 2 unsortierte Zeilen⇒ 2n Schritte von OETS reichen aus.

e ungerade: alle Doppelspalten enthalten eine 1-Stufea) ∃ Doppelspalte ohne zusätzliche 1⇒ in allen Doppelspalten höchstens 3 zusätzliche1’en (da e ungerade)b) in jeder Doppelspalte mind. eine zusätzliche 1⇒ 1 weitere sortierte Zeile⇒ in a) und b) jeweils maximal 2 unsortierte Zeilen⇒ die 2n OETS-Schritte von Schritt 3 reichen aus.

Algorithmus LS 3 -Sort(n)1) Für n = 2 sortiere das Feld durch trivialenAlgorithmus.2) Für n > 2, wende LS 3 -Sort rekursiv auf die vierTeilfelder an (mit LS 3 -Sort( n 2)) und verschmelze diesortierten Teilfelder mit Merge(n).AnalyseT LS 3 −Sort(2) ≤ 4T LS 3 −Sort(n) ≤ T LS 3 −Sort( n 2 ) + 4.5n⇒ T LS 3 −Sort(n) = 9n − 14 ∈ O( √ N)(lässt sich auf ≈ 7n verbessern)(Vorgriff auf später:– untere Schranke für das Sortieren auf gitterverbundenenFeldern: 3n − o(n)– bestes Sortierverfahren: 3n + o(n)(beide Angaben gelten allerdings nur bezüglich eineseingeschränkten Berechnungsmodells!)

Weiteres Sortierverfahren auf gitterverbundenenFeldern:Grobsort (Schimmler)Ideen:a) Verwende ausschließlich Vergleichsoperationen(CompEx) zum Sortieren (keine reinen Vertauschungen).b) Vermeide unnötigen Aufwand im rekursiven VerfahrenDefinition: Ein n × n-Feld heißt grob-sortiert gdw füralle i ∈ [n − 1] alle Elemente der i-ten Zeile kleineroder gleich allen Elementen der (i + 1)-ten Zeile sind.⇒ Jedes grob-sortierte Feld kann mit maximal nOETS-Schritten zeilenweise oder zeilenweise inSchlangenlinien sortiert werden.Vorgehensweise von Grobsort:1) Verschmelze rekursiv grob-sortierte Quadranten zueinem grobsortierten Feld.2) Sortiere das grob-sortierte Feld gemäß dergewünschten Ordnung.

Algorithmus Grob MergeGegeben: Feld mit 4 grob-sortierten Quadranten

Analyse von Grobsort:Grob Merge:(i) Sortiere Spalten: n − 1 Takte(ii) Sortiere Halbzeilen alternierend nach links bzwrechts: n/2 Takte(iii) 2 Schritte von OETS auf den Spalten: 2 Takte(iv) Sortiere Zeilen alternierend nach links bzw. rechts:n Takte(v) Sortiere Spalten: n/2 Takteinsgesamt: 3n + 1 TakteSei GS die rekursive Version von Grob Merge, die einbeliebiges Feld in ein grob-sortiertes Feld transformiertAufwand für GS:T GS (n) = T GS ( n 2 ) + 3n + 1T GS (2) = 2⇒ T GS (n) = 6n + O(log n)⇒ 7n + O(log n) Schritte für das Sortieren inzeilenweiser oder zeilenweiser Schlangenlinien-Ordnung.

Optimaler Algorithmus von Thompson, Kung (1977):nicht 4-Weg-, sondern s 2 -Weg-Merge:s 2 vorsortierte Teilfelder werden bitonischverschmolzen.Für s ≈ n 1/3 erhält man T (n) = 3n + O(n 2/3 log 2 n)

Untere Schranken(Für das Sortieren auf gitterverbundenen Feldern)Gegeben:– gitterverbundenes Feld mit z Zeilen und s Spalten– geordnete Datenmenge DJeder Prozessor enthalte zu Beginn ein beliebiges Elementaus D in seinem Kommunikationsregister undbeliebige weitere Elemente in seinem lokalen Speicher.Jeder Prozessor kann in jedem Takt die Inhalte derKommunikationsregister seiner Nachbarn lesen, beliebigeOperationen ausführen und seinen eigenen Speicherbereichverändern.Die Inhalte der Kommunikationsregister seien zeilenweiseoder zeilenweise in Schlangenlinien zu sortieren.⇒ triviale untere Schranke s + z − 2Nichttriviale untere Schranke:Im folgenden seien z ≥ 2 √ s und |D| > 2s · zOBdA [−s · z, s · z] ⊂ DSei A ∈ D s×z eine Anfangsbelegung mit{a ij | i ∈ [z], j ∈ [s]} = {1, 2, . . . , s · z}

Wesentliche Idee: Betrachte einen ausgezeichnetenBereich des Feldes ( ”Joker-Zone“) und untersuche,wie die Anfangsbelegung dieser Zone den Sortiervorgangbeeinflusst.Wähle als Joker-Zone das kleinstmögliche Dreieck inder rechten unteren Ecke des Feldes, so dass unterhalbder Diagonalen mindestens 2s Elemente liegen.Für die Anfangsbelegung A gelte, dass die Elemente inder Jokerzone größer sind als alle anderen.Sei Sort ein beliebiges Sortierverfahren auf dem z × s-Feld.Weitere Annahme: Nach jedem Schritt von Sort enthältjeder Prozessor genau ein Element der zu sortierendenFolge.⇒ Sort benötigt mindestensz − 2 √ s + s − 1Takte, bis Prozessor (1, 1) Informationen über denInhalt der Joker-Zone erhält.

Sei a das in diesem Takt in (1, 1) gespeicherte Datum⇒ a stammt also nicht aus der JokerzoneSort bewegt a anschließend an seine endgültige Position.Sei j die Nummer der Spalte in der dieser Position.Setze den Joker ein: Verändere A durch Wahl andererDaten in der Joker-Zone so zu einer Matrix A ′ , dass abeim Sortieren von A ′ in Spalte s landet.⇒ höchstens 2s − 1 negative Werte erforderlich, uma in Spalte s zu schieben (höchstmögliche Zahl kannauftreten bei Schlangenliniensortierung).⇒ nach den ersten z − 2 √ s + s − 1 Takten benötigtSort mindestens s − 1 weitere Schritte, um a in Spaltes zu bewegen.⇒ T Sort (n) ≥ z + 2s − 2 √ s − 2⇒ T Sort (n) ∈ z + 2s − O( √ s)• für s = z = n ⇒ untere Schranke 3n − O( √ n)• für s = n/ √ 2, z = √ 2 · n ⇒ untere Schranke2 √ 2 · n − O( √ n)

s 2 -Way-Merge Sort ist in jedem dieser Fälle optimal!aber• Für SIMD ist bestes Verfahren bei 6n + o(n) undkeine bessere untere Schranke bekannt als fürMIMD.• Ohne Annahme (*) (d.h. die Prozessoren dürfenwährend des Sortierens mehr als ein Element derFolge speichern) gilt nur die triviale untere Schrankeund es gibt für diesen Fall auch schnellereSortierverfahren!(siehe Nigam, Sahni 1995)Es gibt zahlreiche Arbeiten über untere Schranken fürandere Sortier-Ordnungen (zeilenweise, spaltenweise,spiralförmig,...) und andere Rechnerstrukturen (Gittermit Wrap-Around, lineares Feld, Kreis,...).

(III) Mesh-of-TreesStruktur: n × n-Gitter von Prozessoren (Blatt-Prozessoren). Zusätzlich gibt es über jede Spalte undjede Zeile einen Baum von Prozessoren (Spalten-,Zeilenbaum).Algorithmus MoT (Leighton 1983)1) Verteile die zu sortierende Folge der Länge n überdie Zeilen- und Spaltenbäume des Mesh-of-Trees andie Blatt-Prozessoren.2) Vergleiche die Daten in den Blatt-Prozessoren;Ergebnis: 1 für a > b, 0 für b ≤ a.3) Sende die Ergebnisse zu den Spaltenbaumwurzelnund addiere sie dabei (⇒ Rang des Datums x i stehtin Wurzel i)

4) Verwende die binäre Darstellung des Ranges, umden rangrichtigen Weg durch den Spaltenbaum zueinem Blatt zu gehen.5) Gib die Werte von den erreichten Blatt-Prozessorenaus über die Zeilenbäume aus.

Analyse:Schritt 1) log n TakteSchritt 2) 1 TaktSchritt 3) log n TakteSchritt 4) log n TakteSchritt 5) log n TakteGesamt: 4 log n + 1 Takte3n 2 − 2n Prozessoren werden verwendet (inklusiveSpalten- und Zeilenbäume)⇒ wesentlich schlechtere Effizienz als z.B. bei Cole SortBemerkung: Die Spalten- und Zeilenbäume könnenals Mechanismen zum Auflösen von Lese-/Schreibkonflikteneiner CRCW-PRAM aufgefasst werden.

Matrix-OperationenMatrix-TranspositionA =⇒ A T =⎛⎜⎝⎛⎜⎝⎞a 11 a 12 . . . a 1na 21 a 22 . . . a 2n⎟. . . ⎠a n1 a n2 . . . a nn⎞a 11 a 21 . . . a n1a 12 a 22 . . . a n2⎟. . . ⎠a 1n a 2n . . . a nnCharakteristik: hoher Kommunikationsaufwand, wenigBerechnungsaufwandSequentieller Algorithmus:PROCEDURE Transponiere ABEGINFOR i := 1 TO n DOFOR j := 1 TO i − 1Vertausche(a ij , a ji )ENDENDEND⇒ Aufwand: O(n 2 )Optimal, da mindestens Ω(n 2 ) Operationen erforderlich

Parallele Lösungenauf einem gittervebundenen Feld:n × n Feld, pro Prozessor ein Datum, P ij enthalte a ijLösung 1:Transponieren durch Sortieren1) Bilde in allen P ij Paare (s ij , a ij ) mits ij = (j − 1) · n + i2) Sortiere die Paare im Feld in zeilenweiser Ordnung(⇒ (s ij , a ij ) wandert nach P ji )⇒ Aufwand: 3n+o(n) (allerdings doppelt lange Daten)Geht es besser? Sollte eigentlich möglich sein, da mannicht alle verfügbaren Informationen nutzt: beim Sortierenwird die Kenntnis der exakten Zieladresse nichtgenutzt.

Lösung 2Jeder Prozessor P ij enthalte 3 Register A ij , B ij , C ijA ij enthalte anfangs a ij und am Ende a jiB ij speichere Daten vom unteren oder linken NachbarnC ij speichere Daten vom oberen oder linken NachbarnIdee: Sende jedes a ij entlang Spalte j bis P jjund dann entlang Zeile j bis P jiFür jedes Matrixelement wird gezählt, wie lange esbis zum Diagonalprozessor braucht, und anschliessendwird es über die gleiche Distanz über die Zeile zumZielprozessor geschickt:

1) FOR i, j := 1 TO n PARDOi < j: C ij := (A ij , 0) || B ij := (0, −1)i > j: B ij := (A ij , 0) || C ij := (0, −1)i = j: B ij := C ij := (0, −1)PAREND2)FOR t := 1 TO 2n − 2 DOFOR i, j := 1 TO n PARDOi = j: IF i < n THEN B ij := B i+1,j ||IF i > 1 THEN C ij := C i−1,ji < j:IF i > 1 THEN C ij := (C i−1,j (1), C i−1,j (2)+1)||IF B i,j−1 (2) = 0THEN A ij := B i,j−1 (1)ELSE B ij := (B i,j−1 (1), B i,j−1 (2) − 1)i > j:IF i < n THEN B ij := (B i+1,j (1), B i+1,j (2) +1)||IF C i,j+1 (2) = 0THEN A ij := C i,j+1 (1)ELSE C ij := (C i,j+1 (1), C i,j+1 (2) − 1)PARENDEND⇒ MIMD-Algorithmus

Zeitaufwand: 2n − 1 Takte⇒ fast optimal (bis auf einen Takt)Kombiniert man die ersten beiden Schritte, erhält mansogar genau 2n − 2 Takte.Lösung 3: Divide-and-Conquer AnsatzA =( )A1 A 2A 3 A 4⇒ A T =( AT1 A T 3A T 2 A T 4)⇒ Idee: Transponieren durch rekursives Vertauschenvon Blöcken (Teilmatrizen)A =( )A1 A 2A 3 A 4→→( )A1 A 3A 2 A 4( )A2 A 1A 3 A 4→→(AT1 A T 3A T 2 A T 4( )A3 A 1A 2 A 4)Zeitaufwand im n × n-Feld:Schritt 1, 2, 3: jeweils n/2 TakteSchritt 4: T (n/2) TakteT (n) = T (n/2) + 1.5nT (2) = 3⇒ T (n) = 3n − 3

Transponieren mit EREW-SM-SIMD-PRAM:trivialer Algorithmus: Verwende Prozessoren P ij2 ≤ i ≤ n und 1 ≤ j < i⇒ (n 2 − n)/2 ProzessorenmitPROCEDURE EREW-transpose(A);BEGINFOR i := 2 TO n PARDOFOR j := 1 TO i − 1 PARDOP ij vertausche a ij und a ji ;PARENDPARENDEND⇒ Zeit: O(1), Parallelitätsgrad: O(n 2 )⇒ kostenoptimalaber: Wie wird die Ausführung dieses Algorithmusdurch die üblichen Verbindungsnetze (Permutationsnetzwerke)unterstützt?

Beispiel: Butterfly-NetzwerkWeg zum Ziel über binäre Darstellung der Zieladresse:0 nach “oben”1 nach “unten”Sofern über jede Leitung nur ein Datum pro Takt laufenkann, gibt es “Staus”, d.h. die Permutation kann nichtin Zeit O(log n) ausgeführt werden, sondern benötigtbis zu Ω( √ n) Takte bei n Prozessoren, da es sein kann,daß bis zu Ω( √ n) Daten über eine Leitung geschicktwerden!Derartige SStaustreten bei vielen praxisrelevanten Permutationenauf (Transposition, Perfect Shuffle, bitreversal-Permutation,...)⇒ generelles Problem!

Beobachtung: Für (fast) jedes Verbindungsnetz enthaltendie in typischen Anwendungen häufig vorkommendenPermutationen gerade die schlechtesten Fälle!Dies gilt zumindest für systematisch konstruierte Netzemit regulärer Struktur!Auswege:a) “random routing”: Schicke alle Nachrichtenzunächst an zufällig ausgewählte Zieladressen und erstdanach an die Originaladresse.⇒ im Mittel gutes (O(log n)) Verhalten (wird bei derCM5 eingesetzt!)b) “random wiring”: Verdrahte das Butterfly-Netzzufällig unter gewissen Einschränkungen (Leitungennach oben (unten) bleiben Leitungen nach oben (unten),verwende doppelt so viele Leitungen).⇒ kein schlechtes Verhalten mehr– besser als unter (a)– wesentlich höhere Fehlertoleranz gegenüberLeitungsausfällen.

Bemerkung: Message-Routing-Algorithmen sind Gegenstandintensiver Forschungs- und Entwicklungstätigkeit,da es ohne gute Routing-Algorithmenkeine guten Parallelrechner geben kann (wesentlicheStichworte:wormhole routinghot-potato routingrandom routingIn dieser Vorlesung leider keine Zeit für diesen Bereich!(siehe z.B. Buch von Leighton)

MatrixmultiplikationGegeben: Matrizen A ∈ R n×p ,B ∈ R p×mR sei mindestens ein Halbring, in der Regel ein Ringoder auch ein Körper z.B. Z, Q, R oder C.Berechne0B@C ∈ R n×m mit C = A · Bd.h. für alle i ∈ [n], j ∈ [m] c ij = ∑ pk=1 a ik × b kja 11 a 12 . . . a 1p @b 11 b 12 . . . b 1ma 21 a 22 . . . a 2p b 21 b 22 . . . b 2m. ... . .a n1 a n2 . . . a np b p1 b p21CA. . . b@pmc 11 c 21 . . . c n1c 12 c 22 . . . c n2. . .=0 B1CA·0 BSequentiell: Schulmethodec 1n c 2n . . . c nnFOR i := 1 TO n DOFOR j := 1 TO m DOc ij := a i1 ∗ b 1j ;FOR k := 2 TO p DOc ij := c ij + a ik ∗ b kjENDENDENDAufwand: O(n · m · p) bzw. O(n 3 ) für n = m = p1CAasymptotisch bessere Methoden bis O(n 2.37 ) für quadratischeMatrizen (Strassen, Winograd, Schönhage)

Im weiteren nur quadratische MatrizenParallele LösungenLösung 1: CREW-SM-PRAMIdee: Berechne alle n 2 Skalarprodukte gleichzeitig.Verwende jeweils n Prozessoren pro Skalarprodukt.⇒ ⌈log n⌉ + 1 Takte pro c ij , n 3 ProzessorenConcurrent Read erforderlich, da stets gleichzeitig nProzessoren auf jedes Matrixelement zugreifen.Andernfalls zunächst jedes Matrixelement an n Prozessorenverteilen.⇒ auf EREW 2 × ⌈log n⌉ + 1 TakteAuf CRCW ebenfalls Ω(log n), da nur zweistellige Operationenzur Verfügung stehen, um aus 2n Daten einenWert zu berechnen, der von allen 2n Daten beeinflußtwird (fan-in vom Grad 2n).

Verwendet man CRCW mit der Schreibregel SUM, sosinkt die Zeit auf O(1), offensichtlich ist dies jedochbei diesem Problem eine zu mächtige Operation.Verbesserung der Gesamtkosten:Verwende statt n 3 nur n 3 / log n Prozessoren:1) Berechne in jedem Prozessor sequentiell ein Skalarproduktvon Vektoren der Länge log n.2) Kombiniere die Teil-Skalarprodukte zu den endgültigenSummen c ij .Schritt 1: 2 log n − 1 TakteSchritt 2: RestBaumtiefe ⌈log n⌉ + 1 − log log n − 1⇒ Zeit < 3 × log n⇒ Gesamtkosten in O(n 3 )⇒ optimal (im Vergleich zur Schulmethode)

Lösung 2: Gitterverbundenes FeldIdee: Jeder Prozessor habe Register A, B, C.– Schiebe Matrix A von links nach rechts durchdas Feld und gleichzeitig Matrix B von oben nachunten.– Am Ende der Berechnung steht c ij in ProzessorP ij .

genauere Formulierung:1) FOR i, j := 1 TO n PARDOP ij setze C ij auf 0PAREND2) FOR t := 1 TO 3n − 2 DOFOR i, j := 1 TO n PARDOIF i + j − 1 ≤ t AND t < i + j + n − 1THEN A ij := A i,j−1 ||B ij := B i−1,j ||C ij := C ij + A i,j−1 · B i−1,jENDPARENDENDBei Zugriffen auf A i,0 bzw B 0,j werden die Komponentender Matrizen A und B entsprechend demangegebenen Schema eingegeben.– in n weiteren Takten könnte die ProduktmatrixC über den Rand ausgegeben werden– inklusive I/O 4n − 1 Takte– kostenoptimal (bzgl. der Schulmethode), dan 2 ProzessorenVarianten:a) Bewege A und C, lasse B fest im Feld.b) Bewege B und C, lasse A fest im Feld.c) A, B und C bewegen sich (nicht ganz so einfach).

Genaueres zu Variante c:A, B und C bewegen sich:

weitere Idee: Führe zwei ineinander verschränkte Matrixmultiplikationen“gleichzeitig” aus:⇒ gleiche Zeit pro Berechnung, aber “Periode” (d.h.mittlerer Abstand) von n Takten

Problem: (Partitionierungsproblem) Multipliziere n·k × n · k-Matrizen auf einem Prozessorfeld der Größen × (2n − 1), d.h. für n × n-Matrizen.Ideen:a) Fasse die Matrizen als n × n-Matrizen auf, derenKomponenten k×k-Matrizen sind, d.h. jeder Prozessorberechnet k × k-Matrixprodukte und -summen.⇒ grobkörnige Parallelität bzw.– lokal sequentiell– global parallelanwendbar auf jeder der betrachteten Strukturen⇒ 4n − 2 “Takte”, pro Takt ein k × k-Matrixproduktund eine k × k-MatrixsummeZeit: O(k 3 n) (bei Verwendung der Schulmethode fürlokale Matrixmultiplikation)bzw. O(k 2.81 n) (bei Verwendung des Verfahrensvon Strassen für lokale Matrixmultiplikation)Parallelitätsgrad: 2n 2 − n

) Fasse die Matrizen als k × k-Matrizen auf, derenKomponenten n × n-Matrizen sind, d.h. das Prozessorfeldberechnet eine geeignete Folge von n × n-Matrixprodukten.⇒ feinkörnige Parallelität bzw.– lokal parallel– global sequentiell⇒ k 3 “Makrooperationen” (n × n-Matrixprodukte)mit Periode n (d.h. mittlerer Abstand zwischenBeginn der einzelnen Makrooperationen)Zeit: k 3 nParallelitätsgrad: 2n 2 − noptimale Kosten (besser als Variante a!)

Lösung 3: Verteilter Speicher, BaumstrukturBerechnung verläuft von der Wurzel zu den Blätternund zurück:Jeder Knotenprozessor P führe folgendes aus:– Falls P vom Vater Matrizen A, B erhält, die zumultiplizieren sind, und falls die Söhne frei sind, teileBerechnung auf:linker Sohn multipliziere A oben und B (oder A undB links)rechter Sohn multipliziere A unten und B (oder Aund B rechts)

sonst führe Berechnung selbst aus und gib Ergebnismatrixan den Vater wieder zurück.– Kombiniere von den Söhnen erhaltene Ergebnismatrizenzu neuer Ergebnismatrix und gib diese weiternach oben zum Vater.Zeitbedarf in Baum mit N = n 2 freien Blättern:– 2 log n Takte für Weg von der Wurzel zu denBlättern– 2n − 1 Takte für Skalarprodukte– 2 log n Takte für “Rückweg” zur Wurzelaber: große Bandbreite für Datentransport erforderlich,es sei denn, es werden beim Aufteilen und beim Kombinierennur die Indexgrenzen der zu bearbeitendenMatrizen weitergegen

Lösung 4: Mesh-of-TreesIdee: Gib die Zeilen von A über die Zeilenbäume ein undgleichzeitig die Spalten von B über die Spaltenbäume.⇒ n SchritteBerechne die c ij in den Blattknoten.⇒ n Schritte, Beginn nach log n − 1 SchrittenGib C über die Zeilenbäume aus⇒ n + log n − 1 Schritte⇒ p MoT (n) = 3n 2 −2nS MoT (n) ∈ Θ(n 2 )T MoT (n) = 2n+2 log n−2E MoT (n) ∈ Θ(1)Bemerkung: auf 3-dimensionalem Mesh-of-Trees Matrixmultiplikationin Zeit O(log n) möglich!

Matrix-InversionInvertierung von Matrizen ist zentrale Operation fürdie Lösung linearer Gleichungssystemesequentiell:Anzahl Operationen für– Matrix-Inversion– Matrix-Multiplikationvon der gleichen GrößenordnungJeder sequentielle Algorithmus für die Matrix-Multiplikation liefert Algorithmus für die Matrix-Inversion mit asymptotisch gleicher Laufzeit (und umgekehrt).Zum Beispiel:Wenn mann eine n × n-Matrix in Zeit I(n) invertierenkann, mit I(n) = Ω(n 2 ) und es gilt I(3n) = O(I(n)),dann kann man zwei n × n-Matrizen in Zeit O(I(n)multiplizieren.Dazu betrachteD =⎛⎝ I ⎞n A 00 I n B ⎠0 0 I nDann giltD −1 =⎛⎝ I ⎞n −A AB0 I n −B ⎠0 0 I n

parallel:Vermutung (von I. Munro, 1973): mindestens Ω(n) fürparallele Matrix-InversionCsanky 1976: Matrix-Inversion in Zeit O(log 2 n) mitO(n 4 ) Prozessoren– verwendet u.a.parallele Matrix-MultiplikationInversion einer Dreiecksmatrix in Zeit O(log 2 n)– entsteht nicht durch Parallelisierung einessequentiellen Algorithmus, sondern durch völligneuen Ansatzwird in dieser Vorlesung nicht genauer behandelt.

Graph-AlgorithmenViele “angewandte Problemstellungen” können als Problemeauf Graphen formuliert werden, z.B.Erreichbarkeit, transitive Hülle, kürzeste und längsteWege; Spannbäume; Zusammenhangsuntersuchungen,Zerfällungsknoten, Brücken; Färbbarkeit; Flußprobleme,...Große Vielfalt paralleler Graph-Algorithmenhier betrachtetes Problem: Transitive Hülle– zentrales Problem für viele Anwendungen, d.h.schnelle Algorithmen für die Berechnung der transitivenHülle führen zu schnellen Algorithmen für einegroße Klasse von Problemen.Problemstellung:Gegeben: Boolesche n×n-Matrix A (Adjazenzmatrix)Gesucht: Transitive Hülle C = A +d.h. C ist die “kleinste” Matrix (bezüglich derAnzahl der Elemente ungleich 0), so daß für allei, j, k ∈ [n](i) a ij = 1 ⇒ c ij = 1(ii) c ik = 1 ∧ c kj = 1 ⇒ c ij = 1

Sequentielle Lösung: Warshall-AlgorithmusIdee: i und j sind über einen Weg verbunden,– wenn sie direkt verbunden sind, oder– wenn i mit einem Knoten k verbunden ist, vondem auch ein Weg zu Knoten j führt.FOR k := 1 TO n DOFOR i := 1 TO n DOFOR j := 1 TO n DOa ij := a ij ∨ a ik ∧ a kjENDENDENDEigenschaft: nach k-tem Schritt gilt a ij = 1 gdw.ein Weg von i nach j existiert, der höchstens dieKnoten 1, . . . , k als innere Knoten hat.⇒ Algorithmus ist korrektZeitaufwand: O(n 3 )

Parallele Lösung auf gitterverbundenem FeldIdee: geeignete Übertragung des Warshall-AlgorithmusBerechne in Prozessor (i, j) für k = 1, . . . , na ij := a ij ∨ a ik ∧ a kj1. Schritt: Bewege die erste Zeile von oben nach untenund speichere dabei die Werte in den durchlaufenenProzessoren.2. Schritt: Bewege die erste Spalte von links nach rechtsund speichere dabei die Werte in den durchlaufenenProzessoren.⇒ Prozessor (i − 1, j − 1) enthält a ij , a i1 und a 1j , d.h.für k = 1 kann die Berechnung a ij := a ij ∨a ik ∧a kjausgeführt werden.

⇒ n-malige Ausführung der für k = 1 beschriebenenSchritte simuliert den Warshall-Algorithmus.aber: Werden die Schritte 1 und 2 sowie die anschließendeBerechnung strikt nacheiander ausgeführt (wiez.B. entsprechend dem SIMD-Prinzip) so benötigt mann-mal eine Zeit von O(n), also insgesamt O(n 2 ).Verbesserung: Führe den Algorithmus in n Berechnungswellendurch, die sich diagonal von links nachrechts unten durch das Feld bewegen.Da jede Berechnungswelle aus einer konstanten Zahlvon Diagonalen besteht, liegt die Gesamtzeit für dieAusführung der n Berechnungswellen in O(n).⇒ optimaler Zeitgewinn gegenüber der sequentiellenAusführung des Warshall-Algorithmus.

Frage: Wie formuliert und wie implementiert man dieAusführung von “Berechnungswellen”?a) gemäß dem SIMD-Prinzip:Auf den Diagonalen der Berechnungswellen stehen jeweilsdie gleichen Befehle, d.h. in jeder Berechnungswelle treten nur konstant viele verschiedene Befehleauf.⇒ Simuliere nacheinander diese verschiedenen Befehlegemäß dem SIMD-Prinzip.⇒ Verlängerung der Ausführungzeit um einen konstantenFaktor.b) asynchron gemäß dem Prinzip der WavefrontArrays:Befehle werden in den Prozessor in der linken oberenEcke eingegeben und dann nach Ausführung an dieProzessoren der nächsten Diagonalen weitergegeben.⇒ Erfordert die explizite Synchronisation (Handshaking)für Datenaustausch mit benachbarten Prozessorenwährend der Befehlsausführung.Dies kann auch als SIMD-Algorithmus aufgefaßt werden,da pro Takt nur ein Befehl eingegeben wird, derzeitversetzt in allen Prozessoren ausgeführt werden soll.

c) gemäß dem Prinzip befehlssystolischer Felder:Zwei orthogonale “Befehlsströme” (vertikal Befehle,horizontal Selektoren) wandern durch das Feld.Jeder Prozessor holt vom oberen Nachbarn einen Befehlund vom linken Nachbarn einen Selektor.Befehle werden überall dort ausgeführt, wo sie auf einenSelektor 1 treffen, andernfalls wird NOOP ausgeführt.Jede “Befehlsdiagonale” des Befehlsstroms wird mitgenau einer “Selektordiagonalen” des Selektorstromskombiniert. (Beispiel: Zeilenrotation, Spaltenrotation)⇒ Ideal geeignet für Formulierung und Implementierungdes Algorithmus für die transitive Hülle.

Weitere Beispiele und grundsätzliche BemerkungenProblem: Berechne die n-te Potenz einer Zahl x ∈ K,(dabei sei K ein beliebiger Körper)Sequentiell: fortgesetztes Quadrieren und Multiplizieren⇒ Zeit: O(log n)Parallel:ein Prozessor quadriert, zweiter Prozessor multipliziert⇒ Zeit: O(log n)kein nennenswerter Zeitgewinn

Problem: Berechne die n-te Fibonacci-Zahl:F ib(0) = F ib(1) = 1F ib(n) = F ib(n − 1) + F ib(n − 2)Sequentiell:naiv rekursiv: Zeit O(2 n )naiv iterativ: Zeit O(n)klug iterativ: Zeit O(log n)Ansatz:( F ib(n + 1)F ib(n))=( 1 11 0)·( F ib(n)F ib(n − 1))(F ib(n + 1) F ib(n)F ib(n) F ib(n − 1))=(1 11 0) n+1Parallel: Wohl kaum besser als O(log n).⇒ Für beide Beispiele keine Verbesserung durch paralleleLösung!

Allgemeine Aussage über Parallelisierbarkeit:Satz Erfordert die Berechnung eines Elementes x einesKörpers K genau a ≥ 1 zweistellige arithmetischeOperationen, so benötigt die kürzeste k-parallele Berechnungvon x mindestens⌈(α + 1 − 2 ⌈log k⌉ )/k)⌉ + ⌈log k⌉parallele Schritte, falls α > 2 ⌈log k⌉ ist, und sonstparallele Schritte.⌈log α + 1⌉Beweis:t := Zeit, die irgendein k-paralleler Algorithmusbraucht, um x zu berechnen (mit zweistelligen Operationen!!)Betrachte die Berechnung rückwärts:Schritt:t: 1 Prozessor arbeitett − 1: 2 Prozessoren arbeitent − 2: 4 Prozessoren arbeiten...t − r: min(2 r , k) Prozessoren arbeitena) a > 2 ⌈log k⌉ − 1 = ∑ ⌈log k⌉i=12 i−1 ⇒ t > ⌈log k⌉

⇒ #op≤ 1 + 2 + . . . + 2 ⌊log k⌋ + k + . . . + k= k(t − ⌈log k⌉) + 2 ⌈log k⌉ − 1⇒ α ≤ k(t − ⌈log k⌉) + 2 ⌈log k⌉ − 1= kt − k⌈log k⌉ + 2 ⌈log k⌉ − 1⇒ t ≥ ⌈(α + 1 − 2 ⌈log k⌉ )/k)⌉ + ⌈log k⌉b) α ≤ 2 ⌈log k⌉ − 1 ⇒ α ≤ 2 t − 1⇒ t ≥ ⌈log(α + 1)⌉ qedMan kann also bei zweistelligen Operationen nichterwarten, mit weniger als logarithmischer Zeit auszukommen(wegen des abschließenden“fan-ins” bei derBerechnung eines einzigen Endergebnisses).Frage:Kann man jedes sequentiell in polynomieller Zeitlösbare Problem parallel in polylogarithmischer Zeit(d.h. in O(log kn) für ein k ∈ N) mit polynomiellemParallelitätsgrad lösen?Diese Frage ist offen, man könnte sie lösen, wenn manein einziges P-vollständiges Problem in polylogarithmischerZeit parallel lösen oder zeigen könnte, daß diesnicht möglich ist.Frage: Wie kann man parallele Algorithmen an andereProzessorzahlen anpassen?

Satz: (Satz von Brent)Sei A ein beliebiger paralleler Algorithmus mitT A,∞ (n) = t(n), der insgesamt α(n) arithmetischeOperationen ausführe. Dann gilt für jedes p ∈ NT A,p (n) = O(α(n)/p + t(n))Beweis: Offensichtlich gilt α(n) = ∑ t(n)i=1 α i , wobei α idie Anzahl der arithmetischen Operationen im (parallelen)Schritt i ist.⇒ mit p Prozessoren ist Schritt i in Zeit α i /p + 1ausführbar.⇒ T α,p ≤ ∑ t(n)i=1 (α i/p + 1) ∈ O(α(n)/p + t(n))also:q.e.d.• theoretisch lässt sich jeder parallele Algorithmus effizientan kleinere Parallelitätsgrade anpassen• praktisch kann die Zuordnung von Operationen zuProzessoren jedoch schwierig sein.• Es lohnt sich immer, zur Erhöhung der Effizienzden Parallelitätsgrad zu erniedrigen, so lange dabeiα(n)/p in O(t(n)) bleibt.

3 Hardware-AlgorithmenAlgorithmen werden Hardware-Algorithmen genannt,wenn sie direkt durch Hardware implementiert werden• durch (einzelne) höchstintegrierte Schaltkreise(auch VLSI-Chips, VLSI=Very Large Scale Integration)• durch Kombination von VLSI-Chips auf einer Leiterplatte(auch MCM = Multi Chip Modules)• durch direkte Verbindung höchstintegrierter Schaltkreiseauf einem Wafer (Siliziumscheibe)Hardware-Implementierung ist sinnvoll• wenn ein Algorithmus (bzw. eine Berechnung) sehrhäufig ausgeführt werden muß.• wenn die “Randbedingungen” der Berechnungen(d.h. z.B. Problemgröße, Datenrate) sich nicht (oderzumindest nicht wesentlich) ändern.• wenn der Durchsatz (=Berechnungen pro Zeiteinheit)wichtiger ist als die Ausführungszeit einer einzigenBerechnung.

Typische Einsatzgebiete für Hardware-Algorithmen:• Arithmetik: Addition, Multiplikation,... im Rechnerkern,Vektorprozessoren Operationen auf Matrizen• Signal- und Bildverarbeitung: Filter (DFT, Mittelwert,Median,...) Signalverstärkung, -kompression,Mustererkennung sichere Kommunikation schnelleVer- und Entschlüsselung von Daten (RSA-Kryptosystem,...)• Echtzeitverarbeitung: Prozeßsteuerung,...• eingebettete Systeme: Nutzung mikroelektronischerBauelemente innerhalb von komplexen technischenSystemen (Waschmaschine, Pkw, Fernseher, Telefon,...)Höchstintegrierte Schaltkreise, die anwendungsspezifischnur einen einzigen Algorithmus realisieren, heißenauchApplication Specific Integrated Circuits= ASIC’sDa Hardware-Algorithmen in der Regel durch VLSI-Chips realisiert werden, heißen sie auch (und von nunan) VLSI-Algorithmen.

BerechnungsmodellVorbemerkungen:Integrationsdichte: (für Logikchips, nicht für Speicherchips)≈ 0.5 Milliarden Transistoren/Chiptheoretische Grenze? (frühere Voraussagen haben sichals falsch erwiesen!)Integrationsdichte bestimmt durch minimale Leiterbahnbreited.h. durchλ = maximal zu erwartende Ungenauigkeit bei derProduktion= maximale zu erwartende Abweichung vomgewünschten Abstand zweier geometrischer Objekte(auch: maximale optische Auflösung des Herstellungsprozesses)minimale Leiterbahnbreite < 0.1µ möglich

Fehlerquellen:• Übertragung der Maske auf den Wafer(Lithographie-Technik: Optisch, Elektronenstrahl,Röntgenstrahl, Ionenstrahl, ...)• Ätzvorgänge (Ungenauigkeiten bei der Ausführungchemischer Prozesse)• Genauigkeit der Justierung aufeinander folgenderMasken (in der Regel ca. 20 Masken, oft auchwesentlich mehr)Regeln für den Entwurf von VLSI-Schaltkreisen werdenhäufig durch λ parametrisiertBeispiel: MOSIS-Entwurfsregeln für SCMOS Technologie:

Probleme bei Erhöhung der Integrationsdichte:• zu große Miniaturisierung (Leiterbahnbreite entsprichtrelativ wenigen Molekülen)• zu kleine Ladungen (einige 1.000 Elektronen)• zu anfällig für Fehler während des Betriebs (z.B.“electro migration” = materielle Veränderungen• Grenze für IntegrationsdichteProbleme, die Integrationsdichte noch weiter zuerhöhen, führen zu Versuchen, die Chip-Fläche zu vergrößern.⇒Probleme mit der “Ausbeute”:Sei p die Wahrscheinlichkeit für einen fehlerfreienChip der Fläche A.⇒ fehlerfreier Chip der Fläche c · A mit Wahrscheinlichkeitp c⇒ Vergrößerung der Fläche führt zu exponentiellschlechterer Ausbeute⇒ exponentiell höhere Kosten

Beispiel: Verdoppelung der Kantenlänge⇒ Vervierfachung der Chipfläche⇒ möglichst viel Rechenleistung auf möglichst kleinerFläche realisieren oderVerunreinigungen, Fehler in Kauf nehmenfehlertolerante Schaltkreise entwerfenIdee: wafer-scale integrationviele Schaltkreise auf einem Wafer integrieren undmit fehlertoleranter Verbindungsstruktur verbinden,um fehlerhafte Bereiche zu umgehen (Idee hat sichnicht durchgesetzt).

Vorteile der VLSI Technologie1. Realisierung komplexer Schaltwerke auf kleinemRaum2. Geringer Kostenaufwand für die Herstellung beliebigvieler Kopien⇒ kostengünstige Entwicklung und Realisierung von- leistungsfähigen Mikroprozessoren- häufig benötigten SpezialrechnernFragestellungen bei der Untersuchung von VLSI-Algorithmen:Was ist ein geeignetes Modell für VLSI-Hardware?(Rechnergraph, Kommunikationsgraph)Welche Verbindungsstrukturen (Kommunikationsgraphen)können am besten für wichtige Operationenwie Sortieren, Matrixmultiplikation, DFT, ... verwendetwerden?

Welches ist das beste Layout für einen Schaltkreis(Rechnergraphen)? Layout: Einbettung des Graphen inein Gitter:Welche Algorithmen sind VLSI-gerecht? (d.h. gut angepaßtan die Anfordungen und Möglichkeiten der VLSI-Technologie)Wie läßt sich die Funktion von VLSI-Hardware testen?

Definition des Berechnungsmodells:VLSI-Algorithmus V über Datenbereich D mit |D| ≥2 wird beschrieben durch ein Tripel V = (G, L, S),bestehend aus• dem Rechnergraphen G (auch Berechnungs- oderKommunikationsgraph, beschreibt die Hardware-Struktur bzw. die Topologie von V )• dem Layout L (beschreibt die Einbettung von Gin einen im wesentlichen zweidimensionalen Raumbzw. die Geometrie von V )• dem I/O-Schema S (legt Zeiten und Orte fest,zu bzw. an denen Eingaben erwartet werden oderAusgaben verfügbar sind)Genauer:Rechnergraph: endlicher gerichteter Graph G =(N, E) mit• Knotenmenge N = N I ∪ N O ∪ N L , bestehend aus– I/O-Knoten ∈ N I ∪N O (externe Ein-/Ausgängevon V , insgesamt p Eingänge, q Ausgänge)– logischen Knoten ∈ N L (Schaltelemente, Zellen)Jeder logische Knoten a ∈ N L ist endlicher Automatmit Zustandsmenge Z a und Übergangs-/Ausgabefunktion:

f a : Z a × D n a→ Z a × D m az, d Zustand und Eingabe von a im Takt t,⇒ (z ′ , d ′ ) = f a (z, d) ∈ Z a × D m aZustand und Ausgabe im Takt t + 1– n a (interne) Eingänge (intern im Gegensatz zuden externen Eingängen des Rechnergraphen)– m a (interne) Ausgänge⇒ logische Knoten sind Moore-Automaten(bzw. zustandsabhängige Automaten).• E Menge der gerichteten Kanten:– Jede Kante führt von einem Ausgang eines Knotena zu einem Eingang eines Knoten b.– Kein Inputknoten ist Ziel einer Kante, kein Outputknotenist Quelle einer Kante.– Jeder (interne) Eingang eines Knoten ist Zielmindestens einer Kante.⇒ Rechnergraph erlaubt die Modellierung einesVLSI-Algorithmus auf sehr unterschiedlichen Abstraktionsniveaus.

Layout:Einbettung von G in den 3-dimensionalen Raum.Festgelegt wird• die Lage der Knoten (“placement”)• der Verlauf der Kanten (“routing”)• die Größe und Form der Knoten und Kanten (“Dimensionierung”)Wesentlich beeinflußt durch Technologie der Realisierung,in der Regel zweidimensional (“mehrschichtigeEbene”).Eigenschaften:• (L1) Das Layout liegt in einem konvexen Gebiet derEbene.• (L2) In jedem Punkt können sich n Kanten kreuzen.(n = Anzahl der leitungsführenden Schichten)• (L3) Jede Kante hat die minimale Breite 2λ und denminimalen Abstand 2λ von anderen Kanten. (λ =maximale Ungenauigkeit der Technologie, häufig unterschiedlicheMindestbreiten in verschiedenen Schichten)• (L4) Jeder Knoten wird auf ein konvexes Gebiet deruntersten Schicht abgebildet.

• (L5) Die minimale Fläche eines Knoten ist b. Dabeisei b ≥ c·λ 2 die minimale Fläche eines zweiwertigenSchaltelements.Knoten haben minimalen Abstand von 2λ.• (L6) Die minimale Fläche eines I/O-Knoten istρ ≥ β. Falls I/O-Knoten ein I/O-Pad ist (Ein- oderAusgang eines Chips), kann ρ mehr als 100 mal sogroß sein wie β.• (L7a) Die I/O-Knoten liegen am Rand des Layouts.(L7b) Die I/O-Knoten können an beliebigen Ortendes Layouts liegen. In den meisten Technologienliegen alle Pads am Rand der Chips, bei einigen(beispielsweise IBM) können sie (fast) beliebig verteiltwerden.• (L8) Die Schaltzeit eines Knoten ist mindestenst > 0.• (L9) Für die Laufzeit σ(l) eines Signals (d.h. einesElementes von D) über eine Leitung der Länge lgilt– (a) σ(l) = Θ(1) (konstantes bzw. synchrones Modell)– (b) σ(l) = Θ(log l) (logarithmisches bzw. kapazitivesModell)– (c) σ(l) = Θ(l) (lineares bzw. Diffusions-Modell)

Physikalisch korrekt wäre: σ(l) = Θ(l 2 )da die Signallaufzeit mit dem Produkt aus Widerstandund Kapazität (R · C) wächst.Teile lange Leitung in Folge von Leitungen konstanterLänge:⇒ lineares Modell vertretbarHäufig ist Schaltzeit eines logischen Knoten von gleicherGrößenordnung (oder erheblich größer) wie dieSignallaufzeit auf längster Leitung.⇒ konstantes Modell vertretbar

I/O-Schema:S legt fest, wie der Algorithmus V mit seiner Umgebungkommuniziert.Aufgabe von V : Berechnung einer Funktion f : D n →D mEingabevariablenmenge: X = {x 1 , . . . , x n }Ausgabevariablenmenge: Y = {y 1 , . . . , y m }Verwendung von V nur sinnvoll, wenn f immer wiederberechnet werden muß, d.h.für beliebige Folgen von Argumenten für f muß V somit Eingaben versorgt werden, daß an den Ausgängenvon V die entsprechenden Folgen von Werten von fablesbar sind:

Eingabeschema: legt für jede Berechnung, jeden Taktund jeden Eingang den einzugebenden Wert fest, dieskann sein• der Wert einer Eingabevariablen (d.h. ein Argumentder zu berechnenden Funktion f),• ein fester Wert aus D zur Steuerung der Berechnungoder für Testzwecke,• ein beliebiger, für diese Berechnung irrelevanterWert, bezeichnet mit ⊥ (dabei gelte ⊥∉ D).Also: in V : N × N → (X ∪ D ⊥ ) pund für i, t ∈ N, k ∈ [p] istin V (i, t) kdie Eingabe für die i-te Berechnung im Takt t anEingang kAusgabeschema: legt für jede Berechnung, jeden Taktund jeden Ausgang fest, welcher Wert ablesbar sein soll:• der Wert einer Ausgabevariablen (d.h. ein Wert derzu berechnenden Funktion f),• ein fester Wert aus D (z.B. ein Testwert)• ein beliebiger, für diese Berechnung irrelevanterWert, bezeichnet mit ⊥.Also: out V : N × N → (Y ∪ D ⊥ ) qund für i, t ∈ N, k ∈ [q] istout V (i, t) kdie Ausgabe für die i-te Berechnung im Takt t anAusgang k

Für jedes i ∈ N seibegin V (i) := min{t | in V (i, t) ∉⊥ ∗ }der Beginn der i-ten Berechnung undend V (i) := max{t | outV (i, t) ∉⊥ ∗ }das Ende der i-ten Berechnung.Nur sinnvoll, falls folgendes gilt:• Jede Berechnung erwartet mindestens eine Eingabeund produziert mindestens eine relevante Ausgabe.• Jede Berechnung erwartet nur endlich viele Eingabenund produziert nur endlich viele Ausgaben.• Jede Berechnung erwartet nach der letzten relevantenAusgabe keine weiteren relevanten Eingaben.Weitere Forderungen:• Die zeitliche Reihenfolge der Berechnungen entsprichtihrer Numerierung, d.h. für alle i ∈ N giltbegin V (i) < end V (i)begin V (i) ≤ begin V (i + 1)end V (i) ≤ end V (i + 1)• Alle Berechnungen sind funktional voneinander unabhängig,d.h. bei gleichen Eingaben produzierendie Berechnungen i und j für beliebige i, j ∈ N diegleichen Werte.

Beispiel: Ripple-Carry AdderVLSI-Algorithmus Add = (GAdd, LAdd, SAdd)für n-bit AdditionGAdd besteht aus• 2n + 1 Inputknoten,• n + 1 Outputknoten,• n gleichartigen logischen Knoten(getakteten Volladdieren);Kantenmenge ist offensichtlich.LAdd ist offensichtlich (wie in der Abbildung).

SAdd sei wie folgt definiert (entsprechend der Abbildung):Variante: Addition von k · n-bit Zahlen für beliebigesk, möglicher Rechnergraph für n = 4:⇒ Folge von Additionen von Blöcken der Länge n,Algorithmus heiße deshalb P Add — für PartitionierteAddition (mögliches I/O-Schema: (Übung))

BewertungskriterienVorbemerkung:V = (G, L, S) VLSI-Algorithmus zur Berechnung vonf : D n → D m⇒ wegen fester Problemgröße schwierig, Aussagenüber Verhalten von V für großes n zu machen:eigentlich: Familie V = {V n } n∈N von Algorithmenzur Berechnung einer Familie f = {f(n)} n∈N vonFunktionend.h. V n berechnet f(n).f(n) : D e(f,n) → D a(f,n)V n heißt Realisierung (auch Inkarnation) von V fürn ∈ N.Flächenkomplexität: Fläche A V (n) von V := Flächeder konvexen Hülle von L⇒ Fläche A Vbesteht aus• der Fläche der Knoten• der Fläche der Kanten• der “freien” Fläche zwischen Knoten und Kantenvon G oder am Rand der konvexen Hülle von L.

⇒ Es reicht nicht aus, den Flächenbedarf eines VLSI-Schaltkreises bzw. eines VLSI-Algorithmus durch dieAnzahl der benötigten Gatter oder Transistoren zucharakterisieren.Beispiel:(i) Layout eines binären Baumes unter der Randbedingung,daß alle Blätter am Rand liegen:Fläche des Layouts liegt in Ω(n log n), da dies bereitsdie Fläche der Kanten ist!(ii) Blätter können beliebig angeordnet werden:⇒ Fläche des Layouts in O(n)

Zeitkomplexität:Annahme: Global getaktete Arbeitsweise⇒ gemessen wird die Anzahl der verbrauchten Zeiteinheiten(andernfalls, d.h. bei selbstgetakteter oder asynchroner Arbeitsweise,hätte man Schwierigkeiten, Aussagen über das Zeitverhaltenzu machen.)Zeiteinheit t V( eines Algorithmus V = (G, L, S))t V = max( Knotenschaltzeit + Signallaufzeit )⇒ t V ist abhängig von den Leitungslängen im Layout,insbesondere von der maximalen Leitungslänge.⇒ die Anzahl der Zeiteinheiten ist allein nicht ausreichendfür Aussagen über das Zeitverhalten, Auswirkungender verschiedenen Modelle sind in t V versteckt,d.h. vor allem bei Verwendung des linearen Modellsmuß auch t V als multiplikativer Faktor berücksichtigtwerden(mögliche Alternative: t V = Signallaufzeit über eine“Einheitsleitung”).⇒ das Layout kann das Zeitverhalten erheblich beeinflussen.

Zeit von V :Zeit für die i-te Berechnung:T V,i (n) := end V (i) − begin V (i)Zeit vom Beginn der Eingabe bis zum Ende der Ausgabehäufige Annahme: ∀i, j ∈ NT V,i (n) = T V,j (n)statt dessen hier folgende Annahmen:(Z1) Es gibt nur endlich viele verschiedene ZeitenT V,i (n).(Z2) Es existiert eine eindeutig bestimmte mittlere ZeitT V (n) = lim k→∞1k T V,i(n)T V (n) heißt Zeit von V .Beispiel:Für VLSI-Algorithmus Add (bzw. Add n ) ist T Add (n) =n und alle T Add,i (n) sind gleich.Für die Variante P Add gilt das gleiche.

Periode von V:Periode der i-ten Berechnung:P V,i (n) := begin V (i + 1) − begin V (i)Zeit vom Beginn der i-ten bis zum Beginn der (i + 1)-ten BerechnungAnnahmen:(P1) Es gibt nur endlich viele verschiedene PeriodenP V,i (n).(P2) Es existiert eine eindeutig bestimmte mittlerePeriode P V (n) = lim k→∞1k P V,i(n)P V (n) heißt Periode von V .Beobachtung: ∑ ki=1 P V,i = begin V (k+1)−begin V (1)⇒ P V ≈ bei voller Auslastung im Mittel pro Berechnungzu veranschlagende Zeit⇒ Durchsatz von V : D V := 1P V⇒ ∀T ∈ N, T · D V = mittlere Zahl der in der Zeit Tbeginn- (beend)-baren Berechnungen

Beispiel:Algorithmus Add: für alle iP Add,i (n) = 1 ⇒ P Add (n) = 1Algorithmus P Add:P P Add,i (kn) = {(k -1)n +1, falls i mod n = 00, sonst⇒ P P Add (n) = kKombinierte KomplexitätsmaßeAllgemeines Entwurfsproblem:Gegeben: zu berechnende Funktion fGesucht: Hardware-Algorithmus, der f berechnet undminimale Kosten verursacht.Übliche Kostenfunktionen: A, T , P , A·P , A·T , A·P 2 ,A · P · T , A · T 2 ,...Grund für kombinierte Maße:häufig unmöglich, alle Maße A, P , T gleichzeitig zuminimieren (“Trade-Offs”)

Interpretation der kombinierten KostenfunktionenA·T : Energie die während der Dauer einer Berechnungdem Schaltkreise zugeführt werden muss.A · P : auf eine einzige Berechnung im Mittel entfallenderAnteil der A · T entsprechenden Energie.A · T 2 , A · P 2 : zentrale Bedeutung für Analyse vonVLSI-Algorithmen, Kommunikationskomplexität.I mißt den für eine korrekte Berechnung mindestenserforderlichen Informationsaustausch zwischen zwei(oder mehr) “Berechnungspartnern”(⇒ untere Schranken, genaueres später)Für viele Probleme bzw. Funktionen gibt es scharfeobere Schranken bezüglich A · T 2 !

Bemerkungen:allgemeines Problem der Algorithmenanalyse:Aussagen über die asymptotische Größenordnungder Komplexität eines Algorithmus lassen nicht unbedingtSchlüsse zu bezüglich seines Verhaltens fürspezielle ProblemgrößenDies gilt besonders für VLSI-Algorithmen und hier insbesonderefür vergleichende Untersuchungen:• VLSI-Algorithmen sind in der Regel nur für festeProblemgrößen realisiert.• beschränkte Chipfläche wirkt sich auf den Bereichder Problemgrößen aus, für die ein VLSIAlgorithmusrealisierbar ist.

Mögliche Methodik für eine “angewandte” Komplexitätsanalyseund für vergleichende Bewertungen:Aufgabe:Vergleichende Bewertung mehrerer VLSI-Algorithmen zur Berechnung der gleichenFunktion f.Methode:1) Analysiere Fläche, Zeit und Periode so exakt wiemöglich, basierend auf den Eigenschaften gemeinsamerBausteine.2) Vergleiche das Zeitverhalten der Algorithmen für eineReihe verschiedener, anwendungsrelevanter Problemgrößen.3) Bestimme für alle Algorithmen– bezüglich einer oder mehrerer Realisierungen dergemeinsamen Bausteine– die maximalen Problemgrößen, für die sie aufeinem Chip realisierbar sind,– sowie die dazugehörigen Zeiten und Perioden.4) Falls möglich, untersuche das Verhalten der Algorithmenin externen Verfahren zur Bearbeitung sehrgroßer Problemgrößen.

weitere Bewertungskriterien:Parallelität und PipeliningPipelininggrad: # gleichzeitig aktiver BerechnungenParallelitätsgrad: # gleichzeitig aktiver Knoten innerhalbeiner BerechnungPipelininggrad von V im Takt t:π V (t) := |{i ∈ N | begin V (i) ≤ t < end V (i)}|Pipelininggrad (während) der i-ten Berechnung:π V,i := max{π V (t) | t ∈ [begin V (i), end V (i) − 1]}Pipelininggrad von V :π V := max{π V (t) | t ∈ N}mittlerer Pipelininggrad von V :π avV:= limT →∞1T π V (t)

Lemma 3.1Der Pipelininggrad eines VLSI-Algorithmus zur Berechnungeiner Funktion f : D n → D m ist wohldefiniert.Beweis:Zu zeigen: ∃c > 0∀tπ V (t) ≤ cV berechnet f ⇒ Jede Ausgabevariable kommt mindestenseinmal im Ausgabeschema vor.Sei T := max i∈N T V,i , t ∈ N, a := π V (t) .⇒ im Intervall [t − T + 1, t + T ] sind mindestens a · mAusgabevariablen in out V⇒ maximal können 2T · q Ausgabevariablen auftreten(q = Anzahl der externen Ausgänge)⇒ a · m ≤ 2T · q⇒ a ≤ 2T · q/mq.e.d.

Zur Beziehung zwischen Zeit, Periode und Pipelininggrad:Satz 3.2Ist p a V v eindeutig definiert, so gilt für jeden VLSI-Algorithmus V T V = πV a v · P V .Beweis:Sei T max := max i∈N T V,i ; oBdA sei begin V (1) = 1.Für k ∈ N sei T k := max(begin V (k + 1) − 1, end(k))⇒ In ∑ T kt=1 π V (t) kommt für i ∈ [k] die Berechnung igenau T V,i mal vor.⇒ ∑ T kt=1 π V (t) ≥ ∑ ki=1 T V,iDa π V (t) beschränkt (gemäß Lemma 3.1), folgtk∑k∑∃c > 0∀k π V (t) ≤ T V,i + ct=1i=1⇒limk→∞1kT k ∑t=1π V (t) = limk→∞1kk∑T V,i = T vi=1Es gilt T k ≥ begin V (k + 1) − 1 ≥ ∑ ki=1 P V,iund T k ≤ ∑ ki=1 P V,i + T max

⇒ lim k→∞T kk= lim k→∞1k∑ ki=1 P V,i = P V⇒ T v = lim k→∞1k∑ Tki=1 π V (t)= lim k→∞ ( 1 T k∑ Tki=1 π V (t) · Tkk)∑1 Tk= lim k→∞ T k i=1 π TV (t) · lim k k→∞ k= lim T →∞1T∑ Tt=1 π V (t) · P V= π avV · P V q.e.d.Folgerung 3.3Für jeden VLSI-Algorithmus V gilt T V ≤ π V · P V .