Letztes Mal hatten wir uns ja so ein bisschen mit den
gefärbten Netzen auseinandergesetzt. Das heißt, wir haben versucht,
dort so eine Abstraktion draufzupacken. Wir werden heute sehen,
dass man sowas auch bei anderen Stellen machen kann. Das heißt,
dass man so einfache Modellen, komplexere Modelle verwendet oder Modellierungsverfahren verwendet,
sodass man da zu Aussage stärkeren Begriffen kommt, Möglichkeiten,
sich besser auszudrücken.
Das andere Thema, was wir hatten, waren Bei der Bankier-Agorithmus,
da gab es jetzt zwei, die ich gesehen hatte,
keine weiteren Fragen von eurer Seite aus.
Das heißt also, wie man diese sicheren Bereiche berechnet und
sowas, scheint euch ja klar zu sein.
So, das Thema bei den Netzen allerdings,
was wir davor hatten, war ja irgendwie Nebenläufigkeit.
Und jetzt kommen wir irgendwie auf Parallelität. Und das ist
eine der Dinge, die häufig immer wieder verwechselt wird.
Das heißt, ihr solltet also aufpassen,
wann ihr sozusagen Nebenläufigkeit... Hier unten ist noch jemand im Zettel.
Wann ihr etwas nebenläufig habt. Das heißt, kausal unabhängig.
Und wenn ihr Parallelität einsetzt, Parallelität ist nur dann möglich,
wenn ihr überhaupt irgendwie kausale Unerfindlichkeit habt, sonst wird das Ganze schlecht parallelisierbar.
Andersrum könnt ihr euch mal Gedanken machen, wie das ausschaut.
So, die Parallelen Maschinen, die wir so haben,
schaut halt so aus, so ähnlich wie ich das jetzt hier auch gerade sehe.
Ich stehe also hier vorne irgendwie und habe ganz viele Parallelverarbeitungseinheiten
vor mir, die jetzt hier im Einzelnen irgendwie sitzen
Und was die im Einzelnen machen, ich hoffe,
dass ihr alle in etwa die gleichen Hintergründe habt,
um den Input sozusagen, der jetzt kommt, entsprechend verarbeiten zu können.
So, das heißt, unter Parallelen und verteilten Algorithmen,
die jetzt ja jeweils an den verschiedenen Stellen ablaufen,
wird die Erweiterung von klassischen, für einen Prozessor Maschinen konzipierten Algorithmen,
auch viele miteinander kooperierende Prozessoren verstanden.
Das heißt, es geht also jetzt darum,
dass wir irgendwie die Idee, die wir bisher hatten,
die sich auf einen einzelnen Prozessor bezieht,
insbesondere von der Turing-Maschine aus gesehen, die wollen wir jetzt irgendwie auf mehrere
Auf mehrere miteinander kooperierende Prozessoren ausweiten. Was wir jetzt hier
im Moment an dieser Stelle nicht machen, ist,
dass wir es auf viele verschiedene echt verteilte Systeme beziehen wollen,
sondern wollen es ein bisschen lokale halten, das Ganze.
Das heißt, man sieht ja irgendwie so eine Menge in
so einem Raum von entsprechenden Einheiten,
für die ich noch eine bestimmte Art von Synchronisation über
ein Zuwinken von euch sozusagen mit reinbekomme
Die parallelen Algorithmen beruhen der Regel auf Speicher oder Rondo-Wus-Inchronisation und da
hat man eine Synchrone-Applaus-Emantik. So, wenn ich sage,
alle aufstehen, alle setzen, funktioniert es hier relativ gut,
je nachdem, je nachdem, wie weit ihr bereit seid,
euch dem zu beugen, diesem Diktat.
Aber es ist sozusagen möglich, euch synchron aufstehen und setzen zu lassen.
Wenn man genau hinguckt, steht ihr ohnehin doch verteilt,
auch, weil ihr verteilt seid, aber vom Modellierungsaspekt,
den ich erstmal einnehmen möchte, können wir hier bestimmte Aktivitäten synchronisieren.
Und wenn ich euch zeige, wie viele Finger habe ich jetzt hier,
ist die Antwort relativ einfach und Und ich muss auch nicht
jedem von euch einen Brief schicken und sagen,
Daniel hat jetzt fünf Finger hochgehalten,
sondern aufgrund der Synchronationsmechanismen und der entsprechenden Lokalität können wir direkt darauf zugreifen.
Das heißt, wir gehen jetzt hin und stellen uns Maschinenmodelle
vor, wo wir so eine Art interne Taktung reinbekommen.
Das heißt, da, wo ich lokal in bestimmter Weise
die Prozessoren noch beeinflussen kann.
Es gilt sich also nicht um vollständig unabhängige Rechnereinheiten
So, weshalb ist irgendwie so eine nette Geschichte,
die wir jetzt im Bratschen Koloquium hatten vor einer ganzen Weile inzwischen schon,
nämlich irgendwie vor zwei Jahren, da ist der Herr Ludwig,
der sich insbesondere mit Höchstleistungsrechner beschäftigt und der eben insbesondere sich um solche Höchstleistungsrechenheit kümmert.
Und die Höchstleistung wird eben nicht mehr dadurch erzielt,
dass sich einen besonders schnellen Prozessor baue und der immer schneller ist,
sondern dem ich halt viele gleichartige Prozessoren verwende und die Einsätze.
Problematik an der Thematik ist,
dass man in irgendeiner Weise hinkommen muss und die Algorithmen,
die man vorher für die sequenziellen Dinge geschrieben hat, Die muss ich umschreiben.
So, und dieses Umschreiben ist genau das,
was für euch in den nächsten Jahren ansteht,
weil wenn ihr irgendwo in die Firmen kommen werdet,
werdet ihr im Wesentlichen sequenzielle Programme vorfinden.
Und wenn ihr jetzt bedenkt,
wie die entsprechenden Anzahlen von Prozessoren in den Rechnern sich gerade ausbreiten,
ist klar, dass man in Zukunft immer mehr auf Parallelität steht,
auf schnellere sequenzielle Sachen irgendwie gucken wird.
Man würde also gucken, wie man die entsprechenden Aufgaben zuwältigen
sind, nebenläufig bzw. parallel verarbeitet
So, und diesem Thema widmen wir uns jetzt heute,
dass wir so ein kleines bisschen in die Richtung gehen,
dass wir uns überlegen, was da eigentlich spannende Aspekte sind,
was einem das bringt und wo es einem nichts mehr bringt.
So, wenn wir das Ganze mit verteilten Algorithmen uns angucken,
das heißt, wenn wir auf die Idee kämen,
wirklich verteilte Rechner anzugucken auf der ganzen Welt und die laufen völlig unabhängig voneinander,
dann würde ich in dem Moment von verteilten Algorithmen sprechen,
wo ich von Nachrichtensynchronisationen rede.
Das heißt, wenn ich quasi einen Puffer in irgendeiner Form
zwischen den aktiven Einheiten habe
Die Frage, inwieweit jetzt das Netzwerk aller Rechner dann wieder einrechne,
ist, gab ja verschiedene Hardware-Produzenten, die sowas mal als Idee hatten.
Das ist das Netzwerk der Computer ist. Das muss ich genau überlegen,
wie man jetzt diesen Computer entsprechend programmiert bzw. ihm das entsprechend gestaltet.
Da stellt sich natürlich auch die Frage,
wie kriege ich also diese verteilten Maschinen an den verschiedenen Orten,
vernünftig Programmier-App.
Mit den dahinterstehenden Problemen
So, die verteilten Dinge werden wir uns jetzt hier nicht angucken.
Dafür gibt es die entsprechenden anderen Veranstaltungen, insbesondere nächstes Semester,
für euch dann sozusagen in nochmal einem Jahr.
Könnt ihr in die entsprechenden Spezialveranstaltungen gehen bzw. im Master,
je nachdem, wenn ihr euch sozusagen orientiert und wann ihr bestimmte Wahlmöglichkeiten benutzt.
Bei euren Veranstaltungen, die ihr habt,
könnt ihr ja
verschiedene Themengebiete aussuchen
So, Verteilung ist also hier nicht ganz so spannend.
Was wir jetzt haben, ist, dass wir von einer
Menge von Prozessoren ausgehen. Sinnigerweise sind die auf den,
in den Rechnern entsprechend auch in ähnlicher Form wieder angeordnet.
Oder man schaltet sie entsprechend in einer bestimmten Art und Weise,
sodass man von einem, ja meinetwegen zweidimensionalen Feld ausgehen kann.
Man kann auf diesen entsprechenden Türen auch Ringarchitekturen oder einen Baum oder ein Feld,
RA oder sowas sich entsprechend vorstellen oder irgendwas entsprechend anderes,
was man sich da vorstellen möchte
Entscheidend ist, dass wir in irgendeiner Weise auf einen gemeinsamen
Speicher zugreifen können und entsprechend dann die einzelnen Prozessoren haben,
die über diesen gemeinsamen Speicher, meinetwegen die Blackboard,
die Wand da vorne, wie viele Finger zeige ich,
sozusagen sich wieder synchronisieren können.
Und die Idee ist jetzt, dass jeder Prozessor für sich
alleine ist ein eigenständiger Rechner im Grunde genommen.
Also eigentlich eine RAM, wenn wir gleich darauf kommen.
Und dadurch, dass wir jetzt mehrere davon haben,
haben wir entsprechend eine P-RAM im Vorliegen,
die wir dann sozusagen als Paradel random Access Machine bezeichnen wollen
Gut, wie schaut das Teil jetzt aus?
Dafür muss man sich die einzelnen Teile ein bisschen genauer angucken.
Da wird man sozusagen auf so eine RAM wiederkommen,
dass man so hingeht und irgendwie genauer nachschaut, woraus besteht denn das?
Solltet ihr irgendwie aus den technischen Zweig der Veranstaltungen mit kennen,
beziehungsweise hier wird es nochmal ein kleines bisschen wiederholt,
weil wir ja erstmal auf die Berechenbarkeit gucken.
Trotzdem sieht es sehr ähnlich aus zu dem,
was ihr von der Hardware
her kennt
Gehst du irgendwie davon aus, dass man eine Eingabe hat.
Man hat eine Ausgabe, das Ding hat also irgendeinen Zweck,
um irgendeine Eingabe, eine Ausgabe zu transformieren. Das,
was ich am Keyboard oder an der Tastatur eingebe oder was
irgendwo eingelesen wird und auf dem Bildschirm entsprechend wieder angezeigt oder in die entsprechende Dateien geschrieben wird.
Intern gibt es halt so ein kleines Programm,
das steht auf der linken Seite,
haben wir irgendwelche Statements stehen, die sozusagen das Programm beschreiben.
Auf der rechten Seite haben wir irgendwelche Register stehen und innen drin haben wir was,
was ordentlich arbeiten kann und was sich merkt,
an welcher Stelle man gerade sozusagen im Programm steht.
Dass jetzt sozusagen das Modell,
was wir jetzt immer wieder in diesen einzelnen Maschinchen finden und
dem wollen wir uns jetzt noch ein bisschen genauer Das ist jetzt sozusagen das,
was früher in FGI 1 dran war.
Das ist jetzt hier in FGI 2 reingeschoben worden,
sodass jetzt hier so ein paar Punkte aus dem Stoff hier auftauchen.
So, sind wir also hier wieder bei diesem Teil.
Und es ist jetzt ein bisschen ähnlich aus, das Ganze.
Auf diesem Eingabeband können wir jetzt irgendwelche Zahlen unterbringen,
sei es einfache Zahlen oder relle Zahlen
Das Band ist unbeschränkt lang. Können also blieb ich viele,
aber es stehen eben endlich viele Eingabesymbole erstmal da drauf.
Und wir haben ein Ausgabeband, auf das wir entsprechend auch
wieder irgendwas rausschreiben können. Das Interessante ist,
dass wir diesen Programmspeicher separieren von unserem entsprechenden Datenspeicher.
Wir hätten also auch sozusagen das zusammenlegen können,
sodass man selber das Programm umschreiben kann, eine Rasp dann in der Stelle.
Das brauchen wir jetzt hier, erstmal nicht,
halt bis zur Klarheit halten wir es erstmal auseinander
So, dieser Instruction-Counter, der IC sorgt eben dafür,
dass man weiß, wo man sich befindet.
Die Alu ist halt für die entsprechenden Rechenoperationen, je nachdem,
wie sie aufgebaut ist, kann sie plus minus oder
auch mit Mal oder noch ein paar andere Dinge dabei.
Und der Comnator hat eben die Möglichkeit, in irgendeiner Weise auf diese Register,
auf den Datenspeicher zuzugreifen und sich dort Sachen zu holen oder zu schreiben.
So, jetzt die Frage, was kann das Teil eigentlich genau tun?
In irgendeiner Weise haben wir jetzt hier Operationen. Das heißt,
wir haben so eine Read-Operation, wir haben unter Ride and Load,
mit dem wir irgendwas aus diesen entsprechenden Registern rausholen können.
Und Store at and Sub, wo wir auch drauf arbeiten, auf diesen entsprechenden Registern.
Und wir haben entsprechende Sprungbefehle, die dort vorkommen. So,
bei diesem Operant, den wir da drin haben,
haben wir also irgendwie die Zahl I,
die wir entsprechend zuweisen, so eine Read-Operation machen,
lesen wir die also von dem Band irgendwie ein und sagen,
das ziehen wir da mal runter.
Dieses entsprechende Ride and Load hat eben die entsprechende Register,
die man gerade am Wickel hat,
was der Akumulator gerade anzeigt
und arbeitet entsprechend darauf
Spannend ist jetzt, dass es die indirekte Adressierung gibt.
Das heißt, ich kann hingehen und mir angucken,
was in einem Register drinsteht und benutze das als entsprechende Adresse.
Wer kennt dieses Verfahren der indirekten Adressierung nicht?
Wer kennt es? Okay, alles klar, sehr schön
. Brauche ich da ja nicht drüber weiter zu philosophieren.
Und die entsprechenden Sprungbefehle mit dem unbedingten Sprungbefehl,
die an irgendein Label hinspringen,
mit dem Goto halt heiß geliebt,
dann der bedingte Sprung,
wenn also im Register null entsprechend eine null steht oder beziehungsweise ob sie größer ist als null,
dann wird entsprechend zu dem Label gesprungen,
sind die beiden anderen Befehle
So, was wir da jetzt haben, ist,
dass wir verschiedene Struktionen halt haben, wie Lot A oder Load A,
wie immer auch immer man das aussprechen möchte jetzt,
sodass wir also irgendeinen Wert aus dem,
von dem Wert A entsprechend in das Register reinpacken.
Dieses C ist halt die entsprechende Speicherabbildung, die wir uns dann angucken müssen,
wo wir das drauf, wo wir drauf zugreifen.
Und das CI ist dann der Inhalt des entsprechenden Registers RI.
Und VA ist halt eben der Wert von A,
wer ein V gleich IMI ist und VI ist dann eben CI,
muss man halt eben ein bisschen auseinanderhalten,
wann der Wert und wann sozusagen der Inhalt des entsprechenden Registers I gemeint ist an den Stellen.
Beziehungsweise das indirekt adressierte Teil. So, bei den entsprechenden Instruktionen,
die wir haben, haben wir halt das Load und Store,
wo wir das halt entsprechend in die Register reinpacken und entsprechend mehrfach halt gucken müssen,
um irgendwelche Werte ablegen zu können.
Das Ed Sub-Mult and Diff ermöglicht uns eben die ganz normalen Operationen,
wo wir dann die entsprechenden Werte von A entsprechend entsprechend mit dem Inhalt von dem jeweiligen Register,
hier null, entsprechend wieder auf das Register null zuweisen.
So, das Reed E und Reed E,
Stern und so weiter sind eben die entsprechenden Eingabesymbole,
die wir jetzt einlesen, beziehungsweise das Eingabesymbol bei den entsprechenden Band,
muss man dann entsprechend sich weiter fortbewegen,
das sozusagen automatisiert dann mit drin und muss das entsprechend dann einlesen beziehungsweise zuweisen.
So, bei dem Ride wird eben in das Feld auf dem Ausgewandt geschrieben,
über dem sich gerade bei den Kopf befindet und man will
sie nach rechts, auch nichts Weltbewegendes an der Stelle.
Das Jump ist halt eben die entsprechende Sprung und dieses
Greater Than und Zero sind die entsprechenden Befehle,
die man hat, wenn man halt den Inhalt noch abprüft.
Das Holt sorgt eben entsprechend dafür, dass die Programmausführung beendet
wird und die Berechnung damit zu Ende ist. So,
Diese Dinge sind das,
was man an den meisten Stellen heutzutage nicht mehr benutzt,
außer man hat irgendwelche ganze Hardware, Dinge zu erledigen,
nämlich dass man sich mit der Semmler rumschlagen muss und sich angucken muss,
was denn da in genauen Tricks und Tipps und Tricks sozusagen in der Maschine genau passiert.
Im Normalfall werden heutzutage die Sachen auf einer abstrakteren Ebene beschrieben,
haben wir rechts so eine Zeudosprache mit Ifs and Els oder Weil oder solche,
welche tollen Konstrukte,
die muss man sich eins überlegen und da muss man
sich angucken,
wie die in die Maschinenbefehle
quasi umgesetzt werden
Das ist das, wenn man die technischen Sachen auf dem Rechner anguckt.
Das Gleiche wollen wir jetzt hier auch spielen.
Wir wollen in irgendeiner Weise abstraktere Begriffe verwenden können und dahinter
aber die entsprechenden Befehle für unser schematisches Modell halt haben.
Das ist je nachdem, was ihr für Prozessoren habt und so weiter,
ganz andere Sachen dahinterstehen können, lassen wir außen vor.
Wissen wir jetzt hier bei dem abstrakten Modell daran? Das heißt,
das Lesen von R1 ist das normale Weed 1. Das ist,
also dann genau das, was man dann so erwartet.
Für das iF haben wir jetzt mehrere Sachen,
die wir da auf die Reihe kriegen müssen.
Wir müssen erstmal
irgendwas laden
Nämlich das R1. Und wenn es entsprechend größer ist,
wenn es keiner gleich null ist, dann schreiben wir entsprechend null.
Und ansonsten springen wir zu Boss und machen dort entsprechend weiter.
Wobei eben dieses Label, was wir da haben,
die entsprechende Sprungabdresse auf der linken Seite, Post eben darstellt.
Und wenn wir aber bei dem Ride waren und wir zum nächsten Befehl kommen,
das heißt, diese Abarbeitung läuft immer von oben nach unten.
Es sei denn, wir haben einen Sprungbefehl
Naja, dann treffen wir jetzt hier auf einen Sprungbefehl an
dieser Stelle bei dem Jump und springen zu dem End-If,
womit wir ganz unten landen und auf dem Halt enden.
Und nicht irgendwie auf dem End ist von dem If,
was da oben rechts steht, sondern es landet bei dem Label,
was wir da haben und müssen ganz nach unten hinspringen.
So, wenn das Ganze positiv ist, naja gut,
was müssen wir da machen? Dann müssen wir auf dieses Register 2
den Inhalt von der 1 draufpacken. Wir laden also erstmal das 1,
dann speichern wir das Ganze in 2,
dann ziehen wir mit dem nächsten Teil, machen wir das,
dass wir jetzt auf das R3 etwas zuweisen wollen.
Und 2-1 minus 1,
woraufhin wir erstmal Lot 1 machen müssen
Ein Abziehen. Das sind drei Abspeichern. So, und
dann geht's jetzt los. Was machen wir damit überhaupt?
Wir berechnen diese Funktion N hoch N. Das heißt,
wir kriegen irgendeine Zahl und haben als Ergebnis ja N hoch N als Ausgabe.
Das Ganze für Null startet. Wollen wir außen vor lassen?
Wollen wir den Eins nehmen? Kann man sich angucken,
was da genau passiert und was da entsprechend drinsteht.
So, wie ist dabei der Ablauf?
Der selbst
Ist aus dem Grunde sinnvoll, weil in der Klausur
eine ähnliche Aufgabe drankommen wird? Irgendein Brechen irgendeiner Funktion aufschreiben
und hinmalen. Das ist im Normalfall nicht so schwierig,
sich dazu so ein Programm anzugucken,
beziehungsweise das zu verstehen oder auch selbst zu schreiben, je nachdem.
Spannend ist nachher die Komplexitätsabschätzung, welche Kosten das Ganze verursacht
und wie aufwendig das ist. Und das ist das,
was er eigentlich dann zählt,
aber dafür müsst ihr erstmal die Voraussetzung erfüllen,
dass diese Programme lesen und schreiben könnt
Es ist mir nicht klar, wie der Ablauf für eins ist.
Wenn man eins hoch eins ausrechnet, oder zwei hoch zwei,
wäre der nächste Schritt. Soll ich mal durchgehen? Okay
, gut. Wird gewünscht. Gehen wir nochmal durch.
Wir lesen irgendwie die 1 ein und stellen fest,
dass es nicht kleiner gleich null ist und springen also zu
dem Post hin,
laden dann entsprechend diese 1
in das Register
Und laden eins, minus eins in das Register 3. Weil wer
das R1 behält, weiterhin die Eins, minus eins ist,
die Null, die wir entsprechend zuweisen auf die Drei.
Jetzt laufen wir in das Weil rein. Solange dieses R3 größer ist
als Null, das ist bei unser Eins nicht der Fall.
Also, weil da ja eine Null drinsteht.
Eins als Startwert. Springen wir sozusagen zu dem Endweil,
schreiben es Register 2 raus.
Was hatten wir da drin? Ja, den Wert Eins,
schreiben den raus und sind fertig.
So,
damit haben wir
die einfachen Durchlauf
Was mache ich jetzt an dieser Stelle? Also,
wenn ich jetzt hier so durchgehe, ich suche mir den einfachstmöglichen Fall aus und versuche,
den wirklich einzeln durchzubuchstabieren und mir klarzumachen, was es ist.
Die komplizierteren Fälle baut man dann nach und nach auf und guckt sich das an,
wie das denn für andere Sachen aussieht, um Verständnis davon zu bekommen.
Zum Beispiel den Fall, dass ihr nicht wüsstet,
was das für eine Funktion jetzt hier eigentlich wird. Was ihr macht,
ist, ihr schreibt euch einmal so ein, zwei,
drei, vier, fünf Möglichkeiten auf und schaut euch an,
was die Ergebnisse sind und schließt darauf, was das für eine Funktion ist.
Solche entsprechende zwei habe, würde ich natürlich auch das Gleiche haben,
würde aber den Weil dann mit dem R3 hat dann die entsprechende Einsinn,
weil ich vorher mit der Zuweisung von R3 und dem R1 minus eins Penner einstehe,
muss ich also unten reingehen,
dann komme ich zu diesem Continue und jetzt komme ich da nämlich rein,
wo ich diese Multiplikation durchführe,
einmal.
Und da kommen wir dahin, dass wir dieses R2,
was verstehen haben, wo die unsere zwei drinstehen,
mal R1 haben und das entsprechend,
also eher zweimal R1 nehmen
Und in diesem Fall, wenn wir die zwei drinnen
stehen haben, kommt halt die entsprechende vier raus.
Dann subtrahieren wir wieder entsprechend eins von dem R1. Wir fliegen aus
der Steife raus und schreiben unten die vier raus und so weiter.
So, und das wird jetzt entsprechend jedes Mal entsprechend oft durchlaufen.
Wie wir sehen, ziehen wir jedes Mal einen runter und
wir müssen jedes Mal einmal mit dem R1 multiplizieren, egal welche zahlweise haben.
Sie wird also en-mal multipliziert, weil wir genau das entsprechend runterzählen
von dem R3, was wir da immer kleiner machen.
Und dadurch, dass wir das dann entsprechend multiplizieren,
über das R2, wo wir das Zwischenergebnis haben,
mal dem R1 und kommen im Endeffekt auf die N-Hoch-Ennen-Geschichte hin.
Bei der N-M-M in Mall haben. Gut, okay.
Das entspricht eigentlich ziemlich genau dem,
was man so in so einer anderen Hochsprache dann auch wieder hinschreiben würde,
halb in Beginn und Reed und If und Els und so weiter und so fort.
Das heißt, das normale Programm, was man dahinter erwarten würde.
Entspricht ja ziemlich genau dem, was wir auf der
linken Seite stehen haben. Ihr müsst also nur aufpassen,
wie ihr in dieser Hochsprache
das hinbekommt
In der nächsten Woche, in der Übungsgruppe, werden wir es mal genauer durchgehen.
Und da wird auch nochmal genau dann erklärt, was die entsprechenden Maße,
auf die ich gleich komme, dann entsprechend sind.
Und wie man das mit den hochsprachlichen Dingen und den einzelnen Befehlen,
die dann dahinter stehen, wieder in Verbindung bringt.
Wichtig ist also, dass jetzt diese einzelnen Befehle,
die da jetzt entsprechend stehen, mit dem Wile und If und so weiter,
wie die wieder aufgelöst werden in die entsprechenden,
ich sag jetzt mal, Assembler-Befehle.
So, was haben wir dabei?
Wir kommen jetzt auf die Idee und wollen Komplexitätsmaße einführen
Es ist die Sache dabei, dass wir das sowohl für
die Zeit als auch für den Platz uns angucken können und sagen,
jedes Mal, wenn wir einen Schritt machen in unserem Rahmen,
ist das eine Zeiteinheit.
Die Frage ist, wie viel Zeit habe ich eben verbraucht?
Naja, jetzt musst du eben aufpassen, ziehe ich das
jetzt für meine abstrakte Sichtweise oder muss ich das für meine Details zählen?
Muss die Details natürlich jetzt im Einzelnen angucken,
die aber im Normalfall dann sich leicht abschätzen lassen im Einzelnen?
So, wenn ich ein Uniformes Zeitmaß habe,
jeder Schritt eine Einheit,
ist das recht einfach zu berechnen und das Platzmaß ist,
nur wenn ich ein Register benutze,
habe ich
eine Platzeinheit dabei
So, die andere Idee wäre jetzt,
dass ich ein bisschen aus Fücher drauf gucke und auf das
gerüchtische Komplexitätsmaß gucke und quasi auf die Länge noch schaue,
was ich dort gerade immer verarbeite.
Wenn ich besonders große Zahlen verarbeite und die immer bearbeiten muss,
dann kann es ja durchaus sozusagen kostenintensiv werden.
Und deswegen versucht man das nochmal in der übersugrötischen Maß anzuschauen.
Und die Idee ist jetzt,
dass es eigentlich prinzipiell erstmal eins ist,
beziehungsweise in dem Moment, wo das i-ungleich null ist,
haben wir den Lugrhythmus von i
plus 1
da drin
Wie sieht das denn genau aus,
wenn wir die Operanten haben, mit dem gleich I?
Naja, dann ist das eben die Länge von dem I,
also genau der Wert. Und das ist in irgendeiner Weise nicht
wie ein Unnäher, sondern meinetwegen Miniär, entsprechend kodiert.
Und dadurch haben wir entsprechende rhythmische zur Basis 2 Bewertung,
wenn wir Zehnergeschichten im Rhythmus zur Basis 10,
also was immer man auch für eine Art von Logorithmus gerade verwenden möchte,
benutzt man an der Stelle.
Und unser Operant I Ist dann halt etwas,
das wir den Wert und die Adresse beziehungsweise bei der indirekten Adressierung
müssen wir halt Wert, Adresse und Adresse zusammen addieren,
was man entsprechend hier unten entsprechend sehen kann.
Wir müssen also die Länge von dem CI-Wert,
was da drinsteht, wieder entsprechend benutzen. So,
damit haben wir jetzt für die einzelnen Operanten, je nachdem,
was sie da drin so haben, unterschiedliche Größen,
die wir da berücksichtigen müssen.
Und natürlich ist eine indirekte Adressierung eine teurere Operation als
irgendwie eine direkte Wertzuweisung an der Stelle,
weil der Wert sozusagen immer mit reinspielt
So, jetzt haben wir die entsprechende Definition.
Wenn wir jetzt also eine Uniform ist, Zeitkomplexität haben von so
einem entsprechenden Rahmenprogramm. Dann ist die maximale Anzahl TA,
der Summen der Uniformkosten aller Schritte des Programms bis zur Termination,
bis es also fertig ist.
Und das Ganze wird eben jetzt als der Zeitkomplexität,
wobei das Maximum eben über alle Eingaben der Uniform Größe N
gebildet wird.
So,
was stellt ihr euch dahinter jetzt vor
Gibt es da oben ein Problem oder? Alles klar,
gut. Diese Zeitkomplexität, schauen wir uns jetzt also an,
für die möglichen Mengen von allen Schritten des Programms,
die wir da haben können, bezüglich der Uniformgröße enden.
So, das Ganze kannst du auch einmal lukrithmisch durchdekliniert,
ist sozusagen gleiche Definition. Das andere ist jetzt halt,
die Uniforme Platzkomplexität von so einem Rahmenprogramm ist die maximale Summe
und so weiter, wie es da entsprechend steht,
kosten alle Register,
die wir
dann zusammenrechnen müssen
So, machen wir ein Beispiel lieber weiter,
weil dann ist das ein Tickchen klarer.
Die Zeitkomplexität bezüglich der Uniform Kosten ist an dieser Stelle
Tight O von N. Warum?
Wer hat eine Idee
Ja. Genau. Genau. Die, wie der Schritt
ist sozusagen ein, einer. Wenn wir jetzt auf
dieses Weihen gucken, wird das N mal gemacht.
Jetzt haben wir natürlich noch ein paar Schritte mehr.
Wir haben ja diese Dump und Lot und Mult und wie
sie alle heißen. Wie sieht es denn damit aus?
Müssen das nicht mehr sein
Du hast einfach, dass die konstant bleiben, in welcher Hinsicht bleiben die konstant?
Ich meine, die kommen doch bei jedem Durchlauf,
kommen sie auch wieder vor. Also kommen sie auch sozusagen,
was weiß ich, achtmal N vor oder neun oder zehn,
wie immer die Anzeige jetzt hier ist,
meinetwegen auch nur drei oder sowas.
Woran liegt das jetzt, dass man das tatsächlich erstmal unter
den Tisch fallen lassen darf?
Ja, genau, was ist die Begründung dann,
Bus, Entschuldigung, habe ich akustisch nicht verstanden?
Nochmal? Ja. Ja, okay,
aber was die Kosten sind sozusagen an Schritten, hatten wir gesagt,
jedes Ding, was da ist, kostet Zeitschritt 1.
So, und jetzt habe ich ein Lot,
kostet Zeitschritt 1, dann kommt das Jump Greater and Zero,
kostet 1,
dann muss ich
mein Lot machen
Kostet eins, mein Mult, kostet eins, mein Store, kostet eins.
So, und wenn ich jetzt aufsummiere, komme ich auf mehr als ein.
Nämlich eins, zwei, drei, vier, fünf,
sechs, sieben, acht, neun, zehnmal N.
Ja. Exakt. Genau, das darauf wollte ich hinaus.
Diese O-Rechnung ist dann das, was einen das vergessen lässt an dieser Stelle.
Und das war ja schon eigentlich die Antwort eben,
ich wollte es nochmal explizit hören,
dass man da halt die Sachen vernachlässigen kann.
Dass da jetzt mit Platzkomplexität haben wir O von 1,
warum gilt das
Na, wie Platz brauchen wir? Wir brauchen irgendwie,
ne, Register 1, 2 und 3.
Und das war's. Und damit sind wir auch wieder in Ufern 1.
Und das Ganze wird relativ billig mit dem Uniformmaß an dieser Stelle.
So, logorithmische Kosten. Da sitzt ein kleines bisschen komplizierter
aus. Wie kommen die denn jetzt zustande?
Die Endquadrat-Log-In beziehungsweise in Log-In-Teile
So, und das ist genau die Frage,
die in der Klausur gestellt wird, weil welche Komplexität hat es denn?
Und jetzt muss man nämlich anfangen, nachzurechnen und im Einzelnen zu gucken,
wo bei diesen Operationen das jetzt hängen bleibt und wo das
immer wieder vorkommt und wo man die entsprechenden Sachen benutzen muss.
Und dafür braucht man die entsprechenden,
ich sag da jetzt hier drauf, entsprechende Kostenüberfahrten,
die habe ich jetzt hier, jetzt nicht hier reinkopiert.
Genau, ne? Wir haben ja unten dieses Teil,
wir haben das Weil mit dem Multiplizieren,
das ist das,
was wir entsprechend eben hatten
Und wenn wir jetzt sozusagen das N hoch I mal N
als Größe sozusagen mal annehmen, was wir da machen müssen,
dann ist das immer wieder dieses L von N hoch I.
Jetzt kommt nämlich darauf an, was man da für Werte
hat in diesen Sachen. Plus das LN von N. Und
das ist sozusagen genau das I plus 1 mal Logorithmus N. So,
und wenn man jetzt hingeht und das N minus 1 mal entsprechend aufsummiert,
kommt man eben entsprechend auf genau dieses wo ein Quadrat-Login mal bezüglich der Zeitkomplexität,
die wir da drin stecken haben.
So, diese Dinge guckt euch einfach nochmal an.
Genau das Gleiche mit den entsprechenden Längen und die Anzahl der Register,
die man da braucht und was das an Platz kostet.
So, das ist jetzt erstmal so die Idee für die Run,
was man da hat, wie man die Kosten anguckt und was da entsprechend zu machen ist.
Was jetzt hier oben auf der Folie draufsteht,
ist die Wechselart Simulation einer RAM und einer Turing-Maschine
Was passiert jetzt? Jetzt gucken wir uns mal an. Webduild-Maschine,
wissen wir, die kann all das, was man so berechnen kann,
auch sozusagen simulieren und entsprechend die verschiedenen Klassen, die wir jetzt haben.
Wir haben jetzt die Ramen eben entsprechend mit einreihen,
dass die, genau, das Gleiche kann eigentlich die Touring-Maschine.
Interessanterweise kann die Touring-Maschine auch das, was sie ran kann.
So, nur offensichtlicherweise hatten jetzt andere Möglichkeiten bei der Ramen
im Vergleich zur Touring-Maschine. Da habe ich irgendwelche Bänder,
auf denen ich rumoperiere und hier mit einmal irgendwelche Register,
die ich irgendwie frei adressieren kann,
wo ich so irgendwo drauf zugreifen kann
So, können wir auf die Idee kommen, das ist ja
viel besser und viel schöner ist man mit der RAM hantiert.
Und das ist das, was wir uns jetzt im Folgenden
ein bisschen genauer angucken. Wir haben also das Arbeitsband und
unsere Steuereinheit steht auf dem I und kann jetzt irgendwie darauf arbeiten.
Wie funktioniert das vom Prinzip? Naja, es gibt einen internen Zustand.
Wir lesen dieses Zeichen jetzt ein und aufgrund dessen,
aufgrund der Konfiguration, nämlich Band plus diesem entsprechenden Kopf und dem,
was jetzt steht, passiert jetzt die entsprechende Operation,
was wir jetzt hier anstellen sollen.
Das werden wir gleich nochmal sehen. Wir haben jetzt hier
dieses entsprechende Teilkomplexität, jetzt wollen wir sehen,
wie wir das mit der RAM sozusagen auf die Reihe bekommen.
Das, was wir bei der Touring-Maschine machen,
wie machen wir das dann auf der linken Seite?
Sollten wir da irgendwas verarbeiten? Und da ist die Behauptung,
dass das Ganze in Tee von N-Locktee von N funktioniert,
wenn ich oben Tee von N-Zeit brauche, um mir das anzugucken.
Das ist das, was dahintersteht. Da ist die Frage,
okay, kann das also irgendwie das simulieren?
Das muss ja die ganzen Operationen alle Nacht spielen mit der
ganzen Konfiguration und so weiter. Deswegen ist der Aufwand auch
bei der RAM nachher höher als bei der Touring-Maschine,
weil sie irgendwas noch tun muss sozusagen.
Die Frage ist andersrum,
wenn die jetzt auf der linken Seite Tee von N hat,
wie braucht man denn da auf der rechten Seite
Und überraschenderweise ist es relativ, relativ billig, das ist
nur quadratisch viel Zeit ist, was man da benötigt.
So, wenn, man fehlen die Folie, da müssen wir
gleich noch kommen. Wir werden es gleich mal angucken,
wie so eine Verarbeitung dann vonstatten geht und was da passiert.
Und zwar gucken wir uns jetzt nochmal an,
was wir da für eine entsprechende Rahmen haben.
Wir haben gesagt, ja. Das ist das Gleiche
Ja, ja, klar, klar. Natürlich braucht die Toolmaschine
länger zum Simulieren für die RAM als umgekehrt, ja.
Ja, ist relativ billig. Und erwartet hatte,
dass es viel, viel mehr wäre, als nur quadratisch.
Das meinte ich damit. Okay, wenn du natürlich schon das annimmst,
dass es nur quadratisch sein sollte, ist das okay.
Aber ich fand, dass ich das erste Mal gesehen habe,
erstaunlich, dass es nur quadratisch ist, der Aufwand.
Ich würde da mehr erwarten, dass diese Willigen-Touring-Maschine mit ihrem Dödelband
sozusagen an der Stelle relativ schnell die Sachen simulieren kann,
inklusive die ganzen Verschieben, arbeiten da drauf,
die ganzen Register hin und her schieben,
verwalten und so weiter.
Das ist ja alles eine recht aufwendige Geschichte,
um die ganzen Register immer ständig übers Band zu schieben und
die Werte einzufügen und solche Sachen
Und diese entsprechenden Abbildungssachen, wie man das effizient hinkriegt,
muss man erstmal ein bisschen drüber nachdenken, bis das auch funktioniert.
Wir werden gleich noch ein bisschen mehr dazu sehen,
wie man es dann auch macht,
aber meine ursprüngliche Erwartungshaltung für mich persönliche Wahrheit,
dass es relativ aufwendig sein muss, so was zu machen,
dass ich den normalen Rechner mit einer einfachen prüngischen simuliere.
Und die ist gar nicht so aufwendig,
wenn man das geschickt anstellt. So,
was wir jetzt haben, wir haben jetzt einen Satz hier,
nämlich wir haben so eine RAM ohne Multiplikation und Division,
die wir uns jetzt hier mal angucken wollen.
Wir haben also eine TN zeitbeschränkte Mehrband deterministische Touring-Maschine M und
die kann durch so eine RAM Plus simuliert werden,
die im Uniform Mars O von TN
zeitbeschränkt ist
Haben wir erst mal das Uniform Mars. Und die im
lugrittelischen Mars, TL-Log, denen zeitbeschränkt ist. So,
dieses Arbeitsband, das wir jetzt hier haben,
ist halt eine entsprechende Steuereinheit, die wir auf dem I stehen haben.
Und da haben wir jetzt irgendwas auf dem Eingabeband entsprechend.
Und wir wollen irgendwas mit dem Ausgabeband irgendwie machen.
Und jetzt haben wir so eine Konfiguration für Sitturing-Maschine.
Das heißt, wir haben halt unseren entsprechenden Zustand,
den wir dort haben. Und wir haben die entsprechende Position
des Kopfes auf dem Band
Und wir befinden uns dort auf dem sechsten Teil. Und ja,
haben jetzt sozusagen da drin stehen,
wenn wir im P sind und I ist da,
dann soll der U geschrieben werden,
wir sollen nach links gehen und in Zustand Kuh wechseln.
Das ist das, was die Touring-Maschine so in ihrem,
in ihrer Steuerung stecken hat.
Gut, was passiert dann da? Naja gut,
wir haben irgendwie dieses P in dem Akkumulator drin.
Das ist der entsprechende Zustand, in dem wir uns gerade befinden.
Wir packen das also ins Register Null und merken uns da
immer den aktuellen Zustand
Dann haben wir uns irgendwie gemerkt, an welcher Stelle wir
jetzt gerade stehen. Das ist also jetzt gerade J,
was jetzt hier gleich sechs ist an dieser Stelle.
Und jetzt muss man natürlich diese Verarbeitung irgendwie hinbekommen.
Und jetzt muss irgendwo entsprechend drinstehen, wenn dieses Ernull gleich
diesem entsprechenden P ist und so weiter und so fort.
Und wenn das Ding gleich I ist,
dann soll man ein U dahin schreiben in die entsprechende Stelle
Übrigens wieder ein weitererzählen. So,
und das R0 soll dann entsprechend das Kuh werden.
Weil wir jetzt ja sozusagen einen nach links marschieren,
deswegen wird um einen runtergezählt bei dem Register 1. Was passiert also?
Wir haben hier dieses Arbeitsband und die entsprechende Steuereinheit
und können das jetzt durch die entsprechende Fünfband-Tool-Maschine
gleich nochmal simulieren
Die, der Satz, der jetzt da drin steht,
ist eben, dass eine rhythmische,
im rhythmischen Mars-TN zeitbeschränkte RAM Plus,
kann durch eine entsprechende O-TN zeitbeschränkte Fünfband-DTM simuliert werden.
So, jetzt fünf Bände haben, ist halt so ein entsprechender Trick,
den wir die entsprechenden Codierungen auf den Bändern wieder hinbekommen,
wie man das macht.
Das ist sozusagen der Gegenstand von FG1 gewesen. Wo wir
mal klar machen, kann das eine bestimmte Anzahl von Bändern haben.
Fünf reicht hier, um das einfach beschreiben zu können
Relativ. So, wenn ich also das so sehe,
habe ich also meine Steuereinheit und nehme also meine fünf Bänder vor,
in der ich die Sachen einzeln eben so ein bisschen unterbringe,
jetzt entsprechend zugeordnet,
habe ich meine Eingabe und mein Ausgabeband,
wobei ich jetzt hier das Eingabeband eben in der zweiten,
also von oben in der ersten Zeile und im grünen Teil habe,
das Ausgabeband ist eben irgendwie das zweite grüne Teil.
Mein Arbeitsband bleibt dabei,
weil das ist das,
auf dem
ich jetzt rumhantiere
Ich gucke mir irgendwie meinen Programmcount da nochmal an,
dann packen wir da auch irgendwo noch rein.
Und dann packen wir oben die entsprechenden Datenspeicher rein. Und das war das,
was ich vorhin meinte, was so ein bisschen aufwendiger ist,
wo also unser I und C sozusagen reinpacken,
was dann entsprechend die jeweiligen Dinge kodiert.
Das heißt, an welcher Position, also mit dem I,
wissen wir, wo wir uns gerade vom Prinzip her befinden und
das CI ist dann entsprechend das, was in dem Datenspeicher drinsteckt.
Das packen wir mal schön durch diese Gatter oder Hash-Symbole oder
sowas entsprechend schön getrennt. Das heißt,
wenn unsere Maschine rüberläuft, weiß ich immer genau,
wo sie wieder zu Ende ist und wann sie sozusagen am Ende
von so einem Teil angekommen ist und weiß auch am Ende,
wann sie vom Band angekommen ist, was wir dort hinschreiben.
Und nach dem Ende vom Band hören wir irgendwer auf und packen halt die Nullen rein,
die wir auch normalerweise beim entsprechenden Datenspeicher überall drin haben.
So ein Blank oder Null ist es dann im Grunde egal. So,
das heißt, wir finden da also ab einer bestimmten Position
ist das Band halt auf der rechten Seite halt leer,
genau wie der Datenspeicher nach unten halt als leer angenommen wird
So, bei der Simulation von den Dingen können wir jetzt
ein bisschen genauer reingucken. Das C-0,
was wir jetzt oben immer Kumulator drin haben, ist auch das,
was wir jetzt dann in das zweite Wand reinpacken.
Und das Beispiel ist jetzt so ein Ad 25 von 25.
Entsprechend indirekt adressiert. Und jetzt müssen wir halt gucken,
wie wir das ablaufen lassen an den Stellen.
Und wir brauchen dafür irgendwie
quadratisch viel
Viel Zeit. So,
und jetzt habe ich hier noch so einen Teil,
dass wir dieses entsprechend, entsprechende Zeit mal den Platz haben.
Und da behaupte ich, dass es immer kleiner als dieses Zeitballzeit.
Warum sollte das jetzt so der Fall sein?
Für die Touring-Maschinen? Die Frage, müsste aus der FG1
denn klar sein,
Genau. Für jeden Platz brauche ich immer mindestens eine Zeit, aber für die Zeit brauche ich nicht unbedingt Platz.
Das heißt, ich bin in der Richtung immer kleiner als dieses D-Kreuz-Tee. Gut,
wenn es jetzt entsprechend durchspielt, muss man halt diese 25 nehmen,
man muss den 25. Platz sich raussuchen,
man läuft oben auf dem Band so lange,
bis man entsprechend die Kodierung,
die man da drin hat, für die 25,
für das 25. Feld halt findet, nimmt das,
addiert es dann dahin, wo das C0 ist,
packt das entsprechend in den Inhalt von dem Register 0 rein und schiebt die Sachen entsprechend in diese,
in das Feld sie einzeln entsprechend rein.
So, und diese Simulation läuft genau wie bei der anderen Seite,
wie dann der einzelne Beweis dazu aussieht,
das ersparen wir euch hier sozusagen an dieser Stelle.
Wer Lust hat, kann es in den entsprechenden Büchern nachlesen,
der entsprechende im Skript angegeben sind. Es sind ja mehrere Literaturangaben drin. So,
dann gibst du noch die Rasp, die nichts anderes bedeutet,
als dass man das Programm mit in den Datenspeicher reinpackt und das noch nur mit manipulieren kann,
was dann sozusagen so ein kleines bisschen sowas wie die universelle Touring-Maschine ist,
die aber auch wieder durch die Rahmen wieder simuliert werden kann.
Also das heißt, von daher sind die Modelle im Endeffekt
So, und was man jetzt also hat, ist,
dass man irgendwie so eine Standardklasse von Maschinenmodellen hat,
die alle Varianten von Turing-Maschinen und die entsprechenden RAMs sozusagen mit reinpackt,
mit lokerithmischem Zeitmaß und die RAM ist mit der Uni-Farm Zeitmaß,
dem lokrithmischen Platz zugeordnet werden.
So, und wichtig ist dabei,
dass wir das Ganze nur mit Additionen machen und nicht mit den Multiplikationen,
weil die Multiplikation relativ ausdrucksstark sind und man da dann wieder
andere Dinge mit veranstalten kann
Und diese Maschinenmodelle in dieser Klasse simulieren sich gegenseitig mit irgendwie
so einem polymiell beschränkten Overhead, den wir da drin haben.
Das heißt, ich brauche nur ein Polynom viel mehr,
um sie sich wechselseitig simulieren zu lassen in dieser Klasse.
Und was dahintersteht, ist,
dass man quasi so eine erste Maschinenklasse hat,
die man da angeben kann, die jetzt genau diesen Run-Plus-Ding,
den Runs sozusagen entspricht.
Das weitere Modell, was wir gleich noch sehen werden,
ist dann das,
wo wir
die PRAM-Sachen mit reinbekommen
So, und da gibt es jetzt alle möglichen Sachen,
die ja euch im Skript doch entsprechend angucken könnt,
weil, wenn jetzt alle durchgehen,
dann müsst ihr euch die Vokabeln genauer angeguckt haben.
Und was wir jetzt haben, ist eben diese Rumtime,
die entsprechend Lugryphmen, beispielsweise Time Lock und Time vom Polynom,
da drin stecken hat, sodass wir also eigentlich genau alle rausbekommen,
die im Polyn-Gelat-Zeit sozusagen berechenbar sind.
Und das entspricht eben genau dieser entsprechenden Touring-Maschine,
die eben auch im Polynom-Zeit
diese entsprechenden Dinge berechnen kann
So. Und interessant ist dann, dass jede Locktime beschränkt daran,
da entsprechend mit drin steckt und dass das hier etwas ist,
was man mit nur einem Band auf die Reihe bekommt.
Also das heißt, die Anzahl der Bänder ist dabei auch
nicht ganz uninteressant, wie man da zur Verfügung hat.
So, die nächste Klasse, die wir dann aufbauen,
ist das mit den entsprechenden Parallelrechnern.
Und das sind dann die entsprechenden Perams,
die wir uns dann angucken
So, das heißt, jetzt geht es also zu dem,
womit ich angefangen bin, dass wir zu den Parallelmodellen übergehen.
Und in irgendeiner Weise jetzt auf die Idee kommen,
wie wir das bearbeiten können, wenn wir uns irgendwie einen Eindruck davon bekommen.
So, und was man hat, schön buntes Bild hier.
Wir haben also die entsprechenden gemeinsam geteilten Speicher, diese schöne,
was weiß ich, Violett da oben, der gemeinsame Speicher.
Auf den wird irgendwie, von dem wird irgendwie gelesen,
das Leben läuft für gelesen, ist sozusagen kein Problem,
aber soweit geschrieben wird, muss man sich klar werden,
wer da eigentlich gewinnt.
Das werden wir
gleich nochmal genauer angucken
Aber was passiert eigentlich in einzelnen Bereichen? Na gut,
da liegt quasi jedes Mal so eine Ramm vor,
die irgendwie so einen Prozessor hat und der auf dem Register irgendwie arbeitet und irgendetwas macht.
Und hat sozusagen seine lokalen Bereiche, auf denen er jeweils arbeitet.
Genau so, wie wir das eben gerade uns angeguckt haben.
Diese R-1-0, R-1-1,
R-1-2 bzw. R-2-0 und so weiter,
das sind lokale Speicher,
auf die nicht von den anderen zugegriffen werden kann.
Das heißt, insofern haben wir schon noch
eine gewisse Trennung oder Lokalität für die Sachen.
Aber wir haben dann diesen gemeinsamen Speicher,
auf den wir alle gemeinsam irgendwie direkt Zugriff haben müssen
Und das war genau das, was ich vorhin meinte,
dass wir da so eine Art Synchronisationsmechanismus in der lokalen Umgebung dieser Prozessoren haben müssen,
was dazu führt, dass man nicht alle Rechner dieser Welt einfach mit diesem Modell wieder zusammenführen kann,
weil es relativ schwierig ist,
die dann wieder über einen gemeinsamen Speicher wirklich zusammenzufügen.
Wie weit dann Cloud-Computing denn dazu führt, könnt ihr euch mal überlegen,
wie weit das ein gedankliches Modell ist und inwieweit das ein praktisches Modell ist,
wird es, was wir hier haben.
Die Programme, die wir auf diesen Prozessoren haben,
die sind alle identisch und wir haben da also jetzt die Idee,
dass wir diese Rechner, alle in gleicher Weise ausstatten.
Was wir jetzt noch zusätzlich daran haben, ist,
dass wir jetzt noch so die Prozesse ID laden können muss.
Einfach deswegen, weil das notwendig ist, dass man weiß,
wer man gerade ist, um daraufhin bestimmte Entscheidungen treffen zu können.
Warum, werden wir gleich nochmal sehen. So,
jetzt habe ich so ein bisschen Augenpulver hier an dieser Stelle.
Das ist jetzt einmal die Definition, das,
was jetzt gerade eben durchgesprochen haben, dass quasi Definitionen aus dem Skript,
dass wir so eine Palide Registermaschine haben,
dass eine endlose Folge von diesen Prozessoren,
da werde ich jetzt auch nichts vergessen,
habe ich das sozusagen hier nochmal ausführlich stehen
Wir haben also eine beliebig lange Folge von diesen Prozessoren angenommenermaßen
erst mal vor uns liegen.
Also keine Beschränkung. Der Index dient entsprechend zur Identifikation
und wird eben genau über die Prozessor-ID des PID bezeichnet.
Die einzelnen Prozessoren des RAMs haben wir, glaube ich,
auch schon genannt. Und die kein Speicher sind eben
diese PIs, die wir dort drin haben.
Das sind die einzelnen Register, die wir dann aufrufen können.
Und kommunizieren können diese Prozessoren jetzt ausschließlich über diesen gemeinsamen Speicher,
indem sie da halt irgendwas reinschreiben, andere können es wieder rauslesen.
Das heißt, ihr könnt sich Gedanken machen,
wann wo sie was wieder lesen wollen und können darauf
entsprechend zugreifen
Die Nulls sind auch eine Art von unendlicher Folge von Registern,
auf die man genauso zugreifen kann wie auf die anderen Register.
Nur eben irgendwie alle gleichzeitig. So, die Instruktionen,
Read und Ride transportieren, dass sie ihren Daten zwischen den lokalen Akkumulatoren.
Das heißt, irgendwie muss sich ja die Werte,
die ich habe von meinem lokalen Teil,
dann in diesen globalen Speicherreihen transportieren.
Das ist genau das Read und Ride von J,
die also dann das
entsprechend hoch und runter laden
Alle anderen Befehle, außer diesen Read and White, sind ausschließlich Dinge,
die lokal arbeiten und haben eben noch zusätzlich mit viel Lot,
PID, dass man sagen kann, wenn man gerade ist,
darauf arbeiten kann. Der in Ausgabekonventionen ist,
dass die Eingabe steht eben auf den Registern M1 bis MN
und entsprechend im Null steht die Länge drin,
dass man weiß, wie lange man überhaupt lesen muss,
weil er sonst ja sozusagen für diese endlose oder unendlich lange Reihe nicht wüsste,
wo man aufhören sollte,
Eingaben zu verarbeiten
So, das Erkennen von Sprachen kann die Entscheidung,
ob er eine Eingabe akzeptiert oder verworfen wird,
auch durch die Art der Halteinstruktion vom P1 geschehen.
So, das heißt, wir können uns anschauen,
wie diese P1-Sachen anhalten und haben damit entsprechende Möglichkeiten zu akzeptieren und zu verwerfen.
Und die PRAM wird spezifiziert durch ein Programm für jeden Prozess,
eine Folge für Instruktionen, die auf eine Eingabe ausführt.
Dies geschieht schrittweise synchron mit den anderen Prozessen.
Dabei gilt,
deswegen nochmal fett
Die Programme sind für die Prozessoren alle identisch. Und eine Brechung startet also,
in dem jeder Prozessor synchron mit NDS zur Instruktion des Programms ausführt.
Und sie endet, wenn P1 die Halteinstruktion erreicht.
Also P1 ist sozusagen da das entscheidende Teil. Und die Beschriftung
des globalen Speichers zu diesem Zeitpunkt spitzfiziert die Ausgabe. Wenn nichts mehr drinsteht,
ist halt leer oder kann auch das ganze Eingabewort wieder sein,
können auch andere Dinge drinstehen, irgendwas mal drin haben möchte.
So heißt das jetzt, dass ich im Grunde genommen
irgendwelche Daten habe und jetzt für alle Prozessoren immer gilt,
dass sie immer dieselben Instruktionen,
die wir gerade gesehen haben,
in der RAM
immer wieder ausführen muss
Erscheint das sinnvoll? Ja,
die mit uns im globalen Speicher, ja,
okay, das können sie machen, so,
aber müssen die auch intern immer an derselben Programmabschnitt genau drin
sein mit dem Jump und dies und mit der Weihschleife und
so weiter und so fort
Genau, es war zum Beispiel, ein Beispiel ist,
dass man die Lot per Idee sozusagen,
also die Prozesse-ID irgendwie hat und daraufhin ja unterschiedliche Dinge tun möchte.
Und man möchte eben genau doch unterschiedliche Sachen, das heißt,
machen. Das heißt, ich habe zwar identische Programme,
aber in welchem Bereich ich mich jetzt gerade in diesem Programm
bewege,
das obliegt jedem Teil separat
So, und wieder auf Sendung, alles klar.
Ja, klar. Ja, alle Programme können irgendwo sein
im Programm,
Einmal letztes Jahr. Genau, das könnte man auch
so machen. Aber für unser Modell,
deswegen habe ich extra ein Fett da reingeschrieben, ist eine der Forderungen,
weil ganz oben links steht eben Definition für unsere PRAM.
Das definieren wir uns jetzt hier so. Wir lassen also
keine unterschiedlichen Programme zu. Auch wenn es jetzt so von der Formulierung,
die jetzt hier in diesem Öffnit direkt da drüber ist, eben genauso anklingt.
Genau aus dem Grund wollte ich euch diese Ballbüste nochmal vorlegen,
um das nochmal genau jetzt hervorzuheben,
dass eben genau das ein Problem ist,
wenn wir da nicht ordentlich aufpasst
Und damit kann auch andere Dinge dann wiederum machen und tun und so weiter.
Wir gehen aber davon aus, dass alle Programme gleich sind
und dann da nimmt Abarbeitungszustand an anderer Stelle stehen.
Gut, bei dem Blackout eben,
jetzt wollte ich dazu noch etwas erzählen,
habt aber jetzt den Faden verloren,
Gut. Scheint ja nicht so wichtig zu sein.
Die Idee ist jetzt, dass wir uns nochmal angucken müssen,
wenn jetzt die einzelnen Prozessionen auf die Idee kommen,
was in die Register, in die globalen Register reinzuschreiben.
Wer gewinnt denn da jetzt, wenn zwei auf dasselbe Register schreiben wollen?
Und das muss man für die einzelnen Möglichkeiten jetzt nochmal ausbuchstabieren.
Und das muss man auch irgendwie technisch realisieren,
dass es umgesetzt werden kann.
Und dahinter stehen
auch unterschiedlich ausdrucksstarke Modelle
Mich alle unterschiedlich, aber die meisten unterschiedlich,
unterschiedlich ausdrucksstark und können unterschiedliche Sachen damit, fallen unterschiedliche Klassen.
Wenn wir so einen Schreibkonflikt haben, kann man sagen,
ja, man kann simultan lesen und simultan schreiben oder noch so,
so wie jetzt in dieser Klasse, dieses Exclusive Read,
Exclusive Right, dann sagt man, nö,
das gibt es nicht.
Es wird einfach nicht erlaubt. Das heißt, wenn Sie
es versuchen, funktioniert es nicht, Sie schreiben dann nicht.
Das heißt, in dem Moment war zwar der Befehl da, aber klemmt.
So, dann ist das nicht zulässig und damit ist das,
was da ausgeführt wird, schon mal nicht sozusagen nicht so,
dass es im Register, im globalen Register erscheinen wird.
Concurrent Read, Exclusive Wright, als nächste Möglichkeit.
Gib mir hin, sozusagen gelesen wird und dann nicht einer
dazwischen schreibt, soll es ja kein Problem sein.
Naja, wenn ich hier irgendwas hochhalte,
können alle gleichzeitig lesen, ist sozusagen kein Problem.
Wenn jetzt aber fünf Leute sagen, Daniel,
halt mal x Finger hoch.
Jetzt können Sie überlegen, wer gewinnt denn jetzt?
Und welche Verfahren würden euch dazu einfallen
Ich bin jetzt der globale Speicher.
Ihr habt alle einen Befehl und sagt jetzt, okay,
irgendwelche von euch wachen auf und sagen, ja, ich bin dabei.
Ich sage mal drei. Wenn alle das Gleiche sagen,
sage ich, okay, zeige ich meine drei Fingerchen an
und ich mache, was ihr wollt.
Damit ist es auch, auch das kein Problem,
weil das Gleiche wollten und von daher ist das auch ein stimmiges Modell.
Was könnte ich noch machen? Genau, alle schreiben
ein bisschen. Jeder sagt was, ich gehe einen am
anderen durch
Aber eine Frage ist, wer gewinnt denn jetzt?
Ja, das mache ich zufällig, ne? Weil wenn ich
irgendwie so durchzählen lasse und dann so drei, okay,
drei, vier, eins, okay, eins gewinnt.
So, dann mache ich irgendwie völlig zufällig,
habe also nicht mehr die Möglichkeit, die Notwendigkeit,
dass alle das identische Ergebnis haben,
sondern ich suche mir irgendeinen Willkürlich raus.
Nächste Möglichkeit?
Noch kräftiger
Genau, wir priorisieren mal und sage, ganz links gewinnt.
Und sortiere es hier durch und solange keiner irgendwie dazwischen redet,
sozusagen, wenn du jetzt sozusagen sagst, drei,
als letztes und alleine davon sagen vier, fünf,
sechs, sieben oder sonst irgendwas,
was mit sechs auch schwierig wird bei einer Hand,
aber okay.
Sag ich trotzdem, du gewinnst und dann sind die drei, schlagen sozusagen durch.
Genau diese Modelle findet man jetzt auch entsprechend hier auf den Folien.
Das wäre also das Concorde Reed und Concorde Wright
in irgendeiner Weise haben. Und dass sie multitane lesen,
ist uneingeschränkt möglich und das simultane Schreiben ist ebenfalls erlaubt.
Da muss man sich halt nur eben ein bisschen noch mal
sozusagen darüber klar werden, was das bedeutet.
Das heißt, alle schreiben denselben Wert da rein,
ist die erste Klasse, die wir da haben.
Das restringiert natürlich die ganzen Sachen so ein bisschen.
Alle müssen das Gleiche haben, was aufgrund der völlig eigenwilligen
Zustände intern einen gewissen Extrakoordinierungsaufwand natürlich mit sich bringen wird,
damit man es immer gut hinkriegt.
Das Zufallsprinzip, wie schon gesagt,
irgendwie zufällig wird das genommen und irgendeiner gewinnt halt davon,
ohne dass man wirklich sagt, wer davon gewinnt.
Haben wir so einen Art Lichteterminismus mit drin
Und als anderes eben, dass man sagt, man hat mit der höchsten Priorität,
sodass ich da also auch eine gewisse Ordnung reinbekomme.
Und wenn ich weiß, dass bestimmte Ordnungen da drin sind,
hat man bestimmt gesehen, sie sind mit Triebrechen und sowas,
sind immer ganz hilfreich für solche Dinge,
um mehr machen zu können und Probleme lösen zu können.
So, das heißt, diese Klassen müssen euch klar sein.
Und wenn ihr jetzt, also das bearbeitet uns auch bei
der verarbeiteten Algorithmen, natürlich berüchtigt werden.
Das heißt, wenn ihr also jetzt einen Algorithmus schreibt und
ihr sollt das Ding programmieren in irgendeiner Weise, diese Parallelrechner.
Und ihr wollt auf irgendwie diesen globalen Speicher zugreifen und ihr wollt dort,
dass da ein Ergebnis erscheint, dann muss euch klar sein,
bei der Konstruktion der lokalen Algorithmen, was es eigentlich bedeutet,
wenn ihr sagt, ich schreibe jetzt einen Wert,
müsst ihr wissen,
in welcher Art von,
klasse ihr euch eigentlich gerade befindet und welche Auswirkungen das hat und ob denn die ganzen verschiedenen separat laufenden Programme alle richtig zusammenspielen,
sodass das Richtige am Ende wieder rauskommt.
Das heißt, diese CRCW-Geschichten muss man sich genau überlegen,
wie die mit diesen nebenläufigen Schreibenden auch wirklich funktionieren sollen und
wie die Algorithmen dafür ausschauen.
Das ist nicht ganz so einfach. Und selbst bei den
anderen Programmen muss man natürlich aufpassen, was das bedeutet,
wenn man nicht erfolgreich schreiben kann
So, die entsprechenden Komplexitätsmaße bei der PRAM ist dann das nächste, was wir uns angucken.
Wir haben also jetzt hier wieder diese Definition für das,
für die Uniforme Zeitkomplexität von einer entsprechenden PRAMM,
die auf eine entsprechende Eingabe X eben zugreift.
Genau in diesem entsprechenden gemeinsamen Speicher. Und die eben entsprechend
auch arbeitet auf eine Eingabe, wie die entsprechende wie wir sie vorher hatten.
Wobei eben die synchronen Schritte bis zur Termination eben angeguckt werden,
für die Zeitkomplexität. Und was wir jetzt hier machen,
ist, dass wir die Zeitkomplexität von M nehmen,
und zwar das Maximum à la Time M, die wir davor finden.
Das heißt, wir gucken uns alle einzelnen an und nehmen das Maximum davon.
Und das ist dann sozusagen die entsprechende Zeitkomplexität, die dort gilt.
Und damit gehen wir also hin und können sagen, okay,
wenn jetzt 20 Prozessoren in Lugrhythmus von irgendwas arbeiten und der andere braucht aber quadratisch,
damit das Ganze zur Ruhe kommt,
damit unser P1 sozusagen am Anfang dann in die Halteposition geht,
brauchen wir also quadratisch viel Zeit.
Das heißt, den Algorithmus, den ihr programmiert habt,
der Bruchquadratisch spielt Zeit. Ist auch klar, ne?
Wenn ihr hingeht und eure Programme geschrieben habt für so Parallelrechner,
dann könnt ihr nicht irgendwie, weil 99 Prozent fertig sind,
sagen, okay, alles geklärt.
Der eine interessiert mich nicht mehr. Dann hätte ich
es gleich so programmieren müssen. Ihr müsst also,
damit es das Gesamtergebnis feststeht,
bis zum letzten Schritt desjenigen warten,
der dort gerade gearbeitet hat und bis dann sozusagen
das P1 in die Halte zum Haltestatement kommt
Das bedeutet, dass ihr euer Programm so gestalten solltet,
dass ihr alle möglichst gleichmäßig alle aufhören.
Wie man das dann macht, werden wir ja nochmal sehen.
Und wie man das dann hinbekommt, ist dann gar nicht so einfach.
Und er fordert durchaus ein bisschen Gehirnschmalz bei den einzelnen Sachen.
So, dann haben wir die Prozessorkomplexität, wie wir uns angucken können.
Und da nehmen wir einfach das Maximum von der Anzahl der Prozessoren,
die wir da vorfinden, sagen wir,
okay, 20 Prozessoren schreiben irgendwie mal,
das sind 20 Prozessoren halt relevant
Das finde ich, also das höchste I,
dass irgendwas auf den entsprechenden Speicher packt.
Und auch hier nehmen wir einfach wieder das Maximum,
weil wenn ich hingehe und sage, ich brauche halt 20 Prozessoren,
die irgendwas schreiben müssen in meinen Speicher, habe ich das.
So. Auch da geht man dann wieder halt über alle.
Dann haben wir noch zwei weitere Komplizitäten als für die PRAMs.
Und zwar ist das Südprozessor Zeitkomplexität oder Prozessor Zeitprodukt.
Was sagt das jetzt aus? Dann nehmen wir Time mal
Prock. Was bedeutet das?
Bitte? Die insgesamt verbrauchte Rechenzeit, genau, aber wenn
ich jetzt auf Zeit gucke, dann reicht mir doch mein Time.
Genau, jetzt kommen wir Richtung Energiesachen und so weiter.
Wie viele Prozessoren verheize ich denn da mal so in der Zeit?
Wenn es 10.000 sind, ist was anderes,
als wenn ich nur einen habe und dann 10 Sekunden brauche.
Da habe ich 10 Sekunden entweder einen Prozess oder 10.000,
was schon einen Unterschied macht wie Herr Ludwig ja gerne in
seinen Green IT-Veranstaltungen auch vorrechnen kann.
Und da ja auch
ganz interessante Ergebnisse hat
So, das Zweite ist das Work,
das die Gesamtzahl der Schritte aller Prozessoren,
die während der Berechnung aktiv sind, nach oben hin abstützt.
Und das sozusagen dieses Work von, das heißt,
wir gehen hin und schätzen die entsprechenden Anzahlen der Operationen,
die tatsächlich ausgeführt werden ab.
Das ist dann entsprechend die Operationenkomplexität. Und auch dann
immer wieder das Maximum, was wir da finden können,
für alle möglichen Eingaben,
die auf dieser Größe N
eben berechnet werden
Das heißt, es gibt durchaus einzelne Fragestellungen,
die sich einfacher lösen lassen, aber im Allgemeinen nimmt man das,
was am schlechtesten Fall da eintreten kann,
weil wir die entsprechenden Klassen von diesen Dingen angucken wollen und nicht nur einzelne konkrete,
spezielle Fälle auf bestimmten Daten, von einem bestimmten Algorithmus.
Je nachdem, wenn man einen Sortialgorithmus hat,
man muss irgendwelche Zahlen sortieren,
kommt da eben auch für die,
auch die Daten und auf den entsprechenden Algorithmus an,
wie schnell er ist bzw. lange er braucht,
bis die Daten
entsprechend sortiert sind
So, wenn man das jetzt mal so ein Beispiel machen,
haben wir hier die entsprechenden elf,
drei und sieben Schritte, die darin bestehen,
dass man halt entsprechend oft auf diesem M0M1 M2 entsprechend etwas macht.
Und da haben wir halt dann entsprechend unser Brock-M und PM
, was wir dort entsprechend angeben können.
Und wie groß ist unser Brock-M hier
Okay, sehe ich schon von einem mundgeformten Teil mit dem
entsprechenden drei, die wir da vorfinden,
weil wir halt drei Register sozusagen beschrieben finden, vorfinden hier.
Sagen wir, dass wir jetzt drei Prozessoren halt entsprechend brauchen.
Wie schaut es mit der Zeit aus? Ja,
auch da sehe ich schon, die Lippen sich bewegen,
auch wenn es nicht laut gesagt wird, elf halt.
Okay, das sind halt die elf Schritte,
die wir haben und die müssen wir nicht abwarten,
bis das Gesamtergebnis für diese Berechnung,
die wir da jetzt add hatten,
So, was ist unser Burke? An der Stelle,
jetzt wird es schon schwieriger, jetzt muss man anfangen zu rechnen.
Da kommen wir dann entsprechend auf die 21,
indem wir halt alles einzeln zusammenzählen, 11 plus 3 plus 7.
Auch das ist das, was man da machen kann.
So, und jetzt kommen wir zu Prozessor Zeit,
zum Prozessor Zeitprodukt, sozusagen, wie lange leistet man das
irgendwie laufen oder was ist so die obere Abschätzung dabei?
Und das ist halt entsprechend 33,
3 mal 11 an dieser entsprechenden Stelle dann
So, und interessant ist, dass es so in etwa
hinkommt, dass die sich so in etwa entsprechen.
Ja, und auf jeden Fall hätte man das gerne
auch so, dass man das so haben möchte.
So, jetzt noch zwei, drei Folien und dann
sind wir auch für heute durch.
Ja. Ja, jetzt habe ich die Animation hier,
ich springe nochmal zurück
So. Also, die Frage war, welche? Okay,
jetzt bin ich noch wieder da oben hin,
springen mit dem Teil, wie das halt definiert ist,
dass die obere Abschätzung von dem,
was an Arbeit insgesamt passiert in dem ganzen System.
Das ist das, was wir da entsprechend angeben.
So, was wir jetzt haben, ist eine beste Zeitkomplexität
für ein Problem P und unter allen sequenziellen Algorithmen,
die das Problem P lösen. Sortieren von Zahlen,
als eine Fragestellung, die ihr ja kennt, aus A und D.
Und da gibt es halt auch eine beste Zeitkomplexität,
die man angeben kann im allgemeinen Fall.
Das ist für eins eine spezielle Sortiersachen,
dann schnellere Sachen geht für spezielle Fälle,
aber im allgemeinen Fall ist das ein Login,
was ihr braucht, um das sozusagen zu sortieren.
Viel schneller geht es dann nicht mehr.
Das Spannende ist jetzt, warum führen wir unsere Parallelität ein?
Wir wollen ja irgendwie schneller sein. Die Frage ist jetzt
also, wie schnell können wir jetzt eigentlich werden?
Und was kann man da insgesamt noch an Beschleunigung reinkriegen?
Kriegt man das immer auf null sozusagen oder auf eins?
Ein Schritt und Bums ist alles fertig.
Genau, ich da in den Kopf schütteln. Genau,
die Erwartetheit ist, dass es wohl nicht so ganz geht.
Aber die Frage ist jetzt halt, was geht und was geht nicht.
Wenn also eine Klausur bestimmte Funktion genannt bekommt,
sollt ihr sagen können, in welche Klasse das reinfällt
Und was da wohl passiert und wie man das sozusagen sich überlegen kann dabei, wie man dabei vorgeht.
Was wir jetzt nur haben werden, ist ein Beispiel,
wir werden das natürlich in der Klausur auch nicht in dem Detail machen können,
weil das Parallele sortieren und mischen und so weiter,
was wir nächstes Mal noch angucken werden,
die sind so komplex, dass es nicht eine Aufgabe,
einzelne Aufgabe in der Klausur sein wird,
das ist neu selber zu entwickeln,
aber ihr könnt durchaus nach den einzelnen Komplizitäten in diesen Bereichen gefragt werden oder nach der Beschreibung von diesen entsprechenden Algorithmen,
die da drin vorkommen.
Das heißt, ihr solltet euch schon klar machen,
was dort sozusagen Thema in diesem in diesen einzelnen Bereichen ist
und was man da jeweils machen kann und was nicht.
So, die Frage ist also für die Zeit für
das Teil und da wollen wir natürlich besser werden.
Und das ist das Ziel, über das dann geht,
das ist eine andere Frage. Dann ist die Frage,
kann man das irgendwie nachher als optimal bezeichnen? Also gibt es irgendwas,
was dann sozusagen als Optimum angegeben werden kann und jetzt wird halt definiert,
so ein Algorithmus heißt optimal,
für welchen Fall,
was würde man
so erwarten
Naja, wenn wir die Sache so hinbekommen,
dass wir die Anzahl der Dinge,
die wir tun müssen, in unseren entsprechenden Maschinen.
Green IT lässt grüßen an der Stelle. Wenn das sozusagen
der Anzahl der Operationen auch in Sequenz allen Fall entspricht.
Wenn ich also möglichst billig rechnen möchte, lasse ich so
ein Teil eben immer end mal laufen für so ein sequenzielles Teil.
Oder ich kann einmal end sozusagen Prozessoren anschmeißen.
Das soll sozusagen
das Gleiche sein
Ob das dann nachher wirklich das Gleiche ist,
weil die ganze Rest ja auch noch mitlaufen muss, das lassen wir außen vor.
Wir gehen also hier erst mal davon aus,
dass wir so ein Algorithmus als optimal bezeichnen,
wenn Work sozusagen genau der Anzahl der Operationen in den sequenziellen entspricht.
Also nicht genau, sondern aus dieser entsprechenden Klasse ist,
mit so ein paar Rundungsdingen dabei natürlich. So,
und wenn wir das jetzt hier angucken,
wir haben unser WAN mit 21 gehabt und da ist jetzt eben die Frage,
wie das sozusagen, wann so ein Algorithmus jetzt,
den wir da haben, irgendwann optimal ist.
Und das heißt, wir müssen also irgendwie hinkommen,
dass wir, wenn wir es jetzt abarbeiten,
quasi die einzelnen Dinge so durchlaufen, dass man genau die aufzählt,
die auch wirklich da drinnen vorkommen und keine Extraschritte mit unterbringt.
So, dann guckt ihr euch zunächst mal das Branche-Sketching-Prinzip an und macht euch klar,
was dahinter steckt und da legen wir dann beim nächsten Mal
wieder los und steigen da ein,
um dann nachher in diese Sortiersachen reinzukommen.
Was für euch hilfreich ist, ist, wenn ihr euch das vorher angeguckt habt.
Es ist relativ schwierig mit den ganzen Indizes und diesen ganzen
A und B-I und ganzen Indizis, die ja wirklich bearbeitet werden müssen.
Wenn ihr euch die vorher angeguckt habt, ist es relativ schwierig,
das nachzuvollziehen. Also einmal vorher angucken, grob wissen,
was A und B und C und so weiter sind,
was oder die ganzen Indizis,
wo die Ms und die Js und die Es alle untergebracht werden.
Und wie ich dann sozusagen die verschiedenen Algorithmen sozusagen zusammenführe und
welche Teile ich da drin habe.
Und ich erzähle euch den Rest dann dazu.
Gut,
bis dann