So, die Idee, wenn jetzt mehrere parallele Maschinen hat,
die auf diesen gemeinsamen Speicher zugreifen, muss man sie in irgendeiner Weise koordinieren.
Entweder macht man es über dieses Exclusive Reed and Exclusive Right,
das dort dann eben kein simultanes Arbeiten auf dem Speicher zulässt.
Oder eben dieses Concurrent Read und Exclusive Right und dann die verschiedenen Möglichkeiten,
die entsprechenden Konflikte jetzt aufzulösen, gucken wir uns dann hier nochmal an.
Discon country, concurrent Right und da haben wir dann entsprechend die mögliche
dass wir alle denselben Wert rausschreiben oder aber dass sozusagen irgendeiner gewinnt oder aber,
dass das Ganze über Prioritäten geregelt wird,
wer dort sozusagen welche Sachen machen kann, wer daraus schreiben kann.
So, diese Modelle sind dann nachher im Hintergrund,
die werden wir meistens bei so einem Verlauf gar nicht
so richtig mehr betonen, wo da die jeweiligen Stärken liegen.
Dann haben wir die entsprechende Komplexitätsmaße bei den Dingen,
da müssen wir darauf achten,
dass wir jetzt nicht nur sozusagen die Zeit uns angucken wollen,
sondern eben auch noch andere Dinge wie eben die Anzahl der Prozessoren,
die wir dort mit reinnehmen wollen, weil es sozusagen darauf ankommt,
wie viele gleichzeitig auch noch mit arbeiten.
Dann haben wir die entsprechende Produktzeitkomplexität,
wo wir es halt entsprechend multiplizieren und dann entsprechend das Work,
was wir dann als Operationenkomplexität dann eben auch gerade ansehen.
So, die Idee ist jetzt, dass wir so ein einfaches Beispiel hatten,
das war ja das, wo wir letztes Mal quasi aufgehört haben.
Wir haben also unseren gemeinsamen Speicher, die einzelnen Prozessoren,
die da jeweils arbeiten und die haben elf,
drei und sieben Schritte und da kann man sich halt die Prozessorenkomplexität mit drei ablesen, Zeit,
die mit elf sozusagen da durchkommt und entsprechend das Work als 21,
weil das die Anzahl der jeweiligen Operationen sind, die dort überhaupt stattfinden.
Während also die Prozessorzeitkomplexität dort eben 33 ist, weil wir
entsprechend dieses elf mal drei berechnen. Wir gehen davon aus,
dass wir irgendwie so eine Abschätzung dazu haben, wo wir davon ausgehen,
dass das in etwa die Anzahl der Operationen ist.
Das heißt, wenn wir unser Programm nicht besonders intelligent schreiben,
haben wir am Anfang erstmal 20 Prozessoren und dann nur im
ersten Schritt und danach ist nur ein einziger,
der da nochmal 20 Schritte sozusagen danach nochmal macht.
Hätte man also 21 Schritte und die ganze Zeit 20
Prozessoren,
Eidel daneben herlaufen
Bei manchen Anwendungen geht es nicht anders. Bei geschickter Wahl bei dem,
was wir nachher noch sehen werden. Gibt es da durchaus Möglichkeiten,
das zu optimieren und zu sehen,
wie man dann die Last auf die einzelnen Prozessoren ein bisschen besser verteilen kann,
sodass man eine gleichmäßige Auslastung kommt,
sodass man in die Region reinkommt,
dass dieses PT gleich Work sozusagen in etwa ist.
Also ungefähr. So, die Idee ist jetzt,
dass man so eine entsprechende beste Zeitkomplexität für so
ein Problem unterm sequenziellen Algorithmus ja vorfinden kann.
Wir hatten zum Beispiel spinäre Suchen,
wie sah es damit aus,
wie ist da
die entsprechende Komplexität
Ja, okay. Wie funktioniert das Binäre Suchen so
in etwa? Okay, noch ein bisschen lauter für die
da hinten
Das probiere ich nicht von meinen Mutterwerfen. Ich muss aber
keine Ahnung haben, als er die alten Vater liegt. Ja,
oder man hat das unten liegen und entsprechend teilt man sich das irgendwie ein und sagt,
redet sozusagen die Hälfte und dann sagt man größer oder kleiner
und dann geht man in die entsprechenden Bereiche rein und kann
entsprechend mit der Zeitkomplexität dann die entsprechenden Sachen suchen.
Genau, genau. So, die Idee ist jetzt,
wie man das, kriegt man das
irgendwie schneller hin?
Als Endlogin
Nein. Okay. Können wir hier mal gucken,
ob wir da noch genau mit diesen Maschinenchen,
die wir jetzt hier haben, vielleicht doch noch schneller werden können.
Das ist ja genau eine der Ideen dahinter. So,
wenn wir also im Parallelen Algorithmus,
den wir natürlich auch nehmen können, und das heißt,
wir sind also mindestens genauso schlecht oder genauso gut wie der,
indem wir einfach einen Prozessor laufen lassen und das dann genauso machen.
Das heißt, da werden wir nicht schlechter werden als die sequenzielle Lösung.
Die Frage ist halt nur, wo man da eventuell
noch schneller werden könnte oder besser in irgendeiner Hinsicht.
Und die Frage ist, wann ist man optimal
Und im Grunde genommen versucht man dann,
das darauf zu reduzieren, dass man die Anzahl der Operationen,
die ich auch im sequenziellen Fall habe,
entsprechend auch bei den nebenläufigen Maschinen habe.
Wenn ich dann so und so... Wenn ich dann so und so schon nebenläufig arbeite,
aber die gleiche Anzahl von Operationen habe, kann ich ja davon ausgehen,
dass ich auch ein bisschen schneller werde als das andere Teil.
So, wenn wir hier unsere Idee,
dass wir diesen Algorithmus optimal schimpfen,
wenn es in etwa so hinkommt,
dass wir die Zeitkomplexität vom sequenziellen Fall der Beste,
der uns bekannt ist
Erreicht wird, indem wir halt als Operationen dort nicht mehr vorfinden,
als das an einzelnen Schritten ausgeführt wird. Gut,
wenn wir jetzt unser V-Ager 21 haben,
können wir halt da entsprechend durchlaufen und gucken und dann ziehen wir sie immer so ab und sagen dann,
naja, okay, funktioniert auch im Parallelen,
wenn es denn sozusagen gerade die Anzahl ist, die man auch im sequenziellen Fall benötigt hat. So,
jetzt ist diese Idee mit diesen Prozessoren läuft unter dem brennischen Skettling-Prinzip,
muss ich jetzt überlegen, wie das funktioniert,
gibt es da so einen schönen Satz zu,
der Beweis kommt dann auch noch gleich nochmal,
wenn also eine Berechnung auf M gleich diesen Max-I-Prozessoren in SIT ausführen kann,
wobei X eben die Anzahl der Operationen im Eaten-Schritt ist,
dann kommt man auf P kleiner M und Prozessoren,
also wir haben P kleiner M-Prozessoren,
dass wir dieselbe Berechnung in der Zeit T plus X durch M,
unabgeschätzt ausführen können,
wobei X eben gerade die Summe dieser einzelnen XI ist.
So, was will uns der geneigte Leser jetzt hinterher dazu erzählen?
Was passiert da vom Prinzip? Wenn man Media-Prozessoren hat,
Ja, ne, das ist so,
man weniger Positionen, da braucht man mehr Zeit,
das ist auf jeden Fall schon mal okay.
Und jetzt gibt es eine relativ klare Ansage,
wie diese Zeit eigentlich aussieht, nämlich X durch P,
ist sozusagen das, was man zu dem normalen Tee nochmal dazu packen muss.
So, und jetzt ist die Frage, was da eigentlich genauer passieren wird.
So, und die Beispiele haben wir jetzt drei Prozessoren und
das können wir da dann im Grunde genommen haben.
Wir können jetzt oben die drei stehen haben und können entsprechend zwei draus machen, ne?
Oder oben mal hingucken. Also zwei Prozessoren da draus.
Jetzt die Frage, was da denn entsprechend passiert.
Wir haben jetzt jetzt unsere entsprechende Anzahl von Arbeitsschritten, haben eben die entsprechenden 21.
Das sind jetzt gerade unsere XI, die wir dort drin vorfinden.
Und die wir jetzt irgendwie ja dann mit dem Teil da oben irgendwie wieder verteilen müssen.
Also was irgendwie eine Auswirkung hat jetzt auf die entsprechende Zeit. So,
und jetzt können wir uns das Tee plus X nochmal angucken,
das ist im Grunde um diese 11 plus,
ja 21 durch 2, also 21,
sollten wir es auf jeden Fall wieder hinkriegen.
Dass das so und so klar ist,
weil es so und so nur 21 Schritte sind,
die nacheinander ausgeführt werden können, ist davon erstmal unerheblich.
Auf jeden Fall sagt er erstmal in dem Bereich,
können wir uns auf jeden Fall bewegen
So, was muss ich dann eigentlich tun? Naja,
ich muss irgendwas machen, ich muss diese M-Schritte irgendwie da
nach unten schieben und unten irgendwie einsortieren.
Das ist das, was man dann entsprechend da macht.
Was passiert, wenn ich nur einen habe? Naja,
dann schiebe ich das Ganze sozusagen ganz nach unten durch.
Dann habe ich sozusagen jetzt aber nach der Berechnung,
was ich vorher gebraucht habe, würde ich sagen, ja, 32.
Also aus der Berechnung käme halt das 32 raus,
wobei ich vorher dieses Operationending mit 33 berechnet hatte.
Also ich bleibe da sozusagen auch noch drunter an dieser Stelle. Okay,
so, jetzt gucken wir uns noch mal an,
wenn wir das jetzt sagen, für vier Prozessoren haben,
die voll ausgelastet sind mit diesen Zweier-Dingern.
Jetzt wollen wir es mit dreien machen. Was wird jetzt
gerechnet? Naja, die Rechnung ist relativ einfach.
Wir haben unsere zwei Zeiteinheiten, die wir haben,
weil wir genau zwei Schritte brauchten.
Und wir haben jetzt acht durch drei,
die wir dazupacken müssen, also eigentlich vier.
So, wie kommt das jetzt zustande? Warum brauche ich
jetzt vier? Ich könnte auch die zwei Dinger nehmen und
einen auf M0 und einen auf M1 liegen,
brauche ich nur drei.
Aber warum kommen wir im münstigsten Fall
das jetzt so rum sein müssen
Ja? Weil Abhängigkeiten bestehen, genau.
Wenn ich jetzt nämlich hingehe und das verteilen würde,
musste ich quasi den ersten Roten, der da zu sehen ist,
dass sozusagen der erste von M3. Und wenn die aus dem
zweiten Schritt alle auf dieses Ding gewartet haben müssen,
dann müssen eben alle auch nach hinten geschoben werden.
Dadurch verschiebt sich eben die grüne Reihe in die dritte Zeile.
Und dann haben wir ja noch den vierten von M3,
den wir auch noch irgendwie runterschieben müssen.
Und dadurch kommen wir auf die entsprechenden vier Zeiteinheiten,
die wir dann da im ungünstigsten Fall haben müssen
Dass es für den einzelnen speziellen Fall vielleicht auch mal schneller gehen könnte,
ist eine andere Geschichte. Es geht hier sozusagen um die grundsätzlichen Abschätzungen,
die wir erstmal da berücksichtigen müssen, was uns schlimmstenfalls sozusagen passieren kann,
wie viel wir weiter schieben müssen. Das heißt,
für unseren Fall hier mit unseren nur 21 Aktivitäten,
die dann einmal 11 und einmal 3 und einmal sieben Schritte lang sind,
könnte man auf die Idee kommen,
das ist vielleicht nicht ganz so schlimm, ist,
wenn man das irgendwie anders durchschedult und ein bisschen geschickter macht.
Für den Fall, dass er aber die ganze Zeit ausgelastet wären,
müsste man es eben entsprechend weiter nach unten teilen und entsprechend
21 Zeitschritte vorsehen, dann auch im ungünstigsten Fall.
Man würde das auf jeden Fall mit 21 Zeitschritten
aber auch hinbekommen
Das ist das, was dahinter steht. Dadurch hat man
also auch was als Aussage dazu. Und dass man,
wenn es sozusagen gerade im ungünstigsten Fall komplett voll ist,
dass man das so durchschieben muss, dann haben wir die entsprechende Zeit,
die wir sonst auch vorliegen haben.
So, das ist jetzt sozusagen jetzt hier der Beweis,
warum das so stimmt, wobei das ja recht hemmsärmlich einfach ist.
Wir haben also diese entsprechende Zeit und wir summieren über die einzelnen Teile
einmal auf und teilen das durch die Anzahl der Prozessoren.
Das gucken wir, wie wir das jetzt aufteilen können.
Wir gucken in jedem Schritt von dem XI, teilen das
und packen das darauf. Wenn wir also Pech haben beim Teilen,
entweder mit der glatte Zahl oder eine schiefe Zahl,
deswegen wird nach oben aufgerundet jetzt im Moment.
Und wir nehmen also immer statt 3,3 oder 6,4
oder sowas packen wir entsprechend entsprechend die obere Zahl,
also 4 bzw. 7 entsprechend einaddieren, das für jede Zeit einmal auf,
von 1 bis T.
Und können das sozusagen hinschreiben als die Gleiche Geschichte,
wenn wir die gesamte Summe nach unten wieder abschätzen, warum funktioniert das?
Genau, sind so ganze Zahlen, deswegen ist das klar,
sehr schön. So, und das soll jetzt auf jeden
Fall kleiner sein als das, was danach kommt.
Danach haben wir jetzt wieder die entsprechende Auflösung, was wir
ja vorher schon stehen hatten, dass dieses XPI sozusagen damit reinkommt.
Wir haben jetzt also die, auf jeden Fall wiederum kleiner,
als wenn wir die XI plus 1 jeweils aufaddieren und
das Thema
Weil das andere war die Abschätzung, wir hatten,
also einmal hatten wir vier und einmal 6,4 und einmal 3,3
und deswegen hatten wir vier plus sieben plus die entsprechende vier,
mich meine Zahlen richtig im Kopf zusammenkriege.
Und das muss ja nicht sozusagen wirklich immer größer sein,
wenn es zufällig immer gerade Zahlen sind,
kommt es eben gerade, kommt es genau hin,
dass es sozusagen das Gleiche wird.
Aber auf jeden Fall ist es kleiner gleich
dieser entsprechenden Summe
So, und jetzt können wir die Einzelne sozusagen rauszählen,
weil die wird zehnmal dabei.
Das ist sozusagen das, was da thema vorkommt.
Das ist das Tee. Und was übrig bleibt,
ist genau diese Abschätzung für die Summe von 1 bis T
über die XI durch P. Und das hat mir gerade genauso definiert,
dass wir das X durch P dahin geschrieben haben. So,
und damit haben wir eigentlich gezeigt, dass das,
was wir oben geschrieben hatten, das ist nämlich mit dem,
wenn wir diesen Prozessoren P kleiner M haben,
dass wir entsprechend die Zeit und diesen Anteil maximal sozusagen erhöhen müssen.
Kann auch
weniger sein
Aber das hängt eben von den jeweiligen Situationen ab.
Das ist halt so eine obere Abschätzung an der Stelle.
Gut, das sind also genau die beiden, die wir
auch entsprechend da finden. Und das ist unten genau das,
was ich gerade eben vorgerechnet hatte,
wo wir dieses Weiterschieben um diese zwei Dinger genau haben,
weil das eben gerade ungünstig hinkommt und wir das alles weiter durchreichen müssen.
Und dadurch mit dem Einsortieren da entsprechend hin.
Wenn man also eine Berechnung, die O von N sequenzielle
Zeit braucht, auf N-Prozessoren, in Log-End-Zeit ausführen kann.
Ich will gleich mal sehen, was das eigentlich genau heißt.
Dann kann man diese Berechnung auf den entsprechenden O von N
durch Log-End-Prozessoren in der Zeit O von Log-End auch ausführen.
Das heißt, in optimaler Zeit,
weil nämlich O von N sozusagen erhalten bleibt,
in Bezug auf das, was wir sequenziell haben.
Das ist ja das, was wir jetzt gerade definiert haben,
wann so ein Algorithmus optimal ist. Sehen wir jetzt hier,
wir haben also einen Prozessor und der hat seine O von
N-Abarbeitung und nun behaupten wir, naja,
wir können das auch mit N-Prozessoren in O
von Log-End-Zeit machen
So, das ist eine Geschichte,
die kann man sich überlegen, für welche Sachen das hinkommt.
Das klappt nicht immer. Aber für den Fall,
wo das jetzt klappt, das ist sozusagen die Annahme ja dabei.
Können wir jetzt arbeiten. So,
und jetzt können wir das Teil von oben entsprechend wieder anwenden und sagen,
naja gut, dann kriegt man es auch hin,
dass wir in N durch Login-Prozessoren das auf die Reihe bekommen.
Also ventuell haben wir schon, wir haben vorher irgendwie einen Prozessor gehabt,
aber wir schaffen das in O von Login.
Das heißt, das Problem ist so, dass es diese
komische Aufteilung für dieses Login in irgendeiner Weise geben muss.
Und dann, wenn das der Fall ist,
dann kann ich diese Umordnung entsprechend auch vornehmen
Sonst nicht. Die Details, warum das genauso ist,
müsst ihr den Originalliteraturdaten lesen, das steht bei uns nicht mehr weiter zu drin.
Das ist sozusagen jetzt einfach nur so ein Fakt,
dass man das halt an dieser Stelle mitnehmen muss,
dass man das machen kann. Wie das genau geht,
wird auch nicht in der Prüfung abgefragt, aber wenn ihr Interesse habt,
könnt ihr da entsprechend nachgucken und euch das nochmal anschauen,
warum das jetzt genau für welche Voraussetzung, für welche Algorithmen genau geht.
So, wenn ich jetzt also entsprechend diese X-Einsätze und M-Prozessoren habe,
statt diesem M, dann brauche ich eben T-Zeit und dieses O von P-Prozessoren
Und dann komme ich eben genau auf diese entsprechenden T plus X durch P-Geschichte raus.
Und das ist genau das Log-in und N durch N-Log-in in dem Teil.
Kommt man genau rein, wenn man das entsprechend jetzt so entsprechend zuordnet,
sieht man, dass das daraufhin entsprechend übertragbar ist,
sodass man da zu diesem optimalen, zur optimalen Zeit halt hinkommt.
Das ist entsprechend diese Einsetzung, die wir dann da vornehmen können.
So, jetzt gibt es ein paar Beispiele für diese Peram-Algorithmen,
um diese Algorithmen jetzt eben zu beschreiben,
benutzen wir eben so einen parallelen Ausdruck.
Das ist jetzt halt so eine Kurzschreitweise, sonst müssen wir es anders notieren.
Wir haben so ein paar A, kleiner I,
kleiner gleich B, für die SI, um zu beschreiben,
dass die Anweisung SI für alle I mit dem zwischen A und B parallel ausgeführt werden sollen.
Gut, das heißt, wir machen genau das sozusagen für alle einmal durch.
Das Beispiel, was da jetzt kommt,
ist sozusagen das Maximum finden,
wir haben also zwei Hoch-M natürliche Zahlen von AN bis A,
zwei minus N und gesucht
wird das Maximum
Und der Algorithmus für das EERAM, also Exclusive 3,
Exclusive, Read, Exclusive Right, Peram,
durchläuft mir jetzt halt diese Schleife,
dass man halt einfach für Elvis M minus 1 einmal runterzählt
sozusagen und dann diesen parallelen Ausdruck macht und das Maximum entsprechend zuweist.
Und dann hat man sozusagen schon die Lösung. Wie sieht das
aus, wenn man das mal bei zwei Beispielen anguckt?
Ich habe irgendwelche Zahlen, die irgendwie so in der Gegend
rumstehen und jetzt möchte ich in irgendeiner Weise hier die Sache mir angucken.
Ich vergleiche die beiden jeweils Guckt mir das an.
Was war denn da das Maximum? Links ist die 10,
die 2, die 9 und die 7 sind in der
zweiten Geschichte jeweils das, was wir da rauskriegen.
Naja, die gewinnt die 10 da und die ziehen dort entsprechend.
Und wir haben entsprechend diese Sachen. So,
die Idee ist jetzt, wenn man also diese entsprechenden Möglichkeiten hat,
wir haben jetzt unsere Endprozessoren gehabt, wir haben in Login-Side die Sachen geregelt.
Jetzt müssten wir das auch in N durch Login-Prozessoren hinbekommen.
Und da muss man halt einfach das brennische Prinzip anwenden und
das wieder so umteilen
Und aufpassen, wie das ist und kann das dann trotzdem noch in Lockdown-Zeit hinbekommen.
Das bedeutet mir, es war vielleicht so tick,
absolut technisch, vielleicht ein Tickchen mehr braucht,
aber das bewegt sich in der Größenordnung von dem Login,
was wir da haben.
Das bewegt sich also im normalen Rahmen, dass man das entsprechend mit einbauen kann.
Wenn wir jetzt also dieses eng gleich Acht haben,
kommen eben sozusagen zwei Zeiteinheiten mehr und man kriegt das dann entsprechend mit hin.
So, jetzt ist die Frage, kriegt man das auch irgendwie schneller hin?
Hatte ich ja eben schon mal so in Robson immer die Fragen,
kriegt man das besser hin oder nicht oder wie schaut das aus?
Naja, der Algorithmus mit N-Quadratprozessoren, so das Maximum von
Endzahlen in der Zeit O von 1 finden.
Wie soll das denn gehen? So, und jetzt stellst du die Frage,
was soll da denn so passieren und wie stellt man sich das so vom Prinzip vor?
Und die Schwierigkeit besteht jetzt für euch da drin,
dass, was ihr euch sozusagen vorstellen müsst dabei.
Und versucht euch einfach diese vielen Maschinchen nebeneinander vorzustellen als kleine einzelne Teile,
Prozessoren, die eben bestimmte Sachen machen können und dann halt auf diesen gemeinsamen Speicher zugreifen können.
Und jetzt müsst ihr euch überlegen, wie ihr sozusagen einzelne
Blöcke von diesen Teilen bestimmte Sachen abarbeiten lasst.
Und man kann die auch so ein bisschen umarrangieren,
dass man sagt, okay, gut, die arbeiten es weile gleichzeitig,
aber ich habe die mir eingeteilt in so zwei Dimensarstrukturen,
dass sie bestimmte Dinge von den Problemen eben gleichzeitig eigentlich redundant abarbeiten können.
Dadurch können sie mehr tun, verbrauchen natürlich auch mehr Energie,
was wir letztes Mal schon so ein bisschen hatten.
Wir kommen eben mit mehr Prozessoren, können wir auch verschiedene Vergleiche schon mal überall machen.
Und wenn wir jetzt alle Vergleiche gleichzeitig überall stattfinden lassen,
weil eben nicht nur N-Prozessoren, die Endzahlen bearbeiten können,
sondern statt meiner 8 habe ich jetzt 64 und die können sich jetzt so schön aufteilen und anfangen,
mit jedem sozusagen zu vergleichen und können da mal gucken.
Jetzt nur die Frage, wenn jeder mit jedem das verglichen hat,
ist ja schön und gut, jetzt muss nur noch irgendeiner natürlich wissen,
dass er, wo sozusagen das Maximum liegt,
beziehungsweise alle müssen das wissen, weil die Sonne ja alle gleichzeitig terminieren und es muss für alle gleich klingen und so weiter.
Das heißt, wir müssen alle irgendwie genau gleich terminieren an den entsprechenden Punkten. Das heißt,
ihr müsst jetzt sehen, wie die Algorithmen so designt,
dass ihr hingehen könnt und dieses Arry,
was ihr irgendwie vor euch seht sozusagen,
die alle reden und dann irgendwas machen, mit bestimmten Merkmalen auszurüsten,
denen sie wieder in die entsprechenden Speicher reinschreiben,
die dann wieder getestet wird und die dann entsprechend wieder zugegriffen wird von den nächsten und dann wird eine Entscheidung getroffen,
weil dass man nur sozusagen die einmal separat arbeiten lässt,
das funktioniert natürlich nicht,
sondern man braucht immer sozusagen noch eine lineare Anzahl von Schritten,
mindestens,
um zumindest einmal nochmal bei denen an der Nacht zu gucken und irgendwas wieder zurück zu reflektieren auf sich selbst.
Was das dann genau ist, ist jetzt genau die Frage,
wer schreibt, wo, was rein.
Und da hatten wir diese verschiedenen Modelle,
die können ja auch alle nur nach M0 oder nach M0
oder gerade nicht,
M2 M3 oder sowas
mit reinschreiben
Allen ein und sie können in die 1 bis MN reinschreiben,
also kleinen N, die Anzahl der Zahlen.
Die würden sich also gegenseitig überschreiben. Jetzt frage ich je nach Modell,
ist die Frage, wer schreibt da eigentlich was rein und
wer gewinnt und wie macht man das?
Das heißt, an der Stelle könnte man die verschiedenen Möglichkeiten der einzelnen Maschinenarten auch ausnutzen.
Also es klappt nur, wenn alle gesehen haben,
es ist das gleiche Ergebnis oder dasselbe Ergebnis. Oder irgendeiner schreibt das rein,
ist egal wer, oder aber der mit der kleinen Spriorität,
der erste, der, weil wir irgendwie wissen,
wir haben es priorisiert, vielleicht weil da eine Reihenfolge oder sowas ist,
haben wir jetzt hier diesen Fall nicht,
dann über den ersten,
der sozusagen reinschreibt und der gewinnt mit seinem Ergebnis
So, in diesem Beispiel, das wir gleich haben,
was ich gleich noch zeige, brauchen wir das Ganze nicht,
aber wenn wir das gleich nochmal anschauen.
So, wir haben also jetzt dieses Teil,
das soll den O von 1 dieses Problem für uns lösen.
Wir haben also die entsprechenden Prozessoren von, ja,
1 bis N, mal 1 bis Ende, also PIJ,
jeweils bis N durch, haben wir einen Quadratprozessoren.
Der Input ist jetzt, dass wir wissen,
welches Ende das sein soll,
das packen wir das
Und die einzelnen Zahlen packen wir halt jeweils auf das M1,
M2, M3 und so weiter bis MN rein.
Damit steht also in dem gemeinsamen Speicher, auf den alle zugreifen können,
die jeweiligen Zahlen, die wir sie angucken wollen.
Wir müssen also die Eingabe auch nicht so,
dass wir jetzt 64 mal was reinschreiben,
weil wir 64 Prozessoren haben,
sondern wir bleiben dabei,
wir haben nur acht Eingabezahlen
Was wir uns jetzt überlegen, ist,
dass wir also so ein Array von entsprechenden Berechnungseinheiten haben und
den Input haben wir halt so gesetzt, dass wir das entsprechend da zuordnen können.
Das führt dazu, dass wir jetzt also auf die M0,
das oben in der Ecke,
da können alle darauf entsprechend zugreifen und den 1M2,
M3M4, haben wir entsprechend auch da stehen.
So, wenn wir jetzt ein einfaches Beispiel nehmen,
packen wir da vier rein und wir schreiben dann halt die 27,
34 als zu bearbeitende Zahlenmenge dort jetzt rein
So, was passiert jetzt? Was machen wir jetzt?
Wir gehen zum nächsten Teil und sagen, wir haben irgendwie Arbeitsspeicher.
Und das sind die Register des globalen Speichers sozusagen,
die wir uns dann angucken. Und die Idee ist jetzt,
dass wir nachher das Maximum in dem M0 irgendwie wieder finden.
So, was wir als erstes machen, ist,
wir weisen erstmal den, das Y, sagen wir erstmal, als Null.
Das packen wir auf, das ist an der Stelle, genau.
Das kommt jetzt da, wird als Null zugewiesen.
Jetzt haben wir erstmal überall eine Null drin stehen
Was passiert hier? Und jetzt kommen wir zum nächsten Schritt
und sagen, wenn das MI kleiner MJ ist,
dann kriegt das YI eben entsprechende Eins zugewiesen.
Oder entsprechend einen Tee an dieser Stelle für Two.
So, was findet ihr da jetzt vor? Wie funktioniert
das? Naja, da die alle nebenläufig lesen konnten,
haben sie jetzt so einen Schritt gemacht,
dass sie diese Abfrage losgeschickt haben.
Jeder für sich,
jede dieser Prozessoren ist ja für eine dieser Vergleiche
sozusagen zuständig
Ja, das heißt also, wenn ich das oberste linke
F habe, dann soll der im einzelnen M1 vergleichen.
Was macht er da? Er vergleicht,
ob zwei kleiner ist als zwei und so sagen wir,
nö, nö, ist halt ein entsprechendes F,
das wollen wir jetzt nicht.
Das ist das, was lokal erstmal berechnet.
Dann haben wir für den zweiten rechts davon den Vergleich,
ob die zwei, kleiner ist als die sieben.
Und dann sagen wir, ja, kommt eine Eins rein.
Ist die zwei kleiner als die drei?
Ja, es sind zwei kleiner als die vier.
Ja, wir gehen weiter durch. Für die sieben,
da war natürlich nichts los, weil das die größte Zahl ist.
Da kommt überall, das bleibt sozusagen bei dem Null
So, das rechnen wir jetzt bis unten hindurch,
machen das für unsere paar Zahlen hier einmal fertig.
Was müssen wir jetzt machen, damit die Anweisung,
die wir links stehen haben, zu Ende geführt wird?
Nur ich weiß, dass ihr bei mir seid.
Was muss ich jetzt tun?
Ja. Also ich gucke mir die entsprechenden Sachen an und aufgrund der Anweisung,
wenn das der Fall ist, dann wird YI gleich eins.
Also muss ich entsprechend in den Zeilen jetzt hier die Eins reinschreiben und überraschenderweise,
bleibt bei Y2 die Null halt entsprechend stehen.
So, damit haben wir die Sachen jetzt soweit abgearbeitet.
Das war sozusagen unsere eine Anweisung, die wir da jetzt
hinter uns gebracht haben. So,
und wenn das YI gleich Null ist,
dann wird das M0 mit MI entsprechend beschrieben und wir schreiben
unsere sieben Reihen und wir sind durch
So, welche Zeit haben wir jetzt gebraucht? War relativ schnell, ne?
Eins, zwei, drei, fertig. Das heißt,
wir sind also in O von 1 in der Größenordnung,
wo wir da entsprechen, drin stehen.
So, was war bei den Prozessoren?
Da hatten wir ein Quadrat, also relativ viele.
Und bei dem Work, wie viele Operationen waren da jetzt drin?
Naja, das war natürlich auch relativ viele Operationen
Und jetzt ist die Frage, für welches Modell haben wir das gemacht?
Naja, das gilt für alle diese Teile,
weil wir da gar keine großen Schwierigkeiten mit hatten.
Deswegen gilt das für alle Klassen an den Stellen.
War das jetzt optimal? Ist das jetzt ein optimaler Algorithmus,
weil er jetzt den O von 1 arbeitet?
Und die gleiche Frage, wie ich schon 3000 Mal,
ist das schon das Grinsen auf den Gesichtern? Ja,
nein, ist natürlich nicht so,
weil wir natürlich was Günstigeres im entsprechenden sequenziellen Fall haben,
wo die Anzahl der Operationen kleiner ist, weil die Anzahl der Zeit kleiner ist als dieses Endquadrat.
Und damit ist das Ding natürlich nicht in irgendeiner Weise optimal
Liefert aber ein ganz überzeugendes Ergebnis,
wenn ich irgendwas wirklich schnell brauche beim Maximum,
dann habe ich jetzt hier einen Algorithmus, wo ich mit ein,
zwei, drei Schritten das Ding vorliegen habe.
Kostet mich nur ein bisschen was. So,
dann gibt es entsprechende Hauptkomplexitätsklassen, wie jetzt wann,
was, in welcher Zeit und wo berechnet werden kann.
Und wie die soeinander sozusagen sich eingliedern an diesen Stellen.
Und man kann die jetzt für die entsprechenden Modelle,
die man dann vorliegen hat für die RAM Plus und so weiter anschauen.
Das ist ja das, wo ich jetzt drüber
relativ locker drüber hinweg gehe. Das ist was,
was man sich im vertiefenden Bereich sozusagen noch mal genauer angucken kann,
um zu verstehen, wie diese Klassen jetzt in Beziehung stehen.
Wie gesagt, für Leute, die das interessiert,
die können noch mal genauer nachlesen.
Für die Prüfung gucken wir erst mal sozusagen,
dass das nicht jeder einzelne Buchstabe abgeprüft wird an den Stellen.
Was aber dahinter steht, ist,
dass wir so eine entsprechende Maschinenklasse jetzt haben und das war
die Zeit und entsprechende Prozessorkomplexität
drin stecken haben
Dieser Beweis dazu zu diesem Satz, der läuft eben genau nach diesem Skettling-Prinzip,
weil wir hinten rechts ja auch genau dieses P durch K
und so weiter stehen haben, wir müssen halt gucken,
wie diese Dinge jetzt beschleunigt werden durch die entsprechenden Veränderungen an den Maschinen,
was man daran schrauben kann.
So, die Idee ist dann,
dass man das für die CRCW-Time-Prog-Sachen halt anguckt und dass die
dann halt entsprechend in diesen O von PET-Dingern halt entsprechend drin
sind für einen Prozessor und dass das eben genau die RAM ist.
Das heißt, dass man damit immer noch im polymiellen Bereich liegt.
So, das ist das, was sozusagen als Quintessenz sozusagen
hier dann mitzunehmen ist. Und dass sozusagen ja die erste Maschinenklasse,
wenn wir uns also auf diese Sachen hier beschränken,
was durchaus in sozusagen eine Überlegung natürlich, klar,
jetzt bin ich halt nur ein Prozessor, habe, wie das dann ausschaut.
So, diese entsprechenden Maschinenklassen kann man jetzt wieder durchdeklinieren,
die ganzen einzelnen Buchstaben kommunizieren, wie gesagt,
sollt ihr euch immer angucken,
damit ihr überhaupt folgen könnt,
was da jetzt
genau drin passiert
Das heißt, dass man sich in dem P-Bereich halt bewegt
mit dem CR, CW Time Prock, Pol Pols.
Das ist immer noch sozusagen das P, wo wir uns
dann drin bewegen. Spannend ist jetzt die zweite Maschinenklasse,
die wir dann haben und wie das dann ausschaut.
Und wenn wir die PRAM Time TN haben,
bewegen wir uns halt in anderen Größenordnungen und kommen da dann entsprechend auf andere Klassen,
die wir dann halt entsprechend noch sehen werden,
nämlich P-Space
So, die Liste, die jetzt kommt, ist genau wie im Skript.
Deswegen werde ich da jetzt auch nicht in der Vorliezung groß näher drauf eingehen,
dass wir also die entsprechenden Enthaltensbeziehungen haben,
mit dem entsprechenden Space SN von der Peram Time und so weiter,
dass das, was das sozusagen einzeln bedeutet jetzt hier.
So, und damit haben wir sozusagen so ein Enthaltensein-Beziehung,
dass wir also Peer Space in diesem Peram Time Poll sozusagen mit drin haben.
Und das ist auf jeden Fall eine spannende Geschichte dabei. So,
und diese Zweite Klasse ist,
dass wir eine Standardklasse von parallelen Maschinenmodellen haben,
die die entsprechenden Varianten von Peram-Maschinen enthält und denen Polynom-Time genau das Gleiche kann,
wie das im polymiellen Platz für sequenzielle Maschinen ist.
Das ist sozusagen das, was dahinter steckt.
Das ist dieses Detail, dass das dort drin enthalten ist.
Das heißt, diese Möglichkeiten, die ich den Parallelrechnern habe,
ist, dass ich damit also ein bisschen weiter komme
Das ist sozusagen der entscheidende Teil hier. So, jetzt
die Frage nach den Grenzen. Kann ich also alles damit
besser, schneller, schöner machen? Und da gibt es
eben eine einfache Antwort von Kung. Kein paralleler Algorithmus,
der die Organisation Operationen, muss man minus durch, benutzt,
kann ein Polynom enden, gerade ist schneller als in Login-Schritten berechnen.
Gut, das ist so die eine Aussage und kein paralleler Algorithmus
kann x hoch en schneller als ein sequenzieller Algorithmus berechnen.
Auch das ist dann etwas, was schon Spannend ist,
dass es also Dinge gibt, die sperren sich gegen diese Palidisierung,
weil man sie nicht benutzen kann irgendwie.
Okay, warum? Das dürfte auch den entsprechenden Originalliteratursachen angucken.
Das damit, das machen wir nicht in der Klausur.
So, damit sind wir jetzt mit den PRAMs durch.
Die parallelen Algorithmen, das war das, was wir schon hatten,
dass wir gesagt haben, wir wollen jetzt irgendwie Richtung Algorithmen reinkommen.
Bisher ging es eigentlich darum, dass ihr versteht,
wie diese Modelle eigentlich funktionieren und was man da machen kann.
Also wenn ich von dem mehreren Prozessoren, die wieder umorganisiere,
wenn ich das in für End-Prozessoren in Login,
macht das, die wir umstapeln kann und so weiter.
Das brennt im Prinzip. Was ich aber,
wenn ich jetzt die Sachen nebenläufig oder mit vielen Prozessoren,
das Maximum suche, dass ich dann auch zu entsprechend guten Ergebnissen kommen.
Dieses Denken in der Richtung sollte jetzt klar sein.
Jetzt ist die Frage, wie arbeitet Google denn auf den ganzen Datensätzen?
Was machen die denn da eigentlich? Was für Algorithmen
verwenden die denn? Und da werdet ihr Schwierigkeiten haben,
den Kern von dem, wie die eigentlich arbeiten,
irgendwo im Netz zu finden.
Die Idee ist, dass man also mit verschiedenen Verfahren irgendwie
in der Lage sein muss,
diese Riesendatenbestände
irgendwie vernünftig durchzugehen
Und das passiert garantiert nicht auf dem HeimpC von irgendeinem, einer Firma, ja.
Sondern das passiert sozusagen massiv parallel in verschiedenen Sachen auf bestimmte Art und Weise,
wo die Daten noch bestimmterweise vorgehalten werden und so und so fort.
Das ist ja relativ spannend, wie schnell ihr
sozusagen bei den verschiedenen Suchmaschinen die Antworten sozusagen angezeigt bekommt.
Und die Frage ist jetzt, das, was die da treiben,
bewegt sich nicht mehr in der normalen sequenziellen Programmierung,
sondern da muss man schon so ein bisschen was von dem,
was jetzt hier erzählt wird und noch etliches mehr,
Also das Thema A und B und dann Algorithmik und so weiter ist dann etwas,
was ihr in der Ecke gut gebrauchen könnt,
wenn ihr euch nur annähernd in die Richtung bewegen wollt.
So, hier werden wir also aber nur so ein paar grundsätzliche Dinge noch mal angucken,
was man bei diesen parallelen Algorithmen jetzt machen kann.
Und es kommt jetzt darauf an,
dass man so ein bisschen ein Gefühl kriegt,
dass man auch komplexere Dinge machen kann,
als nur das Maximum von in Zahlen hervorzurufen.
Das ist jetzt die Frage, was man jetzt macht.
Wir hatten ja vorhin gesagt,
ich habe einen riesen Datenbestand und gehe mit wie näherer Suche
da rein,
dann brauche ich
immer noch Login
Schritte, bis ich da unten angekommen bin.
Wenn ich bei richtig großen Datenbeständen bin,
möchte ich es vielleicht noch schneller haben als nur Login.
Und dann muss ich halt Nebenläufigkeit bemühen. Und da muss
man sich überlegen, wie kommt man da eigentlich hin?
Frage ist, könnt ihr denn jetzt mit mehreren Rechnern
schneller sortieren, die das Binäre suchen?
Wie würdet ihr das denn
jetzt machen
Ja, genau. Wie jetzt ein Begriff. Wir haben so einen,
wir palitionieren. Ja, palitionieren ist ein sehr gutes Verfahren.
Und das Merchant, wenn man so Ergebnisse wieder hat,
ist auch eine gute Idee, wie man jetzt Sachen zusammenbringt.
Genau diese Sachen werden jetzt im Laufe des restlichen Teils hier nochmal angeschnitten.
Und dafür braucht man halt dieses parallele Sortieren.
Und sowohl auch das Merchant als auch das Suchen.
So, und Suchen ist eigentlich ja das Ziel,
was man letztendlich haben möchte an den Stellen.
So, Wir haben also irgendwelche parallelen Algorithmen und gehen in
Folgen jetzt von so einer Darstellung im Pseudo-Code aus.
Und das kann man eben in normaler Zeit dann in die PRAM-Code übersetzen,
das, was da so an Abkürzungen halt steht.
Die entsprechende maximale Anzahl der Operationen, für die Operationenkomplexität hatten wir schon erwähnt.
Das heißt, das haben wir da entsprechend mit drin.
Da hatten wir es auch schon gesehen,
wie das dann aussieht und dass wir hier unsere entsprechenden Zahlen haben
mit den drei Prozessoren und der Zeit elf hier an dieser Stelle und den 21 Operationen,
die da drin vorkommen.
Das ist ja das,
was wir schon kennen
Und oft genug kommt das dann halt so hin,
dass es gleich ist. Das sind dann die Sachen,
die ich eben schon erzählt hatte, mit dem entsprechenden Optimum,
was wir uns dann jetzt halt angucken wollen.
Und genau, dann nur nennen wir das Teil halt optimal. So,
jetzt haben wir hier unsere W21. Wir müssen also sehen,
dass wir jetzt in irgendeiner Weise, dass da auch wieder entsprechend hinbekommen.
So, und das so durchzulaufen, können wir jetzt die Sachen abzählen. So,
jetzt war die Frage, die ich schon vorweggenommen habe,
Ob dieser Max-Algorithmus in Ophon Endzeit und O von End-Quadratposition optimal ist,
war vorhin schon gesagt, nö, das ist wahrscheinlich nicht so,
denn wir hatten ja diese andere, ein anderes Verfahren dafür.
Hier hatten wir jetzt halt die Folie nochmal dazu. So,
die Geschichte, was wir jetzt uns angucken,
oben haben wir Sequenzielles sortieren und unten haben wir halt das Parallele sortieren,
was wir uns dann entsprechend nochmal hinten weiter angucken werden.
Und die Frage war, Die Zeit komplexierte da,
hatten wir auch schon, dass es sozusagen in Ovon N-Login-Schritten passiert.
Das heißt, das ist das, wo wir wissen,
wann unser Parallelalgorithmus nachher wieder optimal sein kann.
Und jetzt aber die Frage, kriegen wir das irgendwie noch schneller hin?
Und haben trotzdem optimalen Algorithmus. Und den muss man jetzt
irgendwie erstmal suchen. Und dann kommt man auf dieses Ergebnis
nachher. Und das sieht dann schon relativ klein aus,
wenn nicht mehr en, mal Login,
sondern jeweils der Logorithmus von beiden Dingen genommen werden kann.
Und da besteht es eben genau die Frage,
die wir eben gerade schon am Rande hatten.
Wie kriegt man es denn besser hin
Da gibt es verschiedene Verfahren, die man dann sozusagen anwendet,
bevor man einige hier kurz angucken werden.
Und ich werde da auch jetzt entsprechend fix drüber gehen über
diese Erläuterung. Die Idee war ja,
dass ihr hingeht und euch die Sachen schon mal vorher angeguckt habt,
damit ihr diese ganzen Algorithmen, die jetzt gleich kommen,
auch besser sozusagen nachvollziehen könnt, wenn ich die einzelne so durchgehe.
Dieses Parallele sortieren, was wir dann haben,
ist das, was ganz nett ist.
Die Frage ist, ob wir da sozusagen dann entsprechend hinkommen,
muss sie
halt entsprechend zeigen
Die Frage ist, wie wir da bei den Prozessoren hinkommen und ob wir das sozusagen auch mit dem N-Teilen schaffen. So bezüglich der Zahlen,
die wir uns jetzt hier angucken,
einfach noch mal so ein paar Beispiele, wenn wir jetzt enden,
als diese normalen Zweier-Potenzen jetzt mal so hinschreiben,
ist das Lock halt eine sehr schöne Geschichte,
dass wir da nur auf acht kommen,
bei Lock-Lock-In sind wir bei drei angekommen,
bei dem Teil Lock-In mal Lock-Lock-Allen sind wir halt bei 24,
was heißt, wir brauchen schon eine ganze Weile,
aber immer noch wesentlich kürzer.
Und dieses N-Lock-In ist eben entsprechend groß,
was wir da entsprechend benötigen für unseren sequenziellen Fall
An der Stelle. Gut, und die Zielsetzung ist jetzt
sozusagen entsprechend auf immer weiter nach links sozusagen zu kommen in der Spalte.
Und das ist sozusagen schon das Ergebnis vorweggenommen. Was wir
uns jetzt also angucken erstmal, um dahin zu kommen,
ist also diese entsprechende Mission.
Und parallel suchen. Und da gucken wir uns aber
die einzelnen Sachen erstmal an und gucken mal,
was man da einzeln so verbessern kann.
Und da gibt es so einzelne Schritte,
die jetzt erstmal mal so und mal so,
da versucht man das besser zu machen, das besser zu machen.
Letztendlich läuft auf dieses Ziel dieses Parallelensuchens letztendlich hinaus,
was man
dann haben möchte
So,
wenn wir also so eine lineare Ordnung haben und zwei Teilmengen,
wir gehen jetzt davon aus, wir haben irgendwie zwei Timing dabei,
nämlich A und B. Und zu denen wir die entsprechenden Folgen haben,
die da drin sind.
Und wir haben hier die IJ und das AI ist kleiner
gleich dem AJ. Das kann man schon mal mit einsetzen.
Das Gleiche gilt auch für die Bs. Dass wir
so schön sortiert sind. Dann haben wir eine Mischung oder
ein Merch von A und B in die Folge C1 bis C2N.
Wobei dann hinterher gelten soll, dass die ganzen CS
wieder entsprechend sortiert sein sollen
So, fängt also an, geh da durch,
geh an den Kopf der jeweiligen Listen und nimmt die
dann einzeln und sortiert sie alle einzeln einmal ein.
Das ist relativ schnell, schnell zusammengemerged. Kann man also einmal
so durchgehen und sequenziell ganz einfach abarbeiten, dieses Problem.
Diese beiden Listen fangt ja vorne an, okay,
erstmal die zwei, dann die drei,
dann die vier, welche vier ist im Grunde genommen,
egal welche ihr da nehmt und dann zum Schluss halt die sieben,
die ihr da dann entsprechend reinpackt.
Wobei dann eben beide Listen sich da entsprechend drin wiederfinden
So, entsprechende Zeit, muss man einmal
alles so durchgehen und immer wieder vergleichen und so weiter.
Das ist bei diesem entsprechenden Merch, wie man jetzt hier unten guckt,
ein Tick anders, wenn wir da auch hingehen.
Wir gucken uns diese beiden alt an. Nehmen die und können
die jetzt sozusagen paralysatieren und ein paralleles Merch daraus machen.
Das heißt, wir können jetzt hier die 12,
die 5 nehmen und zusammenpacken und dann oder vergleichen und dann
das Ganze den Baum hochgehen,
sodass wir oben bei der sortierten Liste
letztendlich ankommen
Das Ganze machen wir dann halt mit den entsprechenden paar Schritten und sind dann fertig. So,
und die Idee ist jetzt, dass wir bei so einer Definition haben,
dass wir jetzt so für solche Listen Ränge vergeben,
nachdem wir jetzt halt wissen, was so in Lockzeit machen kann.
Gucken wir noch mal, jetzt gucken wir uns noch mal die entsprechenden,
medial geordneten Mengen an und jetzt möchte ich irgendwie sagen,
ich möchte den Rang zuordnen können, weil ich das gleich noch brauche.
Wie gesagt, nur wenn ihr gelesen habt,
ist das sozusagen wirklich jetzt richtig schön klar,
warum man das jetzt eigentlich macht,
aber ich will jetzt die sage ich jetzt mal,
die linear geordneten Menge möchte ich jetzt gerne in die Zahl
einsortieren an einer bestimmten Stelle und da möchte ich gerne den Rang von dem Teil wissen und dann möchte ich das sozusagen benutzen können in irgendeiner Weise.
Dieser Rang ist also genau das, dass man,
wenn ich jetzt hier irgendwie den Rang von 13 in dieser Folge X haben möchte,
naja, welcher ist das, wenn ich da jetzt entsprechend reingehe,
habe ich die ganze Sache in irgendeiner Weise sortiert und ich weiß,
dass es sozusagen in Rang entsprechend zwei hat.
Und das kann ich in diesem Verfahren,
was wir eben gerade hatten, mit einsortieren und sagen,
okay, gut, ich nehme halt irgendwie diese Zahlen,
würfel sie durch,
habe meinen X-Strich und dann weiß ich da,
an der zweiten Stelle würde ich die 13 entsprechend einsortieren und
das unterbringen
So, wenn ich jetzt eine zweite Liste habe mit 13,
27 und minus 27, was kann ich jetzt fragen?
Naja, dann brauche ich auch nach dem Rang.
Dann frage ich mit dem Rang von Y in Bezug auf X
und möchte dann sozusagen sagen, an welchen Stellen ich jetzt was zusammenschieben soll.
So, jetzt kommen wir zum Mischen nochmal. Zur Vereinfachung,
gehen wir also jetzt erstmal an, dass A und B sozusagen leer sind.
Also wir haben unsere Vieren, haben wir nicht mehr da drin,
sie sind also unterschiedliche Zahlen. Und das Problem,
die Folgen A und B zu mischen,
wird dann zu dem, was da vorne jetzt steht,
bestimme zu jedem X aus A und B,
den Rang von X bezüglich Arthur I nicht
Und wobei das X und eben das Eate-Element aus der sortierten
Liste sozusagen nachher sein soll. So, das heißt,
ich muss, nehmen wir diese entsprechende Menge,
rechne den Rang aus für die beiden Teile und dann weiß ich,
wie ich die eigentlich zusammenschieben muss.
Das ist die, die dahinter. So,
und wir berechnen also den Rang von B bezüglich A
und das machen wir mit mir näher an Suchen.
Und das heißt halt, wir halbieren das Teil, wir halbieren,
wir halbieren und dann sind wir sozusagen in dem Bereich.
So, und das kann man entsprechend in O von Login
sequenzieller Zeit berechnen
Haben wir eben genau dieses JE wird eben als Rang von B-I-I-N-A
sozusagen gerade zugewiesen. Und das kann man dann parallel auf
alle Elemente B anwenden und wir halten den parallelen Algorithmus in
O von Login paralleler Zeit in O von N-M-M-Login-Operationen,
wie man das dann halt anwendet.
Weil wir entsprechend mehr natürlich dann tun,
müssen wir es für alle einmal durchgehen müssen und zusammenbringen müssen.
So, die Frage ist, ob der optimal ist und nein,
es gibt die ganzen Algorithmen, die das in O von N-Side schaffen.
Das war das,
was wir da schon gehört hatten
So, ein optimaler, paralleler Algorithmus fürs Mission hätten wir
jetzt gerne. Jetzt wollen wir also das besser haben,
weil wir nicht sozusagen nicht optimale Algorithmen angucken wollen.
Was wir jetzt machen ist, jetzt gehen wir hin,
jetzt kommen wir auf das zurück, was vorhin gesagt wurde.
Die Idee ist so ein bisschen was mit Pallitionierung und
dann gucken wir mal, wie machen wir denn das?
Und wir haben jetzt irgendwie zwei Folgen und die haben eben hier
die Länge M und N, weil oben ein AK stehen sollte.
Wir haben jetzt die Länge M als das Bestimmte bei dem
So, und was wir jetzt machen, ist,
dass wir M durch Log Am entsprechend Glöcke einführen.
Das ist gerade für das KM, was wir dann für beide sozusagen irgendwie einführen.
Das A und B werden also in genau diese Anzahl von Blöcken
einfach eingeteilt. So, und was man da macht,
ist, dass man in irgendeiner Weise die Blöcke hinschreibt und
dann entsprechend irgendwie entsprechend aufteilen muss in die entsprechende Größenordnung,
je nachdem, was man dann da entsprechend drinstehen hat.
So, was jetzt interessant ist, dass man versucht,
diese Blöcke so zu gestalten,
dass da was mit dem Größter Kleiner entsprechend drin zu stehen kommt.
Und zwar war das dann so,
dass die X aus dem AI und BI entsprechend größer sind
als alle Elemente davor
Das macht man für alle einmal durch. So,
das heißt, ich gehe jetzt hin und sorge dafür,
dass das, was ich links von dem roten Strich habe,
auf jeden Fall kleiner ist, hat was im rechten Teil ist.
Das kriegt man durch entsprechendes direktes Durchgreifen auf das
letzte Element in dem jeweiligen geordneten Teil immer raus.
Dafür hatten wir unsere Renngeschichten und so weiter,
da kann man jetzt genau gleich sehen, was da passiert.
So, und für diese einzelnen, sagen wir jetzt,
A und B, zwei unterschiedlich lange Listen haben.
Dann haben wir für B M durch LogM,
ist hier gleich zwei Zweierblöcke und die teilen wir entsprechend auf,
wobei das KM jetzt gerade für die Indizes wieder gilt,
die wir da jetzt stehen haben
So, jetzt sind wir da bei diesen entsprechenden Blöcken.
Wir haben unsere Zahlenlisten. Was machen wir damit? Wir
gucken uns das mal an, was war mit dem B-Strich?
Das war für dieses Log-M. Wir wissen also,
da haben wir unseren Cut sozusagen und haben B-0 und B-B-I.
Und jetzt müssen wir halt aufpassen,
wenn wir das Ganze jetzt aufteilen in diese entsprechenden Blöcke.
Wir wissen jetzt auch, was müssen wir jetzt tun mit A?
A, müssen wir ebenfalls in zwei Blöcke einteilen.
Frage ist, wo teilen wir denn jetzt eigentlich auf,
sündigerweise? So, was habe ich jetzt gerade eben gefordert
Ich hätte gesagt, ja, wir müssen jetzt zusehen,
dass alles, was links steht, muss kleiner sein als das,
was irgendwie rechts von diesem roten Strich steht.
Also ziehe ich jetzt den roten Strich hier so durch und stelle fest,
dass das sozusagen bei der Sieben sozusagen das eben genau aufteilt.
Und entsprechend kann man das dann jetzt alles,
also die A0 sind alle kleiner als die,
und B0 sind kleiner als die A1 und B1 und das
immer noch davon rechts stehen würde.
So, das steht dahinter, dass man im Grunde genommen hingeht und
so blockweise die Sachen nimmt Und jetzt immer die entsprechenden Elemente nachgucken muss.
So, wie macht man das? Dafür benutzt man Algorithmus
. Das war genau das, was ich sagte,
was ihr euch auf jeden Fall angucken solltet.
Weil wenn ich das jetzt einzeln durchgehe, wird es relativ obstrus.
Was da vom Prinzip her passiert, ist,
dass ich so eine Eingabe habe mit zwei Feldern,
in aufsteigender Reihenfolge sortiert, wo bei Lock M und K eben ganze Zahlen sein müssen.
Das wird entsprechend gerundet. Dafür sorgt man halt.
Und die Ausgabe sind dann eben KM-Pare, A,
I und B, I von Teilfolgen von A und B.
Das heißt also wieder Untermengen von den Teilen
Die Einser von BI, eben gerade diesem Log-M ist und
die Summe von dem, die da drin steckt,
eben gleich gleich, gleich, gleich enden.
Und jedes Element von AI und B ist größer als jedes Element,
was links davon sozusagen steht. Das ist das,
was ich als Ausgabe von diesem Pallitionierungsteil jetzt bekomme.
Und das kann man im Einzelnen dann an den Sachen durchspielen,
was man macht, ist halt diesen Algorithmus abzulaufen,
wo über das Paar Du eben dieses Parallel Abarbeiten wieder ist,
was als Hochschreibweise für dieses Abarbeiten der Befehle
gemeint ist
Und man setzt eben die Sachen am Anfang,
dann durchläuft man halt eine entsprechende Schleife,
bis man diese entsprechenden von 1 bis KM einmal durchgeschaut hat.
Dafür berechnet man den entsprechenden Rang,
den wir ja entsprechend in den geringen Anzahl von Schritten hinbekommen,
durch benähere Suche,
setzt dann die entsprechende JE und dann gehen wir nochmal durch durch diese Schleife
und nehmen dann jetzt die WIs und gucken uns das an und die AIs und sorgen dafür, dass wir das AI entsprechend einsortieren dabei.
So, wenn wir das jetzt da angucken,
haben wir die entsprechenden Schnitte, die natürlich so nicht hinkommen,
mit der 600 muss natürlich bei der 7 Reihen und das findet man in den entsprechenden Sachen,
dass wir die JE entsprechend setzen müssen mit dem entsprechenden Rang.
Wenn wir ihn gleich zwei halt haben, müssen wir halt gucken,
wo wir da nachschauen müssen und finden dann die entsprechenden Einträge bei den Sachen da drüber.
So, und das A1 und A2 und A3
wird dann entsprechend so bestimmt bei diesen Dingen.
Und das passiert eben hinten mit dem AJI, müssen wir
entsprechend das einsortieren. So, was da quasi rauskommt,
ist genau das, was wir vorher hatten.
Wir nehmen unsere schöne Liste und am Ende
kommt sie
schön sortiert sozusagen
Wieder hin, wobei wir eben das genau über diese beiden pensionierten Mengen
dann eben machen. Haben wir also diese ortierte Folge,
welche durch das Mission von den sortierten Folgen A und B
in der Länge mit den entsprechenden jeweiligen Längen drin ist,
dann teilt eben der Algorithmus, den wir da gerade gesehen haben,
A und B im Paare von Teilfolgen so auf,
dass man dieses BI als Lock von M sehen kann und das AI ist gleich N und das CI ist eben gerade diese sortierte Folge.
Und die kriegen wir, indem wir genau mit dem Mission hantieren.
Dieser Algorithmus benötigt, oh von N, oh von Login Zeit
, mit insgesamt O von N plus M-Operationen.
Das ist das, wenn wir diese Plusgeschichten da noch entsprechend
drin haben. So, das heißt,
die Aufteilung passiert dort und wir müssen jetzt aufpassen,
wie wir das da entsprechend aufteilen
Jetzt geht es sozusagen um die Komplexität bei dem Positionieren.
Was haben wir da eigentlich gemacht? Wie schlimm war das?
Das hatten wir eben gerade schon die Ergebnisse gesehen. Wir haben die Anzahl der Blöcke,
wir haben eine gewisse Zeitkomplexität, die wir davor finden,
naja, das O von 1. Das,
was wir dann hier machen bei dem Rank,
hatten wir vorher gesehen, dass wir da ein O von Log-N-Zeit hinkommen,
um diesen Rank zu bestimmen.
Jetzt benutzen wir eben halt die Sachen von vorhin,
das wird hier einfach jetzt so mit vorausgesetzt und unten
kommen wir auch recht billig davon,
weil wir da einfach nur auf O von 1 zugreifen müssen,
um diese entsprechenden AIs entsprechend ja zuzuweisen
So. Die... Dumme, die da rauskommt,
ist dann im Grunde im O von Login,
was wir da insgesamt an Sachen drinstecken haben.
So, jetzt ist die Operationenkomplexität. Was ist das?
Das ist auf der Stelle UVN 1, das ist natürlich klar.
Das andere ist Login, mal N durch Login, sprich sozusagen,
es ist im Grunde in der Größenordnung von O von N plus N.
Das waren das, was an Operationen dort stattfindet,
wenn man das entsprechend ausmotiviert,
kommt das ja entsprechend raus
Unten kommt halt nur O von M raus,
sodass wir in der Summe halt in Bezug auf die
entsprechenden Operationen auf O von M plus 1 kommen.
So. Damit haben wir jetzt die Möglichkeit,
uns mit dem optimalen Algorithmus fürs Mission jetzt zu beschäftigen.
Mit diesem Algorithmus haben wir also das Mischproblem der Größe N
auf Unterprobleme kleinerer Größe reduziert und der optimale Algorithmus ist,
wir werden den Algorithmus 7.1 an, von dem wir jetzt wissen,
dass er so hat, behandelt die Paare getrennt
Und falls das entsprechende kleiner ist,
mischen wir die entsprechenden Log-End-Zeit mit dem sequenziellen Mischalgorithmus.
So. Und das Anwenden von dem Algorithmus 7.1,
wenn wir wieder an, um diese Blöcke zu zerlegen.
Und wir brauchen die entsprechenden Log-Log-Zeit-Sachen dafür. So, sieht
das aus. Wenn wir jetzt diese 1024 Sachen haben,
wird es entsprechend aufgeteilt. Es kann passieren,
dass es mit 10, 10 und eben irgendwie noch größer
ist in irgendwelchen Bereichen
Und wird davon abhängig dann irgendwann auch terminieren können.
Der Algorithmus funktioniert halt eben auch für den ungünstigsten Fall natürlich.
So, die Zeit ist eben Login und die Operationen
sind O von N an der Stelle. So,
diese Bs, die wir dann entsprechend da drin hat,
werden natürlich jetzt genau benutzt und genau in diesem Algorithmus verwendet.
Und wir kommen dann hier auf die entsprechenden,
auf die parallele Zeit mit dem O von Log B
gleich O von Log Login.
Das ist die, also die da rauskommt,
bei den Operationen haben wir die entsprechende O von A,
was wir
da da drin stecken haben
Insgesamt, für die Zeit brauchen wir auch von Login und
wie von WN ist halt OVNN.
So, der nächste Schritt, den wir jetzt haben,
ist, dass wir mischen und die Komplexität uns jetzt angucken.
Das mischen zwei ja Folgen der Länge N ist von den
Parallelen Algorithmus, also in dieser Zeit entsprechend durchführbar.
Welche Frage stellt sich jetzt
Ob es entsprechend schnelleren Algorithmus gibt. So,
und jetzt können wir das noch weiter durchspielen,
wo eben noch Potenzial für die Beschleunigung ist.
Jetzt geht man wieder hin und guckt die Algorithmen von eben an.
Naja, da war eben dieses O von 1 und O
von Lok und so weiter da drin.
Und wo wird hier wohl noch Potenzial sein?
Wenn ich jetzt halt auf diese Lok-Lok-Geschichten irgendwie nachher kommen möchte,
dann kann man davon ausgehen, dass es genau da ist,
dass wir also hier versuchen, jetzt noch wieder weiter zu optimieren.
Jetzt gehen wir dann also in das Skript rein,
gucken uns die Sachen an und versuchen das jetzt besser hinzukriegen.
Wie kriegt man es jetzt besser hin
Naja, das Suchen, ja. Ja, ich bin ihrer Suche,
aber das ist jetzt gar die Frage, wie kriegt man das besser hin?
Indem man so die Idee kommt, paralleles Suchen mit P-Prozessoren
zu machen, genau. Dass man da jetzt wieder versucht,
ein bisschen mit den Prozessoren zu hantieren,
muss man nur wieder aufpassen, dass man beim optimalen Pile bleibt,
aber das gucken wir uns dann gleich nochmal an.
So, und das führt eben entsprechend jetzt als Ergebnis sozusagen in
diese Richtung zu diesem Of von Lock, Lock-in-Teil wieder rein.
So, diese Fragen Nach dem Warum ist halt immer,
dass man sucht, man möchte gerne schnellere Algorithmen haben oder
bessere Algorithmen haben. Dass jetzt dieses Ziel ist,
sozusagen am Ende nur irgendwas möglichst schnell suchen zu können,
um möglichst schnell wieder irgendwo rauszuziehen, dass das, was eigentlich dahinter steht.
Und dafür treibt man den Aufwand, um irgendwelche Dinge vorzusortieren,
zu sortieren oder zu mischen und so weiter. Das heißt,
diese einzelnen Schritte, die jetzt teilweise relativ,
ich sag mal, jetzt hier unmotiviert nacheinander kommen,
sind dadurch motiviert,
dass man am Ende zu diesem Endergebnis hinkommen möchte und damit
jetzt einzelne Schritte halt anguckt,
die wir dann jetzt zusammenstecken wollen
So, das heißt, an dieser Stelle ist es
relativ trockene Materie mit diesem Teil hier.
So, das Potenzial für die Beschleunigung haben wir also jetzt
hier gesehen. Wir gucken mal,
wie wir da jetzt hinkommen und insbesondere mit den Operationen,
ob wir da mit N, mal N-Log-Log-End sozusagen auch auskommen.
Das wäre sozusagen das Spannende dabei,
wenn wir also die Anzahl der Operationen auch da an der Stelle
niedrig genug halten können, um damit besser hinzukommen.
Das werden wir gleich mal schauen.
So, was jetzt kommt, ist wieder paralleles Suchen.
Jetzt geht es wieder los. Wir haben ja gesagt,
wir wollen jetzt dieses Parallesuchen durchführen.
Das war gerade eben das, wie wir
jetzt da reinsteigen wollen
So, und wir haben hier so eine linear geordnete Folge und verschiedene Elemente.
Jetzt ist das Suchproblem, finde den Index, sodass man das da,
das Y zwischen dem XI und dem XI plus 1 einsortiert.
So, die Dispinäre suchen bezüglich Zeitkomplexität, ist dann eben Login.
Und das Parallele suchen mit den entsprechenden Endprozessoren, wo kommt man da hin?
Naja, da kommt man in dieses Login, durch Log von P1.
Und der Algorithmus ist dann optimal,
wenn man jetzt die dass P. entsprechend konstant hält,
weil es dann sozusagen in diese Größenordnung mit reinstößt.
Wir müssen also aufpassen, dass wir die Anzahl der Prozessoren
jetzt konstant halten und müssen das jetzt als Idee dahinter verwenden,
wie wir jetzt diesen Algorithmus wieder konstruieren, der als nächstes kommt.
Ja, also das heißt also,
das parallele Suchen mit den Prozessoren dort, ein anderer Trick,
jetzt müssen wir sehen, dass wir sie ein,
zwei Prozessoren irgendwie konstant halten und dann entsprechend jetzt die Loggeschichten,
genauso machen wir es vorher auch in lugorithmischer Zeit sozusagen auf die Reihe bekommen.
So, und als Eingabe haben wir eben halt
ein Feld und ein Element und die Anzahl der Prozessoren,
die eben auf jeden Fall kleiner sind als das N und die Prozessorennummern
haben wir auch da und die haben entsprechenden Index,
wie wir hinterher dann als Ausgabe haben möchten
So, und diese Abfragen will ich jetzt nicht ganz genau im Einzelnen durchgehen.
Im Grunde genommen haben wir da unser X0,
wir haben drei Prozessoren und bei der entsprechenden Verarbeitung können wir
jetzt einmal gucken, wie wir das so patitionieren.
Wir teilen das also wieder auf. Genau, das,
was wir da bei den Vinären suchen, sonst ja auch machen.
Nur haben wir jetzt eben so,
dass wir mehrere haben, die raten. Ja,
also ihr sitzt jetzt hier und sollt jetzt eine Reihe von
tausend Zahlen entsprechend durch paralleles Suchen hinbekommen.
Wie macht ihr das
Wir spielen ihre Suchen, war es klar,
der Sach ruft immer eine, eine Zahl.
Einer von euch darf eine Zahl benennen und dann geht es weiter, ja?
Genau, so in der Richtung. Das heißt,
ihr teilt es irgendwie auf, genau das,
was jetzt hier gerade oben geht, sehen.
Und wenn ihr jetzt die Zahlen nennt, verratet ihr euch
sozusagen durch. Wenn wir so drei Leute haben,
die tausend Zahlen irgendwie abraten, 250, 500,
750, werden sozusagen geraten, als so diese drei Zahlen,
haben wir diese Blöcke.
Was muss dann noch passieren jetzt
Was kann jetzt sein, wenn ich jetzt die mal so
geraten habe, die Zahlen? Ich habe drei Prozessoren,
also drei Leute, die jetzt hier was gesagt haben.
Naja, größer oder kleiner kann jeweils sein. Ja,
und was habe ich jetzt für,
wenn ich das jetzt mal mit euch allen machen würde?
Und wir haben hier eine Million Zahlen und die
hätten das in die entsprechenden x-Blöcke von euch sozusagen aufgeteilt.
Was könnte da für eine Folge von Zahlen dann rauskommen?
Na, ich suche die Zahl
In diesen 1 Millionen Dingern. So. Jetzt habt ihr irgendwie
diese geordnete Liste davor liegen. Ihr habt die aufpalitioniert.
Was kann als Ergebnis jetzt rauskommen für mögliche Geschichten?
Wenn die Zahlenfolge doch sortiert war. Was finden die Prozessoren bei sich
vorne vor? Wenn Sie Ihre größere Kleinerfrage beantwortet bekommen.
Kleiner, kleiner, kleiner, kleiner, kleiner,
kleiner, kleiner. Größer, größer, größer,
größer. Also entsprechend Nullen und Einsen. Was muss jetzt
noch passieren
Das weiß ja jeder immer nur, dass er immer größer oder kleiner ist.
Von der Überlegung her. Wie macht ihr das, ja? Genau,
man geht jetzt zu dem hin, wo das wechselt.
Wie gehe ich denn da hin? Gehe ich da jetzt
sequenziell durch? Also ich stelle mich hin und frage,
welche Zahl hast du, welche hast du, welches du,
welches du, ist bei Parallelverarbeitung wahrscheinlich nicht das Optimale.
Also was muss jetzt noch passieren? Das wäre gerade die Idee,
dass ihr jetzt versucht, selber die Prozessoren zu spielen,
die jetzt dieses Parallele suchen gerade nun
veranstalten sollen
Na, ihr dürft mir hier vorne sozusagen noch eine
bestimmte Menge an Dingen jeweils hinlegen, an Informationen.
Was macht ihr denn jetzt? Nehmt an,
ihr sitzt alle in einer Reihe und vor euch habt ihr
sozusagen so einen Speicher, auf den ihr alle gemeinsam zugreifen könnt.
Was reicht euch schon als Synchronisation, um möglichst schnell dann weiterzukommen?
Schreibt euer Ergebnis erstmal raus, damit alle das sehen können.
Jeder sagt, was los ist. Jeder sagt,
0-0, 0-0 und dann kommen die ganzen Einsen.
Was muss ich da noch tun? Ich muss mit
meinen Nachbarn vergleichen. Was haben die denn
Und dann schreibe ich wieder eine 0 oder 1 raus und sage,
wo ein Wechsel stattfindet. Das heißt, alle,
die keinen Wechsel sehen, schreiben eine Null raus sozusagen und alle,
die einen Wechsel sehen, schreiben eine 1 anschließend draus.
Wie viele Einzelnen wird es dann geben?
Wie viele Wechsel gibt es in dieser Liste? Ja,
wir gehen natürlich mit zwei Leuten vergleichen,
da können wir nochmal gucken, aber es gibt sozusagen nur einen Wechsel,
es gibt also sozusagen einen Teil und da ist genau klar,
wo dieser Wechsel stattfindet.
Und das Ergebnis wird nicht die Eins rausschreiben,
sondern wird als Ergebnis in M0 oder sonst irgendwo hin das Ergebnis rausschreiben,
wo denn der Wechsel eigentlich war.
Und das wird dann irgendwo dokumentiert, ja
Mit der Wand vergibt hat, das sind meine meisten Waffen. Genau,
genau, da, wo kein Weg da, wo, genau,
da, wo kein Wechsel ist, die halten den Mund,
so nur die beiden, die jetzt feststellen, da war der Wechsel.
Das ist da oben, die beiden hatten den Wechsel bei der Zahl,
weil alle hatten den nebeneinander gesessen und die beiden hatten genau den Vergleich.
Die beiden schreiben dasselbe Ergebnis, zufälligerweise natürlich raus,
was ja beide das gleiche Ergebnis kommen, packen sagen das,
zur Not machen sie nur einen Vergleich und gucken nur nach rechts,
eventuell findet Geister statt,
weil man da das größte Element schon hat oder das kleinste,
je nachdem, wie das dann gerade aussieht,
aber auf jeden Fall kriege ich im Normalfall erstmal so als ersten Schritt,
wenn ich davon ausgehe,
dass ich mehrfach suchen muss in diesem Teil,
kriege ich jetzt
irgendeinen Bereich
So, was mache ich mit diesem Bereich wieder?
Ich teile ihn wieder auf alle auf,
weil jetzt alle können den Bereich ja lesen, sie können ihn sehen,
sie wissen das und dann wird entsprechend wieder durchgegangen.
Das ist ja genau unsere Anzahl von Aufteilungen.
Wir sagen, wir haben drei Prozessoren und entsprechend wird aufgeteilt
. Wenn ich sage, wir haben hier 100 Studenten,
wie ihr hier seid und die teilen das auf,
dann haben wir 100 entsprechend,
kostet natürlich entsprechend dafür,
Ja, genau. Also wir gehen davon aus,
dass wir eine Million Zahlen haben und wir haben halt 100
Studenten oder eben so wie hier drei Prozessoren und ja,
auch irgendwie eine beliebig große Anzahl von Zahlen,
weil wir die immer wieder dann in diese entsprechenden vier Bereiche aufteilen,
aufgrund der drei Prozessoren.
Und wir immer diesen Vergleich entsprechend machen. Gut. So,
das ist jetzt erstmal so die prinzipielle Idee und jetzt
kann man das in diesem ganzen entsprechenden Befehlen halt wiederfinden.
So, meine Idee war jetzt eher, dass ich einmal dieses,
was passiert dort mit euch so jetzt hier schrittweise durchgehe.
Hat es jetzt dahin noch jeder gehört oder
Vom Gespräch, ja, gut, okay. Wie das also genau aussieht,
guckt ihr euch da drüben dann nochmal an,
weil ihr genau da dann auch nachlesen könnt, wann welcher Wechsel stattfindet,
was wozugewiesen wird und so weiter, ja. So,
die Idee ist jetzt, wir kommen halt da irgendwie hin,
wir haben unser Y, das kommt da irgendwie drauf,
wir sagen, aha, da kommt jetzt auf dieser Wechsel,
da zwischen C2 und C3 haben wir genau den Teil,
der da feststellt, wir zoomen da wieder rein,
teilen das wieder in vier Bereiche auf,
gehen das nächste Runde und sagen,
der gewinnt jetzt an dieser Stelle und es wird wieder aufgeteilt und wir machen da entsprechend weiter.
So, bis wir unten bei dem,
was wir gesucht haben,
angekommen sind und schon haben wir
unsere Sachen
Ist also an der Stelle jetzt klar,
warum man mit den entsprechenden Mehrprozessoren auch schneller arbeiten kann.
Je mehr Prozessoren ich habe, zwischendurch kann ich sein,
wenn ich gerade stark ausgelastet bin,
nämlich halt weniger Prozessor, die länger arbeiten müssen.
Oder ich nehme eben alle Putzzonen, die ich habe,
wenn es ganz schnell sein muss und benutze die alle.
Je nachdem, mit den entsprechenden Preis natürlich für diese Verfahren.
Aber wenn wir es erstmal konstant halten und jetzt das einzeln angucken,
können wir mit der Sache entsprechend die Sachen auch beschleunigen.
So, und was wir haben, sind dann halt die entsprechenden Blöcke.
So, das Beispiel, was wir dann haben, wir haben irgendeine Liste,
wir haben unsere 19 Und wir haben die entsprechenden Prozessoren,
die wir da vorliegen, haben nehmen wir zwei Stück.
Und die teilen sie das Ganze auf und greifen sich jetzt halt
diese entsprechenden Zahlen raus und wählen jetzt für sich natürlich diese Bereiche und stellen fest,
okay, es liegt in diesem Bereich irgendwie,
dann wird das nochmal aufgeteilt.
Zweite Literation, dritte Literation und dann hat man die Zahlen raus.
So, die entsprechenden vorhin stehen daher auch im Netzjahr.
Da könnt ihr halt nachrechnen,
wie sich das auf die entsprechenden Algorithmen,
die davor stehen,
dann auch bezieht
Ja, das Prinzip ist, glaube ich, jetzt klar,
dass man jetzt so hingeht und dann immer sagt,
okay, da wird eingegrenzt,
jetzt teilen die das wieder auf in verschiedene Bereiche, wieder aufgeteilt,
bis sie dann halt letztendlich bei der entsprechenden Zahl halt ankommen und wissen,
wo Schluss ist sozusagen an der Stelle.
Und das ist dann eben ja die Terminationsbedingung,
die dann für alle auch gilt, weil sozusagen allen klar ist,
dass sie jetzt genau an dem Endpunkt angekommen sind.
Das, was ich vorhin meinte,
dass die Prozessoren alle zwar mitarbeiten müssen, aber auch aufpassen müssen,
weil sie selber terminieren oder wann eben sozusagen der Letzte fertig ist.
Das heißt, hier in diesem Fall müsste jetzt unser letztes Eins-Teil,
also der erste Prozessor müsste sagen, jetzt bin ich fertig.
Und das aber alle gleichzeitig machen können auch,
funktioniert das auch so
Jo, gut, okay, das ist sozusagen das,
was wir jetzt mit den Parallelen suchen haben und die Komplexität ist
eben gerade gegeben durch dieses Login, durch Log P plus 1.
Je mehr Prozessoren wir drin haben, desto besser sind wir,
wenn wir das auf eins lassen, dann bleibt das bei dem Login-Teil drin.
Ansonsten wird es Abhängigkeit von der immer stärkeren Anzahl von Prozessoren
, kriegen wir das auch immer schneller. Genau das,
was wir eben gerade ja schon intuitiv sozusagen auch gesehen haben,
vielleicht die Anzahl der Prozessoren der Höhe, verbessere ich natürlich mein Ergebnis,
weil ich ja in immer mehr Bereiche einteile,
wenn ich 100 Zahlen habe und ich habe 100 Prozessoren,
Naja, dann gibt es einen Zugriff, ein Nachgucken,
ein Vergleich, wer ist es,
fertig.
Das ist sozusagen das Optimum, was man dann auf jeden
Fall schon mit 100 sofort so hinkriegen kann.
Und selbst bei kleineren Sachen funktioniert das ja noch. So,
den Beweis dazu schenke ich mir in Anbetracht der Zeit,
dass wir da also entsprechend hinkommen und jetzt im Einzelnen
die Sachen noch angucken,
das überspringe ich hier an dieser Stelle
Zusammenfassung, wir haben die Mischen von Folgen A und B
der Länge N. Und wir kommen jetzt sozusagen auf das Teil,
was im Skript, glaube ich, relativ weit vorne steht,
wo wir eben jetzt halt die verschiedenen Sätze haben mit den entsprechenden Zeitgeschichten.
Und die Algorithmen waren dann auch sozusagen optimal. Das ist interessant,
aber trotzdem konnte man das sozusagen noch besser hinbekommen bei den anderen Dingen.
So, und mit diesem schnellen Suchen kommt man eben auf
diese Teile, die am Ende da stehen,
mit diesem N-Locklock-En-Teil
So, das ist halt das Binäre Suchen,
beziehungsweise das Parallele Suchen, was man dann näher angucken.
So, was jetzt als nächstes kommt,
ist dann das Ordner einsortierten Folge in eine andere sortierte Folge.
Wie macht man das jetzt? Da habe ich ja gesagt,
wir fangen vorne an, sortieren die einzeln ein und sortieren die so rein.
So, das war aber jetzt ein bisschen ungünstig.
Wenn wir jetzt eine Einzahl von Prozessoren halt haben,
wir haben ja, auch da haben wir wieder ein paar Dinge vorliegen.
Das heißt, wir können das Ganze wieder palitionieren und die
das einsortieren lassen. Das heißt,
wenn wir uns alle hinstellen müssten und eine Menge von einzelnen Zahlen zusammensortieren,
dann würde jeder von euch irgendwie mal so ein Teilteil zusammenpacken.
Es würde nebenläufig passieren. Natürlich wäre es schneller,
als wenn ich das hier vorne alleine machen würde und ihr müsstet mir zugucken,
wie ich die 10.000 Zahlen so ineinander einsortiere.
Wenn wir das einmal aufteilen, wenn wir ruckzuck fertig
an denen stellen
Gut, das ist das, was dahinter steckt,
dass man jetzt wieder hingeht, wie man das macht,
läuft eben entsprechend über die Partitionierungsidee.
Da ist ja wieder ein Tickchen anders als bei den anderen Sachen.
Man muss halt als Index jetzt Wurzel-M nehmen sozusagen,
da kann man noch reingucken und da greifen wir auf diesen 7-2er entsprechend Algorithmus zu.
So, und was will ich jetzt Da muss man auch passen,
dass man diese Elemente in dem entsprechenden Teil halt einsortiert.
Aber das sind die, dass wir oben auf die
größten Zahlen sozusagen zugreifen können und uns daran orientieren können,
wie die Teile aufgeteilt werden.
Das machen wir dann über den Renk und passen auf,
dass das mit dem W konform geht an der Stelle.
So, die Idee ist dann halt,
dass wir unsere Bs mit den As jetzt sozusagen im ersten Schritt irgendwie reinpacken.
Wir müssen gucken, wo wir die Schnitte halt
sozusagen machen wollen
Und müssen halt dafür sorgen,
dass wir zum Beispiel das A in diese entsprechenden drei Teile
aufteilen und das B mit den entsprechenden Sachen auch entsprechend zuordnen,
dann gibt es die entsprechenden vier Schritte,
die werden über einzeln angeschaut, wir palitionieren den Kram,
wir haben den Renk und können das einzeln angeben.
Das heißt, wir gucken,
wie sind die einzelnen Ränge von diesen Teilen, benutzen das,
um das dann entsprechend aufzuteilen da oben in diese entsprechenden Bereiche.
Genau, diese bunten Teile beziehen sich eben genau auf das,
was ich gerade vorher hatte
Wie gesagt, das kriege ich jetzt hier nicht mehr visualisiert,
weil ich jetzt leider ein bisschen spät dran bin.
Das war das, was ich in den Frühlingen vorher halt
auch entsprechend pink und grün und rot angemalt habe.
Auf dem Skript könnt ihr das ja vor euch dann sehen,
wo die Teile jetzt wieder einsortiert werden.
So, der Algorithmus, den man dann hat,
der rechnet entsprechend dann den Rank in der Zeit Log-Log-in aus.
Mit N plus M mal Log-Log-in Operationen, also in der Größenordnung.
Und das kommt halt wieder, weil wir diese entsprechenden Aufteilungen
gemacht haben und den entsprechend nebenläufig jetzt verarbeitet haben.
Den Beweis müsst ihr im Skript nachgucken
Wir haben dann entsprechend jetzt als Korular,
das zwei sortierte Folgen der Länge enden können in Ufern Locklock
in Zeit, mit entsprechend Operationen gemischt werden.
Gut, der nächste Satz, es sind auch klar die Aufgabe,
zwei sortierte folgende Länge in zu mischen,
wird in den entsprechenden Zeiten und Operationen Sachen hinbekommen.
Da guckt man in die Literatur.
Ja. So, das kann ich jetzt noch durchbuchstabieren.
Die letzten zehn Folien kriege ich jetzt eh nicht mehr durch.
Ich werde beim nächsten Mal das noch kurz aufgreifen.
Nochmal kurz abschließen, fünf Minuten und dann mit Beispielen
weitermachen und dann mit der Wiederholung vom Gesamtstoff nochmal durchgehen,
was so Klausur interessant sein könnte.
Gut, okay,
damit sind wir für heute durch