Lautstärke, okay. Da hinten, ja, nein.
Ja, nein. Einmal, ja, Kopfschütteln. Okay,
gut, alles klar. So. Habt ihr euch alle schon
die Evolutionsbögen ausgefüllt in euren Übungsgruppen oder sonst irgend sowas?
Wer hat noch keinen? Ich habe hier sonst
ein paar Zettel dabei für die Veranstaltung zum Evaluieren.
Alle beigewiesen, sehr schön.
Okay, noch mal kurz zum letzten Mal, wo wir
stehen geblieben sind bei den parallelen Algorithmen. Da war die Idee,
dass wir da ein bisschen was uns überlegen,
wie wir in diesen gleichpörmigen Rechnern,
die sich irgendwie synchronisieren können, entsprechende Algorithmen draufpacken,
um diese mehreren Rechner entsprechend nutzen zu können.
Und insbesondere haben wir uns damit parallelen Sortieren beschäftigt,
das heißt parallel Algorithmen, die man irgendwie in diesem Peram-Code übersetzen kann.
Wie das geht, was wir da machen,
ist dann das, was wir uns ein bisschen angucken wollen.
Und die Idee ist halt,
dass man sich speziell Algorithmen für diese Maschinen überlegen muss.
Da muss man das Maschinenmodell berücksichtigen. Das, was sozusagen passiert.
Und da gibt es also unterschiedliche Möglichkeiten, wie wir das gestalten können.
Eine wichtige Sache, die wir beim nochmal aufgefallen war,
wie, dass es noch nicht ganz überall angekommen ist.
Was ist denn nun ein optimaler, paralleler Algorithmus?
Das heißt, wo wollen wir eigentlich hin?
Wenn wir so einen sequenziellen Algorithmus haben,
und dann haben wir da irgendwie einen mit der besten Zeitkomplexität.
Also für die ganze Klasse sozusagen steht, Und wir haben diesen Algorithmus,
dann heißt ein paralleler Algorithmus entsprechend optimal, falls dies der Fall ist.
Das heißt, wenn die Anzahl der Operationen,
in dem Teil dieser Zeitkomplexität im Tequenziellen entspricht, das heißt,
das, was wir da tun, ist genau die Anzahl der Aktionen,
die wir auch im Parallelen ausführen wollen.
Wir wollen dort nicht Größenordnungen mehr ausführen. Irgendwelche Faktoren oder sowas
sind andere Geschichte, die so einen kleineren Bereich verschwinden,
aber sozusagen die entsprechende Größenordnung soll auf jeden Fall eingehalten werden.
So, was hatten wir dann da gesehen?
Wir hatten jetzt von dem Denkmodell her, sind wir losgelaufen
und haben irgendwie dieses parallele Maximum, die Parallele Maximumsuche betrieben.
Der Algorithmus ist recht einfach. Wir haben festgestellt, okay,
wir wollen irgendwie so ein Maximum finden. Wir müssen das irgendwie uns angucken, muss man entsprechend durchdenken. Ich habe jetzt nur das Endresultat hier stehen,
dass man halt entsprechend die Algorithmen, die einzelnen Prozessoren durchaus mehrfach rechnen lässt,
mit mehr Prozessoren, entsprechenden Algorithmen so designt,
dass die richtigen Sachen an die richtigen Stellen geschrieben werden,
dadurch eine Synchronisation stattfindet und dadurch letztendlich auch schneller gearbeitet werden kann,
nur eben mit den Problemen, dass die entsprechende,
dass dieser entsprechende Algorithmus nicht mehr optimal ist,
weil er entsprechend viele Operationen dann ausführen muss und man das im Sequenziellen günstiger bekommen kann an den Stellen.
Gut, okay, das ist so die prinzipielle Denkweise,
dass man sich erstmal überhaupt eine Lösung aussucht,
dann guckt man, ob man sie schneller kriegen kann,
da muss man überlegen, ob das schneller oder sozusagen günstiger,
das heißt weniger Operationen auch noch okay ist,
da muss man eine Abwägung treffen, aber auf jeden Fall geht es darum,
dass man sich überlegen kann, dass man wählen kann,
ob man eben schneller oder günstiger,
sprich im Bereich Optimalität, was machen soll.
Die Frage ist also, was soll ich hier denken bei
diesen Teilen? Das heißt, soll ich mir,
was ist sozusagen das Denkmodell, wie übertracht ihr das?
Wie prägt ihr das auf eure Elgorithmen? So,
und das Denken dabei müsst ihr halt üben und entsprechend angucken
und wir greifen uns hier nur so ein paar Teile raus und haben damit halt einige Beispiele,
die aber dann in den entsprechenden Kontexten nochmal anders vertiefen müsst.
Wo geht's hin? Die Idee ist,
dass man hier irgendwie mit Logorithmen dann arbeiten kann,
wenn man irgendwelche quadratischen Anzahlen von Prozessoren haben kann,
wo das mal durchgeschickt ist
Sortieren und geschicktes Anordnen, geschicktes Verwenden von Prozessoren, von entsprechenden Berechnungsverfahren günstiger werden kann.
Und diese größten Leuten, die man da einspart,
die sind natürlich bei den kleinen Ends nicht besonders groß,
aber für wirklich große N wird das dann irgendwann mal richtig spannend.
Mann, was, wie, wo gemacht werden kann,
müsst ihr halt schauen und die Idee,
wonach wir jetzt eigentlich hingehen wollen,
dass wir irgendwie paralleles Suchen haben wollen,
dass wir so möglichst schnell irgendwas auffinden wollen, um irgendwas zu nutzen.
Und was man nebenbei dann halt auch noch betrachtet,
ist das Mischen. Was Mischen ist hier sozusagen mit Voraussetzung,
dass wir da zu diesem günstigen Parallelen suchen letztendlich hinkommen.
Und die Beispiele drin hatten, war, dass wir halt gesagt haben,
wir haben hier halt so irgendwelche Listen, die wir zusammenpacken können.
Und wir haben also dieses Merch für diese entsprechenden Teile. So,
das Ganze läuft immer über Bäume im Normal, ganz oft,
sodass dann da die entsprechenden Folgen auf den Oberknoten dann entsprechend
vorfindet und dort zur Verfügung hat, sodass man darauf arbeiten kann.
So, und die Sachen dahinter ist halt,
dass man irgendwie jetzt hier hingehen kann und macht sich das Leben einfach,
muss nicht immer mit allen Sachen rumhantieren,
sondern sucht sich nur irgendwo sozusagen den Rang raus von diesen Teilen
und merkt sich die Ränge und sortiert das darauf hin ein
Also dieses Verfahren, was man dann da benutzt,
haben wir uns auch angeguckt und dafür haben wir uns halt
irgendwie ausgerechnet wie so eine Liste von verschiedenen Teilen wie 13,
27, minus 27,
wie die sich dann in so einer anderen Liste wiederfinden.
Das kann man entsprechend schnell berechnen, indem man die Sachen entsprechend aufteilt.
So, zur Vereinfachung haben wir also A geschnitten, wie gleich leere Menge genommen.
Das heißt, wir nehmen jetzt unterschiedliche, nicht,
dass wir das Problem haben wie mit der 4 eben,
sondern dass wir hingehen können, dass wir vernünftig einsortieren können.
Und was wir so noch machen müssen,
wir müssen also einfach nur den entsprechenden Rang von den Elementen bestimmen und haben dann quasi,
indem wir die Ränge richtig rum ansortieren,
die Sachen auch wieder so, dass wir sie geschickt verwenden können dabei.
So, und dieses entsprechende berechnet den Rang, da kommt die Idee,
das Binären suchen uns natürlich mit rein und wir können also hingehen und die dann entsprechend aufteilen,
stellen wir fest, dass wir keinen optimalen Algorithmus haben,
bei dem sequenziellen kriegen wir es ein UVN hin, hier brauchen wir mehr entsprechend Operationen.
So, aber auf jeden Fall haben wir irgendwie diese Idee,
dass wir so passende Blöcke haben müssen,
diese As und Bs und die Bs machen wir dann irgendwie so,
dass die vorgeben, wie man den ganzen Kram aufteilt,
diese einzelnen Folgen und diese Blöcke, die da drin haben,
sorgen dafür, dass wir sie letztendlich in solche Teile einsortieren können,
dass wir sagen können, alle Elemente,
die wir da jetzt in A0 drin haben und in B0 sind kleiner als alle Elemente in A1 und B1 entsprechend.
So, und danach teilen wir die entsprechenden Blöcke auf.
Da arbeiten sie und hantieren da drauf,
sodass wir halt dieses Schneiden von diesen Mengen halt irgendwie hinbekommen.
Und was man dann hat, ist halt, dass man diese,
den Lugrithmus sozusagen von dem M an Aufteilungsblöcken sozusagen da reinbekommt,
was man dann entsprechend in den Zeilen da vorne entsprechend sieht.
Und da sehen wir den roten Schnitt,
die sieben und neun kleiner als 10 und 16,
das ist genau das, was man da haben möchte an der Stelle.
So, damit hat man jetzt so ein blockweises Aufteilen,
positionieren und so weiter und so fort.
Und auch dafür gibt es dann wieder entsprechende Algorithmen,
wie man das machen kann. Da haben wir die entsprechenden Teile drin.
Und ach so, jetzt habe ich die nicht ausgeblendet hier.
Da haben wir die einzelnen Betrachtungen und haben dann festgestellt,
dass wir da auf O von Login Zeitkomplexität kommen und
bezüglich der Operationen Kommen wir entsprechend auf den O von N plus N.
So, das heißt, mischen zwei Erfolgen A und B,
die wir da jetzt angucken wollen,
ist eben entsprechend in Log-End-Zeit und O von Inoperation durchfallen, durchführbar.
Und jetzt die Frage, haben wir noch schnellere Algorithmen?
Das ist ja das, was ich am Anfang gesagt habe,
was soll ich jetzt hier denken? Na gut,
ich würde jetzt gerne noch schneller geht es denn,
wie geht es denn, was muss ich überlegen?
Und dann ist eben die Frage, wo ist jetzt das Potenzial für Beschleunigung?
Da sucht man sich natürlich den größten Teil im Grunde
genommen immer aus und sagt, na gut,
da gucken wir doch da mal und schauen mal,
was wir
da machen können
Und das funktioniert jetzt,
dass wir jetzt nicht mehr sozusagen die sibinäre Suche dort drin haben,
sondern da hatte ich ja letztes Mal das Beispiel gebracht,
dass sie hingeht und versucht euch zu überlegen,
wie ihr sozusagen das nebenläufige Suchen von euch funktioniert.
Dass nicht einer sagt, wo das denn so ist,
sondern da ja ganz viele seid, könnte sozusagen jeder sich einen Bereich vornehmen und dann arbeiten.
Ob wir es nun als ihr oder die Prozessorenseite, sei jetzt mal dahingestellt. So,
das heißt, wir gehen also hin und gehen das,
was wir jetzt eigentlich angucken wollten, mich das parallel suchen,
wo wir dann hingehen und in irgendeiner Weise mit diesen P-Prozessoren da reingehen wollen,
die wir dann entsprechend konstant halten,
wodurch das dann diesen entsprechenden Beschleunigungsfaktor geben wird.
So, der Algorithmus also optimal,
wenn das P konstant ist,
das war die grundsätzliche Idee dahinter
So, was wir denn haben, ist, dass wir
so Palissuchungen für die Prozessoren haben, gibt entsprechenden Algorithmus dazu.
Das ist das, was dahinter steckt,
was sie eigentlich macht, ist, ja.
Steht nicht XQJ? Ich habe nie benutzt,
aber es wird dann dauert
Ja, also muss ich jetzt sagen,
habe ich jetzt nicht genau angeguckt an der Stelle,
können wir hinterher nochmal angucken, was da genau reinkommt.
Weil die Idee war ja,
dass ihr euch das nochmal anguckt und dass man separat besprecht
in den entsprechenden Übungen oder weil Michael in der Saalübung,
beziehungsweise wir können das hinterher gleich nochmal angucken.
Aber jetzt wollte ich da nicht drauf eingehen,
auf das Teil. So, die Idee war ja,
dass wir dort hingehen und diese entsprechende, die entsprechende Blöcke haben.
Wir finden dort sozusagen,
dass wir da irgendwie das Y wohl drin haben in dieser Menge
und dann unterteilen wir das wieder und machen wieder Nebenläufe,
die Suche auf allen Blöcken und finden entweder das entsprechende XI als Y oder entsprechenden Y-Block.
Also genau das, was wir da eigentlich haben wollten mit
Genau. So, und diese Komplexität, die wir da hatten,
beruht eben gerade auf diesem Login durch Log P. in der Größenordnung WolP,
kleiner gleich Ende, die Anteil der Prozessoren ist.
So, den Beweis dahinter, ursprünglich jetzt hier nochmal.
Achso, das wollte ich ja nicht übersprungen haben. So,
die Idee dahinter ist jetzt, dass wir mit den einzelnen Sätzen,
die zum Teil gleich noch kommen, würde ich nochmal genau darauf eingehen.
Zum einen eben dieses Beniere suchen haben, beziehungsweise eben das parallele Suchen benutzen,
um dort zu den entsprechenden Operationen und Zeitkomplexitäten zu kommen.
Dadurch, dass wir natürlich mehr Operate Prozessoren haben, kommt es natürlich wieder obendrauf.
Aber das ist das, was wir letztendlich uns angucken wollten.
Die entsprechenden, also entsprechenden Lämmer oder Corola oder Satz,
was wir entsprechend stehen haben, sind das, was wir dann sozusagen dort haben.
So, was jetzt kommt, ist das parallele Merch-Sort.
Wenn wir das sozusagen benutzen, um in diesen Algorithmen jetzt reinzugehen,
um das nochmal ein bisschen besser aufzuteilen,
können wir nochmal einmal sozusagen gucken, was machen wir da eigentlich,
um das letztendlich hinzubekommen und unser paralleles Suchen optimal zu gestalten.
Wir gehen ja von diesem entsprechenden Baum aus,
wir mussten so folgen, die wir entsprechend wieder sukzessive aufbauen.
Und jetzt die Frage, wie packt man das letztendlich dahin?
Und wir haben das WN Login als optimal klassifiziert.
Was wir haben, sozusagen die Baumadressen, die wir da
drin haben. Und was wir dann machen, ist,
dass wir sozusagen die Höhe des Baumes uns angucken.
Die Höhe des Baumes wird jetzt geschickt gewählt, werden wir gleich noch sehen.
Und die entsprechenden Zuordnungen, die man dann findet in den
einzelnen Ebenen, lässt sich entsprechend auch einfach berechnen.
So, die entsprechenden Elt, 2-1,
wenn wir gleich sehen. Das ist also hier dieser entsprechende Algorithmus,
der da reingeht, dass man ein Feld der Ordnung ändert,
wobei man eben endlich zwei hoch L für eben eine ganze Zeit L haben.
Und die Ausgabe ist ein balancierter, wie näherer Baum mit N-Blättern,
der hat, dass dieses LHJ für jedes Haar,
kleiner gleich Login an dieser Stelle,
die sortierte Teilfolge der Elemente im Teilbaum mit der Wurzel HJ,
die wir da oben stehen haben, enthält.
Und dieses einst kleiner J, kleiner gleich zwei enden durch
zwei Hochhaar gegen entsprechenden Höhe.
Haben wir das entsprechend aufgebaut. Und das haben wir hinbekommen
durch die entsprechenden vorherigen Partitionierungen und Aufteilungen dieser entsprechenden Bereiche.
Genau deswegen kennen wir jetzt hier diese entsprechend günstigen Zahlen verwenden.
Damit hält der Knoten HJ die sortierte Liste aus diesen Elementen,
die wir da drin sehen. Und beim Algorithmus, der ist relativ kurz,
dass man also erstmal diese entsprechenden parallelen Zuweisungen von L0J mit den XJs hat,
die wir da reinpacken, diese entsprechenden 12,
die sind sozusagen die einzelnen Bestandteile.
Und dann eben nur bis zu Login,
das Durchlaufen und dann die nächste Schleife noch einmal durchlaufen dabei.
Wobei das eben dann gerade in durch zwei Hochhaar ist,
was dann entsprechend klein ist.
Und dafür machen wir das Mischen und dafür brauchen wir die
Ergebnisse von vorher, die wir jetzt hier entsprechend einsetzen.
Das ist sozusagen der interessante Teil. So,
und die Wurzel sieht also entsprechend klein aus. So,
der Algorithmus, 8-4 müsste es eigentlich heißen,
sich jetzt gerade, ist mit der Zeitkomplexität von O von Login
mal Log-Log-Ander drin und O von N-Malog-in-Operationen, entsprechend optimal.
Das war gerade der Algorithmus,
den wir eben gesehen haben
Was wir jetzt haben, ist also das entsprechende schnelle Mission von Folgen der Länge M.
Mit den entsprechenden Zahlen, die wir oben links sehen.
So, und was wir dann haben,
ist genau das, was jetzt hier rauskommt dabei.
Und wie läuft das jetzt in der Höhe Haar?
Haben wir so Folgen der Länge 2 Hochhaar?
Was ist da für die Zeitkomplexität? Naja,
das ist entsprechend dieses O von Locklock Adden,
was wir da jetzt schaffen, aufgrund dessen,
dass wir das Lockphone 2 Hochhaar Locklock von 2 Hochhaar haben.
So, und das ergibt insgesamt dieses TN,
falsche Klammer, von Lock Adden,
mal Lock Lock Adden
Das ist viel Zeit. Jetzt haben wir auch in der Höhe
die Anzahl der Folgen, die wir da noch drin vorkommen haben.
Jetzt gucken wir nochmal die Operationskomplexität an, die wir
von da oben runterholen. Wie kommt das zustande? Da
haben wir die entsprechende Länge mal diesen entsprechenden Teil der Schleifendurchläufe,
die wir da vorher angegeben haben.
Und haben dann insgesamt das WN-Locklock-Aden. Wie kommt das jetzt zustande,
dass ich jetzt noch einmal dieses Lock-Ander zunehmen muss?
Was war das? Wie komme ich damit einmal jetzt noch
drauf? Weil ich da einfach vorher sage,
W von NSU
Naja, das ist eben,
das ganze Teil hier ist auf alle Log-in-Ebenen entsprechend bezogen,
aber die entsprechenden Höhenoperationen und Zeitkomplexitäten jetzt nur angeguckt haben,
was in jeder Höhe quasi passiert.
Und das müssen wir entsprechend der Höhe des Baumes machen,
das ist Log-in und damit sind wir genau in diesem Teil drin,
den wir eigentlich haben wollten.
Das kommt entsprechend bei jeder Ebene einmal vor und dann ist man damit durch.
Okay, so, damit wissen wir also,
wie wir jetzt besonders schnell parallel suchen können.
Das ist eigentlich quasi das, was wir jetzt hier haben.
Wir haben also ein Mission von diesen Folgen, wo wir
die entsprechenden Sätze für haben, da hatten wir entsprechende Ergebnisse.
Das war sozusagen das Denkmodell, das wir dahinter hatten,
haben ein erstes Ergebnis gehabt
Das war halt schon optimal, aber wir haben gesagt,
okay, wir wollen jetzt mit N-Prozessoren schneller suchen.
Das ist dann sozusagen jetzt entsprechend die Idee dabei.
Da müssen wir einen Satz, den wir da haben,
der nur zitiert wird, wie das dafür ausschaut.
Und wir haben das Ganze eben gemacht mit Binärensuchen bzw. Parallelensuchen.
Und das ist sozusagen das, was ihr von diesen Sachen
mitnehmen müsst. Für die Aufgaben in der Klausur,
hatte ich ja schon gesagt, müsst ihr aufpassen,
dass ihr die entsprechenden lugryphmischen und Uniformzeitmaße euch angucken müsst.
Wissensbier ist anwendet und wie man indirekte Adressierung und sowas aufschreibt.
Das müsst ihr wissen, wie ihr das macht.
Und da fährt ihr ja genau die Übungsaufgabe 14,
wo ihr genau sehen konntet, welche Schritte ihr sozusagen aufbaut,
ist, das entspricht dem genau im Skript,
wo ihr hingeht und dann für die einzelnen Store und Load und so weiter,
die entsprechenden Zeitkomplexitäten drin habt.
Und das müsst ihr entsprechend umsetzen. So, das ein bisschen
grober macht, kann man das für die hochspannlichen Sachen machen.
Nur fehlen einem da normalerweise die Details, was da genau bei passiert.
Deswegen ist es halt Übungszwecken, in dem auf diesem entsprechenden
Loadstore und so weiter befehlen.
Und das müsst ihr entsprechend nur umsetzen können
Gut, okay, damit ist das Thema parallel Algorithmen für mich durch.
Verteilte Algorithmen, wie gesagt, auch sehr spannend,
wie man da sozusagen diverse Fragestellungen bearbeiten kann.
Insbesondere, weil dann ja die Laufzeiten noch mal wesentlich wichtiger werden.
Hier hat man jetzt ja keine Nachrichtenlaufzeit,
weil da nichts irgendwie groß noch passiert,
sondern man geht ja sozusagen von diesen getakteten,
synchronen Aktivitäten der einzelnen Prozessoren aus,
die sich dann wieder lokal quasi abstimmen können über die Register.
Das ist die wichtige Idee dabei,
weswegen das von verteilten Algorithmen sich wirklich unterscheidet,
weil dort sozusagen dieses und Nachrichten verschicken,
was elendig lange ist im Vergleich zu diesem kurzen Speicherzugriffen auf die Register.
So, und damit sind wir an der Stelle
am Ende.
Hat die doch schon da. Genau. Jetzt gibt es
wieder einen Bruch. Wir springen nochmal wieder kurz
zurück zum ein kleines Rifresh, damit ihr wieder reinkommt.
Aber jetzt wieder ganz woanders weitermachen. Ich hatte gesagt,
wir verschieben das ein bisschen, weil das sozusagen zwar add-on ist,
aber auf jeden Fall dieser ganze Themenkomplex nochmal in den Übungsaufgaben bearbeitet werden sollte.
Deswegen hatten wir das jetzt vorgezogen,
sonst hätte ich bei diesem Teil hier gleich weitergemacht.
Das hier gehört auch noch mit zu den Netzen,
um die es jetzt geht. Und da hatten wir die Idee,
wir kannten uns dann Netze zu betreiben,
wo wir in irgendeiner Weise vor die Idee der Platztransitionsnetze hatten,
die wir irgendwie zusammengefaltet haben und der entsprechenden Informationsverlust
Die andere Idee war ja halt, dass wir die Stellen
falten und dann damit zu entsprechenden Kanten konstanten Netzen kommen,
beziehungsweise dann in diesem weiteren Schritt die Abbildung auf die entsprechenden Farben sozusagen hinbekommen.
So, was dahintersteht, ist, dass man verschiedene Netzklassen
hat und die sind jetzt Klassen von einfachen Netzen zu PT-Netzen,
zu Kantenkonstantennetzen, sondern zu gefärbten Netzen kommt.
Die Wege kann man auch sozusagen auch andersrum geben,
man hätte auch von den einfachen Netzen direkt zu den gefärbten Netzen und dann
wieder zurück sind an Sachen kommen können durch entsprechende Verfahren.
Das hängt sozusagen davon ab,
wie man das sozusagen gerne einführen möchte oder wie man
das verstehen möchte an den einzelnen Stellen
Die Idee ist dahinter, dass wir nach Möglichkeit,
die Semantik der Netze, wie sie auf der ganz linken Seite vorkommt,
für die Netze, die auf der rechten Seite,
also alle drei auf der anderen Seite vorkommen, wieder dahinter legt.
Das heißt, wenn ich das verstehen will,
muss ich die linke Seite vollständig verstanden haben,
was dort an Nebenläufigkeit ist, zu sich selbst nebenläufig sozusagen,
wobei das da nicht vorkommt, sondern dass man das als Erklärungsmodell,
warum bei den PT-Netzen oder den anderen Netzen,
etwas zu sich selbst nebenläufig schalten kann,
weil man das als Erfaltung verstehen kann,
wo gleiche Dinge strukturell zwar zusammengelegt werden,
aber von der Ausführung her
getrennt ausgeführt werden können
Das waren die Prozesse, die wir dazu angeguckt haben und
die ihr sozusagen als Denkmodell hinter diesen Sachen haben müsst.
Es ist nicht so, dass ihr nur einen Prozessor halt eben habt,
sondern ihr habt quasi eine ganze Engine,
die jede Aktivität aufgrund ihrer Lokalität behandelt und völlig lokal,
völlig simpariert irgendwie ausführt.
Wir haben also eine unendliche Menge von Ausführungseinheiten für jede Transition
quasi vorliegen oder eine beliebig große, sodass die dann nur guckt,
was ist meine Umgebung und daraufhin tätig wird. So,
was wir jetzt dann nochmal ein bisschen weiter angucken wollen,
heute sind die Gefärbtennetze,
wo man dann ja von den Wie das Jahr eingeführt wurde,
von den Kanten konstanten gefärbten Netzen zu den gefärbten Netzen Transitionsmoothie hinkommt.
Das heißt, ich habe jetzt irgendwie so einen Modus in der Transition drinstehen,
der dann die entsprechenden Kantengewichtungen irgendwie entsprechend auch noch zuordnet und irgendwie abbildet.
Die entsprechende andere Sache, was wir dahinter schreiben können,
das wird es hingehen und sagen, ja okay,
wir packen entsprechende Variable an die Kanten,
haben die entsprechenden Varianten da drin, können Guards ran,
schreiben an die Transition.
Wir können also irgendwelche Funktionen an die entsprechenden Transitionen ranschreiben und
daraufhin den Schaltmodus bestimmen. Je nach Art der Sprache,
auf dem Projekt Kartenlogik nehmen oder irgendwelche funktionalen Premiersprachen,
können wir damit
die entsprechende Modelle implementieren
So, die entsprechenden Ideen sind dann auch noch,
dass wir die Farben auf den Stellen irgendwie vorgeben. Genau,
das ist schon bei den entsprechenden Kanten konstanten Netzen gemacht haben,
dass man dort also in irgendeiner Weise die Mengen benennt,
die man dann auch entsprechend nach dem jeweiligen Formalismus entsprechend bunt gestalten kann.
Kann also durchaus alles und schwarze Token und Farben und
irgendwelche Flüssigkeiten öffnet sich als Mengen, einfach wieder reinpacken,
wenn man es entsprechend definiert.
Das ist also eine reine Frage der Definition,
sprich eine Frage der Faltung der entsprechenden Vorbedingungen,
die man jeweils zusammenlegt,
die man als eh sozusagen ähnlich für die entsprechenden Verhaltenssachen beschreibt
Wenn ich zum Beispiel eine Aktivität habe,
ich hebe etwas von der einen Stelle an die andere Stelle,
dann kann ich bei dem Heben eben alles Mögliche da reintun,
ich kann eine Blume da reintun, ich kann im Netzteil da reintun,
ich kann ein Auto da reintun,
was immer ich dann mal heben kann,
sei es nur ein Kran oder sei es eben eine Hand,
die irgendetwas bewegt.
Und davon abhängig habe ich natürlich auch unterschiedliche Möglichkeiten,
weil per Hand werde ich kaum einen entsprechend großen Container im
Hafen mal so hin und her tragen können.
Jedenfalls nicht ich. So, die Idee ist,
dass wir bei diesen Netzen wiederum vorgehen, dass wir unsere Lokalität haben.
Wir gucken also nur auf eine Transition, gucken uns die entsprechenden Guards an,
die entsprechenden Variablen und dann die Sachen im Vorbereich.
Daran haben wir die entsprechenden Oriablenbindung und wählen also eine Belegung,
die den Guard entsprechend erfüllt. Können wir so frei berechnen,
kommen zu den Kantenkonstanten Netzen hin und dann sagen wir,
okay, jetzt schalten wir das gefärbte Netz,
was wir da drin hatten, war ein schönes Tupel,
was man sich sozusagen angucken muss, woraus es eigentlich besteht.
Wir haben also das Netz, die Farbmengen,
wir haben die entsprechende Farbzuweisungsabbildung, wir haben die entsprechenden Variablen mit den Wertebereichen,
die Guards, die entsprechenden Kantengewichtungen und die entsprechende Anfangsmarkierung,
die wir immer in Abhängigkeiten von den jeweils zulässigen Rahmenbedingungen drin haben.
Also auch nichts, was da weltbewegend ist. Und wir
haben die entsprechende Markierung, die wir entsprechend als Multimengen betrachten,
womit wir so Multimengen Operationen auch haben.
Und haben die entsprechende Belegung und wir haben eine Aktivierung für
die Transition, für eine Transition und eine Belegung zusammen.
Das sind Condity und das Better, was wir entsprechend an diesen Pfeilsachen mit dran schreiben. So,
und entsprechend wird dann die Nachfolgemarkierung entsprechend berechnet,
genauso wie wir es vorher eigentlich auch hatten, konzeptionell,
nämlich die entsprechenden Markierungen, die wir haben, das ab,
was wir berechnet haben, unserer Belegung, ziehen den Kram ab,
packen das hinten wieder, die entsprechend neu berechneten Sachen wieder drauf.
Und haben damit das Schalten sozusagen von der einen zur anderen Seite rüber.
So, die konzeptionelle Idee dahinter ist also entweder das Zusammenlegen,
wobei man hier die Informationen verliert, beziehungsweise hier die Informationen entsprechend beibehält.
Okay, jetzt ist die Früh nicht übersprungen,
da will ich darüber weggehen, das wollte ich gar nicht.
Moment. Jetzt ist hier was nicht in Ordnung
Ich wollte hier weitermachen. Jetzt wollte ich darauf eingehen,
wie man dieses entsprechend an einem Beispiel sich mal genauer anschaut.
Und zwar ein Datenbankmanager, haben wir also die Idee,
dass wir ganz viele Datenbankmanager in irgendeinem System haben.
Wir haben es in Datenbanken da drin, mit entsprechenden Prozessen.
Und die Datenbanken sollen so verwaltet werden,
dass überall der gleiche Inhalt irgendwie zustande kommt
Dafür müssen natürlich die Manager in irgendeiner Weise kommunizieren,
damit ich also Tokio,
New York und Hamburg entsprechend denselben Inhalt meiner Datenbank vorfinden kann.
Und naja, da die weit verteilt sind, schicken sie sich gegenseitig Nachrichten.
Und die Frage ist, was müssen sie eigentlich schicken?
Wer schickt wann wem was? Unter welchen Voraussetzungen darf was
geändert werden? Und wie regele ich eigentlich,
wer von denen eigentlich zum Zuge kommt mit welcher Lösung?
So, und die Idee ist, dass man also irgendwie
so ein entsprechende Zustände hat, wo man irgendwas versendet.
Die anderen müssen dann das aktualisieren, wenn sie fertig sind,
entsprechende Rückmeldung zu rückgesendet haben, dass sie fertig sind.
Dann kennt der Manager wieder entsprechend in den Zustand Inective
zurück und der Nächste kann sozusagen loslegen bei der Geschichte
So, und dabei wollen wir die Datenbank jetzt nicht darstellen,
noch eben die Aktualisierung, was man da so einzeln auf der Datenbank macht.
Das macht ihr an den entsprechenden anderen Veranstaltungen,
die ja dann auch genau die Sachen dazu bringen.
Wir wollen es hier nur auf den Nachrichtenaustausch konzentrieren.
Was haben wir da drin? Wir haben die entsprechenden Modelle,
das heißt, wir haben die Zustände der Manager,
Inactive, Waiting und Performing. Das heißt,
wir sind irgendwie inaktiv oder wir warten auf irgendwas,
dass wir noch wieder, weil wir irgendwas in Gang gesetzt haben.
Oder wir machen gerade dieses Update, was da entsprechend drinsteht.
Dann haben wir die Nachrichten,
die entsprechend von S nach R sozusagen zu sehen sind,
wobei das eben die jeweiligen Datenbankmanager sind und man an sich
selbst nichts schickt.
Das ist sozusagen
die Idee dabei
Zustände der Nachrichtenpuffer, die wir haben, sind eben anused,
Cent, received und echnologed, gleich noch sehen werden,
was da genau passiert. Wir haben wechseitigen Ausschluss,
der wechselte Ausschluss ist genau das Element, was wir jetzt brauchen,
um sozusagen die Symmetriebrechung zwischen all diesen gleichförmigen,
entsprechenden Datenbankmanager auch hinzubekommen und auch dafür zu sorgen,
dass nur genau einer sozusagen einen kritischen Abschnitt entsprechend eintritt.
Und die Spezifikation ist insgesamt ein gefärbtes Netz aus der
entsprechenden Abbildung, die gleich noch sehen werden.
Und dadurch haben wir die entsprechenden Farben für die Datenbankmanager D1 bis DN.
Wir haben die entsprechenden Nachrichten, die wir durch diese Menge entsprechend beschreiben
Und da haben nochmal so ein Black Token oder so ein
spezielles Element, was wir haben oder nicht haben.
So, die Variablen führen wir dann halt auch noch irgendwie
ein, haben wir eine Menge von Variablen.
Wir haben eine Domäne für die jeweiligen Variablen, die wir drin haben.
Das heißt also, hier oben die, ne,
muss ich ja nicht rübergehen, ne.
Hier oben für die entsprechenden, für das E und S.
Und R&S sind ja die entsprechenden Datenbankmanager, die natürlich aus
dieser Remedien kommen müssen und hier das schwarze Token.
Was wir dann noch haben,
sind Funktionen und jetzt kommen wir nämlich zu diesen entsprechenden Dingen,
die wir an der Transition ranschreiben.
Wir wollen jetzt in irgendeiner Weise letztendlich Guards formulieren bzw. kannten
dann Schriften schreiben und wollen dort nicht immer die ganzen Multiming
alle einzeln auflisten
Nochmal deswegen, weil wir natürlich das N als entsprechende Menge
von Datenmitmanagement haben und wir wollen das sozusagen einmal verallgemeinert hinschreiben.
Dafür brauche ich aber irgendwie Notation und die Notationen sind entsprechend
hier jetzt die entsprechenden Funktionen. Was wir machen müssen,
Diatenbank-Manager müssen irgendwie auf eine Multimenge von Nachrichten abgebildet werden,
wobei eben entsprechend der Sender, den wir hier haben,
alle umfasst, nur nicht an sich selbst zu sagen.
Das heißt, ich packe da alle rein,
die von eins an und dann alle zwei, drei,
vier bis n sozusagen Nachrichten sind oder entsprechend,
wenn es drei ist, 1, 2,
4 und die anderen bis n. Dann haben wir die entsprechenden Weg.
Die Empfänger, wo wir auch den Martifet auf den Datenbankmanager abbilden müssen,
das heißt, wir wollen hier die empfangenden Teile abbilden,
sodass wir auf das R kommen, wir würden also Projektionen haben.
Hier haben wir die entsprechenden Möglichkeiten, den Datman-Flancher auf das E abzubilden,
was dann einfach in dem Black Token ist.
Wir werden gleich sehen, wofür die entsprechend benötigen. So,
die entsprechende Anfangsmarkierung, die wir dann haben in den entsprechenden Darstellungen,
ist, dass wir die Datenmanager als inaktiv die Nachrichten als unbenutzt haben.
Wir haben die Anfangsmarkierung, wobei P eben genau das hat.
Und ansonsten sind die Stellen alle leer, die wir gleich
sehen werden
Ja, was sehen wir da? Wir haben hier ein
entsprechendes Netz, was von oben nach unten quasi durchlaufen wird.
Wir haben die Waiting Unjust Cent und Exclusion Stelle,
die wir da oben liegen haben erstmal,
wo wir eben genau die Initialisierung drin haben, die ich ihm sagte.
Wir haben alle Unbenutzten und wir haben den Black Token
dort liegen und wir haben nichts versendet und keiner erwartet.
So, und dass das jetzt Aktivität haben,
wir machen jetzt ein Update in Cent Messages.
Dieses Style kann wie oft Nebenläufe zu sich selbst schalten
Sehen wir an, die sind entsprechend alle mit dem Un-Used und Cent
entsprechend auch vernünftig und dem Rating und Inactive und so weiter,
alle richtig im Anfangszustand.
Dann ist durch die entsprechende Stelle P4,
der Exclusion und dem Black Token sichergestellt,
dass das nur an einer einzigen Stelle passieren kann.
Das ist also das, was wir irgendwie hinbekommen müssen.
Wie gesagt, wie man das hinbekommt,
dass da so ein Token in so einem verteilten System zwischen
Tokio New York und Hamburg wieder existiert.
Dafür gibt es dann bei verteilten Algorithmen Ideen, wie man sowas macht.
Ob das nun so ein Token Ring ist oder so ein
Sprechliter-Algorithmus oder wie auch immer, wie man das sozusagen sicherstellt.
Dafür gibt es noch wieder andere Verfahren,
die das dann auch erreichen in den praktischen Systemen.
Wie ihr wisst, funktioniert das für Datenbanken.
Es ist im verteilten System nur entsprechend darauf zu achten,
dass man es auch effizient oder effektiv implementiert bekommt.
So, hier haben wir sie jetzt sozusagen sichergestellt durch diesen
einen schwarzen Token, dass wir irgendwie nur einmal schalten können.
Und wir würden sozusagen die Marken von dem Inactive abziehen und da anfangen zu schalten.
Wir würden das S abziehen, das E abziehen,
das wollen wir noch abziehen. Das meinen von S,
das heißt, wir gehen hier rüber und ziehen,
also von den Inactive den Sender ab,
diesen entsprechenden Black Token und das Main von S,
was eben sagt, dass sich genau die Marken abschicke,
die nicht an S gehen.
Ja, also wenn ich Nummer drei bin,
schicke ich eben von 1 und 2 und 4 bis N
die Sachen sozusagen raus und packe die in.
Sie müssen nochmal, das Main von S, das kommt also,
die werden jetzt gerade rausgepackt und hier auf das Cent gelegt.
Und hier drüben sage ich jetzt, der Sender wartet jetzt.
Naja, was macht er da? Erwartet,
dass er hier irgendwas empfängt, nämlich die entsprechende Bestätigung.
Irgendwie wartet er jetzt drauf. So, was da jetzt
genau dann hinter steckt, ist dann quasi hier unten zu sehen.
Was passiert da? Das ist das, also, das wehting.
Und die werden jetzt quasi rausgepackt und hier auf das Cen,
dämie, das ist das mind,
das ist das d,
das wemind,
Nachrichten empfangen haben, das gilt für die jeweiligen Erst,
die hier drin sind, also alle anderen,
die noch nicht erst heißen von dem Teil,
also 1, 2, 4 bis Ende,
werden dort sozusagen einmal tätig und holen sich jeweils nacheinander irgendwie diese Nachrichten,
müssen alle irgendwie machen,
was wir jetzt nicht haben in diesem Beispiel ist,
dass alle mal irgendwie, dass irgendeiner sagt,
was sonst im Netz üblich ist,
oh schalt mal nicht, ich will jetzt nicht.
Irgendwann gehen wir davon aus,
dass das Ganze mal fortschreitet und auch tatsächlich irgendwie passiert,
Sobald sie dann halt so ein Signal bekommt,
da ist was drin im Puffer, dann auch entsprechend abarbeiten können.
Gut, was dann passiert ist, dass dieses SR sozusagen
hier raufgepackt wird nach dem Motto, habe ich empfangen.
Und da drin ist er dann im Zustand Performing.
In dem Teil tut er also irgendwas, ohne dass wir sehen,
welche Aktivitäten jetzt wirklich ausgeführt werden an den Stellen.
So, und damit haben wir also jetzt, wenn wir alle erst abziehen,
abziehen von den Darkmark Managern und das Durchführen, okay,
dann machen sie das alle.
Irgendwann werden sie nach endlicher Zeit da hoffentlich wieder rauskommen und senden dann eben ihre Egnolishments zurück,
sodass er jeweils wieder sagen kann, okay,
ich bin jetzt wieder inaktiv,
weil Performing muss ich nicht mehr machen
Habe ich erledigt, bin ich wieder inaktiv. Und was
habe ich hier gemacht? Ich habe hier die entsprechenden Nachricht,
die mal ursprünglich von hier oben kamen, habe ich hier genommen,
Empfangen verarbeitet und hier wieder zurückgelegt, habe also Zach Knowledge zurückgepackt.
Das passiert für alle und dann sind wir durch.
Das ist das, was da letztendlich hintersteht. So,
das war sozusagen der grobe Überblick. Wir haben jetzt zwar 1,
2, 3 halt hier haben, haben wir die entsprechenden Marken da drin liegen.
Wir haben die von 1 nach 2,
von 1 nach 3, 2, 1, 2,
3 und 3-1,
3-2 da drin liegen.
Bei den entsprechenden Nachrichten, die wir dort haben.
Das inaktiv 1, 2,
3 ist auch relativ klar,
was da passiert
So, das ist das, womit wir jetzt hantieren.
Und was wir jetzt machen, ist,
dass wir diese Marken nehmen und entsprechend wegpacken.
Der schwarze Token, der ist ja sozusagen im Nirvana verschwunden.
Hätten wir auch auf einer extra Stelle liegen können,
haben wir hier nicht. Was wir sehen, ist also,
dass wir die entsprechenden beiden Nachrichten da drin liegen haben.
Wir haben also von 1 nach 2 und 1 nach 3
die Nachrichten da drin. Die anderen sind da und 2
und 3 liegen da irgendwie rum und sind noch inaktiv,
weil die sind nicht zum Zuge gekommen bei der Auswahl oder bei Wettstadt.
Vielleicht wollten die auch was verändern in ihrem Datenbankbereich und die kommen nicht zum Zuge,
weil jetzt entsprechend die eins halt gewonnen hat.
Und da nur da eine Token drin war. So,
was passiert jetzt, was ist jetzt hier passiert sozusagen? An dieser Stelle,
wir haben hier diesen Wechsel und kommen jetzt sozusagen auf die Idee,
dass wir da vielleicht eine extra Stelle hinlegen müssen, warum möchten wir das gerne haben? Ja,
jetzt kommen wir auf das zurück,
was am Anfang der Veranstaltung mal gemacht wurde,
mit Invarianten und so weiter, dass man irgendwie zusagen konnte,
okay, wenn ich jetzt einen Token habe,
das löst du nicht auf und dann kommt mal wieder irgendwas raus,
sondern ich sage sozusagen beim Systemzustand,
dass ich das irgendwie habe und dann schiebe ich es eben einmal dahin und einmal hierhin,
dass ich also irgendwie eine Verwaltung meiner Ressourcen irgendwie da drin
habe,
die da drin vorkommen können
So kann man also quasi eine Innenvariante überlegen,
dass man entweder ein Rating, ein Exclusive oder in dieser neuen Stelle
diesen Token liegen hat und egal, was unser System tut,
in einer von den beiden Stellen liegt eine Marke drin.
Wenn wir noch mal sehen, was man da so anstellen kann.
So, das kann man wieder wegmachen. So,
was wir jetzt machen, ist, okay, drei ist jetzt hier,
hat jetzt hier was empfangen und hat entsprechend die Nachricht eins verarbeitet.
Ja, was passiert jetzt? An dieser Stelle ist noch nicht,
jetzt kommt die zwei dran,
jetzt liegen sie beide da und die entsprechenden Updates sind gezielt,
dass zwei sich entschließt, okay, gut, das ist klar.
Dann habe ich die entsprechende 3 und sage, yo, auch fertig.
Und jetzt kommen wir zu dem Zug, dass wir entsprechend hier,
dass wir zurückpacken können, sagen können, alles klar.
Jo. Gut, damit sind wir sozusagen ein Durchlauf durch.
Das sollte jetzt klar sein, wie der Ablauf so in etwa ist. Interessanterweise,
was man jetzt hier sehen kann, ist, dass ihr den Datenbankmanager,
wie er vor diversen Jahren von Kurt Jensen sozusagen entworfen wurde, vorfindet.
Interessanterweise gibt es für die Pitnets-Konferenz,
die dieses Jahr hier auch in Hamburg stattfindet,
ein entsprechendes Logo für die Pitnets-Konferenz,
wo die Sachen ganz anders angeordnet sind,
wo nämlich die entsprechenden Aktivitäten nebeneinander liegen und die Stellen irgendwie oben und unten angesetzt sind.
Und das zeigt, wenn ihr da rauf guckt,
werdet ihr auf den ersten Blick nicht erkennen,
dass das gleiche Netz ist,
wenn ihr nicht sozusagen wisst, ist halt so ein Datenbankmanager.
Das zeigt, wie schwierig das ist,
solche Sachen wiederzuerkennen und wie dieses Formatieren von solchen Netzen eigentlich funktioniert.
Das heißt, wenn ihr mit Netzen arbeitet,
ist das Layout, das Anordnen und das Hinschreiben eine der Dinge,
die relativ schwierig sind
Durst Oberquelle hat in seiner Habi zum Beispiel sich damit beschäftigt,
wie man sowas auch vernünftig designt und anordnet.
Also Ergonomieaspekte davon betreibt. Und da kann man eben ganz triviale Dinge falsch machen,
aber die trivialen Dinge überhaupt mal sich genau anzugucken,
muss man, muss man durchaus mal ein bisschen drüber nachdenken,
was davon eigentlich einen wirklich stört oder was einen nicht stört.
Selbst wenn er so gut zeichnet und keine trivialen Fehler macht
wie merkwürdige Boxen durch überkreuzte Linien sozusagen zu konstruieren oder sowas,
bleibt die Frage der Anordnung von diesen Elementen
Das heißt, möchte ich irgendwelche In-Varianten betonen? Möchte ich
irgendeinen Fluss betonen? Möchte ich Prozesse? Möchte ich
bestimmte Anwendungsbereiche betonen? All sowas kommt sozusagen da zum Tragen
und stellt eine der weiteren Hürden für die Petrinetze dar,
wenn man damit entwirft. Insbesondere ist interessant,
wie gut oder wie schlecht man sich daran wieder orientieren kann,
wenn ihr also so ein Netz jetzt habt.
Und ich fange an und ordne das alles um,
dann braucht ihr länger, als wenn ihr das gleiche Bild,
was ihr vorher schon mal gesehen habt, wieder bearbeiten sollt.
Sondern wenn ich das jetzt umgeordnet euch in der Klausur präsentiere,
Müsst ihr erst mal drüber nachdenken, was passiert da eigentlich?
Habt ihr vielleicht bei den Hausaufgaben gemerkt? Hatten wir euch
auch untergeschoben? Wir haben ihn jetzt so umgestellt und ihr
solltet irgendwas machen. Und es hat relativ lange gedauert,
wahrscheinlich bisher erkannt, dass es dasselbe Netz ist,
was ich in der Vorlesung benutzt hatte,
um entsprechend die Beschränktheit oder sowas dann mal anzugucken.
Oder Michael dann auch gemacht hat. So, also dieses Anordnen,
dieses zweidimensionale Entwerfen von solchen Spezifikationen ist nicht ganz uninteressant.
Und die gedachten Dinge über,
das gehört auch zusammen oder das ist doch damit drin.
Das ist etwas, was nur implizit in ein Modell
drinsteckt und nur von dem entsprechenden Modellierer und Menschen
rausgelesen werden kann
Es gibt dort keine Entsprechung nachher in dem entsprechenden formalen algebraischen Darstellung,
dass man sagen kann, ja,
das ist doch klar, dass das zusammengehört oder nicht.
Das ist etwas, was das Leben damit relativ schwierig macht
und wo man durchaus sich noch überlegen kann,
wie man solche semantischen Inhalte dort in solchen Modelle mit reinbekommt.
Aber das könnt ihr dann ja in eurer Situation euch dann vielleicht nochmal angucken.
Gut, bis dahin gucken wir uns noch ein bisschen was anderes an.
Wir haben jetzt also dieses entsprechende Netz und jetzt die Frage,
was kann ich damit eigentlich noch anstellen,
außer dass ich jetzt schöne Modellierung machen kann.
Ich verstehe jetzt, was da so in etwa passiert.
Wir haben ja immer unser Rechner, das Ding steckt im
Rechner irgendwie drin, wir haben es gemalt.
Jetzt würden wir uns gerne unterstützen lassen.
Und da wir in der Eilgebrauch dahinter liegen haben,
können wir also auch formalere Dinge darauf loslassen.
Und es ist die Frage, was geht da jetzt eigentlich?
So, jeder Datenbank Mensch, wer ist in genau einem
der drei Zustände in Active Waiting oder Performing?
Was heißt das jetzt für euch
Ja, das heißt erst mal, diese Datenbank-Manager,
die verschwinden nicht so wie unser schwarze Token, den wir gerade eben hatten.
Sondern so ein Datenbank-Manager ist entweder in einer der drei Stellen,
wo er eben anhand von Licht in Active oder eben Waiting oder Performing.
Das heißt, egal wo ich hingucke,
ich finde die Datenbank-Manager immer in meinem System wieder.
Und egal, was ich da irgendwie machen möchte,
das soll sichergestellt sein. Wenn ich jetzt Anfänger bin oder
wenn ich auch erfahren bin und ich mich unterstützen lassen möchte,
könnte ich jetzt ein Werkzeug anschmeißen und sagen,
ist denn das auch überhaupt gegeben?
Und das werden wir mal angucken. So,
wir haben diese drei Stellen und können dann sagen,
jo,
da soll es gelten
Was haben wir noch für eine Aussage? Wir können auch sagen,
jede Nachricht aus MS ist in genau einem der
vier Zustände an Houst Cent, Received oder Egknowledged.
Das ist das, was wir da mit einbauen können.
So, das ist auch irgendwie klar,
weil wir dann die entsprechenden jetzt blau markierten Teile,
nämlich Unused Cent, Received und Egknowledged da mit drin haben.
So, das ist irgendwie klar. Und wenn wir jetzt
an die Innenvarianten denkt, die wir sonst benutzen könnten,
können wir jetzt also hingehen und das mal formulieren.
Jetzt haben wir ein Problem, wie kennt ihr in Varianten
Nur für die einfachen Netze, ne? So, jetzt ist die Frage,
wie macht man das denn jetzt eigentlich für die Gefärbtennetze?
Und das wollen wir uns mal nachher nochmal angucken.
Was wir noch haben, ist eine interessante Aussage über das gesamte System.
Höchstens ein Datenbank-Manager wartet. Das ist natürlich nochmal eine andere
Qualität von Aussage. Da habe ich nichts überverschwinden und erhalten sein,
sondern ich sage, okay, höchstens einer kann da jetzt rein.
Naja, das hatten wir vorhin schon geklärt, wie das funktioniert.
Und ein Datenmensch ist genau dann im Zustand Performing,
wenn eine Nachricht an ihnen im Zustand received ist.
Naja, was bedeutet das? Wenn ich also entsprechend in
meiner Performing-Stelle bin, dann muss ich auch irgendwas in Receive
liegen haben
Das ist sozusagen die Idee, dass wir da irgendwie sowas aussagen können.
Das ist auch relativ klar. Die Transition tut irgendwie was
rein. Oder es wird entsprechend gleich wieder abgezogen,
danach durch die Transition Cent, oder Cent Enonagement.
Damit ist das anschaulich voll klar. Noch eine Aussage.
Wenn der Datenbankmanager im Zustand Waiting ist, dann sind alle
seine Nachrichten in den Zuständen Cent, Received oder Egnoleged.
Kann ich also wieder hingehen. Ich habe da oben
meine Stelle Waiting und habe da natürlich meine Cent received und
technologged Geschichte in irgendeiner Weise gerade liegen
Warum finde ich sie nicht unused? Naja,
weil gerade die Idee ist, dass der entsprechende Sender seine Nachrichten
gerade an ihr eine verschickt hat und sie sollen gefälligst verarbeitet werden.
Und erst in dem Moment,
wo er selber wieder verschwindet aus diesem Waiting-Zustand,
sollen natürlich die anderen wieder auch zurückgesetzt werden und sollen sozusagen weg sein.
Für alle erreichbaren Markierungen, wie wir in diesem Reifbarkeitsgrafen des
Netzes haben, was gilt denn da jetzt?
Sollte also folgendes gelten? 1, 2, 3,
dass genau diese Aussagen hinkommen.
Wie schreibe ich das jetzt auf
Ja, genau, wie vorher bei den Invarianten,
die wir vorher schon hatten, wir gucken uns an,
wie es mit den Markierungen aussieht,
Gewicht ein bisschen und sagen, was da da rauskommen soll.
Hier ist es nur ein kleines bisschen anders,
da kommen nicht irgendwie nur Zahlen raus oder ein, zwei,
drei oder sowas, sondern wir sagen, die Markierung von Innective,
plus die Markierung von Waiting plus die Markierung von Performing,
soll genau diese Datenbackmanager-Minge ergeben.
Okay, hatten wir gerade eben gesagt, über alle Stellen,
irgendwo finden wir die wieder und das soll nie mehr und nie weniger sein.
Egal, was ich also schalte in meinem Netz,
soll in allen Markierungen das so sein,
dass sich dort immer die Datenbackmanager in der Summe wiederfinde
Gut. Bei dem anderen,
sag ich es auch so aus, ich habe M Unused,
also die Markierung von Unused Cent, Received, Technologged,
soll genau diese MS insgesamt wieder ergeben.
Und ja, dann habe ich da unten Ups von M
von Waiting plus M von Exclusion, ist gleich das.
Was passiert da? Wieso gibt es denn Ups?
Das war die Funktion, die ich so ganz laffidar im
Schnelldurchgang vorhin euch miterzählt habe
Die sozusagen von einer Markierung irgendwie das Teil nimmt. Und das bildet auf dieses E.
Das ist genau diese Projektion auf diese Sache. Das heißt,
ich muss irgendwie einen schwarzen Token gerade dort haben,
wo wir schwarze Token, kein schwarzer Token ist,
sondern eben, das wird euch eben von Waiting mit abgebildet.
Was passiert dabei jetzt? Naja, dadurch schaffe ich es,
dass ich nicht extra diese eine Stelle hinzeichnen muss,
in der ich diesen einen Token drin liegen habe.
Weil das ist sozusagen mein impliziter Platz,
den ich damit habe und den ich dann noch kompodiere in
diese entsprechende Sache, dass ich einen Datenbankmensch liegen habe.
Und der repräsentiert dann sowohl den Datenbankmanager als auch die entsprechenden
Black Token. Dafür muss ich aber
eine Funktion schreiben
Diese Funktionsschreiben ist genau das,
was ihr üblicherweise auch bei eurer Programmierung und sowas ja macht.
Das heißt, von da ist eigentlich kein Problem.
Der Vor- und der Nachteil ist, ich spare,
der vorsätzlich spare mir eine Stelle. Der Nachteil ist,
ich muss eine Projektionsfunktion irgendwo aufgeschrieben haben,
damit mein Rechner das auf die Reihe bekommt,
dass er das sozusagen auch so nachrechnen kann und das auch entsprechend so vorfindet.
Und irgendwo soll es dann auch sozusagen nachprüfbar entsprechend stehen.
Was wir jetzt noch haben, ist,
dass wir hier hingehen und quasi eine Multimengenvereinigung haben.
Das heißt, wir haben also auch mehrere Mengen,
die wir da zusammenpacken wollen und müssen
Für alle erreichbaren Markierungen, bla bla bla, gilt.
Vier und fünf. Auch das soll irgendwie gelten.
Wie schreiben wir das jetzt auf?
Wäre da eine Idee? Was muss da jetzt passieren?
Jetzt hätte ich gerne mal eine Antwort von euch.
Wie weit ich euch noch mitgenommen habe hier.
Erstmal rein intuitiv
Das ist ja fokussiv und das passt ja nicht so ganz.
Genau, okay. Also, vom Performing und
irgendwie sowas mit Received, aber ist nicht ganz klar,
wie das so nun gleich aussehen soll.
Was noch weitere Kommentare, das muss ich also machen?
Ja, ich mache sowas, ne?
Genau. Ich projiziere das irgendwie da drauf und sage,
der Receiver von diesem Ding da
Den will ich sozusagen jetzt mal haben und projizierst drauf.
Und das muss das Gleiche sein wie Performing. Das war genau das,
was ich also machen kann, dass ich nämlich den einen Token,
der auf Performing liegt, der Datenbankmanager, der eine,
der jetzt gerade irgendwie die Daten nun updaten soll.
Und auf der anderen Stelle liegt genau dieses S,
Komma R, wo eben genau das Händer und Receiver sozusagen drinsteht.
Und deshalb interessiert mich an dieser Stelle jetzt nicht,
sondern ich rufe daraus den entsprechenden Receiver jetzt hier raus.
Und das mache ich mit der Reckfunktion, die einfach sagt,
jo, der projiziert das entsprechend da drauf und holt
das raus
So, also auch wieder eine Anwendung in der Funktion auf einen Wert,
der das Leben halt wieder schwierig gemacht,
aber dafür habe ich auch schön ein sauberes Tuppel da stehen.
Dieses Jahr ein Tuppel stehen hat, eigentlich müsste ich dort sozusagen,
wenn ich mir das als richtiges Netz angucken wollte,
ganz viele Möglichkeiten von verschiedenen Stellen haben, die genau nur dann feuern,
wenn da entsprechende Belegung ist, was dann einmal,
dass die Stelle einmal das R und einmal das S repräsentiert und für die.
Das heißt, ich hätte eigentlich eine riesige Menge von Transitionen und Stellen,
die ich alle einzeln hinzeichnen müsste,
wo ich dann mit jedem Feuer das immer wieder aufgefaltet mir angucken würde.
Was wir beim letzten Kopf haben können, ist,
dass wir diese Struktur ist für alle ähnlich und ich würde
sich eigentlich alle nebeneinander legen und habe sie jetzt eigentlich gefaltet
und mit dem Falten habe ich jetzt genau diese S,
Komma R und so weiter zusammengelegt
Dieses Zusammenlegen ist genau das,
was wir jetzt bei diesen Funktionen ja gerade machen, nämlich,
dass wir Funktionen anwenden und die entsprechenden Projektionsfunktionen und so weiter dafür haben müssen.
Muss man halt gucken, wie die ausschauen und die fallen
jetzt hier im Moment wie Mana vom Himmel für euch,
dass wir die also einfach so sehen.
Das andere ist, für fünf ist halt,
dass wir dieses meinen von Rating sozusagen angucken und das ist dann
entsprechend gleich dieses M von Cent und M von Received und M von Acnoleged,
wo wir eben genau diese entsprechenden Abbildungen machen.
So, was wir jetzt dann dahinter stehen haben, ist,
dass wir auf die Idee kommen, so einen invarianten Kalkül aus dem PT setzen,
die jetzt schon mehrfach angesprochen habe, zu benutzen.
Wir haben also unser Lisa-Schreiber-Problem hier auf der linken Seite,
die Lese auf der rechten,
die entsprechenden Schreiber und wir haben in so entsprechenden Aufträge mit sichergestellt,
dass das vernünftig läuft, haben wir die entsprechenden Ressourcen.
R. Und wir hatten die entsprechenden Innenvarianten,
I1 und I2, die eben einfach nur aussagen,
dass wir in diesen äußeren Kreis sozusagen L-A-L-Lock und S-A-S die entsprechenden Marken haben und dass die Anzahl,
die da drin liegt, eben genau gleich eng ist.
Das war ja genau die grundlegende Idee dabei
Das andere war, dass wir die andere Variante haben,
eine lineare In-Variante, dass wir entsprechend noch gewichten können für das S mit dem Faktor N,
damit wir auf das N immer hinkommen.
Das heißt, wir zählen nicht nur die Marken direkt zusammen,
sondern auch da machen wir schon sozusagen so eine Operation drauf und sagen, okay,
gut, müssen wir dem N mal gewichten oder zweimal oder was auch immer,
nach dem jeweiligen Netzen notwendig ist, so als Grundprinzip dahinter.
Was wir so haben, ist eine entsprechende Matrix, Wirkungsmatrix,
die wir dort aufschreiben können, da wir ja keine Schleifen haben,
können wir auch direkt als Wirkungsmatrix hinschreiben, wir müssen nicht die,
was trifft noch groß unterscheiden zwischen ein und aus und können uns jetzt die Wirkung für die Transition A angucken,
wo wir halt von Lok eben entsprechend minus eins abziehen und bei LA eine Marke hinpacken,
was wir dann entsprechend hier vorne sehen können.
Und der Rest ist halt null, weil das per Lokalität,
das wirkt nur auf diese beiden Stellen, haben wir diese Sachen da drin stehen.
Entsprechend sehen wir dann hier die entsprechende Gewichtungssachen,
was bringen wir hier für S, naja,
da ist das N, was wir eher wieder zurückpacken.
Wir ziehen aber von S eben nur eine Marke ab und die entsprechende eine Marke,
die wir zurück auf das Lok packen,
das ist nämlich die Kante,
die wir von hier unten wieder nach oben
wieder zurückpacken
Damit sieht man also das Netz,
man sieht das in der Matrix wieder, findet den Kram.
Okay. Dafür hatten wir dann die entsprechenden Innenvarianten,
die wir hier angucken können. Wir sehen nämlich,
dass wir hier entsprechend diese jeweils mit einmal Gewichten,
diese blenden einfach aus, aus die Ressourcen und sagen dann,
okay, das ist eine Innenvariante,
dass das immer gleich eng ist, was wir dann vorfinden.
Und hier vorne eben genau das entsprechende, dass also das L,
das R und das S entsprechend gewichtet, immer ein Elner gibt.
So, diese Innenvarianten kann man miteinander kombinieren,
noch mehrfach kombinieren, es gibt wirklich viele in Varianten,
aber es gibt sozusagen eine bestimmte Menge von grundlegenden Varianten,
die wir da formulieren können.
Die anderen kann man sozusagen
dann wieder daraus ableiten
Okay, die entsprechenden Abbildungen sind dann, dass wir uns
halt genau angucken können und für bestimmte Sachen halt mit rechnen können.
So, was machen wir jetzt hier bei unseren gefärbten Netzen?
Jetzt kommt sozusagen der große Schritt und da müssen wir jetzt was machen.
Das hatten wir hier eben. Wir hätten hier unsere
entsprechende Matrix, die wir uns irgendwie angeguckt haben.
So, jetzt müssen wir das für das hier entsprechend aufbauen
Da gehen wir also hin und sagen, okay,
so, wir haben ein Datenbanksystem, wir packen unsere Transition,
T1, T4 und die entsprechenden P1 bis P8 damit rein,
die wir hier haben.
Hier stehen die entsprechenden Menarmsungen und hier sind die T1,
T2, T3 und entsprechend T4 hier unten.
Die Transition packen wir hier oben hin und packen hier die entsprechenden Stellen hin,
entsprechend über die Namen, an dieser Stelle gekennzeichnet.
So, und die entsprechenden Farbmengen stehen jeweils daneben,
was da sozusagen gelten soll für diese Dinge hier an
dieser Stelle
So, was wir jetzt haben, ist,
dass man hier so eine Identitätsfunktion hat,
die wir darauf abbilden können, unser Receive, was wir dort haben.
Und das ist genau die Wirkungssache, was wir dort abziehen wollen von diesen Dingen.
Und das repräsentiert eben genau diese entsprechenden Funktionsanwendungen,
die wir jetzt direkt in die entsprechende Matrix einbauen können,
sodass wir sagen können, wenn die drei eben schaltet,
wird eben gerade von Inective, das wollen wir T3,
Entsprechend hier.
Wird aus Inneractive eben dieser Receiver abgezogen. Das wird nach Performing raufgepackt.
Und hier wird sozusagen die entsprechende Identität von dem Cent und Receive
sozusagen rausgepackt. Auf den Stellen. So,
und das gilt entsprechend für die anderen genauso,
dass man sich anguckt, was macht T1,
was macht ihr zwei, die drei und T4.
Und der Rest ist halt entsprechend leer. So,
und die Anfangsmarkierung können wir auch noch hinschreiben und können sagen,
okay, hier liegen Summe der Datenbankmanager drin,
da der schwarze Token und hier die entsprechenden Nachrichten,
die wir
dort unterbringen wollen
So, und wenn wir jetzt hingehen und das für die einzelnen Sachen,
die wir vorher gerade gefunden haben, irgendwie aufschreiben wollen,
dann kann man das jetzt genau aufgrund der Matrix sozusagen sich
auch nochmal überlegen und findet diese Sachen entsprechend vor.
So, wenn ich mir das jetzt angucke für diese entsprechende Markierung,
gucke ich mir das nochmal an und springe halt entsprechend in diese Dinge rein,
ups, wo ist das jetzt hier?
Da kommen wir auf die nächste. Da geht man also
für die einzelnen Sachen jetzt durch und guckt das sozusagen anhand
der jeweiligen Markierungen für diese Sachen jetzt durch und rechnet das entsprechend aus.
Interessant ist jetzt, dass man die Invarianten dazu aufstellt,
die wir eben jetzt genau hier schon sehen.
Gehen wir einmal zurück. Nee, da habe ich das da
vorne gar nicht drin. Dass wir hier die entsprechende Innenvariante haben,
die an dieser Stelle eben auch auftaucht. So,
und das kann man jetzt für die einzelnen Varianten,
die man sich so ausdenken kann,
dahin schreiben und muss das natürlich entsprechend mit den jeweiligen Sachen abgleichen.
So, die komme ich hier nicht weiter.
Das habe ich hier gerade ein Teil,
was ich hier gar nicht so haben wollte
Ups, fehlt dir eine Folie. Gut, letztendlich sind wir bei,
ich spring gleich noch mal weg, da hänge ich in der Schleife.
Können wir die einzelnen In-Varianten überprüfen und ausrechnen? Die Frage,
wie das dann genau geht und wie man das entsprechend hin und her rechnet,
könnt ihr dann entsprechend euch sozusagen so nochmal angucken.
Was hier noch mitgenommen werden sollte, ist,
diese grundsätzliche Idee der Modellierung,
wo man hingeht und die entsprechenden in Variantenkonzepte der Stellentransitionen auf
die gefärbten Netz überträgt und dass man sich angucken muss,
welche Funktionen dafür genommen werden und wie man die entsprechenden Projektionen oder sonstigen Funktionen eben hinbekommt.
Und das hängt eben genau ab von dem,
wie kompliziert die einzelnen Aktivitäten in diesen Netzen sein sollen.
Und man kann die Funktion so lange vorantreiben,
bis wir halt diese kleinste Faltung sozusagen hinbekommen.
Da mussten wir Guard und die Funktionalität entsprechend komplex sein. Das heißt,
es ist ein Abwägen von der Komplexität der Funktionen,
die dann teilweise auch immer schwieriger werden, zu verstehen,
gegenüber dann den entsprechenden Netzen,
die sonst immer größer werden
Also entweder habe ich ein sehr großes Netz und wenig Funktionen oder
ein kleines Netz, aber viele Funktionen, der komplizierte Funktionen.
Und dieses Optimum dazwischen hängt davon ab,
wie gut man so etwas lesen kann,
welche Erfahrungen man hat, wie gut die formale Darstellung ist,
wie leicht sich diese Funktionen auch überhaupt beschreiben lassen.
Das heißt, inwieweit eigentlich eine inhärente,
strukturelle Ähnlichkeit der Subnetze sozusagen gegeben ist oder ob das nicht
alles ganz völlig unterschiedliche Aktivitäten sind,
sodass man sie auch gar nicht erst zusammenfalten möchte an den
einzelnen Stellen
Gut. Was wir jetzt machen, wir springen nochmal einen weiter.
Jetzt die Frage, wie kann man das Ganze darstellen?
Und da wollte ich nochmal ganz kurz eine einfache Erklärung von dem,
was ja auch im Skript findet, hier nochmal anführen.
Und da werde ich beim nächsten Mal kurz nochmal das
sozusagen in Aktionen zeigen, wie das dann funktioniert.
So, und zwar haben wir hier jetzt das Regio-Werkzeug,
mit dem wir auf die Idee gekommen sind,
sozusagen Netze zu modellieren.
Wobei sich dann um spezielle Netze handelt,
die eine entsprechende Besonderheit haben,
auf die ich jetzt mal so zu sprechen komme
Die Idee, dass man mit nicht nur Black Tokins verwendet,
sondern auch Gefährtenetze, das war für uns relativ klar.
Die Frage ist, wenn jetzt auch die gefärbten Netze diese
Schwierigkeit haben und ich male da mal mehr hin und ich muss,
es ist in ein einziges Netz, in eine einzige Darstellung reinpacken,
dann werden die Netze sehr unübersichtlich.
Was ich schon am Anfang gehört habe bei Michael Kühler.
Busmeier ist, dass sie was wie Abstraktionen irgendwie kennengelernt hat,
dass ihr so irgendwelche Aufteilungen, Abgrenzungen und so weiter kennengelernt habt.
Was dahinter steht, sondern auf die Idee kommt und
irgendwie so Unterteile bilden kann unter Bereiche von diesen Netzen
Was wir jetzt noch machen, ist,
mit dem Renio-Werkzeug ist, wir gehen noch einen Schritt weiter.
Wir gehen an der Stelle hin und sagen, okay,
wir haben zwar diese entsprechenden großen Netze,
aber ich möchte irgendwas aus der Softwaretechnik auch mit drüber retten,
was sich da sozusagen als erfolgreiches Modell gesehen hat.
Das Verfahren, was ihr eben gerade gesehen habt,
waren im Wesentlichen eine funktionale Betrachtung von diesen Systemen.
Das heißt, ich gucke irgendwie mit Funktionen oder Predikaten und
sowas auf die Sache. Habe aber immer noch das eine Netz,
und wenn ich das war feiner,
dann habe ich irgendwelche hierarchischen Substitutionstransitionen oder Impocation-Positions,
wie man das nennen möchte,
das ist in dem Buch von Kurt Jensen sehr schön beschrieben
und wird in dem CPN-Tools auch ganz nett abgedeckt
Habe ich selber so jahrelang auch mitgearbeitet. Was man dann hat,
ist, dass man zum Beispiel eine funktionale Programmiersprache dann stehen hat und dann aber im Wesentlichen einen funktionalen,
eine produktionale Perspektive verwendet, wenn man so ein System designt.
Wird aber dadurch sehr schön, dass man sagt,
ich gebe erstmal die obere Ebene an und dann zoome ich in die einzelnen Teile rein,
wobei ich mir überlegen muss, ob ich verhaltensbewahren,
verfeinere oder eben nicht verhaltensbewahren verfeinere,
wodurch das oberste Teil dann nur noch quasi ein Kanal Instanznetz wird,
sodass ich sagen kann, hier sind passive Teile,
das sind aktive Teile und das aktive Teil,
das verfeinere ich mal und dann zoome ich da rein und
gucke mir an,
was da genau drin entsprechend passiert
So, diese Verfeindungsoperationen sind etwas, wo man sich relativ lange mit beschäftigen kann.
Ist in der Software-Technik auch üblich, dass man sich überlegt,
welche Arten von Abstraktionen habe ich und welche Semantik packe ich
jeweils hinter meine Funktionalität und wie kriege ich das auf die Reihe?
Wenn ihr euch sozusagen die verschiedenen Arten von Funktionsaufrufen anguckt,
Corby Value, Corby Reference oder sowas ähnliches,
also allein schon die Parameterübergabe in Programmiersprachen,
auch das ist etwas, wo man sich überlegt,
welches Konzept habe ich hinter meiner Verfeinerung eigentlich,
wie soll das eigentlich wirken,
worauf wirkt es,
welche Nebenwirkungen hat es quasi und so fort
So, was wir jetzt machen, ist,
wir versuchen irgendwie Richtung Objektorientierung nochmal so ein bisschen zu gehen und zu sagen,
okay, gut, wenn wir jetzt irgendwas beschreiben,
dann habe ich sozusagen Klassen von Dingen,
die ich beschreibe und dann entsprechende Instanzen,
die ich miteinander kommunizieren lasse.
Was wir so haben in den Referenznetzen, ist,
dass wir also jetzt ein Template erstellen,
dann sagen wir, das ist die Struktur.
Und dann kann ich davon mehrere Instanzen erzeugen, sodass ich das Netz,
was ich da habe, einfach mehr von nebeneinander lege.
Was erreiche ich damit? Naja,
wenn ich eine Struktur habe und die dann instanziere,
Dann nehme ich die Anfangsmarkierung für diese Struktur.
Da war die neue Instanz, immer ob ihr es sonst kennt,
von irgendwelchen Polmiersprachen. Ihr macht eine neue Instanz,
habt die Initialmarkierung, den Anfangszustand für den Abschnitt,
den ihr gerade instanziert habt und habt die separat liegen.
Davon könnt ihr das beliebig viele haben. Das Schöne ist dabei,
ihr habt zwar einmal das Ding hingezeichnet,
aber zur Laufzeit könnt ihr euch die einzelnen Instanzen völlig separat angucken,
vorstellen, bearbeiten und schalten und walten lassen.
Das ist sozusagen die Idee, wie man jetzt Netzinstanzen schaffen muss.
Dafür braucht man aber eine Idee,
wie man zur Laufzeit solche Sachen neu dazu packt.
Kleine Anmerkung dabei, was dahinter steckt, ist,
dass sich zur Laufzeit Netze erzeuge. Das heißt,
ich habe zur Laufzeit erweitere ich die Struktur meines Netzes,
was eigentlich vorliegt. Wir hatten bis jetzt eigentlich immer ein Netz,
wo gesagt haben, ST und S, das heißt,
dass wir unsere Struktur konstant haben und dann darauf die Nackierung anschauen.
So, diese entsprechenden Markierungen sind jetzt sozusagen pro Instanz anzuschauen.
Können wir also immer völlig separiert betrachten und können jede Instanz
unsere Marken in diesem lokalen Bereich
auch lokal behandeln
Bleibt noch die Frage, wie man die kommunizieren lässt und
das werden wir gleich nochmal dann sehen. So,
also das Ringio-Werkzeug, was ihr auch schon kennt von den Übungen,
wo ihr die entsprechenden Sachen ausprobiert habt hoffentlich,
wo man eben entsprechend die,
wann es denn irgendwie gelandet hat mit verschiedenen Möglichkeiten hier oben,
wir haben unsere Stellen und Transitionen und können entsprechende Kanten
dazwischen zeichnen und können das irgendwie wie namensen und können auch
ein bisschen drin rummalen und anordnen und beschriften,
was dann sozusagen
sekundärer Natur ist
Was man haben kann, ist,
dass man hier so ein einfaches Black-Token-Netz irgendwie erzeugt,
wobei die Black-Tokens bei uns ja durch diese Ecke, Klammer auf,
Ecke, Klammer zu, sozusagen realisiert werden in Reniu.
Und man kann jetzt irgendwie so ein Teil haben,
dass man A und B hat,
diesen Struktur ähnlich und wir haben jetzt irgendwie was,
dass die sich geschäftsmäßig unterhalten und jeder hat so Geld und irgendwas wird dort,
passiert dort in irgendeiner Weise.
Und da kann jetzt irgendwie geschaltet werden, das heißt,
wir schalten jetzt hier die entsprechende Transition links da oben
und haben da entsprechenden Token liegen,
der dort stattfindet
Dann können wir das auch wieder zurücklaufen lassen, wenn nichts da passiert.
Und ja, das können wir jetzt sozusagen ein paar Mal machen. So,
die andere Idee ist, wenn das nochmal schalten kann und
jetzt kann man aber auch auf die Idee kommen,
dass das auch da passiert, wenn da jetzt einer liegt,
jetzt haben wir eine weitere Möglichkeit, die wir noch haben.
Wir können jetzt nämlich das Talk-Business sozusagen ausführen und können sozusagen für beide wieder entsprechend etwas produzieren,
beziehungsweise einer von denen kann auch entsprechend wieder weggehen.
Was Sie gemacht haben, ist,
wenn wir jetzt hier einmal geschaltet und das Talk-Business sozusagen ausgeführt.
Wir könnten jetzt hier erstmal die Marken,
also wieder schön hochschrauben an den entsprechenden Stellen
Gut, wir könnten aber auch wieder jetzt sagen, oh,
jetzt haben wir genug, wir sind also nicht mehr auf der Arbeit,
sondern sind wir zu Hause,
dass wir jetzt nach Hause gehen und sagen, okay,
ist Schluss damit.
Dann kann entsprechend natürlich hier drüben nichts mehr produziert werden,
hier oben kann auch kein entsprechendes Geld verdient werden, nennen wir das mal. So,
kann man auch anders hinmalen,
wir können das jetzt auch einmal hinzeichnen,
dass wir so A und B sind irgendwie zu Hause und wenn wir es
jetzt zusammengefaltet und können jetzt hier diese Operationen haben und hier packen wir auch noch gefärbt die Sachen drauf,
dass wir so ein A und B haben und die schalten jetzt entsprechend mit den Kantenanschriften einfach da durch.
Hier sehen wir das gefärbtes Netz,
was dann entsprechend die entsprechenden Farben hier drin hat,
die entsprechend kannten Gewichte hier dran, was entsprechend Variablen sind,
die entsprechend zu A oder B evaluiert werden können und dann hier schalten können.
So und hier haben wir unser XY und das können wir
zurückpacken und so weiter. So. Die Idee ist jetzt,
dass wir das also für irgendwelche Netze irgendwie machen können,
dass wir jetzt diese Färbung auch in Renio entsprechend darstellen können.
So, jetzt haben wir nicht so ein ganz einfaches Bankkonto,
wir haben ein Deposit und wir können was abheben und wir
haben dort jetzt verschiedene Möglichkeiten was man jetzt hier ranschreiben kann,
was wir ranpacken an die Kanten, sind immer entsprechende Tuppel.
Das ist auch genau der Grund, warum wir die entsprechenden
Black Tokens als Klammer auf Klammer zugesehen habt.
Die Möglichkeiten dann auch entsprechende Rechenoperationen da reinzupacken,
dass man hier zum Beispiel A plus 100 hat.
Das heißt, ich ziehe hier beim Deposit was ab und
fuck halt eben entsprechend hier 100 rein.
Und ich habe die andere Möglichkeit, dass ich hier hingehe,
was abziehe und dann wieder zurücklege, das aber nur in kleineren Schritten.
Man kann so 100er draufpacken und Zähne abholen.
Das dauert also ein paar Mal, bis man das runterbekommt.
Die Anfangsmarkierung ist für A gleich 300. Das heißt,
wir gehen also hin und haben jetzt für A ein entsprechendes
Bankkonto auf seinem Geld und sagen,
da können wir irgendwas tun
Naja, was wir jetzt auch machen können, ist,
wir können das Ganze so nebeneinander zeichnen und die sind jeweils wieder zu Hause,
A und B oder entsprechend bei der Arbeit hier,
könnt ihr sie rumlaufen und können sich hier übers Business unterhalten.
Und das Ganze ist hier drüben nochmal dargestellt,
dass wir so ein Deposit haben mit dem Geld und das entsprechende Wistraw,
was ihr dann entsprechend immer einmal was abzieht.
Kann man also ein bisschen anders darstellen. So,
die Idee war ja, dass wir das unten so stehen hatten,
wobei wir jetzt diese Ähnlichkeit auch sehen,
aber was wir jetzt haben,
ist,
dass wir so ein Talk Business und Deposit
wieder rausgenommen haben und in irgendeiner Weise synchronisieren wollen
So, was machen wir da also? Wir gehen uns
entsprechend hin und packen die Synchronisation durch Kanäle da rein.
Was mache ich da jetzt gerade? Ich bin im Moment
nur noch in einem Netz hier gerade zu Gange und führe ein neues Konstrukt ein,
wo ich erst mal sage, okay, gut,
wir haben jetzt irgendwie hier so ein entsprechenden Kanal,
den wir dann hier jetzt angeben wollen und die fuhr mal sozusagen hier synchronisierten Transitionen,
die zusammen schalten sollten,
deswegen hier dieser Strich zusammen und hier oben auch schon der Strich.
Die kann ich auch aufteilen,
indem ich hier ein Wiss-Whist-Draw und X,
Östro X
sozusagen drinstehen habe
Hier rufe ich einen Kanal zum Abziehen sozusagen auf, beziehungsweise hier zum Einzahlen entsprechend auf.
Und This ist sozusagen für das Objekt ganz typisch,
ich rufe was bei mir selber auf und packe das da rüber.
Könnt ihr euch ein anderes Objekt eintragen, vielleicht,
können wir gleich noch sehen, aber kann ich jetzt hier sozusagen machen.
Welche Möglichkeiten habe ich jetzt dadurch? Naja, ich kann jetzt
in meinen Netzen Netzteile schon so hinzeichnen und sozusagen auseinanderziehen.
Ich kann aber jetzt auch das so sehen,
dass ich diese Weltlinie,
die sozusagen am Anfang mal mit erwähnt worden sind,
dass man sozusagen hingeht und die Lebenslinie von einem Objekt und am zweiten hat,
die wer sich irgendwo synchronisieren bei irgendeiner Handlung und dann
wieder auseinanderlaufen,
ist genau die Idee jetzt dahinter
Das wird jetzt hier durch die Synchronen, Kanäle expliziert.
Genau das passiert hier. Ich habe die auseinandergeschnitten, eine Aktivität,
die quasi synchron eingezeichnet wird, die bleibt weiterhin synchron,
nur zeichnet sich an zwei Stellen und habe eben genau durch diese entsprechende,
durch das Einführen von so einem synchronen Kanal die Möglichkeit,
die entsprechend zu binden.
Welche Möglichkeiten die synchronen Kanäle insgesamt bieten, ist ganz beeindruckend.
Im Grunde genommen kann ich über die synchronen Kanäle auch ein Prologprogramm implementieren.
Das heißt, die Möglichkeiten sind genauso groß wie bei der
kompletten Programmiersprache letztendlich. Das wird neulich im Detail hier noch
mit angucken, aber das nur so als Hinweis
Das ist also ein ausgesprochen mächtiges Konstrukt und ist sozusagen eine Ergänzung in die Netze hinein,
dass man dort die Möglichkeit beim Schalten hat und die entsprechenden Guards,
die man da dran stehen, hat,
auch entsprechend zu synchronisieren und zusammenzuführen.
Wenn ich keine Kanäle hätte, was würde dann passieren?
Ich kann die Transition zusammenfalten, ja genau. Das ist
genau die Idee dabei. Also die Idee dahinter ist,
dass ich jetzt so eine Art Faltungsidee dahinter habe,
aber das Synchronisieren ist ja etwas, dass ich sage,
das muss zusammengelegt werden
Was habe ich jetzt hier für Möglichkeiten? Wenn ich jetzt
das Ganze dupliziere, werden gleich noch ein bisschen was davon sehen.
Leider nicht alles. Deswegen gleich beim nächsten Mal
ein bisschen mehr dazu zeigen. Ist, dass wir jetzt
mehrere solche Deposit-Kanäle haben, mehrere verschiedene Aufrufe von irgendetwas.
Und dann ist das sozusagen eine Option,
dass ich mit mehreren anderen synchronen Kanälen wieder verbinden kann.
Das heißt, diese Möglichkeit ist jetzt hier nur eine Möglichkeit habe,
nämlich genau die Verbindung zwischen diesen beiden unteren und beim oberen Transitionen.
Das ist natürlich sozusagen kein großer Gewinn erstmal,
sondern es ist erstmal das Einführen des Konzepts,
das ist ja eine unteilbare Handlung handelt
Der nächste Schritt ist dann,
wenn ich jetzt mehrere Möglichkeiten habe, was passiert denn jetzt,
wenn ich noch eine zweite Transition hätte,
wo auch Deposit dran steht, wird XY.
Dann könnt ihr auch noch im anderen Bereich mich vielleicht.
Und dann muss man sich überlegen, was macht das Teil eigentlich?
Und das, was dann dahinter steht, ist,
dass man diese Netzteile separieren kann. Man weiß ja auch,
links geht es um eine bestimmte Sache und rechts geht uns eine bestimmte Sache.
Warum? Naja, auf der rechten Seite hatten wir irgendwie
darüber geredet, dass es sich um ein Konto handelt.
Und links geht es irgendwie um die Aktivitäten, die man dann hat.
Und das ist Auswirkungen auf das andere Objekt hat,
ist eigentlich dann ja klar. Wenn ihr entwickelt,
wollt ihr natürlich auch nicht eine große Main-Routine schreiben und da
dann eure Sachen reinpacken,
sondern ihr wollt sowas in einzelne Objekte aufteilen und einzeln behandeln
Vor allem, wenn wir das Ganze jetzt für mehrere entsprechende Konten
auch erst mal führen möchte und so weiter und so fort,
muss man erst mal hingehen, wie mache ich denn das,
wie teile ich das denn eigentlich auf?
Und das kann man sich jetzt noch überlegen und da werden wir noch
ein bisschen was jetzt zu sehen, aber wie gesagt,
wir werden das nur am Rande erst mal streifen.
Aber was hier jetzt mitgeteilt bekommt, ist,
es gibt diese Netze und diese Netze erlauben einem jetzt
erst mal irgendwelche Aktivitäten irgendwie querweht sozusagen wieder zusammenzustöpseln.
Was da genau hinter steckt, werden wir gleich noch
ein bisschen was zu sehen
So, das heißt,
hier ist das Deposit und entsprechend war das andere Deposit,
was jetzt zusammengeschmolzen wird, was in diesem Netz,
da ist ja nur ein Netz ist und genau dieses Teil hier ist also klar,
welches Ding ich jetzt hier verbinde und was ich dabei machen möchte.
Und The This ist eben genau das,
dass es sich um diese Instanz auch handeln soll,
in der ich jetzt mich auch gerade entsprechend befinde.
Was habe ich bei meinen entsprechenden Parametern jetzt gemacht?
Ich habe hier gesagt, naja,
ich habe da X und Y und Deposit
auf X und Y und verwalte jetzt hier alle Konten auf
den Schlag
Wir jetzt, also das nächste,
was ich dann dabei tun würde, naja,
ich komme vielleicht auf die Idee und sage, okay,
wollen wir ein bisschen ändern?
Wir wollen das mal ein bisschen anders machen.
Dann geht es euch hier oben wieder besser,
was vorher da war und würden das gerne jetzt einen Tick anders machen.
Wir sagen nämlich, wir wollen das zweimal aufrufen.
Wir wollen das sozusagen quasi getrennt behandeln und X und Y-Cent darauf legen.
Und jetzt wird mir einmal auch das Netz hier drüben ein bisschen einfacher.
Das, was ich auf meinem Kumpel anrufe. Nämlich nicht,
dass ich alle konnten gleichzeitig bearbeiten muss,
weil sonst könnte ich das leider nur machen bei einer Bank.
So kann ich es jetzt erstmal schon mal mir gedanklich vorstellen,
dass ich jetzt eine Kontos,
andere Konto habe
Und die müssen nicht an demselben Pfeil direkt erstmal liegen.
Liegen sie natürlich, aber ja. Warum liegt auf
dem Konto für X, auch B? Also,
was da liegt, ist, dass ich erstmal die Sache
von oben genommen habe und bei dem Deposit jetzt aufgezeigt habe,
wie ich die Sykronenkanäle auch noch anders benutzen kann.
Ich kann also hier drüben zweimal einen Aufruf machen.
Ich rufe an dieser Transition zweimal eine andere Position auf.
Was steckt jetzt dahinter? Ich habe eine Transition,
die da erstmal hingezeichnet wurde,
zur Laufzeit rufe ich aber zweimal
diese Transition auf
Das heißt, wie viel kommen da raus? Da kommen zwei Xe raus. So,
aber diese Xe werden jetzt entsprechend nicht entsprechend an denselben Wert gebunden,
weil sie an derselben Kondition statisch dran stehen.
So dynamisch wird entschieden, anhand der Bindung der Parameter,
die ich dort übergebe, werden die entsprechenden Sachen benutzt.
Wenn ich also jetzt entsprechend ein A und ein B darüber packe,
was entsprechend von hier drüben nämlich kommt,
nämlich das X und Y, die hier sind,
wird entsprechend X und Y hier entsprechend draufgepackt,
so dass das A und B entsprechend darauf kommt.
Das heißt, sich weiterhin um einen Speicher,
wo beide konnten verwaltet werden,
der Aufruf sieht nur aber ein bisschen anders aus an dieser Stelle.
Und man sieht, dass man an den Transitionen
auch mehrere solche Aufrufe haben kann
Was wir in Zukunft nicht sehen werden, ist,
dass wir mehrere Uplinks haben. Das heißt, wir haben nicht
die Möglichkeit, hier jetzt mehrere, solche Deposit-Sachen zu machen.
Sehr wohl können wir aber irgendwelche Sachen nach unten hin aufrufen.
Dadurch habe ich eine gewisse Asymmetrie drin,
die mir aber dann bezüglich der Algorithmen sehr große Vorteile bringt,
sodass sozusagen sehr viele Sachen polymiell bleiben,
weil beim Aufrufstruktur suchen ich quasi so eine Art Baum von oben nach unten quasi durchsuchen kann.
In der Hoffnung, dass es noch endlicher Baum ist.
So, die entsprechenden Möglichkeiten sind, also hier,
dass ich jetzt dieses Wisdow und das Deposit entsprechend benutzen kann
und das jetzt irgendwie ausführe
So, und an der Stelle,
also du hattest eine entsprechende X, genau die Frage,
die eben auftauchte, was ist denn das für ein X?
Naja, das wird eben entsprechend der Aufrufparameter von dieser Seite her entsprechend bestückt,
sodass sie also entweder das X oder Y hier entsprechend auch
reinstopfte und das X und Y sind genau diese beiden Xe,
die hier ankommen.
Es wird aber einmal als X und einmal als Y bewertet und entsprechend drüben übertragen.
So, und dieser Bezeichner des Netzes ist das,
was wir da jetzt dann drinstecken haben
Und was wir jetzt auch noch machen können, ist,
dass wir jetzt hingehen können und sagen können, okay,
jetzt wollen wir ein bisschen Algebäude reinbringen, jetzt wollen wir das,
was ich ganz am Anfang gebracht hatte, dieses Konto,
dass man hoch und runter rechnet,
wollen wir jetzt mal anfangen und wir fangen an,
darauf zu rechnen.
Wir haben ja gefärbt, das Netz, können wir so
auch irgendwelche Algebäude aufmachen und das entsprechend ausführen. So,
damit habe ich also jetzt die Möglichkeiten, hier entsprechend immer einen abzuziehen,
ist ja auch 10 oder 100 oder sowas eintragen können,
je nachdem, was man da gerade macht.
Und hier habe ich sozusagen das Deposit 1,
das ist also von der Berechnung her dann das Entsprechende.
Wenn ich also hier jetzt hier eine andere Zahl eintragen würde,
würde ich entsprechend andere Sachen auch entsprechend übertragen und hier aufrechnen
Und die Diktoration, die ich dafür brauche,
haben wir jetzt hier, sehen wir hier gar nicht,
weil die sozusagen implizit sich daraus ergeben,
aus diesen entsprechenden Farbmengen, die hier verwendet werden.
So, entsprechend sieht hier das Deposit und Wisdow aus,
was wir jetzt natürlich wieder auch hätten hochzeichnen können mit sowieso Auslösung vorher.
Aber so haben wir das Netz,
was wir ganz am Anfang hatten mit dem einfachen Verarbeiten darauf.
So, was machen wir jetzt? Jetzt haben wir die
Idee, dass wir also in einem Netz drinstecken haben.
Was möchte ich aber jetzt für in Wirklichkeit haben?
Ich wollte ja, wie gesagt, ich würde gerne Objekte
haben, einzeln getrennt oder sowas.
Was muss ich also tun? Ich muss so hingehen und
Netzstrukturen zeigen, die mir entsprechend
einzelne Bereiche aufzeigen
Die ich dann wieder instanziere. Das heißt,
ich gehe ja so hin und sage, okay,
machen wir mal so ein neues Netz und erzeugen das mal.
Erstmal jetzt sozusagen schematisch, bevor wir in die hinteren Sachen dann wieder wieder einsteigen.
Wir haben also das Hauptnetz, ein Creator,
der hat oben ein Black Token und es werden zwei Sachen aufgerufen,
nämlich X und Y von New Abonnett, also nett,
was wir hier machen.
Und das heißt X und Y wird sozusagen rübergepackt und
wir erhalten da zwei XY drin. So,
dass Athanet, was wir auf der rechten Seite sehen,
haben wir irgendeine Struktur da drin, meinetwegen sehr einfach ist an dieser Stelle.
Jetzt ist aber die Frage, was liegen denn XY drin?
Wenn ich jetzt die oberste Transition einmal schalte,
was meint ihr denn, was da drin liegt?
Alle Antworten sind richtig. Gibt mehrere Möglichkeiten
Ja. Es liegt das Netz auf der rechten Seite drin.
Ja, das wäre eine Möglichkeit,
dass man jetzt das Netz der rechten Seite drin liegen hat.
Jetzt habe ich ja aber oben X und Y.
In welcher Weise spiegelt sich das jetzt nieder?
Zweimal separat. Genau. So, jetzt ist aber
die Frage, liegt das Netz jetzt da drin
Oder sozusagen nur eine Referenz auf dieses Netz. So,
und da kann man jetzt länger darüber nachreden und da gibt es verschiedene Implementationen.
Die Referenznetze von Renio, Reference Net Workshop ist das ja die Idee. Ist jetzt,
dass wir dort nicht die Netze selbst reinpacken als Objekte,
sondern dass wir die Referenzen auf die Objekte da drin haben.
Wodurch wir es schaffen, erstmal First or Objects zu haben,
jedes Netz für sich,
jede Netzinstanz für sich wird ein First or Object,
die dann entsprechend verpointert werden mit entsprechend enthalten sein.
Dadurch erreichen wir, dass er letztlich selbst enthalten kann bald
Ihr lacht. Warum kann Netz sich nicht selbst enthalten?
Wenn ein Objekt hat irgendwelche entsprechenden Listen oder sonst irgend sowas und Elemente
und da könnt ihr mit Point dann irgendwie rumhantieren.
Das zeigt auf sich selbst. Ist also ein bekanntes Konstrukt aus
der Programmierung. Erstmal kann man eine Menge Unsinn machen.
Das ist, glaube ich, bei den Workflow-Netzen.
Wir können hier erstmal eine Menge Unsinn machen.
Die Idee ist aber natürlich, dass man solche Strukturen sucht,
wo man keinen Unsinn macht. Das ist der Trick nachher,
wie man einen guten Softwareentwurf beziehungsweise gute Netzspezifikationen herstellt.
Was für mich das Gleiche ist im Endeffekt
Was jetzt hier so haben, ist, dass wir so ein einfaches Netz haben.
Und jetzt gehen wir hin und lassen das irgendwie mal so schalten.
Was wir also haben, ist,
dass wir links und rechts jeweils so ein Netz liegen haben und was wir dann drinstecken haben,
sind genau diese beiden Dinge hier, nämlich Avanet 1 und 2,
sodass wir so zwei Objekte quasi da referenziert oder drin haben,
je nachdem, wie ich euch das jetzt mal vorstellen wollt.
Solange ich nur genau eine Referenz auf ein Netz habe,
kann ich also auch davon ausgehen,
dass quasi das Netz selbst drin liegt.
Wenn ich an mehreren Stellen Referenzen habe,
was wir nochmal dann diskutieren werden demnächst, ist dann,
dass man halt dann nicht mehr
sich den Werte vorstellen sollte
Eine andere Variante wäre halt, dass man ja so macht,
dass man das entsprechend an der Stelle unterbringt. Wie geht das? Naja,
wenn ich also hier drüben hingehe und Your X,
Avanet, New Avanet, raufpacke und jeweils ein X raustue,
dann liegt das zweimal hier drin, der Token,
das X, aber das Netz kann er ja nicht mehr zweimal,
also man müsste das dann schon duplizieren und da doppelt reinpacken.
Da ist es dann aber sozusagen eine Geschichte, die interessant wäre,
wenn ich nur mit einem New gleich zwei Instanzen durch das Schalten der Transitionen drin habe,
deswegen haben wir die Referenzsevantik gewählt,
weil das einfach sozusagen intuitiver ist,
dass es jetzt ein Pointer auf das andere Netz ist oder eine Referenz auf das andere Netz,
was man dann einmal erzeugt hat,
auch darstellt
So. In Anbetracht der Zeit, die weiteren Dinge,
ich werde noch ein paar Dinge dazu beim nächsten Mal dann genauer ausführen.
Und dann wollte ich auf die entsprechenden Wiederholungssachen eingehen,
wobei nächstes Mal die Veranstaltung nicht weiter aufgezeichnet wird,
weil wir das dann nicht hinbekommen. So,
damit sind wir durch für heute und ich hoffe,
ich sehe euch dann beim nächsten Mal,
wo wir dann den kurzen Rest,
die letzten 15 Folien noch besprechen, von diesem Teil hier,
ich noch eine kurze Demo gebe und dann über die entsprechenden Klausurgeschichten nochmal eingehe,
was dann sozusagen vom Prinzip da kommen soll.
Gut,
okay,
vielen Dank