Ja, schönen guten Morgen.
Ich wollte jetzt an folgender Stelle einsteigen
Ja. Und zwar an dieser Definition oder Erklärung der sogenannten ersten Maschinenklasse,
weil ja das Hauptthema hier im Kontext dieser Vorlesung die zweite Maschinenklasse ist, also die Parallelrechnern.
Nicht nur die erste Maschinenklasse, umfasst alle Modelle,
die sich in vollenongialer Zeit bewegen und gegenseitig eben entsprechend eben simulieren lassen,
wie wir das ja ein Beispiel der Ram und der Turing-Maschinen gesehen haben,
dass einmal die Ram plus ohne Multiplikation und Division,
dann hier die Deterministin-Turin-Maschine und die deterministische Zurückmaschine ist noch mit einem Band.
Ich und danach begann ja das eigentliche Thema,
nämlich die Appeeren, die parallel externen, detaile,
random Access-Maschine,
die jetzt aus der Negnanderschaltung von vielen Rams besteht,
wie wir sie vorher kennengelernt haben und die über einen
gemeinsamen Speicher miteinander kommunizieren und außerdem aber auch noch einen
lokalen Speicher haben
Nicht in dem gemeinsamen, in den Speichern,
gibt es dann Schreibkonflikte, die dann in der folgenden Form unterschieden werden.
Wichtig ist auch noch, dass die Programme für alle Prozessoren identisch sind,
aber im Verhalten voneinander abweichen können,
dass es eine Abfrage nach der eigenen ID gibt,
sodass sie sich dann entsprechend verzweigen können.
Ja, das sind jetzt hier die verschiedenen Klassen,
die jetzt verschiedene Disziplinen des Schreibzugriffes beinhalten,
was aber für uns nicht
besonders wichtig ist
So. Dann hatten wir die Komplexitätsmaßen erweitert. Es gab dann hier wieder die Zeitkomplexität,
die jetzt über alle Parallelen Ramps ging. Und die Prozessorkomplexität,
also die jetzt neu ist und jetzt ähnlich wie bei der Speicherkomplexität,
die maximale Anzahl der aktivierten oder aktiven Maschinen eben beschreibt.
Ja, dann gab es das Prozessor Zeitprodukt PT von M.
Und zwar unterschieden jetzt hier auch den Bezug auf die einzelne Eingabe
und auch dann die vorher in Bezug auf ein N,
wobei man das Maximum über alle Eingaben der Länge Ende nimmt und die Operationenkomplexität WM von L. Ja,
wobei man jetzt bei der Operationenkomplexität alle Operationen zählt,
also auch die Parallelen.
Ja, das hatte ich halt mit einem kleinen Beispiel verdeutlicht,
wo wir hier jetzt drei aktive Rams haben,
wo die maximale Rechnung elf Schritte umfasst und aller Schritte zusammen eben 21.
Es sind das Produkt 33 ist und ja,
und oft eben diese Annäherung gibt,
dass man dies dem Prozessor Zeitprodukt ungefähr gleich ersetzt.
In Wirklichkeit, dass aber nur eine Abschätzung ist,
weil ja dieses Recht echt nicht immer ganz ausgefüllt ist.
Ja, dann sind wir zu dem wichtigen Begriff des optimalen
parallelen Algorithmuses gekommen, der damit damals zu tun hat,
dass man parallele Algorithmen mit optimalen,
sequenziellen Algorithmen vergleichen kann
Und der wichtige Punkt war eben der, dass man die
Operationenkomplexität vergleicht mit der besten Zeitkomplexität für die sequenziellen Algorithmen.
Ja, das heißt, der Algorithmus heißt optimal, falls die Operationenkomplexität,
also im Totisch, gleich ist der besten oder der bestbekannten sequenziellen Zeitkomplexität.
Also an der Stelle muss man sich noch mal klar machen,
dieses gleiche Zeichen ist etwas nicht räuchlich,
weil hier handelt es sich um eine Klasse von Funktionen und hier eine Funktion.
Deswegen schreiben manche Autoren an dieser Stelle auch ein Elementzeichen,
was eben sinnvoller ist und vielleicht auch manchmal eine Verwirrung vermeiden eben kann. Ja,
und dieses Argument der Optimalität hatte ich dann nochmal hier durch ein kleines Beispiel,
versucht zu verdeutlichen, wo ich jetzt diese Ordnung ausgeblendet habe,
weil jetzt Funktionen hier anschaulich zu machen,
die wir hier in der Ordnung unterscheiden, ein bisschen schwierig war.
Also wir betrachten nur den Fall,
dass wir diese Optimalität jetzt nicht über die Ordnung,
sondern über die tatsächlichen Funktionen beschrieben hatten und dann gesehen haben,
wenn wir jetzt hier eine bessere Operation in Komplexität finden würden,
wäre das im Widerspruch zu der Annahme,
dass die sequenzielle Komplexität ja optimal war,
weil wir dieses bessere Algorithmus,
diesen besseren Algorithmus ja auch gewissermaßen sequenziell ausführen könnten und dann an einen besseren,
sequenziellen Algorithmus hätten.
Ja, das hier war nochmal zur Erinnerung an die Landau-Symbole mit dem O oder Omegra,
dem Tetter, was wir jetzt eben hatten.
Und dann sind wir zu diesem pränzlichen Ablaufprinzip gekommen,
das also beschrieben hat,
wie wir von einer Prozessorzahl M zu einer kleineren übergehen können,
dafür aber mehr Zeit brauchen und das sozusagen in konkrete Werte eben gefasst haben,
was wir an so einem Beispiel von 3 auf 2 hier nochmal verdeutlicht haben,
was aber jetzt hier keinen besonderen Effekt hat.
Wir hatten an der Stelle nochmal argumentiert,
dass es nicht einfach darum gehen kann, einfach hier,
dass hier die Lücken reinzuschieben,
sondern das muss eben eher so gehen wie hier,
dass wir dann diesen einzusparenden Prozessor hier irgendwo reinschieben,
weil wir sonst irgendwelche Prioritäten und Abhängigkeiten verletzen.
Ja, und dem Beispiel kann man sich jetzt auch nochmal
diese Rechnung klar machen, dass Tay und diesen zweiten Seminten. Ja,
und das haben wir aber dann in der Merkel oder in bestimmten oder interessanten Weise dann eben auch nochmal auf die U-Netation eben angewandt,
in denen wir uns überlegt hatten,
dass wir eben auch jetzt die Zeitkomplexität verbessern,
Das geht ja hier immer um die Operationenkomplexität,
dass wir die verbessern können, aber bei gleicher Zeitkomplexität in Bezug auf die 100 Patienten.
Ja, dann hatten wir Beispiele gesehen,
das war hier zunächst mal das Maximum finden, was,
wo wir einen solchen benähren Baum haben,
wo also zunächst immer die Zweierpaare miteinander verglichen werden und das dann fortgesetzt wird,
bis das letzte Zweier das letzte Paar dann zu dem Ergebnis dann eben führt.
Nicht, was dann eine Zeitkomplexität von Logorithmus N hat,
entsprechend der Höhe oder Tiefe des Baumes,
einer Prozessorkomplexität von O von N und einer Operationenkomplexität von N-1,
also auch von N. Ja, das brennt im Prinzip,
könnte man darauf anwenden und das auch noch drücken durch Zusammenschieben von Operationen und dann noch der Hinweis in einer Aufgabe,
dass es also auch noch besser geht, wenn man spezielle Datenstrukturen findet,
was also genauer beschrieben ist in diesem Buch von Jahr,
Jahr,
was ich hier zugrunde gelegt habe
So, und dann hatten wir noch einen interessanten, aber weniger praktischen Algorithmus zur Maximumsfindung gesehen,
der nur mit der auch mit konstanter Zeit erarbeitet, indem er aber Endvertragsprozessoren eben benutzt.
Nicht nur das ging also folgendermaßen,
indem wir uns also die Daten in einem Schema,
im quadratischen Schema vorstellen können,
wo wir also die Endvertragsprozessoren uns aluziert vorstellen können, in der Gestalt,
dass also am Anfang diese Y-Werte mit null initialisiert werden und die dann eben überschrieben werden,
wo wir dann also diese diesen Schreibkonflikt dadurch umgehen,
dass sie also, wenn sie überhaupt schreiben,
also das Gleiche schreiben, nämlich eine Eins.
Und der Effekt trat dadurch ein, dass also nur bei
dem Maximum dieser Test eher überall F aus falsch ausgeht.
Und deswegen die Null eben nicht überschrieben wird und davon eben
das Maximum eben abgelesen werden kann. Ja,
das führt dann also zu einer Zahlenkomplexität in der Tat von von 1,
also konstant, weil wir hier gar keine Schleife drin haben,
dann die Prozessorkomplexität, wie gesagt, Endquadrat und die Operationenkomplexität eben auch.
Ja, klar, dass das nicht optimal ist,
nicht weil man im Maximum ja Sequenzen sehr viel schneller berechnen kann.
So, dann hatten wir jetzt nochmal das Bremsschuh-Prinzip angewandt,
um zu überlegen, was passiert,
wenn wir in dieser parallelen Klasse alles voll innomiell sein lassen.
Das heißt, wenn wir also hier Ja,
also das war nächstes Mal der Satz, jetzt der,
dass das praktische Prinzip eben benutzt,
wie wir auch jetzt wieder die Prozessekomplexität verringern können von Tee nach Pedurch K,
in möglicherweise eben Erhöhung der Zeitkomplexität.
Und das haben wir jetzt angewandt eben, um zu überlegen,
wenn jetzt hier dieses P und dieses Tee erpolonomiell sind.
Ja, das sah dann eben so aus,
dass wir jetzt für die CRCW folgendes machen,
das K gleich P wählen,
sodass wir hier also nur eins haben,
das heißt nur ein Prozessor haben und wieder eben in die einen Prozessormaschinenklasse zurückkomme.
Und dann diese Zeit und Prozesse kommen,
Komplexität polynomiell erwählt, was dann dazu führt,
dass wir insgesamt dann nur ein Koordinon hier an dieser Stelle haben.
Das heißt also, wir haben dann auf diese Art und Weise
ein Äquivalent von einem Prozessormaschinen, die in polynomieller Zeit eben arbeiten.
Ja, das war also jetzt die Spezialisierung von diesem Satz
und wir kommen zurück in die erste Maschinenklasse
Das heißt also, wenn wir hier Paul, Paul, Paul innomiell einsetzen, haben wir die Klasse LP.
Nicht nur die zweite Maschinenklasse sind ja eben die Parallelen,
der Rechner, die wir dann bekommen,
wenn wir hier, oder bekommen wir nur was Neues,
wenn wir hier diese Restriktion aufgeben,
also praktisch kann es natürlich auch schon schneller gehen,
aber in der Ordnung geht es erst schneller,
wenn wir hier diese Restriktion aufgeben und dafür beispielsweise hier zwei
hoch TVN einsetzen und diese Klasse dann entsprechend so definieren,
weil sie jetzt nur noch
von TVN abhängt
Ja, und was das gibt, hatten wir uns dann überlegt,
oder hatte ich ihn, hatte ich zitiert,
dass das dann die Klasse P-Space ergibt, was insofern bemerkenswert ist,
weil wir jetzt praktisch von dem damals neuen Gebiet der parallelen Maschinen ein Interesse von Gleichkommuniter gleich dran,
zu allen interessanten Bezug gibt zu das,
was vorher schon länger untersucht worden ist,
nämlich die Klassen LP und P-Space, und das führte dann dazu,
dass wir die zweite Maschinenklasse mit dem Parallelrechnern definierten.
Ja, Ihre Frage? Ja, ist es wichtig,
dass wir, kann ja eine bestimmte Art von Parallelen brauchen
die Planung haben zu dem Ersatz davor, also dieses Seher, Sebir.
Nee, das sollte eben ausdrücken,
auch gerade auch jetzt hier diese folgende These, soll ausdrücken,
dass man solche Klassen definieren kann, die relativ robust sind.
Nicht genauso wie bei der ersten Maschinenklasse konnten wir ziemliche Variationen machen,
aber gerade wie so Schreibkonflikte, die bringen die überhaupt nicht.
Das ist genau das Gute, wenn wir ein CR,
EW. Wenn da die Klasse wäre genau dasselbe gewesen.
Ja, genau. Gut, ja, dann, wie gesagt,
es ist jetzt hier nur ein ganz kleiner Ausschnitt von dem
ganzen Gebet und da ist jetzt hier noch ein bisschen was zu
Es waren interessante Sätze, jetzt zitiert, dass es eben manchmal auch nichts nützt.
Parallele, Algorithmen zu benutzen, wenn man beispielsweise hier Polylnomen
Entesten Grades berechnen will oder speziell im XXL. Ja,
dann nochmal die Folie, die ich vorher schon mal gezeigt hatte,
für die ein bisschen später gekommen sind und das letztes Mal nicht mitgekriegt hatte.
Es wird also jetzt wieder so ein Repetitorium angeboten wegen der Klausurtermine,
die sie in der Woche haben,
leider dann am Wochenende hier in den Räumen und auf jeden
Fall nochmal kurz vorher E-Mail checken oder Webseite nachgucken,
falls sich da was geändert hat,
dass sie da nicht am Wochenende her
Vergeblich her. Gut. Und dann sind wir jetzt zu
dem Thema der Paarallelen Algorithmen gekommen. Im Gegensatz zu den parallelen Maschinen,
auf denen wir natürlich auch schon parallele Algorithmen betrachtet haben.
Nicht, aber hier ist der Fokus auf den parallelen Algorithmen eben selber.
Und diese werden jetzt also nicht mehr unbedingt mit dem Rahmen oder P-Ramm-Code beschrieben,
sondern mit einem Pseudo-Code, der sozusagen etwas abstrakter ist.
Aber wo wir uns immer vorstellen müssen,
dass wir im Zweifelsfalle den ersetzen,
können uns zwar in linearer Zeit in einen P-Ramm-Code,
damit wir wirklich eine exakte Essemantik-Ebene haben
Ja, und da haben wir das entsprechende Bild wieder,
was ich vorhin bei dem Erklärung des optimalen Algorithmus, jetzt angewandt,
auf das Beispiel, nicht unter den vielen tausenden parallelen Algorithmen,
die untersucht worden sind, hatte ich jetzt hier das Sortieren rausgesucht.
Und da würden wir dann eben begründet auf die Optimalität,
dass eben Vergleichen mit allem optimalen, sequenziellen Sortieren Algorithmus.
Nicht, wo Sie ja wissen, das ist in Ohr von Endlock eben unmöglich. Und wir werden,
dass das hier also schaffen, das Ergebnis wird sein,
dass wir Log-in mal Locklock-in schaffen werden,
aber mit einer Operation Komplexität mit Uhr von N-Login, sodass die sagen,
also eben optimal ist und auch wieder Ovon Ellen Prozessoren braucht,
ähnlich wie wir das eben bei dem Maximum eben hatten,
also genauer gesagt, in halbe.
Ja, nicht, um nochmal zu bedeuten,
zu beleuchten, was Star Login und Loglock-N bedeutet,
was ist denn hier nochmal so ein Schema,
der projiziert einige Werte von N mit dem Login,
mit Loglock-N oder Loglock-N oder N-Log-N,
was natürlich eine Verbesserung ist gegenüber Endquadrat,
wo wir hier schon,
also bald
Dann eben da. Ja, und nicht nur,
wie Sie ja wissen, basiert eben dieser Merch, sagt,
Algorithmus auf dem Merchant oder mischen und deswegen haben wir uns damit zu befassen,
was wir in der letzten Stunde schon angefangen haben.
Das heißt, wir haben jetzt zunächst einmal die Mischung von zwei geordneten Folgen betrachtet,
was eben ganz natürlich ist, eine neue geordnete Folge,
jedes ursprüngliche Element genau einmal enthält,
wo also die anschauliche Erklärung sehr viel einfacher ist als Hier die abstrakte mathematische Definition,
wo man sich dann erst durchwühlen müsste,
wenn man sich vorher schon eine Vorstellung eben hält.
Ja, nicht nur, das benutzen wir dann für das Parallele sortieren,
indem wir hier unten die Elemente in einer Anzahl einer Zweierpotenz
anordnen und dann immer die jeweils paar weise mischen und dann eben hier zur längeren,
aber sortierten Listen.
Folgen kommen, bis wir irgendwann mal in der Wurzel die Gesamtfolge dann eben sortiert eben hatten.
Und in dem Algorithmus selber her steckt dann nichts mehr,
Besonderes drin, sondern die ganze Untersuchung konzentrieren sich darauf eben das Mischen,
was hier in den einzelnen Schritten passiert,
eben besser zu geschalten,
als er sozusagen naiv der Fall werden.
Ja, und dazu betrachten wir jetzt den Rang eines Elementes
in einer solchen Menge oder Erfolge.
Das ist jetzt die Anzahl der Elemente XE,
die also kleiner sind
Das heißt also,
wenn wir hier so eine Folge haben oder sogar, nee,
nicht sortiert, dann wird wollen den Rang von 13. Wir wissen,
dann können wir uns zum Beispiel vorstellen, dass wir die erst sortieren.
Und dann eben die Position suchen,
wo eben die 13-1 aurtiert wäre.
Das wäre jetzt hier an der dritten Stelle,
sodass also zwei Elemente noch davor liegen.
Und so ist dann der Rang als zwei definiert.
Vielleicht auch die Definition wird dann eben erweitert auf die
ganze Felder
Indem jetzt diese 13 hier an der ersten Stelle steht und die 27 und die
minus 27 dann entsprechend behandelt werden und dann sozusagen das Ergebnis wieder einfällt ist.
Wir haben also das erste Ergebnis 2,
die 27 würde hier an der,
die würden vier Elemente vorher haben und die minus 27,
27, 1 vorher, die hätte dann also den Wagen eben null.
Und dieses Berechnen von diesem Rang hier ist jetzt erstmal
das erste Ziel
So, das heißt, wir betrachten jetzt erst mal das Jungtenmengen,
was keine besondere Einschränkung ist,
und bestimmen jetzt für jetzt die Vereinigung dieser Dissjunkten-Mengen den Rang eines Elementes im X.
Und dann wäre X das ePlus erste Element in der Vereinigten Menge eben LC.
Ja, und das machen wir durch im ersten Schritt durch Binäres Suchen,
nicht indem wir eben,
als dass die Folge als sortiert eben annehmen dann eben irgendwie ein Mittelelement wählen,
wo wir dann entscheidend kommen können,
ob wir links oder rechts weitermachen müssen und dann rekursiv entsprechend weiter.
Also hier zum Beispiel rechts, da ist auch wieder in der Mitte
irgendwo rumsuchen und bis wir dann irgendwann mal die richtige Stelle dann eben gefunden haben.
Ja, und das können wir jetzt so zusammenfassen,
für ein BE aus Großb kann man jetzt durch Binäres suchen,
ein solches, einen solchen Index J, die finden,
sodass das BE zwischen den entsprechenden Elementen,
AJE und AJE plus 1 ist.
Und das geht natürlich in Logarithmus,
N sequentieller Zeit
Ja, und das wäre dann also der Rang von BI in diesem A. Nicht
dieses Verfahren kann man jetzt parallel auf alle Elemente von B anwenden,
nicht am Ende, also nicht nur einen Rang bestimmen wollen,
sondern wieder ein ganzes Feld von den Errängen.
Damit erhalten wir jetzt in der Eva Weise einen parallelen Algorithmus,
der jetzt natürlich immer noch genauso viel Zeit benötnt,
nämlich Logarithmus N, weil die alle parallel arbeiten.
Und wenn wir da sozusagen endmal parallel arbeiten,
wären das also N mal, ich glaube, N-Operationen.
Ja, nicht, das halten wir also fest,
dass wir das jetzt erstmal mit Login paralleler Zeit und Endlock
in Operationen in Komplexität eben erschaffen können.
Ja, und das ist natürlich nicht optimal,
denn wir können jetzt das natürlich in sequentuellen UFON-N-Zeit schaffen,
sodass eigentlich naheliegend ist, dass wir das eben verbessern können.
Und unser erstes Ziel ist jetzt, einen solchen optimalen,
parallelen Algorithmus für das Mädchen zu finden.
Und da ist jetzt das Entscheidende,
dass wir A und B in Blöcke passender Länge sortieren
Unterteilen und da werden wir später dann also noch eine Verbesserung Besserung finden,
indem wir eine andere Einteilung erfinden und ich was meiner Meinung nach eine ganz interessante Beobachtung ist,
wie man durch solche Wahlen doch das Ergebnis entscheiden,
das dann eben beeinflussen kann.
Also wenn jetzt A, die Länge N und G,
die Länge M hat, dann können wir uns die Elemente
so vorstellen und wir werden jetzt also so viele Blöcke einführen,
nämlich KM als M durch Logorithmus M und nehmen dann nur solche Ms,
wo das auch eine natürliche Zahlen ist.
Das heißt also, das wird hier als Einschränkung ergenommen.
Das heißt also, wenn wir mal folgenden Fällen betrachten,
also zum Beispiel Endgleich 4, dann der Legorithmus M2,
hier durch zwei wären dann zwei Flöcke.
Wenn wir acht und drei haben, würden wir das
nicht nehmen, weil das keine ganze Zahlen gibt.
Und bei 16 und 4 hätten wir vier Dreppe,
dann würden wir wieder das als Möglichkeiten eben betrachten.
So, und das Entscheidende ist,
dass die Vlöcke natürlich was miteinander zu tun haben und es soll so sein,
dass immer alle Blöcke links, kleiner gleich, den Werten der Blöcke recht sind.
Und zwar unten ist es natürlich, also in derselben Pscheide ist klar,
weil das sortiert ist, aber eben auch in dem anderen Block,
um dass wir uns da so eine Linie vorstellen können,
wo wir das kleiner haben.
Das heißt, alle Elemente aus AI, Vereinigt BI,
sind größer als alle Elemente von AI minus 1b minus 1 vorher.
Das ist jetzt das Ziel, was wir da eben anstreben
Das heißt also, wenn wir jetzt wieder den Fall nehmen mit M gleich 4 und KM gleich 2,
also ich habe hier die Notation von dem Buch,
von diesem Jar Jar übernommen, der die Indie-Tays-KM in solchen Klammern schreiben.
Nicht, dass es zum Tippen einfacher, aber muss man sich dran gewöhnen,
wenn man das jetzt liest. Also das war ja dieses M,
solch Lockerhythmus, Embers 2 ist,
haben wir also zwei Blöcke und wenn wir das also jetzt entsprechend in zwei Blöcke teilen,
dann passiert folgendes erste nochmal der Hinweis,
dass das eben Indie-C-Film und wenn wir das jetzt auf die nächste Seite darüber retten und da nochmal kopieren,
dann heißt das also,
dass wir das BM hier in zwei Teilen erteilen.
Und diese Bedingungen, die eben beschrieben ist,
dadurch eben erreichen, das sind also die Blöcke B0 und B1,
dass hier die Blöcke A1 und A2 so zu wählen sind,
weil eben die drei neuen kleiner ist als 10 und die 46 auch kleiner sind als 16,
dass man das nicht auch noch weiter vorschieben kann.
Das heißt also, so wären dann jetzt hier oben
die Blöcke A0 und A1 zu festzulegen.
Nicht und im Algorithmus sieht das dann ein bisschen abstrakter aus,
nicht wenn also hier die Die A-Blöcke und die B-Blöcke erseln,
dann haben wir erstmal die gleiche Einteilung der B-Blöcke.
Und das wird dann entsprechend hier die unsere Grenze gesucht,
so wie das ewig, das eben gerade beschrieben habe.
Nicht und der Algorithmus sieht also folgendermaßen aus.
Wir haben also die Eingabe dieser beiden Felder an ARB,
nicht 1 bis AN und B1 BN, in aufsteigender Reihenfolge,
wobei wir diese Einschränkung haben mit dem KM.
So, die Ausgabe sollen also diese Paare von Teilfolgen sein,
der Gestalt, dass die B-Blöcke alle Logorithmus entlang sind
Dass die Summe aller A-Blöcke wieder die ursprüngliche Länge hat und
dass jedes Element von AI und BI größer ist,
als jedes Element von AI minus 1 oder BE minus 1,
also gerade was vorher auch schon da stand.
So, und das läuft jetzt folgendermaßen aus.
Wir setzen also das J0 auf null und das JKNFL,
also sagen die äußeren Grenzen. Und jetzt machen wir folgende innäherere Suche,
indem wir jetzt für alle ein E von 1 bis K von M,
also für die B-B-B-Blöcke, den Rang von dem BE,
der entsprechenden BE,
in dem A durch Binäre Suche ermitteln und dann die entsprechende Position und hier unten in dem A, eben beschimpfen.
So, und dann müssen wir dann eben noch hinterher die A-Blöcke definieren,
was jetzt ja nicht mehr viel ist und die B-Blöcke auch,
indem wir jetzt die entsprechenden Grenzen berücksichtigen und die entsprechenden Blöcke dann eben benutzen.
Nicht so, dass wir dann also das bekommen,
was wir vorher auch schon angedeutet hatten,
wo wir hier um die B-Blöcke und oben die Arbschlöcke für diesen speziellen Fall haben.
Nicht hier dieses J von I, Das ist jetzt also
dann gerade der Rang von dem EEI-Loggerhythmus M in A,
Logarismus M war ja die Länge eines Blogs und ist eh mal der sozusagen der Ete-Blog.
Ja, und ich war eh gleich zwei,
würde dann hier das letzte Element des Blogs dann.
Eben bestimmt. Was dann zu dem RB1-Blog eben da oben
gehört. Also das wäre dann das Element A2,
was dann danach kommt
Ja, und hier an dieser Stelle, und da werden also die BE-Blöcke, also als von eben bestimmt parallel,
indem eben jeder paralleler Prozessor so einen Block da bestimmt,
von E-Log, M plus 1, bis zu so einem E plus 1.
Da müssen wir mal in der Klammer noch stehen, um das Log. Ja,
und damit haben wir jetzt Folgendes geschafft,
wenn wir als C jetzt die sortierte Folge nehmen,
welche durchmischen, der sortierten Folgen A und B,
mit den Längen N bzw. N erklärt,
dann teilt der Algorithmus A und B die Paare von Teilfolgen ich und BI so auf,
dass eben die BE-Klöcke, diese Länge Lockerhythmus M haben,
also wie vorher angesetzt,
die Summe der AI-Blöcke N ist und wir das C in solche Zeblöcke einteilen können,
wobei CI die sortierte Folge ist,
welche aus den AI und BI-Blöcken durch Mission entsteht.
Nicht so, dass wir dann jetzt eben sozusagen ein
kombiniertes Mission von den ganzen Plöcken haben.
Und das schaffen wir in Lockerhythmuszeit und in O von N plus N Operationen,
was wir, also so war ja das Bild und was
wir dann jetzt auf der nächsten Folie uns dann nochmal angucken,
wie das hier zustande kommt.
Ja, und dazu gucken wir uns jetzt mal den Algorithmus an.
Und können wir jetzt nochmal eine kleine Übung in Komplexität machen.
Also wenn wir jetzt die Zeitkomplexität von dem gesamten Algorithmus untersuchen,
können wir uns ja erstmal die einzelnen Teile betrachten.
Wenn wir uns das hier betrachten, was ist da die
Zeitkomplexität von dem Algorithmus? Ja, bitte. Genau,
nicht, dass es also Ohr von 1. Machen wir weiter,
haben wir hier diese Fonds, das ist eine Fondspaar Durchleife,
also keine Schleife, sondern eine Parallelanweisung.
Da steht ja also hier, was für ein Binärer Suche
, was haben wir da als Zeitkomplexität?
Genau, da haben wir das in Log All.
Und jetzt hier beim letzten, da haben wir jetzt wieder die Parallelanweisung.
Was gibt das für eine Zeitkomplexität nach dem dritten?
Wiedersehen. Jetzt ist die Frage, sind die erstmal konstant
aus, aber man muss sich ja die Kunden aufschreiben.
Das heißt, man muss drüber laufen
Nee, nee, das ist konstant. Es werden einfach
nur diese Zuweisungen gemacht und die Werte sind ja bekannt hier.
Und die man da berechnet, also auch in Uhr von N.
Da machen wir jetzt einen Strich drunter. Was gibt es
also insgesamt? Ja, zähl vielleicht wieder, oder? Genau,
ich meine, das wäre ja nur eben,
das können wir abschätzen mit Logarhythmus N und dass wir dann dreimal Logarhythmus ein,
was die Konstante mit da drin bedeutet, die unwirksam.
Jetzt ist in der Unloteration in der Urnotation,
was ja oben in Millionen geht.
So, machen wir dasselbe jetzt für die Operation, Komplexität.
Was haben wir an Operationenkomplexität hier
Genau, haben wir auch wieder im Euro von L.
Was haben wir an Operationen, Komplexität hier? Ja,
das ist aber schwieriger, weil sie ja folgendes beobachten müssen,
das Login war schon richtig, aber die Blöcke haben ja Ämterschluck-Ernlänge.
Genau. Und das ist nicht so ganz intuitiv,
da kann man jetzt das abschätzen nach O von M. Plus N und das geht mit dieser Rechnung,
dass man M-Log-End durch Log-End durch das abschätzen kann und das durch endlos M,
was sie sehen, dass das nur für ein größer gleich vier gilt,
dass das ein klein bisschen spezieller ist.
Das schätzen wir also so ab. Das gibt also auch
ein N plus N und hier unten haben wir wieder,
hier haben wir jetzt Ufon ähnlich,
weil wir jetzt nicht WM mal das Ganze parallel ausführt,
was also jetzt insgesamt dann jetzt durch das hier wieder dominiert wird und insgesamt wo kommt das Handy nicht,
wobei wir jetzt das Ergebnis haben, dass wir eben schon zitiert haben.
So, das heißt also,
mit diesem Algorithmus haben wir das Mischproblem der Größe N auf Unterprobleme
kleinerer Größe reduziert und wir kriegen jetzt einen optimalen Algorithmus,
für das Mischen, in dem wir den Algorithmus zum Aufteilen jetzt anwenden,
also erst aufteilen und dann mischen.
Wir behandeln jetzt die Paare AIBI getrennt. Und, naja,
die hatten ja die Länge der Para BE war ja eben parallel.
Und wenn also diese Länge der zugehörigen AIs kleiner gleich Logarithmus enden,
in meiner Konstante er ist, dann lohnt sich dieser Aufwand,
das parallel zu machen nicht,
dann machen wir das mit einem sequenziellen Algorithmus.
Wenn das aber größer ist, dann, wenn wir den Algorithmus an,
den wir gerade hatten, und das heißt also,
wir haben also Blöcke AE, Im Blöcke der Länge,
Logarith muss ernster zerlegen.
Und da haben wir dann gerade die zitierte Komplexität.
Das heißt also, das wäre ja eproportional zu längern,
das Teilblockes. Wenn wir uns das mal anschaulich,
könnten wir uns vielleicht sofort anschauen, nicht,
das wäre jetzt während jetzt vielleicht das A und das B, beide mit
1024. Die Blöcke von B sollen der Länge 10 haben.
Und hier oben haben wir dann vielleicht unterschiedliche Blöcke,
je nachdem wie die Elemente verteilt ist.
Also ich erinnere die Grenze so,
mit dem aber würde sie
so erlegen
Da würde dann jetzt so ein großer Block drin vorkommen,
wo wir jetzt an der Stelle die Zeit Logarhythmus N und Operation
O von N brauchen, aber bezogen auf die Blockergröße.
Und wenn wir das jetzt dann im nächsten Schritt machen,
also den großen Block A2 jetzt wieder in Bezug auf das B2 aufteilen,
wird der Algorithmus dann wieder angewandt.
Und jetzt aber mit der neuen Länge,
was jetzt dann ja der Logarhythmus von der ursprünglichen Erlänge
dann eben ist
Ja, nicht was sagen, nochmal jetzt steht.
Und insgesamt schaffen wir dann eben,
dass das Missions euer Folgen A und Bede Länge in der N von einem optimalen,
parallelen Algorithmus in Ovon Leck Lock and Side mit Ovon End Operationen eben durchführbar ist.
Ja, und wir fragen jetzt,
ob wir eben noch einen schnelleren Algorithmus erfinden können.
Ist das denn überhaupt eine sinnvolle Frage,
wenn wir schon einen optimalen Algorithmus haben,
kann es denn dann noch schneller gehen?
Ist das nicht ein Widerspruch optimal,
optimaler geht es doch eigentlich
gar nicht
Mit diesen Operationen, Komplexität, können wir auf jeden Fall nicht Untertäter von Emre.
Genau, die Optimalität, aber die tatsächlichen Zeitbedarf.
Genau, nicht also die Zeit kann ja trotzdem sein,
dass die Zeit noch gedrückt werden kann.
Insofern ist dieser Begriff optimal, mit Vorsicht zu genießen.
Das ist nicht optimal in jeder Hinsicht, sondern nur,
wie sie richtig sagen, in Bezug auf die Operationen Komplexität,
dass wir dann eben diesen Vergleich mit den sequentiellen herstellen können.
Es kann also andere auch Optimale geben, die eine
bessere Zeitkomplexität haben. Und in der Tat können wir hier
dieses Log ändern,
noch auf dem Log-Log zeugen
Nicht und dazu müssen wir uns den Algorithmus mal anschauen,
wo denn jetzt noch Potenzial für eine Beschleunigung ist.
Also nehmen wir nochmal, den Algorithmus. Nicht haben wir
hier vielleicht die drei Teile. Wo würden Sie denn jetzt
noch Potenzial für eine Beschleunigung sehen? Also durch Parallelisierung.
Ja, bitte. Ja, bitte. Ja, ne,
das ist ja hier noch, haben wir noch gar nicht richtig ausgereizt,
diese Binäre suchen, wenn wir das auch noch verbessern.
Die wenigere Suche parallel machen, dann ist da vielleicht etwas drin.
Und in der Tat können wir mit,
wenn wir das als parallelen Algorithmus gestalten, die Suche,
also mit P-Prozessoren, das von Login nach,
also von Login plus 1,
nach Login plus 1 durchgeteilt durch eben versättert.
Und da haben wir jetzt eben Anlass, nochmal einen anderen
schönen Italien-Algorithmus kennenzulernen, nämlich das Suchen durch P-Prozessoren.
Das heißt, wir werden jetzt kennenlernen, Parallele suchen mit EP-Bot zu suchen.
Und das führt dann zu einem Misch-Algorithmus mit Locklock-In-Zeit-Komplexität und N-Lock-Lock-In-Operationen-Komplexität.
Nicht nur, dass jetzt ein eigener Abschnitt, nämlich das Parallele suchen. Ja,
dann haben wir die klassische Suchanaufgabe, wir geben eine lineare,
auch nette Menge, X von X-1 bis X-N,
von verschiedenen Elementen, einer lineare auch eine Menge und ein Element Y,
was mich da enthalten werden, enthalten sein muss,
aber kann.
Und das Suchproblem besteht da drin,
jetzt den Index zu finden,
wo dieses eben
eingeordnet werden kann
Ja, nicht uns beim binären Suchen haben wir ja eben
die Zeitkomplexität TV und N von Login.
Und jetzt das Parallere suchen mit T-Professor,
wird das also wie eben geschildert auf diesen Wert hier verbessern.
Und der Algorithmus ist sogar optimal, wenn Pekon stand ist. Nicht,
das ist ja immer bei diesen Kompensitätsgeschichten wichtig zu sehen,
was man Konstern hält oder was man sozusagen der Variation
der Optimierung noch eben zulässt
Ja, und dann wollen wir uns jetzt mal eben betrachten,
dieser parallele Algorithmus sieht jetzt so aus.
Also hier haben wir wieder die Eingabe, wie eben beschrieben,
Feld, Suchelement, Anzahlen der Pebrotessoren, das ist natürlich klar sinnvoll,
dass das kleiner gleiche N ist, wenn wir nur Elemente haben.
Und das ist jetzt wieder der Algorithmus für den Prozessor PJ.
Und wo dann in der allgemeinen Formulierung die Prozesse-ID eingesetzt würde,
Und ja, gesucht wird eben der Index, eh,
wo eben das Y eben einzusortieren werden.
Ja, fangen wir mal jetzt im Detail an.
Wir fangen also hier mit der Initialisierung an. Hier steht
was von If Jord Clys 1, dann wird irgendwas gemacht.
Was heißt denn das? Diese Abfrage J hat gleich eins
und was bewirkt das? Wir erinnern sich,
J war die, ja, was... Da wird abgefragt,
ob wir es mit Kopf wehen, diesen Foto,
gerade auf Prozessor Nummer eins zu führen.
Das heißt, es wird sichergestellt, dass dieser 1-
1 und 1-2 noch in allem einzigen Prozessor ausgeführt.
Okay, nicht, dass er instriert. Also schön,
dass das Verhalten aller dieser parallelen Banks nicht gleich ist,
sondern wir können zum Beispiel den ersten nehmen,
um hier eine Art Verwaltungsaufgabe zu übernehmen.
Und die anderen brauchen da an der Stelle noch nichts zu machen.
Das heißt also, wenn das das ursprüngliche Feld ist,
von X-0 bis X, nee, von X-1 bis X-N dazwischen,
dann denken wir uns noch ein X-0 und ein X-Endlos und eins davor.
Und wir geben dem den Wert minus unendlich bloß unendlich,
um da irgendwie noch solche Solche Grenzen zu haben.
Also konkret soll, dass da nur ein kleines Element unten größtes Element sein.
So, und jetzt setzen wir außerdem noch ein C00 und
ein CP plus eins auf 0 und 1.
So, und als nächstes machen wir jetzt,
also das haben wir jetzt hier hier dargestellt,
also 1C0 und ein C4 wäre das in diesem Fall gleich eins.
Und als nächstes unterteilen wir jetzt dieses Feld hier in vier Teile.
Warum denn vier Teile, wenn wir drei Prozessoren haben,
warum nicht in drei Teile
Wer kann sich das denken? Ja, bitte. Heweibe?
Das ist zu sterben. Nee, das ist kalt,
die Antwort. Das, wo hohen Lade liegt das?
Wie würden sich die drei Prozessoren da widerspielen?
An welcher Stelle werden die arbeiten? Wird die arbeiten hier
an den Grenzen? Nicht, wenn wir drei Grenzen haben,
haben wir vier Teile. Wenn sie beim Binären suchen,
haben sie einen Prozessor, Aber zwei Teile.
Und in der Mitte arbeitet der eine Prozessor. Nicht,
also ich weiß nicht, ob das nochmal aufmalen soll.
Nicht beim Binären suchen, da haben wir die Situation,
dass wir hier irgendwo in der Mitte der eine Prozessor sucht und vergleicht mit rechts und links.
Und unsere P in unserem Falle drei Prozessoren,
die machen das jetzt an drei Stellen und dadurch kriegen wir vier Blöcke.
Okay. So, und das machen wir jetzt hier auch.
Ja, und wir machen das so lange,
bis also diese Blöcke werden immer weiter verkleinert.
Machen wir so lange, bis sie kleiner sind als
die Anzahl der Prozesse
Und nicht, wenn die Projekte so kleiner sind als die Anzahl der Prozessoren,
dann waren wir also nur jeden Prozessor gewissermaßen auf ein Element anzuwenden.
Da haben wir, sind wir dann am Ende. Und ja,
und deswegen haben wir hier am Anfang jetzt ja auch schon,
ja, und deswegen setzen wir diese Kuhs hier so.
Also das Q0, setzen wir auf das linke Element und das QOP
plus eins auf das rechte Element. Und die anderen,
die QEs, die setzen wir entsprechend so ungefähr dazwischen hier.
Wo wir hier von dem linken Element die Länge des Feldes addieren,
also die Differenz, geteilt durch die PPlus-1-Prozessoren und dann eben sozusagen der J-Block.
So, und jetzt kommt die Abfrage in Bezug auf unser Element Y,
das heißt, wir müssen jetzt in unserem Beispiel irgendwie mal annehmen,
wo das Y liegt, das möge jetzt mal darlegen.
Und da machen wir jetzt Folgendes, das setzen wir jetzt hier irgendwelche Cs.
Und das sieht dann so aus. Dann können Sie erkennen,
was das für eine Bedeutung jetzt hat, diese Cs.
Ganz schnell erkannt, ja. Bitte? Das ist die
billigen Unterscheidung, was größer oder kleiner ist
Ja, das heißt also, wir haben hier sozusagen 0-0
-0 und dann springt es auf eins und genau da, wo das Element lief.
Und warum ist das wichtig, dass wir sowas haben?
Ja? Ja, und vor allem eben alle Prozessoren sollten
das wissen, wo das ist. Das heißt,
hier haben wir ein schönes Beispiel dafür, für Speichersynchronisation,
denn diese Cs sind ja im globalen Speicher und jeder kann nachgucken,
wo dieser Sprung ist,
aber jeder setzt nur lokal die Cs für sich.
Nicht alle anderen sehen dann, wo das Y in
welchem Intervall das entsprechend eben liegt.
Das passiert hier, wo also diese CEJs dann hier mit
der bedingten Abfrage gesetzt werden
Ja, und jetzt, und dann passiert natürlich etwas,
dass jetzt die Stelle rausgesucht wird, wo dieser Sprung stattfindet.
Nicht, dass an dieser Stelle, und dort wird jetzt
an dieser Stelle das neue Linke und das neue Rechte sozusagen,
Grenze werden an diese Stelle gesetzt.
Das heißt, jetzt in der Iteration geht es dann entsprechend weiter. Das war jetzt,
naja, Öfland haben wir dann auch immer noch,
das muss ja dann da irgendwo liegen,
aber zu sagen,
die neue linke Grenze wird jetzt hier rübergezogen und die rechte Grenze hier,
und dann in der nächsten Iteration folgt jetzt wieder eine
Einteilung,
entweder in vier ungefähr
Teile. Und so geht das dann also weiter,
bis diese Länge also kleiner ist als die Anzahl der Prozessoren.
Da haben wir dann auch wieder die Cs und den Sprung an einer entsprechenden Stelle.
Und im letzten Teil haben wir dann die Ausgabe,
da kann es natürlich sein,
dass das Y genau eines dieser Elemente ist,
nicht und dann findet das der entsprechende Prozessor oder es ist irgendwo dazwischen,
dann kann der entsprechend die zwei Prozessoren das finden und dann machen sie das hier wieder mit solchen Cs
Und die Ausgabe ist dann entspannt, finden Sie dann wieder
an dieser Stelle hier. Und die Ausgabe ist dann linke,
plus dem entsprechenden Prozessor und eins vorher da. Ja,
und damit haben wir jetzt das parallele Suchen in P,
Kleinergleich mit P, Kleinergleich Endprozessoren.
Der Prozessor 1 haben wir, wie gesehen,
ist zuständig für die Initialisierung. Und die Randsegularitäten,
dann hatten wir die Aufteilung von X in P plus 1
Blöcke von etwa gleicher Länge. Und jede parallele Runde,
er findet ein X-Eg gleich Y oder einen Y enthaltenen,
um der Vlog ja bitte
Und was wäre der Mann, einen Algorithmus nehmen?
Würde der genaue Endprozessoren benutzt, wo jeder Prozessor sich genau ein Element,
diese Endpliste anguckt und derjenige, der genau dieses Element Y findet,
das einfach zurückgibt, hätte das nicht.
Ja, das hat ja auch lange der letzte Schritt.
Er ist der letzte Schritt, war das davor, ohne das.
Das würde dann fallen, weil wir ja die Abfrage von haben.
Dann hätten wir, um jetzt die Zeitkomplexität, oh,
von eins und von der Sendung extrem hoch von Enden.
Warum wäre der nicht? Ja, das wäre ja
nur ein Schritt. Nur derjenige, der das findet,
der gibt die Ausgabe.
Und weniger Prozessoren auszubauen
Bitte? Das würde aber mit weniger Prozessoren auszukommen, warum man da...
Ja, natürlich, weil dieses Feld hat ja vielleicht
die Größe von Millionen und wer hat schon Millionen Prozessoren?
Ja, aber wir wollen ja nur im Großbruch von er
den Prozessor Komplexität haben. Nö, Theorie. Ja,
was ist denn hier jetzt hier? Ja,
und dann habe ich gesagt, konkret ist es natürlich so,
dass wir immer weniger Prozessoren haben als wir Längen.
Gut, ich habe jetzt hier nochmal ein konkretes Beispiel.
Jetzt habe ich hier also schon mal die Elemente angeziehen,
also jetzt hier schön verteilt, 2, 4,
6, 8, 10.
Das sind jetzt meine Ausgangselemente,
Mein zu suchendes Element ist 19, also zwischen 18 und
20 und das Ganze jetzt mit zwei Prozessoren. So,
dann würde er jetzt,
wenn wir jetzt diese ganzen Iterationen jetzt mal ablaufen lassen,
das so aussehen,
dass wir hier die linke und die rechte Grenze ganz am Rand setzen und hier haben wir C00 und C1.
Das heißt also, das Fenster,
was wir für links und rechts betrachten,
ist also das Ganze und darin liegt natürlich das Elemente sozusagen eine Invariante,
eine Schleifen in Variante.
So, in der nächsten Iteration würde sich dann also
das Feld hierhin verkleinern, hier zwischen 5 und 10.
Und dann würde das neue 100 und C1 C2 dann hier so eingesetzt.
Und ja, das sind die Grenzen. Das heißt also,
das entsprechende Feld wäre dann jetzt so. Dann in der nächsten Iteration,
wo wir das Element ja dann hier trügen,
gefunden hätten, würde sich das Suchfeld hierhin verringern.
Und ganz am Schluss haben wir dann weniger als zwei Prozessoren Unterschied.
Die linke Grenze und die rechte Grenze,
die unterscheiden sich nur um eins
Also wir, da wir jetzt nicht den Fall haben,
dass die 19 gerade da enthalten ist, dann,
glaube ich, müssen wir nochmal genau gucken,
dann findet das, glaube ich, der rechte Prozess,
erfindet das und nimmt das dann hier,
rechnet dann 9 plus 1 minus 1 und findet dann da diese entsprechende Position 9 für das Y.
Das war jetzt also hier dieser letzte Sonderfall,
wo wir ungefähr so viele Prozessoren haben,
wie wir
nur Elemente haben
Ja, das heißt also, wir hatten ja behauptet,
dass das Ganze jetzt zu schaffen ist in Log End Plus 1
bis Log Pey Plus 1 durch Zeitkomplexität.
Ja, und die Berechnung von dieser Zeitkomplexität,
das wird in dem Buch und dann auch im Skript,
dadurch beschrieben, dass man so eine rekrusive Ungleichung hat,
nicht wo man also SE oder SE minus 1 hat,
auf beiden Seiten einer Ungleichung und die ist dann eben lösen kann.
Das kann ich jetzt hier nicht vorführen,
sondern ich habe jetzt einen analog Schluss,
der so ungefähr, dass vielleicht klar machen kann,
warum das hinkommt
Wir haben ja bei der Abbruch der Waldschleife das letzte Element,
ist ja kleiner als P,
also links minus rechts ist kleiner gleich P im letzten Intervall.
Und im, ja, das heißt, S-I-minus 1,
das ist kleiner als P-Plus, ein Payplus 1. So,
in der, in dem Schritt vorher haben wir ja das Entsprechende mit dem Quadrat,
weil wir ja das entsprechend immer der Vielfachen der Prozessoren immer verkleinert haben,
also wenn wir jetzt rückwärts gehen, dann die entsprechende Vergrößerung.
Ja, gut, beim Nummer 3 Stück zurück kriegen wir
das also hoch 3 und irgendwann mal wird man dann
Beim ersten Schritt ein Ankommen und beim nullten Schritt, wie hätten wir dann eh.
Und eh ist ja jetzt die Anzahl der Schleifendurchläufe, die uns interessiert.
Und dann würden wir jetzt also für die Anzahl der Schleifendurchläufe bekommen,
weil wir ja jetzt sozusagen das ganze Feld am Anfang umfassen,
also N oder Endlos 1,
dass wir dann das E jetzt Logerhythmus zur Basis P plus 1 von Endlos 1 wäre.
Und wenn wir das auf den Zweierlogerhythmus umschreiben,
würde das dann in den Nenner kommen.
So kann man das umgekehrt sehen. Ist ein bisschen geschönt,
damit das alles so ein bisschen hinkommt.
Aber so kommt das ungefähr hin
Ja. Ja, nicht, da sieht man also,
wie jetzt dieses exponentiell oder dieses Wiederholte, ja,
kann man sagen,
verkleinern sich dann in dieser Zeitkomplexität dann eben wieder erspielen.
Gut. Das heißt, das haben wir bis jetzt geschafft?
Jetzt nochmal als Tabelle zusammengeförst. Wir hatten ja zunächst mal
das Mischen in Logerhythmus ein N,
Zeitkomplexität und O von N, Operations im Komplex.
Wir sehen,
das war optimal
Dann hatten wir das verbessert nach Log-Log-in mit dem schnellen Suchen.
Und der nachfolgend beschriebene Satz macht das dann also auch noch
optimal, indem wir hier die Zeitkomplexität beibehalten können.
Aber die Operation, Komplexität dann wieder nach Ovon N.
drücken können und das Ganze optimal machen können.
Das heißt also, am Anfang hatten wir nur dieses vimäres Suchen eingesetzt.
Dann hatten wir das verbessert durch das Parallele Suchen.
Und jetzt kommt noch ein Abschnitt,
wo wir dieses mit den Blöcken besser machen,
indem wir jetzt eine andere Bloggröße eben erwähnen.
Das heißt, als nächstes wird jetzt noch ein schnellerer Algorithmus
zu mischen entwickelt, der jetzt in Locklock-End-Zeit eben arbeitet.
Nicht, das ist insofern erstaunlich, weil ja schon die
Maximum-Schritte Lockerhythmus einparallele Schritte eben erfordert. Und das Lämmern,
was wir dann jetzt eben ableiten wollen,
ist dieser Algorithmus berechnet, also jetzt dieses Welchproblem,
den Rangbestimmung in dieser entsprechenden Komplexität
Ja, und worin jetzt der Unterschied besteht, das sehen Sie auf den zweiten Blick,
dass wir jetzt hier die Plotgröße jetzt mit der Wurzel wählen.
Das erscheint jetzt zunächst mal gar nicht einsichtig und nur aufgrund der Analyse,
der kommt dann eben heraus, dass das wirklich was bringt.
Da muss man dann also erst mal drauf kommen. Das heißt also,
wir schaffen jetzt Plöcke, der länger erwurzelnden M und das heißt also,
wir achten die Elemente eben mit dem Algorithmus,
den wir eben vorher hatten, ebenso, dass wir da diese Wortel-M-Blöcke haben.
Und dann suchen wir ja die entsprechenden Einträge in den AE und kriegen dann die,
ja, die A-Blöcke und dann behandeln wir sozusagen die Teile vorher,
die jetzt hier schon grün hervorgehoben sind und berechnen,
dann machen da an dieser ansprechenden Stelle dann eben weiter.
Ja, das war anderes jetzt im Detail nicht,
sondern nur jetzt in Form eines kleinen Beispieles,
nicht M gleich 4 und purzel M gleich 2,
das war kein großer Unterschied zu einem Logorithmusbeispiel,
aber es geht jetzt nur um das Prinzip,
hätten wir ja dann hier also jetzt die B-Blöcke bis dahin
und dahin und die entsprechende Eintrag wäre dann an dieser Stelle.
Das wären sozusagen die rechten Grenzen der B-Blöcke.
Und dann haben wir da die rechten Grenzen der A-Blöcke.
Das wäre also jetzt der,
die 2 hat den Rang 2 und die 21 stehen Rang 6.
Und jetzt geht es also vorher weiter.
Die 1, in dem, in dem Block und die
5 sind in dem Block und das gibt dann die Ränge 2 und 4.
So arbeitet das im Detail. Ja, wie gesagt,
also da mache ich jetzt nicht mehr im Detail,
sondern zitiere nur noch das Ergebnis.
Denn Beweis habe ich mir noch die Mühe gemacht im Skript,
nochmal sozusagen skizziert aufzuschreiben. Und das Volk im Wesentlichen,
diesem Buch von Yaltya, ein Introduction to parallel Algorithmus.
Und wir haben damit jetzt das Korrola,
nicht wenn wir also endgleich M setzen,
dass wir zwei suchtierte Folgen der Länge nennen,
können in Locklock and Zeit mit N Locklock and Operation
eben gemischt werden
Ja, und in der Tat geht es aber noch besser,
wo ich jetzt auch wieder auf das Buch fallweise,
wo ich aber jetzt nicht mal mehr den Beweis übernommen habe.
Denn wir können jetzt hier das N-Lock-Lock-N,
kann man sogar noch auf Ruhe von N-Operationen reduzieren.
Wobei man jetzt die Zeit eben beibehält. Und da sieht man,
da steckt eine ganze Menge jetzt drin im Lesen.
Milchalgorithmus, den wir ganz am Schluss eben haben,
also da auch wieder nur der dazukommen,
auf das
Ja,
und dann käme ich dann jetzt zu dem Parallelen Mission Palien Merch sort,
was ja, wie am Anfang schon dargestellt hat,
diese Komplexität haben und was jetzt durch sukzessives Mission dann funktioniert,
wo wir jetzt also uns nur noch jetzt vergewissern müssen,
dass er tatsächlich diese Komplexitäten eben erwischen.
Ich finde, dazu ist es nur sinnvoll,
erstmal hier nochmal Notationen einzuführen, die Höhe 0,
1,
2,
Und außerdem Bezeichnungen für die Knoten, das heißt,
hier haben wir in der Höhe Null,
haben die in der ersten Komponente alle Null und in der zweiten Komponente werden hier durch,
in der Maria, nicht in der Höhe zwei,
haben wir hier überall die Eins und dann werden sie von 1 bis 4 durchnummeriert,
in der Höhe 2 von 1 bis 2 und der Höhe 3 haben wir nur,
das alles liegt einfach nur daran,
dass wir dann in dem Algorithmus,
wenn wir den,
sozusagen als Pseudocode aufschreiben,
sozusagen diese gedachten Stellen dann
eben ansprechen können
Ja, nicht? Und nun geht's los. Das heißt,
wir haben also jetzt den Algorithmus, ein Feld X,
der Länge N, wo wir beide wieder übrig,
das N, jetzt als Zweierpotenz annehmen und zur Not eben auffüllen,
wenn wir eine kürzere Folge haben.
Und wir haben jetzt einen binären Baum mit in Plättern. Und ja,
und in diesem Baum wird also dieses L, HJ,
nicht was jetzt hier diese Werte sind,
wird die eben dann für jedes,
für jede Höhe,
die sortierte Teilfolge in den Elementen
eben enthält
Und damit enthält jeder Knoten, die entsprechende sortierte Liste. Nicht nur, das geht eben so, dass wir am Anfang unsere Ausgangselemente hier unten platzieren, sich in der Höhe null,
nicht von J gleich 1 bis,
bis N. Und dann geht es weiter von der Höhe 1 bis zur Worte,
also Höhe Logorithmus N.,
haben wir jetzt Ende durch jeweils N durch zwei Haaren Parallele Prozessoren,
die dann eben hier von der Höhe H minus 1 Einträge,
2 J minus 1 und 2 J. Die entsprechende,
das ist auch die alte Liste berechnet, eine Höhe,
eine Höhe weiter,
also von heiminus 1 auf how-ha und an der Stelle J,
so wie das hier unten dann eben vorgeführt ist.
Und das heißt also dann für die Wurzel haben wir ja dann,
haben wir ja dann die ganze Liste sortiert, dann eben vorlegen.
Ja, und wie kommen wir jetzt zu diesen Komplexitäten?
Das war jetzt also die Aussage und dazu brauchen wir dann
jetzt aber nochmal die Ergebnisse von dem besten Ergebnis,
was wir jetzt eben in der Zusammenfassung dann zitiert haben.
Nicht, dass wir also das Schnelle mischen,
von Folgen der Länge M in der Zeit Locklock M und in der Operationenkomplexität,
Urvon M erschaffen können.
Und daraus wollen wir jetzt also diese Komplexitäten dann eben ableiten.
Dazu überlegen wir uns, dass wir in der Höhe H,
haben wir nur Folgen der Länge 2 Hochhaar. Das heißt,
in der Höhe Null ist 2 Hochhaar gleich 1. Das heißt,
hier haben wir nur Folgen der Länge 1.
In der Höhe 1 ist 2 Hoch 1 gleich 2,
haben wir Folgen der Länge 2 und hier entsprechend dann weiter
Daraus folgt, dass wir jetzt als Zeitkomplexität haben, folgendes.
Das heißt, wir nehmen jetzt die Zeitkomplexitäten für das Mischen. Das heißt,
das ist ja dann gerade Lock Knock, zwei Hochhaar,
weil wir ja die Höhe, die Länge zwei Hochhaar haben.
Und da haben wir jetzt die entsprechende,
die entsprechende Zeitkomplexität, die wir doch entsprechend eben einsetzen.
Und Logarhythmus zwei Hochhaar ist dann gerade wieder Haar und nicht,
und das können wir jetzt abschätzen zu Lock Lock N,
die Höhe höchstens durch Log-in eben beschränkt ist,
auf diese Art und Weise kommen wir dann zu der Zeitkomplexität.
So, dann brauchen wir jetzt noch die Operationenkomplexität.
Achso, ja, das brauchen wir noch vorher.
Das war zu viel, also nochmal. Ja, nicht insgesamt,
das war ja zu sagen, nur für die Höhe Haar.
Und da wir insgesamt Logarettmuth in sozusagen Ebenen haben,
müssen wir dieses Ergebnis dann noch mit Logarithmus in multiplizieren und
dann kommen wir dann zu der entsprechenden er gegrößert hat.
Und nicht nur so ähnlich geht das jetzt auch mit der Operationenregrößität.
Da müssen wir jetzt uns überlegen, wenn wir ja sozusagen,
zählen wir ja alle Parallelen Operationen und da müssen wir überlegen,
wie viele Folgen wir haben.
Das heißt, die Anzahl der Folgen ist jetzt Ende durch zwei Hochhaar.
Das heißt, in der Höhe Null haben es zwei Hochhaarjahr 1. Das heißt, wir haben N-Folgen.
In der Höhe 1 haben wir in halbe und so weiter.
Das heißt, die Operationenkomplexität, die kriegen wir jetzt,
indem wir jetzt die Operationenkomplexität von dir oben nehmen,
indem wir jetzt die Länge der Folge mal der Anzahl neben.
Die Anzahl, weil es endlich zwei hoch enden und das zwei Hoharm,
das war eben die weinige Länge, plötzlich weg,
sodass wir jetzt also zu dem U-Funden entkommen und insgesamt,
wenn wir jetzt gewissermaßen allen Ebenen zusammenzählen,
dann kriegen wir jetzt And Love N.
Das heißt also, das kann man auch gut so sagen,
als Merkregel benutzen,
anstelle sich der binären Baum vor,
der hat die Höhe Logerhythmus N und dann kommt eben
das Logerhythmus N kommt hier vor und dann kommt eben
dieser Charakteristiker für dieses schnelle Mission hinzu und dann kann man
so das vielleicht ganz gut gut merken
Ja, das bin ich eigentlich am Ende und wirst du
eigentlich gar nicht mehr, was ich noch machen soll.
Haben Sie jetzt noch Fragen? Können Sie jetzt fragen,
über die ganze Vorlesung stellen? Ansonsten können Sie die Fragen
auch für Donnerstag aufbewahren, woher Molt da nochmal durchgeht,
aber natürlich auch die ganze Vorlesung in einer Doppelstunde ist natürlich knapp.
Sonst machen wir jetzt halt Schluss und ihr
könnt euch ja mal lernen anfangen.
Okay,
vielen Dank erstmal