Was wir uns letzte Woche angeguckt haben, war das Problem mit dem mit dem Häsersatz bei den Daten.

So von der Art wir wollen uns Daten aus dem Speicher laden als Beispiel und die hinterher

zusammen addieren. Dann müssen wir in der Zwischenzeit mal wie auch immer Däumchen drehen.

Wir haben uns angeguckt wir müssen Däumchen drehen. Wir wissen manchmal nicht so recht wie lange wir

Däumchen drehen müssen, was letztendlich einfach von unserer Pipeline abhängt. Wie lang die ist.

Wir haben schon gesehen wenn man entsprechend durch den Compiler Nops einfügt, das ist ja

doch irgendwie ein bisschen kontraproduktiv. Wir haben die Pipeline gebaut damit es schneller geht

und haben gesehen mit den ganzen Nops die wir da einbauen ist die ganze Performance eigentlich

nahezu wieder weg. Was könnte man tun? Das eine sogenanntes Interlocking heißt wenn wir

gerade nicht weiter wissen, also wir haben da oben angestoßen das laden von zwei Werten.

Jetzt geht es im Moment nicht. Wenn wir das erkennen, aber wenn wir das sagen wir mal

erkennen, dann könnten wir Nops in die Pipeline schieben. Das muss man ja nicht notwendigerweise

durch den Compiler machen lassen, das kann man im Prinzip auch die Hardware machen lassen. Wenn

die Hardware sieht mir fehlt noch ein Datum, dann schiebt die Hardware Nops rein. Ist das jetzt

besser als durch den Compiler? Oder schlechter? Das sind schon mal zwei gute Argumente.

Compiler nicht anfassen, das macht man einmal. Das ist schöner wenn man es nicht machen muss,

aber das ginge ja notfalls noch. Aber wichtig natürlich unabhängig jetzt wie lang die Pipeline

ist, dem Compiler ist das wurscht, dem Programmierer ist das wurscht, die Hardware regelt das schon.

Noch ein dritter Punkt. Das ist jetzt kein Vorteil, das steht auf der anderen Seite.

Das kostet natürlich Hardware irgendwie, müssen wir uns bauen. Schneller werden wir nicht,

ne. Also das steht weder auf der Positiv- noch auf der Negativliste, das genauso schnell wie

vorher. Aber wir haben noch einen großen Pluspunkt. Wir brauchen in unserem Programm nicht die

ganzen Nops reinzuschreiben, das soll heißen, sie stehen auch nicht im Speicher. Wir hatten

ja zwischenzeitlich zum Teil mehr Nops in unserem Programm als eigentlich Instruktionen. Das soll

heißen, wenn ich das Programm mit Hardware, mit den Nops erledige, dann schrumpelt das Programm

auf die Hälfte oder was zusammen. Ich brauche für mein Programm nicht ein Megabyte, ich brauche

ein halbes Megabyte Speicher oder so. Also insofern, wo du sagst, man braucht mehr Gatter,

man braucht zwar in der CPU mehr Gatter, dafür braucht man aber sehr viel weniger Speicher.

Jo, das wäre eine Lösung, die man machen kann. Die gucken wir uns später ein bisschen genauer

an. Und das zweite, das ist eigentlich das, was man heutzutage bevorzugt, das sogenannte

Forwarding. Das soll heißen, wenn man sich das in der Pipeline anguckt. Wir haben unseren

Fetch, wir haben unser Decode, wir haben unser Execute. Und jetzt kommt noch unsere Memorystage

und unser Writeback. Und unser Problem war ja, das wird erst von da reingeschrieben. Das soll

heißen, ein, zwei, drei Schritte. Eigentlich ist das Rechnergebnis ja schon an der Stelle

fertig. Das wird ja eigentlich nur noch da hinten so durchgeschoben. Manchmal braucht

die Memory Unit ja das als Input. Man könnte aber auch sagen, naja, man könnte das doch

hier so sich gleich wiederholen. Wenn ich rechne, in einem Schritt rechne ich, dann

habe ich das Ergebnis. Und wenn ich das Ergebnis für die nächste Rechnung brauche, dann könnte

ich mir das doch so hintenrum mal abzweigen. Das ist nicht so ganz einfach, das werden

wir uns noch angucken, wie das genau geht. Das wäre jedenfalls das sogenannte Forwarding.

Allerdings, das Forwarding geht nicht immer. Wir hatten gerade schon ein Beispiel gehabt,

nämlich hier dieses Beispiel mit dem Load. Bei dem Load, naja, da kommt das Ergebnis

da hinten raus. Aber das ist natürlich, wenn ich das mir jetzt als nächstes hole zum Rechnen,

das ist nicht im nächsten Takt da. Das ist erst einen Tag später da. Und wenn es einen

Tag später da ist, dann kann ich es nicht sofort verwenden. Das geht definitiv nicht,

das ist einfach noch nicht da, das Ergebnis. Das wäre dann eine Möglichkeit, dass man

sagt, naja, eigentlich mache ich immer ein Forwarding, wenn es irgendwie geht. Aber jetzt

in dem Fall, wenn es erst aus dem Speicher geholt wird, dann kann es noch nicht da sein,

per Definition. Und dann sage ich eben, naja, gut, dann bauen wir halt mal eine Blase ein.

So eine Boppe. Jo, wie im Einzelnen machen wir das Interlocking. Jo, die Pipeline soll