Technik funktioniert. Moin moin. Wir haben neue Technik. Könnte wieder richtig funktionieren.

Schauen wir mal wie lange sie durchhalten. Das erste. Ich habe für euch kleine Zettelchen.

Muss ich dazu noch was sagen oder? Ich glaube ihr kennt das alle. Dann reiche ich die mal rum.

Drei Stück. Offiziell haben wir ja eine Vorlesung und eine Übung. Ob wir das jetzt gemischt halten

oder nicht. Aber wir haben offiziell eine Vorlesung und eine Übung. Und für die Leute,

die auch noch die Übungen machen, die Laborübungen, die können sich dann noch mal

darüber auslassen. Hat zwar noch keiner irgendwelche Beratungen in Anspruch genommen.

Insofern könnt ihr wahrscheinlich auch noch nicht groß beurteilen, ob die gut oder schlecht war.

Aber ich soll euch sie austeilen. Also machen wir das.

Okay, dann. Was haben wir letzte Woche gemacht? Letzte Woche haben wir uns unterhalten über

Caches. Haben wir uns da DirectMap Cache, einfach associativ und so angeguckt. Und als letztes kam

dann noch dran dieser Victim Buffer. Wo wir gesehen haben, wenn man sich das noch mal kurz merkt,

was man eigentlich aus dem Cache gerade rausgeschmissen hat, hat man noch einen Vorteil.

Einen zweiten Mini-Cache, sagen wir mal, so ein extra Teil, den gucken wir uns jetzt noch an.

Jo, kleines Beispiel dazu. Typisches Rissprogrammchen. Ich lade zwei Register aus dem Speicher. Ich mach

was mit denen, in diesem Fall aktieren und das Ergebnis wegspeichern. Ich hole mir zwei neue

Operanten, mach was mit denen, wegspeichern. Kann man natürlich sagen, naja meistens hole ich doch

erst mal alles. Also die Loads wandern nach oben, die Stores nach unten. Das ist bedingt richtig.

Das kann natürlich aber auch sein, dass hier drum eine Schleife ist zum Beispiel. Dann kann ich die

Loads nicht nach oben und die Stores nicht weiter runter. Jo, und was man dann sieht ist,

da kommen, das kann man sich auch mal einen echten Code angucken, es kommt relativ häufig vor,

dass nach einem Store wieder ein Load kommt. Irgendwas habe ich fertig, abspeichern und jetzt

weiter geht's. Jo, und da kann man sich natürlich vorstellen, wenn der Cache jetzt bedingt funktioniert,

nicht richtig, dann blockiert uns dieses Store hier das Load. Typischer Fall, wenn wir so haben,

wir haben bisher gesagt, naja wir schreiben durch den Cache durch. So heißt das, das dauert eigentlich

immer langsam. Aber eigentlich könnte das doch im Hintergrund so langsam vor sich hin klackern und

irgendwann mal im Speicher landen. Wer uns ja wüsst, Hauptsache das Load kommt mal in eine Pötte,

dass es weiter geht. Und da ist die Idee, naja man könnte ja so einen sogenannten Write Buffer

einführen. Write Buffer soll heißen, wenn unsere Pipeline was lesen will, dann holt sie sich das

aus dem Cache und wenn sie was schreiben will, dann schreibt sie es erstmal in den Write Buffer und

der regelt das dann schon so irgendwann einmal. Im Prinzip ja, naja, wenn wir uns gleich darüber

unterhalten, im Prinzip zeitlich erstmal, wasch, Hauptsache passiert irgendwann.

Jo, aber, kommt wieder mein Aber hinterher, ihr kennt es schon. Das geht nicht, das geht nur bedingt.

Warum geht das nicht? Also hier steht die Frage, wie beeinflusst der Write Buffer die

sogenannte Write Order? Erste Frage, wer weiß überhaupt was die Write Order ist?

Ja, das ist das, was man eigentlich so erwartet, wenn ich a schreibe und b schreibe,

dass dann erstmal a im Speicher landet und danach b. Man könnte es auch andersrum schreiben,

was im Prinzip wurscht ist, außer wenn a und b die gleiche Speicherzelle ist.

Okay, Memory mapped IOs ist noch eine andere Geschichte, aber natürlich auch noch ein guter

Hinweis. Und es macht genau dann einen Unterschied mit dieser Write Order, wenn neben den Write

natürlich auch noch Reads auftreten. Also wenn ich hinschreibe, was weiß ich,

Move 1 nach a, Move 2 nach b, Move a nach Register 1, dann habe ich was hingeschrieben

als Programmierer und ich erwarte eine gewisse Semantik. Was würdet ihr jetzt erwarten, steht

im Register 1. Wenn ich das a mit der 1 beschrieben habe und hinterher aus dem a was rauslese,

erwarte ich eigentlich, dass da eine 1 dran steht. Jetzt könnte natürlich auch das hier

noch ein a sein. Was würdet ihr jetzt erwarten? Jetzt würdet ihr erwarten, dass wohl eine 2 in

eurem Register hinterher drin steht. Aber, und das ist jetzt eben das Problem, wenn jetzt die

Hardware das hier irgendwie kunterbunt durcheinanderwirbelt, so nach dem Motto,

ach mache ich später, habe ich ja noch Zeit für. Und das war ja die Idee mit dem Write,

das machen wir, wenn wir mal Zeit haben, dann kann es uns passieren, dass irgendein Write auch,