WEBVTT

00:06.860 --> 00:09.820
Ich bin Lars Bauer, hallo, willkommen, Rechnerorganisation heißt die

00:09.820 --> 00:11.960
Vorlesung, ich vertrete Tami Montanhänke.

00:13.440 --> 00:16.300
Ja, und wir machen direkt da weiter, wo wir letztes Mal aufgehört

00:16.300 --> 00:16.600
haben.

00:16.940 --> 00:19.880
Wir hatten angefangen, uns Pipelines anzuschauen, was ja an sich ein

00:19.880 --> 00:21.140
sehr schönes, spannendes Thema ist.

00:23.460 --> 00:26.840
Wir werden uns heute angucken, Pipeline-Konflikte, also Pipelines

00:26.840 --> 00:29.680
funktionieren nicht immer so schön, wie man sich das wünscht, dass in

00:29.680 --> 00:33.360
jedem Takt ein Befehl fertig wird, sondern es gibt da Abhängigkeiten,

00:33.540 --> 00:36.740
Probleme, Konflikte, die dazu führen, dass es angehalten werden muss.

00:36.780 --> 00:38.320
Oder vielleicht kann man die auch irgendwie anders lösen.

00:38.720 --> 00:42.000
Bevor wir uns das anschauen, noch mal kurz als Wiederholung, wie sah

00:42.000 --> 00:43.140
die Pipeline eigentlich aus?

00:43.180 --> 00:46.160
Das ist im Wesentlichen die Pipeline, wie wir sie letztes Mal gesehen

00:46.160 --> 00:46.480
haben.

00:48.080 --> 00:52.560
Wir haben einen Befehlsspeicher, es gibt einen Program-Counter, so ein

00:52.560 --> 00:55.980
dummes Wort, einen Befehlszeiger, der zeigt, welcher Befehl als

00:55.980 --> 00:57.180
nächstes ausgeführt werden soll.

00:57.600 --> 01:00.980
Der Befehl wird aus dem Speicher geladen, wird in die Pipeline-Stufe

01:00.980 --> 01:03.980
hier reingeholt und in der Dekodierstufe wird er auseinandergenommen,

01:03.980 --> 01:08.360
wird geschaut, welche Register müssen geladen werden, als Eingabe für

01:08.360 --> 01:10.320
die Operation, die ausgeführt werden soll.

01:11.140 --> 01:15.040
Wir gucken uns den Normalfall an, dann wird quasi nach dem Register

01:15.040 --> 01:18.540
-Satz, kommen die Daten aus dem Register raus, die also gerade geladen

01:18.540 --> 01:22.420
worden sind, kommen in die Ausführungsstufe, Execute-Stage.

01:22.900 --> 01:25.820
Da ist eine ALU, die macht irgendeine Operation, addieren, shiften,

01:25.980 --> 01:27.620
multiplizieren, logische Sachen.

01:29.120 --> 01:31.980
Das Ergebnis von der ALU bei einer normalen Rechenoperation geht in

01:31.980 --> 01:35.180
die Memory-Stufe, da wird nichts gemacht, es wird einfach beigepasst,

01:35.260 --> 01:36.300
also weitergeleitet.

01:36.900 --> 01:42.100
Und in der Write-Back-Stufe gehen die Rechnungsergebnisse zurück ins

01:42.100 --> 01:43.600
Register -File und werden geschrieben.

01:44.380 --> 01:48.180
Gleichzeitig haben wir noch die ganze Zeit das Zielregister, wohin

01:48.180 --> 01:51.980
geschrieben werden soll, in der Dekod-Stufe hier auch rausgezupft aus

01:51.980 --> 01:54.920
dem Befehlswort und einfach nur, ohne es zu bearbeiten, weitergeben,

01:55.000 --> 01:57.520
weitergeben, weitergeben und auch in der Write-Back-Stufe wieder

01:57.520 --> 02:00.140
zurück, damit wir wissen, wohin wir eigentlich schreiben müssen.

02:00.740 --> 02:04.020
Es gibt mehr als nur Arithmetik, man kann auch andere Sachen machen.

02:04.480 --> 02:09.580
Man kann auch Arithmetik mit Immediates, also nicht nur Register,

02:09.740 --> 02:14.140
sondern auch normale, im Assembler-Code hart codierte Daten.

02:14.560 --> 02:15.900
In dem Fall sind es 16-Bit-Werte.

02:16.360 --> 02:20.200
Die können hier Vorzeichen erweitert werden auf 32-Bit-Werte, also

02:20.200 --> 02:23.640
einfach vorne mit dem Most Significant Bit auffüllen, also dass sie

02:23.640 --> 02:26.140
negativ bleiben, wenn der 16-Bit-Wert negativ war und positiv, wenn

02:26.140 --> 02:27.260
der 16-Bit-Wert positiv war.

02:28.320 --> 02:29.960
Und die können auch in die ALU rein.

02:30.320 --> 02:31.160
Was gibt es sonst noch?

02:31.240 --> 02:33.720
Es gibt Ladespeicherbefehle auf den Hauptspeicher.

02:34.120 --> 02:36.260
Da ist es so, dass bei einem...

02:36.820 --> 02:38.000
Ja, fangen wir mal mit Schreiben an.

02:38.380 --> 02:41.640
Beim Schreiben haben wir einmal das Datum, wohin geschrieben werden

02:41.640 --> 02:41.940
soll.

02:42.160 --> 02:44.600
Das kommt hier direkt aus dem Register-File raus.

02:44.980 --> 02:47.380
Und das andere ist die Adresse, wohin geschrieben werden soll.

02:47.460 --> 02:48.980
Das Wohin, das wird berechnet.

02:49.420 --> 02:50.800
Das kommt aus der ALU hier raus.

02:51.420 --> 02:54.460
Und die ALU kann dann normalerweise berechnen, das andere Register,

02:55.360 --> 02:59.580
plus, minus, egal, den Wert, der von hier kommt.

02:59.660 --> 03:02.060
Und das ist halt genau dieses Sign Extended Immediate.

03:02.300 --> 03:05.040
Also ich kann sowas machen wie Basisadresse plus Offset.

03:05.360 --> 03:06.380
Da soll hingeschrieben werden.

03:06.860 --> 03:07.660
Ich kann auch laden.

03:07.820 --> 03:09.820
Laden ist für die Adressberechnung genau das gleiche.

03:10.100 --> 03:11.520
Und dann kommt am Ende hier das Ergebnis raus.

03:11.640 --> 03:15.320
Dann wird das Ergebnis am Ende hier auch wieder Writeback-mäßig ins

03:15.320 --> 03:16.280
Register -File reingeschrieben.

03:18.100 --> 03:20.600
Was jetzt noch fehlt, ist der obere Teil von der Pipeline.

03:20.600 --> 03:23.560
Das ist im Wesentlichen für den Kontrollfluss verantwortlich, sprich

03:23.560 --> 03:25.300
alle Formen von Sprüngen.

03:25.580 --> 03:29.280
Im Normalfall habe ich halt eben, hier steht der Befehl, der jetzt

03:29.280 --> 03:30.260
abzuarbeiten ist.

03:30.340 --> 03:31.920
Und Sie fragen, was ist der nächste Befehl?

03:32.200 --> 03:36.500
Im Normalfall ist der nächste Befehl einfach der jetzige plus 4.

03:36.940 --> 03:40.340
Und das plus 4 geht hier in einer interessanten Schleife wieder zurück

03:40.340 --> 03:41.320
in den Program Counter.

03:41.720 --> 03:43.640
Das heißt, es wäre sequentiell einfach immer der nächste Befehl.

03:43.740 --> 03:45.900
Es gibt aber auch Sprünge, bedingte Sprünge, unbedingte Sprünge.

03:46.340 --> 03:48.120
Da muss man das Sprungziel berechnen.

03:48.120 --> 03:51.040
Das Sprungziel berechnet wird von diesem Addierer.

03:51.520 --> 03:56.700
Der bekommt einmal den aktuellen Program Counter-Wert, plus 4, und

03:56.700 --> 03:57.920
springt um ein Immediate.

03:57.980 --> 03:59.700
Das Immediate ist das gleiche, was wir hier auch schon hatten.

04:00.100 --> 04:03.760
Also aus dem Befehlswort raus, 16-Bit-Wert, der auf 32 Bezeichnungen

04:03.760 --> 04:04.380
gesendet wurde.

04:05.020 --> 04:07.440
Und dann ist hier noch so ein Shift-Links-2.

04:07.640 --> 04:10.960
Das ist einfach, weil ich möchte angeben, wie viele Befehle ich

04:10.960 --> 04:12.400
springen möchte, nicht wie viele Bytes.

04:12.500 --> 04:14.100
Aber ein Befehl ist immer 4 Byte groß.

04:14.560 --> 04:16.600
Naja, ein Shift-2, das sind gerade die 4 Byte.

04:16.600 --> 04:18.480
Da kann ich dann sagen, 2 Befehle weiter.

04:19.160 --> 04:23.380
Und aus den 2 Befehlen muss dann ein 8-Byte gesprungen werden.

04:24.900 --> 04:26.720
Gut, das ist die normale Pipeline.

04:26.840 --> 04:28.100
Also das ist der Aufbau der Pipeline.

04:28.200 --> 04:31.700
Und der Ablauf ist halt eben so, dass pro Takt ein neuer Befehl

04:31.700 --> 04:33.040
reinkommt, wenn alles gut läuft.

04:33.320 --> 04:34.480
Wir sehen gleich, das klappt nicht immer.

04:35.620 --> 04:38.220
Und im nächsten Zyklus wird der Befehl einfach weitergeschoben.

04:38.320 --> 04:40.440
Er geht quasi in die nächste Pipeline-Stufe.

04:40.780 --> 04:42.080
Neuer Befehl kommt in die Fetch-Stufe.

04:42.420 --> 04:43.500
Und das geht dann so durch.

04:43.500 --> 04:44.940
Bis es irgendwann ganz hinten voll ist.

04:45.000 --> 04:46.480
Jetzt ist er mit 5 Befehlen gefüllt.

04:46.620 --> 04:49.660
Und im nächsten Zyklus wäre dann der nächste Befehl hier ein weiter.

04:50.060 --> 04:52.380
Und ich habe dann hier den sechsten Befehl von außen reingeholt.

04:52.900 --> 04:54.800
Okay, Wiederholung vom letzten Mal.

04:55.160 --> 04:56.300
So funktionieren Pipelines.

04:58.440 --> 05:00.240
Ja, wenn alles gut geht zumindest.

05:00.960 --> 05:04.060
Jetzt gibt es sogenannte Pipeline-Hemmnisse.

05:04.680 --> 05:07.320
Hemmnis ist, man kann das Wort schon erahnen, das ist nichts Gutes.

05:08.380 --> 05:12.060
Das hat irgendwie was damit zu tun, dass es so Probleme gibt, die man

05:12.060 --> 05:13.820
jetzt nicht so direkt auflösen kann.

05:14.120 --> 05:17.900
Jetzt gibt es potenzielle Probleme und es gibt Probleme, die wirklich

05:17.900 --> 05:19.000
eine Auswirkung haben.

05:20.640 --> 05:22.040
Die beiden Wörter muss man echt unterscheiden.

05:22.620 --> 05:26.320
Es gibt Abhängigkeiten, Hemmnisse, potenzielle Probleme.

05:26.580 --> 05:29.560
Und manche davon führen zu echten Konflikten.

05:29.920 --> 05:32.960
Und Konflikte heißt immer, da muss man jetzt entweder was tun.

05:33.100 --> 05:34.340
Ja, da muss man auf jeden Fall was tun.

05:34.460 --> 05:37.660
Und was tun kann heißen, ich spendiere extra Hardware, cleverere

05:37.660 --> 05:39.260
Software, um das irgendwie aufzulösen.

05:39.260 --> 05:41.520
Oder ich muss warten, weil es einfach nicht geht.

05:41.960 --> 05:43.780
Und da gibt es verschiedene Arten von solchen Hemmnissen

05:43.780 --> 05:44.560
-Abhängigkeiten.

05:45.040 --> 05:48.280
Im Wesentlichen Datenabhängigkeiten, Struktur- und

05:48.280 --> 05:49.340
Steuerflussabhängigkeiten.

05:49.460 --> 05:50.600
Und die gucken wir uns nacheinander an.

05:51.560 --> 05:52.540
Als Übersicht.

05:53.560 --> 05:55.740
Datenkonflikte, also das sind die, wo wirklich dann Probleme

05:55.740 --> 05:57.700
auftreten, die man bearbeiten muss.

05:58.280 --> 06:02.520
Die treten auf, wenn ein benötigter Operand noch nicht verfügbar ist.

06:02.800 --> 06:04.920
Benötigter Operand heißt, ich habe eine Operation, eine

06:04.920 --> 06:08.240
Rechenoperation und die Eingabedaten sind noch nicht verfügbar.

06:08.240 --> 06:09.540
Da kann ich nichts machen.

06:09.660 --> 06:11.380
Da muss ich warten, bis sie verfügbar werden.

06:11.900 --> 06:14.300
Ich kann versuchen, dass sie früher verfügbar werden.

06:14.500 --> 06:15.260
Das sehen wir gleich noch.

06:16.740 --> 06:19.980
Struktur-Ressourcenkonflikte heißt immer, ich habe eine Ressource, die

06:19.980 --> 06:23.180
kann eine gewisse Sache tun, aber bitte nur einmal pro Zeit.

06:23.600 --> 06:27.560
Und wenn die zweimal pro Zeit, pro Takt hier belästigt wird, dann kann

06:27.560 --> 06:28.760
die nicht bereits auf einmal erledigen.

06:28.840 --> 06:30.740
Das ist ein Konflikt, dann muss man erst das eine, dann das andere

06:30.740 --> 06:32.180
oder irgendwie muss man da drumrum.

06:33.980 --> 06:37.440
Steuerflusskonflikt ist im Wesentlichen immer bei Sprüngen, bei

06:37.440 --> 06:39.360
Verzweigungen des Kontrollflusses.

06:40.160 --> 06:42.820
Da ist einmal die Frage, wird die Verzweigung genommen?

06:43.120 --> 06:46.020
Bei bedingten Sprüngen weiß ich es noch gar nicht genau.

06:46.380 --> 06:49.000
Und das andere ist, wohin wird gesprungen?

06:49.120 --> 06:50.020
Wo geht es denn weiter?

06:50.140 --> 06:51.620
Muss ja erstmal ausgerechnet werden.

06:52.000 --> 06:54.240
Und bis das ausgerechnet ist, weiß ich nicht, wo ich weiterrechnen

06:54.240 --> 06:54.400
soll.

06:54.700 --> 06:55.840
Das sind die drei verschiedenen Arten.

06:56.140 --> 06:58.000
Und ich gucke mir jetzt einen nach dem anderen durch, fangen wir mit

06:58.000 --> 06:59.600
den Datenkonflikten an.

07:02.860 --> 07:06.320
Da gibt es Datenabhängigkeiten.

07:06.320 --> 07:09.480
Abhängigkeiten, nochmal gesagt, können zu Konflikten fühlen, müssen

07:09.480 --> 07:09.920
aber nicht.

07:10.060 --> 07:11.640
Also erstmal nur Abhängigkeiten.

07:12.120 --> 07:13.320
Es gibt drei verschiedene Arten.

07:13.800 --> 07:16.180
Das eine ist die echte Datenabhängigkeit.

07:16.440 --> 07:17.340
True Dependency.

07:19.400 --> 07:21.880
Das kann ich leider nicht schreiben hier drauf.

07:22.820 --> 07:27.320
Als Beispiel, wenn wir mal einfach zwei Befehle uns vorstellen, zwei

07:27.320 --> 07:28.420
Additionen, völlig egal.

07:29.420 --> 07:34.520
Und der erste Befehl schreibt nach Register 1, addiert irgendwas,

07:34.520 --> 07:37.880
schreibt es nach Register 1 und der zweite Befehl liest Register 1.

07:38.440 --> 07:39.520
Das ist eine echte Datenabhängigkeit.

07:40.400 --> 07:43.520
Der obere Befehl hat es gerade erst geschrieben, der nachfolgende will

07:43.520 --> 07:43.960
es lesen.

07:44.380 --> 07:44.860
Datenabhängigkeit.

07:45.220 --> 07:48.460
Der zweite kann nicht ausgeführt werden, bis der erste seine Daten

07:48.460 --> 07:49.200
herangeschafft hat.

07:51.600 --> 07:55.060
Das, naja, das kann man nicht gegenteils sagen, aber was anderes ist

07:55.060 --> 07:58.020
eine Gegenabhängigkeit, eine Anti-Dependency.

08:01.600 --> 08:04.500
Warum das Abhängigkeit heißt, sehen wir gleich noch, bzw.

08:04.500 --> 08:05.980
warum es nicht Abhängigkeit heißen sollte.

08:06.920 --> 08:09.480
Zumindest, ich habe auch wieder zwei Befehle und hier ist es gerade

08:09.480 --> 08:09.900
umgekehrt.

08:09.960 --> 08:12.460
Beim ersten, bei der echten Datenabhängigkeit war es so, der erste

08:12.460 --> 08:14.040
Befehl hat geschrieben, der zweite hat es gelesen.

08:14.380 --> 08:15.180
Hier ist es umgekehrt.

08:15.680 --> 08:20.180
Der erste liest ein Register 5, der zweite schreibt es.

08:20.860 --> 08:22.900
Ist erstmal nicht so das Problem.

08:23.200 --> 08:25.260
Also ist auch in unserer Pipeline kein Problem.

08:25.260 --> 08:28.180
Aber als Konzept gibt es das und in anderen Architekturen ist es ein

08:28.180 --> 08:28.420
Problem.

08:28.840 --> 08:33.900
Nochmal, erster Befehl liest Register 5, zweiter Befehl überschreibt

08:33.900 --> 08:34.840
Register 5.

08:35.100 --> 08:38.860
Damit ist schonmal vorgegeben, der zweite Befehl darf auf keinen Fall

08:38.860 --> 08:39.780
den ersten überholen.

08:39.840 --> 08:41.600
Die dürfen ihre Reihenfolge auf keinen Fall tauschen.

08:41.700 --> 08:43.700
So gesehen ist da eine Art von Abhängigkeit vorhanden.

08:44.060 --> 08:47.120
Wenn die ihre Reihenfolge tauschen würden, dann würde der zweite

08:47.120 --> 08:50.180
Befehl den Wert überschreiben, den der erste Befehl erst noch lesen

08:50.180 --> 08:50.400
wollte.

08:50.400 --> 08:53.980
Wenn ich eine etwas parallelere Architektur habe, entweder mehrere

08:53.980 --> 08:58.080
CPUs oder eine Pipeline, wo mehrere Ausführungseinheiten da sind, wo

08:58.080 --> 09:00.340
Befehle wirklich in einer anderen Reihenfolge ausgeführt werden

09:00.340 --> 09:03.640
können, wie sie im sequentiellen Befehlsstrom drin standen, dann kann

09:03.640 --> 09:04.720
sowas ein Problem sein.

09:04.980 --> 09:08.160
Bei der einfachen DLX-Pipeline, MIPS-Pipeline ist das kein Problem.

09:09.900 --> 09:13.320
Als letzte gibt es noch die Ausgabeabhängigkeit.

09:14.300 --> 09:18.560
Das ist einfach, wenn zwei aufeinanderfolgende Befehle in das gleiche

09:18.560 --> 09:19.700
Zielregister reinschreiben.

09:19.700 --> 09:22.420
Zwei Befehle schreiben in das gleiche Zielregister rein.

09:22.940 --> 09:25.660
Ist an sich erstmal auch kein Problem, aber es gibt zumindest mal

09:25.660 --> 09:30.740
einen potenziellen Konflikt, eine Abhängigkeit erstmal, weil einfach

09:30.740 --> 09:31.940
das gleiche Register benutzt wird.

09:32.180 --> 09:35.200
Da muss man auch gucken, bei DLX kann man gleich vorweg sagen, macht

09:35.200 --> 09:35.980
nichts, ist nicht schlimm.

09:36.380 --> 09:39.420
Aber es gibt auch wieder andere parallelere Architekturen, wo die

09:39.420 --> 09:43.240
Ausgabeabhängigkeit wichtiger wird, wo sie berücksichtigt werden muss.

09:43.300 --> 09:45.260
Deswegen als Konzept taucht sie hier auch mit auf.

09:46.580 --> 09:47.920
Wenn wir uns mal ein Beispiel anschauen.

09:50.500 --> 09:53.140
Mehrere Assemblerbefehle, die seien jetzt mal so sequenziell

09:53.140 --> 09:53.820
hingeschrieben.

09:54.280 --> 09:56.200
Gucken wir uns vielleicht nur die rechte Hälfte an, das ist irgendwie

09:56.200 --> 09:56.980
einfacher zu lesen.

09:57.320 --> 10:03.180
Da haben wir auf jeden Fall mal, hier wird R1 geschrieben und hier

10:03.180 --> 10:04.440
wird es direkt wieder gelesen.

10:04.920 --> 10:07.200
Das ist also eine richtige Datenabhängigkeit.

10:07.340 --> 10:10.480
Was auch immer hier als Ergebnis rauskommt, wird hier gleich wieder

10:10.480 --> 10:11.020
konsumiert.

10:11.340 --> 10:13.160
Das ist eine echte Datenabhängigkeit.

10:14.480 --> 10:15.020
Was gibt es noch?

10:15.020 --> 10:21.220
Hier wird ein Register gelesen, was hier überschrieben wird.

10:21.760 --> 10:25.120
Das war gerade die Gegenabhängigkeit, Anti-Dependency.

10:26.240 --> 10:29.320
Also ein Write-after-Read wird das nachher auch heißen.

10:30.100 --> 10:33.920
Und final noch, hier, die schreiben beide in das gleiche Register

10:33.920 --> 10:34.300
rein.

10:35.020 --> 10:36.460
Das ist eine Output-Dependency.

10:36.780 --> 10:39.260
Also haben wir hier ein Beispiel nochmal das Ganze aufgezeichnet.

10:39.800 --> 10:43.720
Wenn man das jetzt als Graph aufmalen möchte, was hier mal gemacht

10:43.720 --> 10:46.880
ist, in klein nochmal das gleiche Beispiel, kann man die

10:46.880 --> 10:49.140
Abhängigkeiten von den Befehlen so aufmalen.

10:49.480 --> 10:52.540
Da muss man je nach Architektur, die man hat, gucken, welche sind

10:52.540 --> 10:55.400
relevant für meine Architektur und wie kann ich die auflösen.

10:55.580 --> 10:58.300
Der Compiler kann da was machen, die Hardware kann da was machen.

10:59.200 --> 11:00.360
Ja, gibt es verschiedene Möglichkeiten.

11:03.520 --> 11:04.620
Zum Namen nochmal.

11:05.620 --> 11:06.100
Abhängigkeiten.

11:07.880 --> 11:11.160
Die Datenabhängigkeit, also die echte Datenabhängigkeit, ist der

11:11.160 --> 11:14.300
einzige Fall, wo wirklich der eine schreibt, der Nachfolger liest.

11:14.380 --> 11:17.260
Da fließen Daten vom Produzenten zum Konsumenten.

11:17.860 --> 11:21.120
Bei den anderen beiden, bei der Gegenabhängigkeit, da fließen keine

11:21.120 --> 11:21.440
Daten.

11:21.700 --> 11:23.940
Bei der Output-Abhängigkeit fließen auch keine Daten.

11:24.600 --> 11:26.540
Nochmal hier, Output-Abhängigkeit.

11:26.940 --> 11:31.320
Das Einzige, was die gemeinsam haben, ist, die schreiben ins Register

11:31.320 --> 11:32.420
mit dem gleichen Namen.

11:33.100 --> 11:35.200
Die Daten sind nicht interessant, das ist der gleiche Name.

11:35.200 --> 11:36.280
Genauso hier.

11:37.780 --> 11:40.140
Er liest und er überschreibt.

11:40.780 --> 11:42.400
Es ist kein Datenfluss zwischen den beiden.

11:42.500 --> 11:43.680
Die schreiben nur in den gleichen Namen.

11:43.980 --> 11:46.040
Deswegen heißt das Ganze auch Namensabhängigkeit.

11:46.200 --> 11:48.300
Das ist ein sinnvolleres Wort als Datenabhängigkeit.

11:49.180 --> 11:51.920
Und wird auch häufig in so parallelen Architekturen dadurch erledigt,

11:51.980 --> 11:53.960
dass es ein Register-Renaming gibt, was dann diese

11:53.960 --> 11:57.260
Namensabhängigkeiten einfach auflöst und damit die Probleme beseitigt.

11:58.140 --> 12:01.100
Wie gesagt, bei Deluxe-Pipeline braucht man das jetzt nicht.

12:03.860 --> 12:05.960
Okay, das waren die Abhängigkeiten.

12:07.140 --> 12:08.660
Welche davon führen zu Konflikten?

12:08.720 --> 12:11.740
Naja, es können genau die gleichen drei Können zu Konflikten führen,

12:11.880 --> 12:12.340
je nachdem.

12:13.000 --> 12:17.180
Es gibt Read-After-Write, Lese-Nach-Schreib-Konflikte bei

12:17.180 --> 12:21.520
entsprechender True-Dependency, Schreib-Nach-Lese bei entsprechender

12:21.520 --> 12:26.440
Anti -Dependency und Schreib-Nach-Schreib bei entsprechender Output

12:26.440 --> 12:27.080
-Dependency.

12:27.080 --> 12:30.740
Also es gibt für jede Abhängigkeit entsprechend eine Konfliktart, die

12:30.740 --> 12:31.540
dann auftreten kann.

12:32.660 --> 12:36.080
Ob so ein Konflikt auftritt, hängt wie gesagt ab von der Pipeline und

12:36.080 --> 12:37.420
wie nah die Befehlen nacheinander sind.

12:37.500 --> 12:39.700
Wenn ich zum Beispiel eine Datenabhängigkeit habe, eine True

12:39.700 --> 12:43.740
-Dependency, also hier Read-After-Write, der Konflikt tritt nur dann

12:43.740 --> 12:46.700
auf, wenn die beiden Befehle sehr nah beieinander stehen und deswegen

12:46.700 --> 12:47.700
die Daten noch nicht da sind.

12:48.120 --> 12:50.520
Wenn da 100 andere Befehle dazwischen sind, naja bis dahin wird die

12:50.520 --> 12:51.440
Berechnung ja wohl fertig sein.

12:51.540 --> 12:53.480
Dann habe ich zwar eine Abhängigkeit, aber keinen Konflikt.

12:58.290 --> 13:00.710
Ja, die letzten beiden.

13:01.070 --> 13:03.390
Können die, ich habe es schon vorweggenommen, können die überhaupt

13:03.390 --> 13:05.190
auftreten in der fünfstufigen Pipeline?

13:05.610 --> 13:06.990
Naja nein, sie können nicht auftreten.

13:07.610 --> 13:09.250
Warum können sie nicht auftreten?

13:10.130 --> 13:12.030
Pauschal, weil die Pipeline ziemlich einfach ist.

13:12.490 --> 13:18.810
Etwas konkreter liegt es daran, dass alle Befehle, egal welcher Art,

13:18.890 --> 13:21.870
gerade verschiedene Befehlsformate, Sprung, Ladespeicher, Arithmetik

13:21.870 --> 13:25.690
und so weiter, alle diese Befehle gehen immer durch alle fünf Stufen

13:25.690 --> 13:25.930
durch.

13:26.070 --> 13:28.970
Es gibt nicht welche, die machen nur die eine Hälfte der Stufe oder

13:28.970 --> 13:30.450
die Pipeline verzweigt sich irgendwo.

13:30.850 --> 13:33.490
Nein, nein, es gehen immer alle Befehle durch alle Stufen durch.

13:33.730 --> 13:34.970
Das ist sehr übersichtlich.

13:36.210 --> 13:40.410
Und die, die Register lesen, lesen sie immer in der gleichen Stufe.

13:40.730 --> 13:41.670
Immer in Stufe 2.

13:42.150 --> 13:45.830
Und die, die schreiben, schreiben immer in Stufe 5, also später.

13:45.830 --> 13:50.950
Und diese drei Bedingungen zusammen sorgen dafür, dass Output

13:50.950 --> 13:55.030
-Konflikte, also Write-after-Write nicht auftreten können und Write

13:55.030 --> 13:57.010
-after -Read auch nicht auftreten können.

13:57.710 --> 14:00.590
Wenn man das ein bisschen anders designt hätte, entweder weil man dumm

14:00.590 --> 14:03.510
war oder weil man mehr Parallelität einbauen wollte, häufig übrigens

14:03.510 --> 14:09.150
beides, dann können vor allem die Write-after-Read-Konflikte stärker

14:09.150 --> 14:10.350
werden, also häufiger auftreten.

14:12.770 --> 14:17.630
Ja, nochmal ein Beispiel für ein Read-after-Write.

14:19.210 --> 14:23.030
Hier haben wir jetzt zwei Ladebefehle, also jetzt Konflikt.

14:23.210 --> 14:25.270
Abhängigkeit ist auf jeden Fall vorhanden, jetzt haben wir auch einen

14:25.270 --> 14:25.690
Konflikt.

14:26.410 --> 14:29.710
Zwei Ladebefehle, beliebige Adresse, irgendwas, mir egal.

14:30.530 --> 14:33.870
Register 1, Register 2 werden mit Inhalt gefüllt und der addiert

14:33.870 --> 14:34.170
sofort.

14:34.850 --> 14:36.090
Also Abhängigkeit ist klar.

14:36.090 --> 14:39.950
Der Least-Register 1, der Least-Register 2, das ist auf jeden Fall mal

14:39.950 --> 14:43.170
eine True-Dependency vom ersten zum dritten und vom zweiten zum

14:43.170 --> 14:43.450
dritten.

14:43.970 --> 14:50.750
Es ist auch ein Konflikt, weil der erste Befehl wird sein Ergebnis

14:50.750 --> 14:53.910
erst in der Write-back-Stufe ins Register-File reinschreiben.

14:54.670 --> 14:57.650
Naja, und erst danach kann es aus dem Register-File wieder rausgelesen

14:57.650 --> 14:57.910
werden.

14:58.650 --> 15:00.950
Jetzt will aber dieser Befehl hier unglücklicherweise bereits in der

15:00.950 --> 15:04.470
Decode -Stufe die Ladeergebnisse haben.

15:04.470 --> 15:05.410
Er möchte sie lesen.

15:06.010 --> 15:09.310
Wenn er sie hier aus dem Register-File liest, wird er merken, dass er

15:09.310 --> 15:11.510
leider nicht die Daten bekommt, die ersten Takt später da

15:11.510 --> 15:12.350
reingeschrieben werden.

15:12.650 --> 15:15.290
Das heißt, hier ist die Abhängigkeit auch wirklich ein Konflikt.

15:15.610 --> 15:18.010
Da will man auf Daten zugreifen, die noch gar nicht vorhanden sind.

15:18.390 --> 15:19.510
Genauso für den zweiten Befehl.

15:20.630 --> 15:25.470
Da ist dieser zeitliche Versatz noch etwas stärker, weil der Befehl

15:25.470 --> 15:26.250
näher dran ist.

15:28.150 --> 15:29.210
Weiter genau hier.

15:29.890 --> 15:33.790
Der Multiplizierbefehl möchte R1 und R2 lesen.

15:33.830 --> 15:35.310
R2 wurde gerade erst geschrieben.

15:36.390 --> 15:42.030
Darum auch True Dependency von hier, die zu einem Konflikt wird, weil

15:42.030 --> 15:43.710
die Befehle zu nah beieinander stehen.

15:43.850 --> 15:47.130
Was in der Write-back-Stufe geschrieben werden soll, kann hier noch

15:47.130 --> 15:48.770
nicht in der Decode-Stufe gelesen werden.

15:49.070 --> 15:51.670
Das ist der Punkt, wo es zum Abhängigkeiten-Konflikt wird.

15:52.870 --> 15:55.650
Ja gut, es ist klar, die Konflikte muss man jetzt irgendwie behandeln.

15:56.070 --> 15:58.750
Derjenige, der den Assembler-Code hier hingeschrieben hat, der

15:58.750 --> 16:01.610
erwartet, dass der semantisch das tut, was da geschrieben ist.

16:01.930 --> 16:04.590
Dass das in Wirklichkeit von der Pipeline ausgeführt wird und dass da

16:04.590 --> 16:06.970
Abhängigkeiten, die zu Konflikten werden können, das interessiert den

16:06.970 --> 16:07.650
Programmierer doch nicht.

16:07.930 --> 16:10.350
Der will, dass das passiert, was da steht, also müssen die Konflikte

16:10.350 --> 16:11.750
irgendwie aufgelöst werden.

16:15.110 --> 16:19.750
Ja, hier nochmal verdeutlicht, wie er den alten Wert lesen würde.

16:19.970 --> 16:22.310
Die beiden abhängigen Befehle, gerade die gleichen von vorhin.

16:22.310 --> 16:25.590
Hier wird es geschrieben, er würde den alten Wert lesen, mit dem alten

16:25.590 --> 16:26.310
Wert weiterrechnen.

16:26.590 --> 16:27.230
Nicht gut.

16:29.730 --> 16:31.490
Wie kann man das Ganze jetzt auflösen?

16:32.290 --> 16:33.690
Ja, es gibt mehrere Lösungen.

16:33.810 --> 16:36.590
Es gibt sehr einfache, die dann auch meistens nicht so wahnsinnig

16:36.590 --> 16:37.230
performant sind.

16:37.650 --> 16:40.850
Und dann eben komplexere, die Hardware-Support brauchen, also

16:40.850 --> 16:43.930
irgendwie auch Fläche und Stromkosten, aber dafür auch Geschwindigkeit

16:43.930 --> 16:44.230
bringen.

16:45.970 --> 16:50.530
Compiler, beziehungsweise derjenige, der den Assembler-Code erzeugt,

16:50.650 --> 16:54.830
Compiler, Mensch, egal wer, könnte es ganz einfach machen, indem er

16:54.830 --> 16:58.690
hinreichend viele No-Operations dazwischen schreibt.

16:59.130 --> 17:02.950
Sprich bei dem Beispiel von hier, da müssen einfach genug andere

17:02.950 --> 17:06.670
Befehle, No-Ops dazwischen, dass der nach hinten geschoben wird.

17:06.670 --> 17:10.950
Damit kann man die Abhängigkeit, naja, die Abhängigkeit kann man nicht

17:10.950 --> 17:14.010
auflösen, man kann dafür sorgen, dass die Abhängigkeit kein Konflikt

17:14.010 --> 17:14.250
wird.

17:14.530 --> 17:20.570
Er ist natürlich nicht so clever, also No-Ops machen jetzt nicht so

17:20.570 --> 17:23.570
wahnsinnig viel sinnvolle Arbeit, also es kostet Performance.

17:24.390 --> 17:25.370
Was kann man noch machen?

17:25.670 --> 17:29.370
Das Allgemeinere ist Instruction Scheduling, also Pipeline Scheduling

17:29.370 --> 17:30.430
halte ich für ein seltsames Wort.

17:30.430 --> 17:34.410
Instruction Scheduling, Scheduling heißt irgendwas in eine zeitliche

17:34.410 --> 17:36.990
Reihenfolge bringen und irgendwas sind die Befehle.

17:37.310 --> 17:41.950
Also die Reihenfolge der Befehle so erzeugen, dass die Abhängigkeiten

17:41.950 --> 17:43.310
nicht zu Konflikten führen.

17:43.630 --> 17:50.850
Sprich genug andere Befehle dazwischen stopfen, dass halt eben die

17:50.850 --> 17:52.390
Abhängigkeiten aufgelöst werden.

17:53.610 --> 17:55.570
Das ist für gewöhnliche Sache, die die Compiler auch machen.

17:55.570 --> 17:58.270
Schauen wir uns nochmal an, wie das aussieht.

17:58.510 --> 17:59.710
Wir haben hier diese beiden Befehle.

18:00.390 --> 18:04.270
Wir haben die Abhängigkeit, er schreibt R2, er liest R2.

18:04.910 --> 18:08.510
Wenn man es einfach so hinschreiben würde, wäre der wünschenswerte

18:08.510 --> 18:10.510
Wert hier noch nicht verfügbar.

18:10.650 --> 18:12.870
Der alte falsche Wert würde gelesen werden.

18:13.310 --> 18:15.330
Rechenergebnis im folgenden Borus.

18:16.270 --> 18:19.670
Also könnte der Compiler sagen, wir verschieben den den Takt nach

18:19.670 --> 18:22.930
hinten, indem wir einen No-Operation dazwischen stopfen.

18:26.470 --> 18:29.350
Die Sachen sind sich schon mal näher gekommen, aber es hat noch nicht

18:29.350 --> 18:33.270
gereicht, um die Abhängigkeit nicht zu einem Konflikt werden zu

18:33.270 --> 18:33.510
lassen.

18:33.610 --> 18:35.870
Die Abhängigkeit ist immer da, aber sie wird hier immer noch ein

18:35.870 --> 18:36.310
Konflikt.

18:36.730 --> 18:40.110
Wenn wir eine weitere No-Operation dazwischen schieben, haben wir es

18:40.110 --> 18:40.470
geschafft.

18:41.490 --> 18:46.350
Jetzt ist es so, dass das Schreiben und das Lesen quasi gleichzeitig,

18:46.470 --> 18:48.770
also im gleichen Takt zumindest mal, passiert.

18:50.050 --> 18:55.490
Es gibt Architekturen, sagen wir lieber Register-Files, wo man das,

18:55.590 --> 18:58.430
was man am Anfang des Taktes reinschreibt, am Ende des Taktes gleich

18:58.430 --> 18:59.650
auch wieder auslesen kann.

19:00.130 --> 19:04.550
Wenn man so ein Register-File hat, dann können wir in dem Fall das von

19:04.550 --> 19:07.570
der Write-Back-Stufe Geschriebene hier unten gleich wieder lesen.

19:07.670 --> 19:10.870
Sprich, die Daten werden darüber kopiert und jetzt haben wir hier den

19:10.870 --> 19:12.150
neuen Wert und alles wird gut.

19:12.150 --> 19:15.650
Wenn wir ein Register-File haben, wo das nicht geht, sprich, wo man in

19:15.650 --> 19:18.490
dem Takt, in dem man schreibt, es noch nicht lesen kann, sondern erst

19:18.490 --> 19:21.650
im Takt danach, müssten wir eine dritte No-Operation reinschieben.

19:22.110 --> 19:25.010
Genauso, wenn ich eine längere Pipeline habe, 5 ist nicht lang,

19:26.290 --> 19:29.130
Pension 4 hätte 31 Pipeline-Stufen, sehr unangenehm.

19:30.510 --> 19:34.450
Dann muss man entsprechend mehr Lücken füllen oder andere sinnvolle

19:34.450 --> 19:35.110
Befehle nehmen.

19:35.110 --> 19:40.930
Oder eine Hardware-Alternative finden, die das Ganze erledigen kann

19:40.930 --> 19:42.890
ohne extra Befehle dazwischen.

19:44.430 --> 19:47.690
Vorher noch die etwas bessere Version vom Compiler, die der Compiler

19:47.690 --> 19:50.870
oder wer auch immer den Assembler-Code generiert, machen könnte.

19:52.330 --> 19:58.490
Hier mein Beispiel, wo hier oben zwei Befehle hingeschrieben sind, bei

19:58.490 --> 20:00.890
denen es eine Datenabhängigkeit gibt, eine True-Dependency.

20:00.890 --> 20:04.550
Hier wird R0 geschrieben, hier wird R0 wieder gelesen.

20:05.850 --> 20:07.330
Also hier klare Abhängigkeit.

20:08.410 --> 20:12.250
Und jetzt habe ich rein zufällig hier unten noch zwei Befehle, die

20:12.250 --> 20:14.190
benutzen R5, R6, R7, R8, R9, R10.

20:14.710 --> 20:18.430
Also komplett disjunkte Menge von R0, R1, R2, R3, R4.

20:19.410 --> 20:22.750
Und rein zufällig, weil die halt so unabhängig sind, kann man die

20:22.750 --> 20:25.970
jetzt einfach von der Reihenfolge quasi dazwischen schieben, hat

20:25.970 --> 20:31.010
sinnvolle Arbeit geleistet, hat aber trotzdem durch die zwei extra

20:31.010 --> 20:33.770
Takte, wenn ich das hier zwischenschieben würde, die zwei extra Takte,

20:33.870 --> 20:38.390
die das Ganze nach hinten geschoben ist, die Abhängigkeit so massiert,

20:38.770 --> 20:40.590
dass sie nicht mehr zu einem Konflikt führt.

20:40.710 --> 20:43.610
Also kein Bedarf mehr, in Hardware irgendwas zu tun.

20:44.890 --> 20:47.930
Naja, jetzt hat man halt nicht immer solche Befehle, die unabhängig

20:47.930 --> 20:49.330
sind, dazwischen geschoben werden können.

20:49.450 --> 20:51.390
Wenn, das ist the way to go.

20:51.810 --> 20:53.510
Ansonsten muss man gucken, wie man es sonst machen kann.

20:53.510 --> 20:55.290
NOP ausfüllen oder Hardware?

20:56.910 --> 20:58.630
Was kann die Hardware machen?

20:59.590 --> 21:04.950
Naja, das Erste ist fast genauso dumm wie das NOP einfüllen, nämlich

21:04.950 --> 21:10.030
wenn eine Abhängigkeit vorhanden ist, die zu einem Konflikt führen

21:10.030 --> 21:16.170
würde, dann muss man die Pipeline einfach so lange anhalten, bis die

21:16.170 --> 21:19.810
Abhängigkeit erzeugende, also der Schreiber, fertig ist.

21:19.810 --> 21:22.070
Bis der Schreiber es ins Register-File geschrieben hat.

21:22.590 --> 21:24.750
Danach lässt man den nächsten Befehl weiterlaufen.

21:25.150 --> 21:29.410
Der nächste Befehl darf gerne in die Fetch-Stufe rein, der darf gerne

21:29.410 --> 21:31.130
auch schon mal den Decode vorbeischnuppern.

21:31.350 --> 21:33.510
Man muss ja erkennen können, da ist eine Abhängigkeit, man muss also

21:33.510 --> 21:34.870
wissen, welchen Register liest der überhaupt.

21:35.770 --> 21:36.730
Danach wird er angehalten.

21:36.890 --> 21:40.310
Und zwar so lange angehalten, bis der vorherige Befehl wirklich sein

21:40.310 --> 21:42.870
Ergebnis in die Writeback-Stufe, in seiner Writeback-Stufe ins

21:42.870 --> 21:44.010
Register -File geschrieben hat.

21:44.330 --> 21:46.290
Und dann lässt man den nächsten Befehl weiterlaufen.

21:46.290 --> 21:52.350
Ist genauso klug oder schlecht, wie No Operations einzuführen, von der

21:52.350 --> 21:53.330
Geschwindigkeit her.

21:54.010 --> 21:54.970
Der Trade-Off liegt woanders.

21:56.250 --> 21:59.510
Ich habe etwas mehr Hardware-Overhead, weil ich muss in Hardware

21:59.510 --> 22:01.190
erkennen, dass eine Abhängigkeit da ist.

22:01.290 --> 22:03.130
Es ist nicht so viel, aber man muss es machen.

22:04.450 --> 22:07.370
Und ich muss eine Steuerlogik haben, mit der ich die Pipeline anhalten

22:07.370 --> 22:07.650
kann.

22:07.870 --> 22:10.210
Also ist auch nicht viel, aber ein bisschen Hardware-Overhead.

22:10.710 --> 22:13.270
Dafür habe ich aber eine bessere Code-Density.

22:13.270 --> 22:17.770
Sprich, ich brauche weniger Assembler-Befehle, um das Ganze zum

22:17.770 --> 22:18.410
Ausführen zu bringen.

22:18.530 --> 22:22.090
Und weniger Assembler-Befehle, kleineres Programm ist gut, wenn man

22:22.090 --> 22:24.750
wenig Speicher hat oder teuren Speicher, Flash.

22:25.870 --> 22:29.850
Und ist auch gut für Befehls-Caches, die vielleicht noch irgendwann

22:29.850 --> 22:30.310
mal dran kommen.

22:31.770 --> 22:36.190
Sprich, die können dann besser arbeiten, weil sie nur die sinnvollen

22:36.190 --> 22:37.030
Befehle haben müssen.

22:40.030 --> 22:44.070
Interessantere Techniken sind Data-Forwarding, das schauen wir uns an.

22:44.510 --> 22:47.190
Und das klappt nicht immer und deswegen muss man eine Kombination

22:47.190 --> 22:49.330
machen, Data-Forwarding mit Interlocking.

22:51.750 --> 22:54.450
Das wäre erstmal das, was ich gerade gesagt habe, das normale

22:54.450 --> 22:54.950
Anhalten.

22:55.490 --> 22:58.670
Ich habe oben den ersten Befehl, unten den zweiten, der im Idealfall

22:58.670 --> 22:59.970
eine True-Dependency hat.

23:00.650 --> 23:04.970
Schauen wir mal, hier wird Register 2 geschrieben, er liest Register 2

23:04.970 --> 23:05.310
wieder.

23:05.310 --> 23:09.430
Ja, er muss erkennen, da ist eine Abhängigkeit.

23:09.970 --> 23:12.710
Sie muss erkennen, die Abhängigkeit ist so nah beieinander, dass sie

23:12.710 --> 23:15.650
zu einem Konflikt werden würde, wenn man nicht reagiert.

23:16.230 --> 23:18.530
Und dann muss sie reagieren und die Pipeline anhalten.

23:18.830 --> 23:22.550
Und anhalten heißt im Wesentlichen, es wird Bubbles genannt, also wie

23:22.550 --> 23:23.230
Blasen.

23:23.350 --> 23:25.590
Irgendwas steht immer in der Pipeline drin, das sind Register, die

23:25.590 --> 23:27.170
haben 1 und 0, die können nichts anderes haben.

23:27.290 --> 23:32.170
Also irgendwas ist da und es hat dazu das Fleck, mach's nicht, ich bin

23:32.170 --> 23:34.370
nur ein Bubble, ignoriere mich, nicht ausführen.

23:34.370 --> 23:38.910
Also quasi wie ein Know-op, was von der Hardware eingeführt wird

23:38.910 --> 23:39.170
sozusagen.

23:39.270 --> 23:43.290
Die Pipeline hält an, der Befehl hier oben läuft natürlich weiter, der

23:43.290 --> 23:45.610
kann die Pipeline nach hinten raus weiter verlassen.

23:45.970 --> 23:49.030
Dazwischen macht sich diese Lücke auf, bis der zweite Befehl, der

23:49.030 --> 23:51.250
datenabhängige, das Go bekommt.

23:51.430 --> 23:54.030
Jetzt sind die Daten da, kannst es im Register verlesen und dann

23:54.030 --> 23:54.870
rechnen.

23:56.250 --> 23:59.230
Also das ist die einfache Version der Hardware-Implementierung.

24:00.650 --> 24:01.810
Forwarding ist besser.

24:02.310 --> 24:04.110
Forwarding kostet aber auch echt mehr Fläche.

24:05.350 --> 24:11.370
Die Idee von Forwarding ist, warum soll ich eigentlich warten, bis der

24:11.370 --> 24:15.830
erste Befehl, der irgendwas schreibt, bis der in der Writeback-Stufe

24:15.830 --> 24:16.690
angekommen ist.

24:17.170 --> 24:21.430
Das Berechnungsergebnis steht am Ende der Execute-Stufe fest, es ist

24:21.430 --> 24:21.870
bekannt.

24:21.870 --> 24:24.890
Nachdem die Execute-Stufe die Addition, was auch immer es gerade war,

24:25.310 --> 24:28.790
gemacht hat, ist das Ergebnis bekannt.

24:29.430 --> 24:33.490
Und es ist ja eigentlich nur dem Konzept der Pipeline geschuldet, dass

24:33.490 --> 24:36.570
ich jetzt noch bis zur Writeback-Stufe warten muss, bis es wirklich

24:36.570 --> 24:38.090
ins Register-File geschrieben wird.

24:38.670 --> 24:39.830
Aber die Daten sind ja da.

24:40.270 --> 24:42.790
Die Daten kann man doch direkt benutzen eigentlich.

24:42.790 --> 24:45.710
Deswegen gibt es hier einen Bypass.

24:47.290 --> 24:50.570
Hier ist die ALU, bekommt ihren Input aus dem Register-File, macht die

24:50.570 --> 24:51.450
Addition von gerade.

24:52.230 --> 24:54.820
Die ALU schreibt ihr Ergebnis, wie immer, ins Ausgaberegister.

24:55.410 --> 24:59.710
Das Ausgaberegister ist das Pipeline-Register, was zwischen Execute-

24:59.710 --> 25:01.490
und Memory-Stage platziert ist.

25:02.490 --> 25:06.630
Am Ende des Ausgaberegisters gibt es den Bypass, der das Ergebnis

25:06.630 --> 25:11.090
direkt nehmen kann und wieder hochführen kann als Input in die ALU.

25:11.950 --> 25:15.510
Und damit ist es zumindest erstmal möglich, also rein datenfahrtmäßig

25:15.510 --> 25:19.050
möglich, dass man das Ergebnis von der ALU direkt im nächsten Takt

25:19.050 --> 25:19.910
wieder benutzen kann.

25:21.410 --> 25:25.450
Das andere ist, das ist gut, wenn zwei Befehle direkt nacheinander

25:25.450 --> 25:27.070
stehen und eine True Dependency haben.

25:27.850 --> 25:31.570
Wenn dazwischen ein anderer Befehl ist, dann muss man noch was anderes

25:31.570 --> 25:31.910
machen.

25:31.910 --> 25:36.290
Wenn quasi der schreibende Befehl, ein Mir-doch-egal-Befehl und dann

25:36.290 --> 25:37.270
der lesende Befehl.

25:37.690 --> 25:42.630
Dann sind die Berechnungsergebnisse von dem schreibenden Befehl erst

25:42.630 --> 25:47.810
in der ALU-Stufe, wandern danach weiter in die Memory-Stufe, während

25:47.810 --> 25:50.890
der Mir-doch-egal-Befehl in die ALU-Stufe kommt.

25:51.330 --> 25:52.750
Und jetzt kommt der Abhängige.

25:53.030 --> 25:56.790
Das heißt, ich brauche einen weiteren Bypass, der am Ende der Memory

25:56.790 --> 26:00.690
-Stufe die Daten zurückführen kann an den Input der ALU.

26:00.690 --> 26:02.830
Das ist hier der rote, der eingemalt ist.

26:03.330 --> 26:06.290
Das heißt, der kommt von der Memory-Stufe, danach wäre das

26:06.290 --> 26:09.010
Ausgaberegister von der Memory-Stufe und von diesem Ausgaberegister

26:09.010 --> 26:12.510
geht es wieder hoch an den Input der ALU.

26:14.450 --> 26:17.250
Also zum einen muss man jetzt für die Hardware hier sagen, ich kann

26:17.250 --> 26:21.470
natürlich nicht einfach hier so Busse zusammentüddeln und hoffen, dass

26:21.470 --> 26:21.970
das gut geht.

26:22.050 --> 26:22.810
Das ist ein Kurzschluss.

26:23.350 --> 26:24.430
Also potenzieller zumindest.

26:25.310 --> 26:29.510
Da ist natürlich implizit ein Multiplexer von nöten, sprich ein Ding,

26:29.730 --> 26:31.930
was einen der Inputs durchlässt.

26:32.170 --> 26:36.990
Ich habe einen Input entweder direkt vom Register-File kommend oder

26:36.990 --> 26:42.870
vom Bypass-Netzwerk nach der Execute-Stufe oder vom Bypass-Netzwerk

26:42.870 --> 26:44.310
nach der Memory-Stufe.

26:44.750 --> 26:46.750
Danach brauche ich keine mehr, weil danach ist es in Writeback und

26:46.750 --> 26:48.390
wird sowieso ins Register-File geschrieben, dann kann ich es auch da

26:48.390 --> 26:49.190
gleich wieder rauslesen.

26:49.970 --> 26:52.550
Okay, also ich habe hier den Multiplexer, der genau einen davon

26:52.550 --> 26:55.510
durchlässt und dann brauche ich auch entsprechend die Steuerlogik, die

26:55.510 --> 27:01.590
erkennt, ist überhaupt der Fall da, dass eine Abhängigkeit vorliegt

27:01.590 --> 27:06.010
und dementsprechend, welcher von diesen drei Datenmöglichkeiten soll

27:06.010 --> 27:07.190
eigentlich genutzt werden.

27:07.570 --> 27:11.090
Das heißt, da muss ein Steuerblock sein, der sich die ganzen Befehle

27:11.090 --> 27:16.110
anschaut, der sich merkt, der aktuelle Wert von Register 5 ist gerade

27:16.110 --> 27:16.430
wo.

27:16.970 --> 27:19.730
Der aktuelle Wert von Register 5 ist normalerweise im Register-File,

27:20.170 --> 27:22.310
es sei denn, es kommt ein Befehl, der Register 5 schreibt.

27:22.310 --> 27:25.950
Und dann muss man gucken, ist das Schreiben schon fertig, sprich

27:25.950 --> 27:27.290
Execute -Stufe schon durch.

27:27.570 --> 27:30.470
Dann muss man wissen, der aktuelle Wert von Register 5 ist jetzt nicht

27:30.470 --> 27:33.590
mehr im Register-File und auch noch nicht wieder im Register-File,

27:33.910 --> 27:35.830
sondern er ist am Ausgang der Execute-Stufe.

27:36.330 --> 27:39.170
Einen Takt später ist er am Ausgang von der Memory-Stufe und noch

27:39.170 --> 27:41.150
einen Takt später ist er wieder im Register-File.

27:41.550 --> 27:42.130
Alles wieder gut.

27:42.970 --> 27:45.810
Und wenn man dieses Wissen hat, für jedes Register, kann man

27:45.810 --> 27:49.130
entscheiden, welcher von diesen Werten durchgelassen werden soll an

27:49.130 --> 27:49.870
den Input der ALU.

27:51.410 --> 27:54.010
Multiplexer sind ärgerlich, die kosten erstaunlich viel Fläche.

27:54.510 --> 27:58.570
Das heißt, die Steuerlogik ist lästig vom Denken, aber die Multiplexer

27:58.570 --> 27:59.710
sind lästig von der Fläche.

28:01.390 --> 28:02.950
Zusätzlich gibt es hier noch weitere Multiplexer.

28:03.070 --> 28:05.370
Es gab ja noch die Immediate-Werte, die durchgelassen werden.

28:05.450 --> 28:06.710
Da musste ja auch gemultiplexed werden.

28:06.770 --> 28:09.510
Das wird also in der Summe Stück für Stück langsam größer, die ganze

28:09.510 --> 28:09.930
Geschichte.

28:10.270 --> 28:12.370
Hat so einfach angefangen, aber es wird immer ärgerlicher.

28:13.750 --> 28:16.630
Gut, also erhöhte Hardware und Steuerungsaufwand.

28:16.630 --> 28:22.070
Aber kein Bedarf mehr, die Pipeline in irgendeiner Form anzuhalten,

28:22.470 --> 28:26.530
wenn ich True Dependencies habe zwischen Rechenoperationen.

28:27.150 --> 28:29.610
Jetzt musste ich leider dieses Rechenoperationen noch sagen, weil es

28:29.610 --> 28:30.410
klappt halt nicht immer.

28:30.990 --> 28:33.570
Also für Rechenoperationen klappt es immer, für andere Operationen

28:33.570 --> 28:34.010
leider nicht.

28:34.750 --> 28:35.910
Bildlich nochmal dargestellt.

28:36.010 --> 28:40.230
Ich habe auf einer zeitlichen Achse die Pipeline für zwei Befehle

28:40.230 --> 28:44.770
hingemalt und vom Ausgang der ALU des ersten Befehls geht es direkt an

28:44.770 --> 28:46.710
den Input der ALU des nächsten Befehls.

28:47.230 --> 28:49.770
Potenziell an beide Inputs und hier war es offenbar der obere, der die

28:49.770 --> 28:50.570
Daten gebraucht hat.

28:58.260 --> 29:00.500
Hier klappt das eigentlich auch ganz gut.

29:02.780 --> 29:05.940
Interlocking hatten wir schon gesehen, Interlocking war einfach nur

29:05.940 --> 29:08.560
das Anhalten der Pipeline und das brauchen wir jetzt nochmal.

29:09.760 --> 29:12.300
Interlocking war das Anhalten der Pipeline durch die Hardware.

29:13.000 --> 29:14.220
Wofür brauchen wir das?

29:18.800 --> 29:22.340
Wenn das die Version von Interlocking war, sprich mit Pause, dann

29:22.340 --> 29:24.400
können wir jetzt halt eben auch nochmal eine andere Darstellung von

29:24.400 --> 29:25.280
dem Gleichen eigentlich.

29:25.760 --> 29:29.240
Vom Ausgang der Execute Stage direkt an den Input der Execute Stage.

29:29.440 --> 29:31.580
Diese Schreibweise kommt gleich noch, deswegen war das Bild nochmal

29:31.580 --> 29:32.080
zwischendurch.

29:35.420 --> 29:38.140
Jetzt habe ich Arithmetikbefehle gesagt, weil mit leider

29:38.140 --> 29:39.480
Speicherbefehlen klappt es nicht so schön.

29:39.480 --> 29:42.860
Meine Speicherbefehle geschenkt, die modifizieren das Registerpfeil

29:42.860 --> 29:46.100
nicht, da ist nichts, was eine Datenabhängigkeit erzeugen könnte, denn

29:46.100 --> 29:47.120
sie schreiben nichts ins Registerpfeil.

29:47.180 --> 29:48.120
Also Ladebefehle.

29:49.460 --> 29:51.140
Ladebefehle sehen ja wie folgt aus.

29:52.880 --> 29:59.280
Die Execute Stufe hat nicht am Ende das Ergebnis der Berechnung, das

29:59.280 --> 30:03.300
ist ja keine Berechnung, sondern das Ergebnis der Adressberechnung und

30:03.300 --> 30:08.980
erst nach der Memory Stufe weiß ich, was wirklich geladen worden ist.

30:08.980 --> 30:13.280
Also das Wissen, was die Daten sind, die der Datenabhängige, der ist

30:13.280 --> 30:16.540
jetzt im Idealfall datenabhängig, was der Datenabhängige hier als

30:16.540 --> 30:19.280
Input braucht, habe ich jetzt erst einen Takt später zur Verfügung.

30:19.680 --> 30:22.600
Bei normalen Arithmetikbefehlen weiß ich am Ende der Execute Stufe,

30:22.800 --> 30:26.140
was das Ergebnis ist, bei Ladebefehlen weiß ich erst am Ende der

30:26.140 --> 30:29.100
Memory Stufe, was das Ergebnis wirklich ist, mit dem der nächste

30:29.100 --> 30:30.220
Befehl weiterrechnen soll.

30:31.520 --> 30:32.500
Naja, das ist ein Problem.

30:34.760 --> 30:38.480
Egal wie ich mich winde, es passt nicht.

30:38.480 --> 30:44.480
Ich kann nicht vom Ende der Memory Stufe direkt im Befehl danach an

30:44.480 --> 30:48.460
den Eingang der Execute Stufe, weil das ist zeitlich schon vorbei.

30:49.140 --> 30:52.920
Der Anfang der Execute Stufe, das ist schon passiert, bevor die

30:52.920 --> 30:53.700
Ergebnisse da sind.

30:53.800 --> 30:57.180
Also hier habe ich mit Data Forwarding keine Chance, geht nicht.

30:57.300 --> 30:59.580
Konzeptuell, durch den Aufbau der Pipeline, geht nicht.

31:01.140 --> 31:04.120
Wenn man jetzt Execute Memory irgendwie parallel gemacht hätte, würde

31:04.120 --> 31:04.580
das gehen.

31:04.720 --> 31:06.640
Aber dann müsste man wieder sagen, wer berechnet die Adresse?

31:06.640 --> 31:10.040
Also es gibt da beliebig viele Sachen, wie man Pipelines basteln kann.

31:10.600 --> 31:12.340
In dieser hier funktioniert das auf jeden Fall mal nicht.

31:12.780 --> 31:17.880
Das heißt, wir müssen einen Kompromiss aus beidem machen, aus beidem

31:17.880 --> 31:19.660
Forwarding und Interlocking.

31:20.040 --> 31:23.840
Wir können immer noch forwarden, nämlich vom Ausgang der Memory Stufe

31:23.840 --> 31:25.540
an den Eingang der Execute Stufe.

31:25.660 --> 31:28.320
Das ist das gleiche Forwarding-Netzwerk, wie wir es vorhin benutzt

31:28.320 --> 31:28.540
haben.

31:28.840 --> 31:33.660
Aber zusätzlich bei Ladebefehlen müssen wir Interlocking einen Takt

31:33.660 --> 31:37.440
anhalten oder vom Compiler halt eben einen anderen sinnvollen oder

31:37.440 --> 31:39.520
unsinnigen Befehl der Zwischenschedule.

31:40.280 --> 31:43.540
Also die Kombination aus beidem ist notwendig.

31:43.640 --> 31:46.980
Das heißt, Interlocking muss man, wenn man den Compiler oder den

31:46.980 --> 31:49.100
Menschen der Assembler-Code nicht traut, muss man auf jeden Fall

31:49.100 --> 31:50.720
Interlocking in Hardware implementieren.

31:51.280 --> 31:53.680
Und je besser der Compiler oder der Mensch es macht, desto weniger

31:53.680 --> 31:54.320
braucht man es.

31:54.800 --> 31:57.840
Aber wenn halt eben solche Sequenzen wie Load und Add direkt

31:57.840 --> 32:00.660
nacheinander vorkommen, braucht die Hardware Interlocking, geht nicht

32:00.660 --> 32:00.980
anders.

32:00.980 --> 32:04.120
Und zusätzlich kann man Data Forwarding einbauen.

32:04.560 --> 32:09.680
Das bringt einiges an Geschwindigkeit, wenn sehr datenabhängige Code

32:09.680 --> 32:10.920
-Sequenzen auszuführen sind.

32:11.980 --> 32:15.000
Deswegen wird es auch in eigentlich jeder modernen Pipeline gemacht.

32:30.620 --> 32:36.560
Also, als Wiederholung, das waren die Datenkonflikte.

32:37.480 --> 32:40.360
Datenabhängigkeiten, die durch zeitlich zu nah aufeinanderfolgende

32:40.360 --> 32:43.640
Befehle zu Konflikten werden, es sei denn, der Assembler-Programmierer

32:43.640 --> 32:48.420
oder Compiler oder die Hardware oder eine Kombination tut was dagegen.

32:49.320 --> 32:51.280
Jetzt gibt es noch andere Konflikte.

32:51.440 --> 32:53.200
Wir hatten die Folie vorhin schon gesehen.

32:53.640 --> 32:55.980
Struktur-Ressourcen-Konflikte, Steuerfluss-Konflikte.

32:56.400 --> 32:59.200
Schauen wir uns zuerst Struktur-Ressourcen-Konflikte an und danach die

32:59.200 --> 33:00.860
Steuerfluss -Konflikte.

33:02.960 --> 33:08.120
Ressourcen-Konflikt heißt, ich habe eine Ressource und ich will sie

33:08.120 --> 33:10.140
mehr benutzen, als sie kann.

33:10.960 --> 33:15.460
Ich habe einen Addierer und ich will mit dem Addierer zwei Additionen

33:15.460 --> 33:16.700
im gleichen Takt machen.

33:16.700 --> 33:17.820
Das geht nicht.

33:18.340 --> 33:20.760
Der Addierer macht eine Addition pro Zeit.

33:21.340 --> 33:23.640
Wenn ich zwei Additionen machen will, brauche ich zwei Addierer.

33:24.100 --> 33:28.800
Also weil auch immer eine Ressource überbelastet ist, also zweimal

33:28.800 --> 33:31.920
gleichzeitig zugegriffen wird, obwohl sie nur einen Zugriff zulässt.

33:32.200 --> 33:33.540
Das ist ein Ressourcen-Konflikt.

33:35.260 --> 33:39.320
Die DLX-Pipeline ist so gebaut, dass es genau null Ressourcen

33:39.320 --> 33:40.300
-Konflikte geben kann.

33:40.440 --> 33:42.100
Was nett ist, dann muss man nicht drüber nachdenken.

33:43.340 --> 33:46.320
Wir machen es aber trotzdem, wenn es andere Pipelines gibt, nicht,

33:46.420 --> 33:48.920
dass die dümmer sind, sondern die sind komplexer und dann lässt sich

33:48.920 --> 33:50.020
es manchmal nicht mehr vermeiden.

33:50.380 --> 33:53.820
Deswegen einfach mal als Beispiel eine andere Pipeline, in dem Fall

33:53.820 --> 33:57.840
eine dümmere, um zu zeigen, wie ein Ressourcen-Konflikt überhaupt

33:57.840 --> 33:58.600
aussehen könnte.

34:00.400 --> 34:03.320
Stellen wir uns vor, wir hätten eine veränderte DLX-Pipeline.

34:03.960 --> 34:09.340
Stellen wir uns vor, ich habe einen Arithmetik-Befehl und wie gesagt,

34:09.340 --> 34:11.420
nach der Execute-Stufe weiß ich das Ergebnis.

34:12.100 --> 34:14.740
Was macht denn der Arithmetik-Befehl eigentlich in der Memory-Stufe?

34:15.240 --> 34:15.880
Er macht nichts.

34:16.060 --> 34:17.540
Er macht genau gar nichts.

34:17.640 --> 34:18.520
Er ist langweilig.

34:19.180 --> 34:21.820
Um danach in der Writeback-Stufe geschrieben zu werden.

34:22.180 --> 34:25.040
Also wäre es doch nicht schlecht, wenn man diesen Arithmetik-Befehl

34:25.040 --> 34:28.520
erlauben würde, direkt in der Memory-Stufe ins Register-File zu

34:28.520 --> 34:28.840
schreiben.

34:29.260 --> 34:31.960
Hat man einen Takt früher geschrieben, hat man weniger

34:31.960 --> 34:34.460
Datenabhängigkeiten, die zu Konflikten werden.

34:34.540 --> 34:35.980
Also an sich eine gute Idee.

34:37.920 --> 34:42.280
Zum Beispiel hier, ein Additionsbefehl, der schreibt Register 3 und

34:42.280 --> 34:45.600
wir erlauben dem schon, in der Memory-Stufe ins Register-File

34:45.600 --> 34:46.380
reinzuschreiben.

34:47.340 --> 34:48.080
Tolle Sache.

34:48.620 --> 34:53.220
Es sei denn, wir hätten zum Beispiel davor, direkt davor, einen

34:53.220 --> 34:58.540
anderen Befehl, der ein beliebiges anderes Register, könnte das

34:58.540 --> 35:00.140
gleiche sein, kann ein anderes sein, völlig schnuppe.

35:00.240 --> 35:02.880
Aber er lädt einen Wert in einen Register.

35:02.880 --> 35:07.800
Naja, der kann offensichtlich nicht in der Memory-Stufe den Wert

35:07.800 --> 35:08.160
schreiben.

35:08.360 --> 35:11.000
Der muss ja in der Memory-Stufe erstmal die Daten ranladen aus dem

35:11.000 --> 35:11.340
Speicher.

35:12.220 --> 35:15.240
Der muss also weiterhin in der Writeback-Stufe den Wert ins Register

35:15.240 --> 35:15.820
-File schreiben.

35:16.380 --> 35:21.020
Und wenn diese beiden nacheinander ausführenden Befehle so angeordnet

35:21.020 --> 35:23.460
sind in der Pipeline, haben wir jetzt das Problem, dass in der

35:23.460 --> 35:26.720
Writeback -Stufe der Load-Befehl gerne ins Register-File reinschreiben

35:26.720 --> 35:31.420
möchte und der Additionsbefehl in der Memory-Stufe schreiben möchte

35:31.420 --> 35:35.540
und durch dieses Pipelining versetzen, ist jetzt beides gleichzeitig

35:35.540 --> 35:36.360
im gleichen Takt.

35:37.100 --> 35:38.800
Das hat man immer, so ein Problem hat man immer, wenn man aus

35:38.800 --> 35:41.780
verschiedenen Stufen die gleiche Ressource benutzt.

35:41.920 --> 35:45.840
Dann wird früher oder später so ein Effekt passieren, dass es durch

35:45.840 --> 35:49.740
eine geschickte, ungeschickte Anordnung von Befehlen dazu kommt, dass

35:49.740 --> 35:52.900
die kollidieren, also wirklich physikalisch kollidieren.

35:53.680 --> 35:56.480
Das Register-File ist jetzt ein bisschen unglücklich, es kann jetzt

35:56.480 --> 35:57.640
nicht beides schreiben.

35:57.640 --> 36:00.620
Ich habe ein normales Register-File mit einem Schreibport, es kann

36:00.620 --> 36:02.860
nicht beides schreiben, also das lässt sich nicht auflösen.

36:03.740 --> 36:06.040
Wie gesagt, das ist im Wesentlichen der Grund, warum man

36:06.040 --> 36:09.760
Arithmetikbefehle halt eben nicht erlaubt in der Memory-Stufe zu

36:09.760 --> 36:12.920
schreiben, sondern deswegen Arithmetikbefehle einen Takt später in der

36:12.920 --> 36:13.860
Writeback -Stufe schreiben.

36:14.000 --> 36:17.280
Das ist der einzige Grund, um so ein Problem gar nicht erst aufkommen

36:17.280 --> 36:17.660
zu lassen.

36:18.300 --> 36:21.680
Es gibt sinnvollere Beispiele für solche Probleme und die benutzen

36:21.680 --> 36:24.740
sehr viel komplexere Pipelines und deswegen ignorieren wir sie

36:24.740 --> 36:25.080
geschickt.

36:27.380 --> 36:32.820
Ja, wenn ich jetzt so einen Ressourcenkonflikt habe, also wir haben

36:32.820 --> 36:35.480
gesehen, die können auftreten, was mache ich dann?

36:36.160 --> 36:38.420
Ich kann ja nicht einfach irgendwie nur einen der beiden schreiben

36:38.420 --> 36:40.260
lassen, der andere wird verworfen, das geht ja nicht.

36:40.320 --> 36:42.420
Ich muss ja irgendwie sinnvoll darauf reagieren.

36:44.500 --> 36:47.940
Na ja, das eine ist das, was wir quasi vorhin schon gesehen haben, das

36:47.940 --> 36:50.120
klappt auch sehr gut, Interlocking.

36:50.440 --> 36:54.240
Wenn dieser seltene Fall, wenn ich wenig Loads habe, ist es vielleicht

36:54.240 --> 36:57.600
ein seltener Fall, wenn dieser seltene Fall passiert, muss es eine

36:57.600 --> 37:01.560
Logik haben, die es erkennt und die dann einen der beiden Befehle

37:01.560 --> 37:02.020
anhält.

37:02.560 --> 37:05.520
Welchen der beiden, da gibt es keine Wahl.

37:06.580 --> 37:10.840
Im sequentiellen Befehlsstrom, also im Assembler-File, war der Befehl

37:10.840 --> 37:14.440
hier vor dem Befehl, also muss der hier angehalten werden.

37:14.520 --> 37:17.700
Der hier muss angehalten werden, bis der das Schreiben erledigt hat

37:17.700 --> 37:20.480
und die sequentielle Reihenfolge, wie sie im Programm vom

37:20.480 --> 37:23.240
Programmierer, vom Compiler festgelegt worden ist, wirklich auch

37:23.240 --> 37:24.220
einzuhalten in Hardware.

37:25.240 --> 37:28.960
Also, Interlocking, der spätere Befehl wird angehalten.

37:33.060 --> 37:36.320
Übertaktung, kommt drauf an, also kann eine tolle Sache sein,

37:36.420 --> 37:37.300
funktioniert manchmal echt super.

37:38.340 --> 37:41.800
Einfach die Idee ist, ich habe die Ressource und vielleicht ist die

37:41.800 --> 37:46.160
Ressource ja von der Frequenz, die sie kann, viel schneller, als was

37:46.160 --> 37:47.300
der Rest der Pipeline kann.

37:47.700 --> 37:49.560
Der Rest der Pipeline hat irgendwo eine Bremse.

37:49.920 --> 37:52.940
Von mir aus, die ALU ist unglaublich langsam, also da ist ein

37:52.940 --> 37:53.540
Multiplier drin.

37:53.780 --> 37:55.180
Multiplizieren ist jetzt nicht unbedingt schnell.

37:55.740 --> 37:58.900
Wenn der Multiplizierer an einem Takt fertig sein soll, dann hat das

37:58.900 --> 38:00.880
Register -File vielleicht noch Luft.

38:01.140 --> 38:03.420
Vielleicht kann man das Register-File mit der doppelten Taktfrequenz

38:03.420 --> 38:08.420
betreiben und kann dann quasi in einer Pipeline-Stufe zweimal den

38:08.420 --> 38:12.260
Schreibport des Register-Files benutzen und könnte dann wirklich die

38:12.260 --> 38:15.620
beiden Schreibzugriffe, die gewünscht wurden, von dem Load und dem

38:15.620 --> 38:18.620
Add, in der gleichen Pipeline-Stufe mit dem doppelt so schnell

38:18.620 --> 38:20.540
getakteten Register-File durchführen.

38:21.280 --> 38:26.020
Kostet wenig Fläche, wenn man die Frequenz wirklich doppelt so schnell

38:26.020 --> 38:26.280
macht.

38:26.400 --> 38:29.000
Es ist auch sehr wenig Logik-Overhead.

38:29.460 --> 38:34.160
Wenn man komische Frequenzen wie 2,879 mal so schnell, dann wird das

38:34.160 --> 38:36.660
langsam ärgerlich mit dem Synchronisieren, aber so doppelt so schnell

38:36.660 --> 38:36.980
ist nett.

38:37.660 --> 38:41.020
Also wenn das Register-File das hergibt, dann ist es eine tolle Sache.

38:43.580 --> 38:46.600
Letzte Lösung, die man machen kann, Ressourcenreplizierung.

38:47.580 --> 38:51.140
Das heißt einfach, wenn eine Ressource mehrfach gebraucht wird,

38:51.240 --> 38:54.220
potenziell nicht in jedem Fall, aber ab und zu, dann können wir die

38:54.220 --> 38:56.320
Hardware -Ressource einfach replizieren.

38:56.800 --> 38:59.640
Bei einer ALU kann man sich einfach vorstellen, wenn es passieren kann

38:59.640 --> 39:02.760
durch eine Pipeline-Struktur, dass zwei ALU-Operationen gleichzeitig

39:02.760 --> 39:06.020
gemacht werden, dann müssen wir halt eine zweite ALU spendieren.

39:06.020 --> 39:08.200
Haben wir genau genommen sogar schon gemacht.

39:08.420 --> 39:10.120
Wir haben das für die Adressberechnung gemacht.

39:10.200 --> 39:13.300
Wenn ihr euch erinnert, für die Adressberechnung war ein extra

39:13.300 --> 39:14.720
Addierer eingebaut worden.

39:15.040 --> 39:19.720
Und das war deswegen, weil die Addition um Offset, also Basisadresse

39:19.720 --> 39:23.480
plus Offset, um diese Berechnung auch in der Exigit-Stufe machen zu

39:23.480 --> 39:25.600
können, dafür wurde der extra Addierer spendiert.

39:25.700 --> 39:28.120
Hätte ja normalerweise die ALU auch machen können, hätte aber

39:28.120 --> 39:29.280
kollidiert mit anderen Befehlen.

39:30.000 --> 39:31.920
Also Ressourcenreplizierung.

39:31.920 --> 39:35.460
Und hier ist es halt so, man könnte in dem konkreten Beispiel mit dem

39:35.460 --> 39:38.740
Schreiben ins Register-File sagen, ich kann auch Register-Files

39:38.740 --> 39:40.640
kaufen, die haben zwei Schreib-Ports.

39:41.180 --> 39:43.100
Ich meine, ich habe ja jetzt sowieso ein Register-File gehabt, das

39:43.100 --> 39:44.740
hatte zwei Lese-Ports, ein Schreib-Port.

39:44.860 --> 39:48.520
Es gibt CPUs, wenn ich was mit mehr Parallelität machen will, dann

39:48.520 --> 39:50.680
brauche ich auch mehr Eingabedaten und ich erzeuge auch mehr

39:50.680 --> 39:51.360
Ausgabedaten.

39:51.720 --> 39:55.620
Also es gibt Register-Files mit deutlich mehr Lese-Ports und etwas

39:55.620 --> 39:56.460
mehr Schreib-Ports.

39:56.460 --> 40:01.660
Die sind teuer, also flächenmäßig teuer, stromverbrauchsmäßig teuer.

40:02.300 --> 40:04.760
Deswegen, das will man im Idealfall vermeiden.

40:04.840 --> 40:07.960
Die oberen beiden Lösungen sind die üblicheren, weil sie

40:07.960 --> 40:09.100
ressourcenschonender sind.

40:13.000 --> 40:16.520
Gut, das waren die Ressourcenkonflikte und als letzten Punkt haben wir

40:16.520 --> 40:17.920
noch die Steuerflusskonflikte.

40:19.060 --> 40:22.960
Steuerflusskonflikte ist immer, wenn der Kontrollfluss der Anwendung

40:22.960 --> 40:23.920
irgendwie ins Spiel kommt.

40:23.920 --> 40:26.640
Solange ich nur sequentiell meine Anwendung ausführe, da kommt kein

40:26.640 --> 40:29.020
Sprung, kein Nix, dann habe ich keine Steuerflusskonflikte.

40:29.280 --> 40:33.280
Wenn ich einen Sprung habe, habe ich einen Konflikt aus verschiedenen

40:33.280 --> 40:33.700
Gründen.

40:34.280 --> 40:35.520
Warum habe ich überhaupt einen Sprung?

40:36.020 --> 40:38.180
Ich meine, ist klar warum, aber was für Arten von Sprüngen?

40:38.340 --> 40:41.400
Ich kann eine bedingte, unterbedingte Sprung, also bedingte,

40:41.500 --> 40:43.600
unbedingte Sprungbefehle haben.

40:44.160 --> 40:49.320
Ich kann Unterprogramme aufrufen oder zurückkehren, Unterprogramme.

40:49.880 --> 40:52.400
Und ich kann Unterbrechungsbefehle haben.

40:52.400 --> 40:55.760
Vielleicht dazu noch mal kurz, welche Folie war denn das?

40:57.740 --> 40:58.620
Genau, mein Gott.

41:00.120 --> 41:03.520
Diese Pipeline, wie wir sie bisher gesehen haben, kann leider keine

41:03.520 --> 41:04.540
Funktionsaufrufe.

41:04.940 --> 41:05.920
Das ist ziemlich ärgerlich.

41:06.480 --> 41:09.560
Also sie kann schon Funktionsaufrufe, aber sie kann nicht zurück.

41:10.460 --> 41:14.040
Was muss ich denn machen, um bei einer Pipeline wieder zurückzukommen,

41:14.120 --> 41:15.180
da wo ich hergekommen bin?

41:15.600 --> 41:19.500
Ich habe einen unbedingten Sprung an der Adresse, die kann ich

41:19.500 --> 41:21.480
berechnen, alles super und da ist die Funktion.

41:21.480 --> 41:24.900
Die Funktion kann von verschiedenen Stellen angesprungen werden.

41:25.240 --> 41:30.500
Also der Rücksprung ist kein unbedingter Sprung mit bekanntem

41:30.500 --> 41:31.080
Sprungziel.

41:31.260 --> 41:34.040
Ich weiß das Sprungziel nicht, weil ich weiß nicht, von wo die

41:34.040 --> 41:35.160
Funktion aufgerufen wurde.

41:35.240 --> 41:36.840
Aber genau dahin muss ich wieder zurück.

41:37.520 --> 41:40.720
Und deswegen merkt man sich, wo man hergekommen ist, in einem

41:40.720 --> 41:41.040
Register.

41:41.340 --> 41:43.320
Da merkt man sich, dahin musst du wieder zurück.

41:44.100 --> 41:47.880
Und was jetzt fehlt, ist im Wesentlichen, das Register, wo man es

41:47.880 --> 41:51.800
gemerkt hat, was jetzt hier im Registerpfeil drin wäre, das müsste

41:51.800 --> 41:55.760
irgendwie eine Möglichkeit haben, irgendwie hier an den Programme

41:55.760 --> 41:56.760
-Counter heranzukommen.

41:57.060 --> 41:58.540
In der Architektur fehlt diese Verbindung.

41:58.920 --> 42:01.900
Normalerweise hätte man einfach vom Registerpfeil noch eine Anbindung

42:01.900 --> 42:04.760
irgendwie an den Programme-Counter, damit man irgendwo den

42:04.760 --> 42:10.300
Assemblerbefehl return hinschreiben kann, der aus dem, das ist einfach

42:10.300 --> 42:13.800
festgelegt, welches Register das ist, das Link-Register, der dann

42:13.800 --> 42:16.980
quasi dahin springen kann, welche Adresse auch immer im Link-Register

42:16.980 --> 42:18.020
vorher reingeschrieben ist.

42:18.460 --> 42:20.520
Das ist nur ein Pfeil, der hier fehlt, aber naja.

42:21.520 --> 42:23.020
Das müsste man noch dazu haben.

42:25.100 --> 42:26.160
Jetzt noch wüsste, wo ich war.

42:34.480 --> 42:38.760
Und der letzte Punkt, warum man springen möchte, Unterbrechungen.

42:39.760 --> 42:41.060
Unterbrechungen sind anders.

42:41.280 --> 42:44.080
Es gibt synchrone und asynchrone Unterbrechungen.

42:44.620 --> 42:47.900
Unterbrechungen ist irgendwas, was jetzt nicht als Sprung im Assembler

42:47.900 --> 42:52.340
-Code steht, sondern irgendwie passiert, aus Ausnahmegründen.

42:53.300 --> 42:57.820
Synchrone Unterbrechungen, Traps, werden vom Programm selbst

42:57.820 --> 42:58.400
ausgeführt.

42:58.960 --> 43:02.520
Zum Beispiel, wenn ich einen Divisionsbefehl in den Assembler-Code

43:02.520 --> 43:06.720
hinschreibe und das Eingaberegister hat 0, also irgendwas geteilt

43:06.720 --> 43:07.220
durch 0.

43:07.780 --> 43:09.580
Das lässt sich nicht ausrechnen.

43:09.680 --> 43:11.800
Da wird ein Division-by-0-Trap ausgelöst.

43:12.800 --> 43:16.500
Dann springt das Programm in einen speziellen Trap-Händler, der ist an

43:16.500 --> 43:19.760
einer bekannten Stelle im Speicher und der muss dann entscheiden, was

43:19.760 --> 43:20.800
mit dem Programm gemacht wird.

43:21.220 --> 43:24.060
Ein Division-by-0 lässt sich nicht auflösen, da kann man nichts mehr

43:24.060 --> 43:24.220
machen.

43:24.340 --> 43:26.500
Das heißt, das Programm wird beendet.

43:26.960 --> 43:30.840
Ein anderes Beispiel, wenn ich ein Loads-Befehl, Store, völlig egal,

43:32.140 --> 43:35.400
Speicherzugriffsbefehl habe und der geht an eine Adresse und die

43:35.400 --> 43:37.160
Adresse ist gerade nicht im Speicher.

43:37.380 --> 43:40.300
Das soll heißen, wir haben jetzt ein Betriebssystem, das

43:40.300 --> 43:43.920
Betriebssystem hat Paging und es hat gesagt, die eine Speicherseite

43:43.920 --> 43:46.700
ist jetzt gerade auf die Festplatte ausgelagert, weil der

43:46.700 --> 43:47.440
Hauptspeicher war voll.

43:48.120 --> 43:51.660
Wenn jetzt ein Load-Befehl an genau diese Adresse geht, die gerade gar

43:51.660 --> 43:54.560
nicht im Hauptspeicher drin ist, dann ist es ein Page-Fault.

43:54.680 --> 43:58.480
Das wird also synchron durch den Load-Befehl der Page-Fault ausgelöst

43:58.480 --> 44:02.120
und der Händler ist dann verantwortlich, aus der Festplatte, wo auch

44:02.120 --> 44:04.940
immer die Seite gerade liegt, die Seite zurückzuladen in den

44:04.940 --> 44:07.460
Hauptspeicher und dann geht es zurück ins Programm.

44:07.660 --> 44:10.600
Der Befehl kann nochmal ausgeführt werden und dann wird er die Daten

44:10.600 --> 44:11.080
auch finden.

44:11.340 --> 44:13.880
Das sind synchrone Unterbrechungen, die werden vom Programm selber

44:13.880 --> 44:14.420
ausgelöst.

44:15.520 --> 44:18.420
Asynchrone Unterbrechungen, Interrupts, kommen von außen.

44:19.160 --> 44:23.000
Ein Timer-Interrupt, der sagt, du warst jetzt lang genug dran, du, der

44:23.000 --> 44:25.820
Task, wirst unterbrochen und ein anderer Task kommt dran.

44:25.820 --> 44:29.280
Oder einfach nur der Reset-Interrupt, also das Drücken eines Knopfes.

44:29.600 --> 44:32.160
Das sind von außen unvorhersehbar irgendwann passierende

44:32.160 --> 44:32.800
Unterbrechungen.

44:33.480 --> 44:36.940
Und alle diese Arten von Sprüngen oder Unterbrechungen sorgen zu,

44:37.480 --> 44:40.060
naja, das sind erst mal Programmsteuerbefehle und die sorgen zu

44:40.060 --> 44:41.600
Steuerflusskonflikten.

44:42.140 --> 44:45.100
Hier ist es so, dass Steuerflussabhängigkeiten, also wenn ich nicht

44:45.100 --> 44:48.800
vorher, wenn ich nicht sequentiell im Programm weiterarbeite, so eine

44:48.800 --> 44:52.260
Abhängigkeit habe, ist es bei DLX-Fibern immer ein Konflikt.

44:52.940 --> 44:54.120
Warum ist es ein Konflikt?

44:54.840 --> 44:56.860
Also ein Problem erst mal nur.

44:58.180 --> 45:02.260
Der Programmsteuerbefehl, der wird erst mal, sagen wir mal Jump, egal,

45:02.500 --> 45:05.840
Jump bedingt unbedingt, der wird gefetscht, dann habe ich irgendwas

45:05.840 --> 45:06.200
gefetscht.

45:06.280 --> 45:07.660
32 -Bit, kein Mensch weiß, was es ist.

45:08.240 --> 45:11.100
Erst in der Decode-Stufe erkenne ich, das war ein Sprung.

45:12.040 --> 45:15.600
Aber in der Decode-Stufe habe ich ja schon längst den nächsten Befehl

45:15.600 --> 45:16.100
gefetscht.

45:16.620 --> 45:19.900
Der nächste Befehl war der Plus-4, der sequentiell danach kommende.

45:19.900 --> 45:23.280
Das heißt, ich habe möglicherweise schon längst den falschen Befehl

45:23.280 --> 45:23.660
geholt.

45:24.220 --> 45:26.260
Ich habe erst in der Decode-Stufe gemerkt, dass es ein Sprungbefehl

45:26.260 --> 45:26.460
war.

45:27.520 --> 45:30.760
Selbst jetzt, wo ich gemerkt habe, es ist ein Sprungbefehl, weiß ich

45:30.760 --> 45:34.180
immer noch nicht, wird der Sprung genommen oder nicht genommen.

45:34.440 --> 45:36.180
Beim unbedingten Sprung weiß ich es, okay, gestimmt.

45:36.540 --> 45:38.920
Beim bedingten Sprung weiß ich es nicht, der hat ja eine Bedingung.

45:39.280 --> 45:40.740
Die Bedingung muss ausgerechnet werden.

45:41.100 --> 45:43.400
Die Bedingung wird für gewöhnlich in der Exit-Stufe ausgerechnet.

45:43.560 --> 45:46.960
Das ist irgendwie ein Vergleich oder ein Vergleich mit 0 oder ein Zero

45:46.960 --> 45:51.780
-Flag, und den weiß ich für gewöhnlich erst am Ende der Execute-Stufe,

45:51.900 --> 45:53.100
ob der Sprung überhaupt genommen wird.

45:54.760 --> 45:55.520
Drittes Problem.

45:56.720 --> 45:58.200
Angenommen, ich wüsste jetzt, er wird genommen.

45:58.740 --> 46:00.060
Wohin geht der Sprung?

46:00.480 --> 46:01.500
An welcher Adresse?

46:01.960 --> 46:04.140
Also ich muss ja auch ein Sprungziel irgendwie berechnen.

46:04.520 --> 46:07.500
Das Sprungziel ist ja häufig Basisadresse plus Offset, also

46:07.500 --> 46:10.200
Basisadresse ist hier der Programme-Counter, und der Offset steht im

46:10.200 --> 46:11.560
Sprungbefehl mit drin, als Immediate.

46:11.900 --> 46:13.980
Also auch das Sprungziel muss berechnet werden.

46:13.980 --> 46:18.740
Und während all dieser Zeit Erkennen, Taken, Ja, Nein, Sprungziel,

46:19.160 --> 46:22.620
hole ich die ganze Zeit neue Befehle in die Pipeline rein, als wäre

46:22.620 --> 46:24.940
nichts passiert, als würde es sequenziell weiterlaufen.

46:25.380 --> 46:26.840
Das war eventuell alles umsonst.

46:26.940 --> 46:28.380
Vielleicht waren die Befehle gar nicht ausgeführt.

46:28.900 --> 46:30.660
Das sind die Steuerflusskonflikte.

46:32.600 --> 46:33.860
Einfach mal als Beispiel.

46:34.960 --> 46:36.420
Ja, hier ist der Sprungbefehl.

46:36.940 --> 46:39.380
Das Sprungziel würde erst hier erreicht werden.

46:39.380 --> 46:42.780
Also angenommen, hier steht Bedingter, Unbedingter, ist sogar egal,

46:43.800 --> 46:44.880
also Bedingter, Unbedingter, Sprung.

46:45.600 --> 46:49.000
Hier würde erst das Sprungziel, also da, wo der hinspringen möchte,

46:49.360 --> 46:50.380
wirklich erreicht werden.

46:50.720 --> 46:56.500
Weil das Berechnen der Sprungadresse, wohin geht's, ist erst hier

46:56.500 --> 46:57.560
verfügbar geworden.

46:57.920 --> 47:00.000
Deswegen ist es hier sogar egal, Bedingter oder Unbedingter, weil das

47:00.000 --> 47:02.800
Berechnen der Adresse das Langsamste an der ganzen Sache ist.

47:04.220 --> 47:06.080
Zwischendurch wurden drei Befehle reingeholt.

47:06.400 --> 47:07.100
Was mache ich mit denen?

47:08.900 --> 47:10.380
Da gibt es mehrere Möglichkeiten.

47:11.020 --> 47:12.160
Ich kann die Befehle löschen.

47:13.220 --> 47:15.040
Das richtigere Wort wäre annulieren.

47:15.520 --> 47:16.740
Ich kann jetzt aber gar nichts rauslöschen.

47:16.860 --> 47:17.920
Ich kann ein Bit nicht löschen.

47:18.040 --> 47:20.080
Das ist da, es ist in Hardware, ich kann es nicht löschen.

47:20.480 --> 47:24.520
Aber ich kann einen Zusatzfleck durch die Pipeline durchschleusen, das

47:24.520 --> 47:28.820
sagt, das, was du gerade in deiner Stufe siehst, mach es oder mach es

47:28.820 --> 47:29.060
nicht.

47:29.720 --> 47:33.600
Und wenn ich Blödsinn hole, weil ich zum Beispiel weiß, ich weiß das

47:33.600 --> 47:36.740
Sprungziel noch nicht, aber irgendwas kommt in die Pipeline rein, dann

47:36.740 --> 47:39.740
kann ich nachträglich sagen, annuliere das.

47:40.160 --> 47:43.200
Wenn das ein Arithmetikbefehl war, schreib es nicht ins Register-File.

47:43.400 --> 47:45.160
Gib es nicht ans Data Forwarding-Netzwerk weiter.

47:45.780 --> 47:48.620
Wenn es ein Ladespeicherbefehl ist, laden ist nicht so schlimm, aber

47:48.620 --> 47:50.020
trotzdem, spart Zeit, mach es nicht.

47:50.460 --> 47:52.600
Speichern, auf keinen Fall, nicht speichern.

47:52.840 --> 47:54.860
Das würde alles den Zustand vom System verändern.

47:55.400 --> 47:56.500
Das ist mit annulieren gemeint.

47:58.180 --> 48:00.360
Ja, und erst nach drei Takten habe ich das, was ich wollte.

48:01.100 --> 48:02.280
Das kann man hier nochmal sehen.

48:06.060 --> 48:09.820
Ja, hier habe ich das Sprungziel berechnet.

48:11.140 --> 48:14.240
Also in der Memorystufe, also nicht gerade am Ende, aber irgendwo in

48:14.240 --> 48:16.300
der Memorystufe schreibe ich es in den Programme-Counter rein.

48:16.820 --> 48:20.480
Und danach kann ich erst in der nächsten Fetch-Stufe, kann ich es

48:20.480 --> 48:21.260
wieder lesen.

48:21.700 --> 48:23.240
Daher kommt diese Verzögerung.

48:26.140 --> 48:28.860
Ja, wir können sie nicht komplett verhindern.

48:29.060 --> 48:31.520
Können wir sie vielleicht verkürzen, dass die Verzögerung nicht so

48:31.520 --> 48:37.300
brutale drei Takte ist, Na gut, um das machen zu können, müssen wir so

48:37.300 --> 48:40.680
schnell wie möglich wissen, ob der Sprung genommen wird oder nicht,

48:41.020 --> 48:44.800
bei einem bedingten Sprung, und so früh wie möglich wissen, wohin geht

48:44.800 --> 48:45.280
der Sprung.

48:47.340 --> 48:52.460
Wir könnten zum Beispiel versuchen, die Taken-Not-Taken-Entscheidung

48:52.920 --> 48:56.740
und die Sprungzielberechnung bereits in der Decode-Stufe zu machen.

48:57.460 --> 48:59.080
Also so früh wie möglich.

48:59.800 --> 49:01.100
Hat aber mehrere Probleme.

49:01.100 --> 49:05.700
Das eine Problem ist, zur Berechnung des Sprungziels war zum Teil die

49:05.700 --> 49:06.300
ALU involviert.

49:07.760 --> 49:09.240
Die ist aber in der Execute-Stufe.

49:09.480 --> 49:12.280
Wenn wir die jetzt von zwei verschiedenen Stufen zugreifen, baustellen

49:12.280 --> 49:14.400
wir uns vielleicht wieder einen Ressourcen-Konflikt ein.

49:15.080 --> 49:16.240
Also einen Struktur-Konflikt.

49:17.080 --> 49:20.060
Das andere ist, dass das kann man einfach lösen, indem man das

49:20.060 --> 49:22.420
reproduziert, weitere Ressourcen hinzufügt.

49:23.000 --> 49:27.060
Das eigentliche Problem ist, dass man jetzt folgendes alles in der

49:27.060 --> 49:28.660
gleichen Pipeline-Stufe tun muss.

49:28.660 --> 49:31.860
Man muss den Befehl, der potenziellen Sprungbefehl ist, dekodieren.

49:32.820 --> 49:37.120
Man muss das Sprungziel berechnen aus dem Programme-Counter und dem

49:37.120 --> 49:39.220
Immediate von dem Wert, den man gerade erst dekodiert hat.

49:40.460 --> 49:43.840
Und muss dann den Programme-Counter neu schreiben.

49:44.260 --> 49:46.180
Dieser Pfad ist ziemlich lang.

49:46.580 --> 49:49.480
Es gab einen Grund, weswegen vorher das Dekodieren und Register-Access

49:49.480 --> 49:50.720
nur eine Stufe war.

49:51.020 --> 49:53.900
Jetzt haben wir nach Register-Access, nach Dekodieren noch weitere

49:53.900 --> 49:54.200
Sachen.

49:54.680 --> 49:57.680
Dadurch kann die Frequenz der ganzen Geschichte deutlich beeinflusst

49:57.680 --> 49:57.920
werden.

49:57.920 --> 50:01.900
Also der kritische Pfad von Beginn der Stufe bis Ende der Stufe wird

50:01.900 --> 50:03.660
länger, weil mehr gemacht wird in der Stufe.

50:04.020 --> 50:06.360
Das kann die Frequenz der gesamten Pipeline beeinflussen.

50:06.860 --> 50:10.780
Jetzt habe ich vielleicht weniger Takte, bis ich beim Sprungziel

50:10.780 --> 50:11.480
ankomme.

50:11.760 --> 50:13.680
Aber jeder Takt ist langsamer geworden.

50:14.160 --> 50:16.860
Kann sein, dass es in der Summe Nullsummenspiel oder sogar negativ

50:16.860 --> 50:17.280
ausgeht.

50:17.620 --> 50:20.300
Da muss man dann genau angucken, wie die Pipeline strukturiert war, ob

50:20.300 --> 50:21.500
es sich lohnt oder nicht.

50:23.220 --> 50:25.340
Nehmen wir mal an, es würde sich lohnen und wir hätten es gemacht.

50:26.660 --> 50:36.400
Jetzt habe ich trotzdem noch mindestens einen Takt hintendrin, weil

50:36.400 --> 50:39.760
ich ja erst in der Dekod-Stufe erkenne, dass es ein Sprung ist und

50:39.760 --> 50:41.040
dann das andere Ganze mache.

50:41.440 --> 50:43.420
Auf jeden Fall habe ich jetzt schon in der Fetch-Stufe einen neuen

50:43.420 --> 50:44.000
Befehl geholt.

50:44.360 --> 50:47.280
Und mindestens diesen einen Befehl kann sein, dass der falsch war.

50:47.820 --> 50:49.720
Wenn der Sprung nicht genommen wird, okay, super, aber wenn der

50:49.720 --> 50:50.760
genommen wird, war es der falsche.

50:50.760 --> 50:55.500
Also auch mit diesem Verkürzen der Sprung, Verzögerung, bis es bekannt

50:55.500 --> 50:59.100
wird, selbst mit diesem extremen Verkürzen klappt es nicht, dass ich

50:59.100 --> 51:01.400
Null extra Befehle reinhole.

51:01.540 --> 51:02.980
Mindestens einen hole ich immer rein.

51:03.320 --> 51:05.720
Und für den muss ich mir jetzt überlegen, was mache ich mit dem einen

51:05.720 --> 51:06.100
Befehl?

51:07.240 --> 51:09.720
Ja, und da gibt es, wie eigentlich immer, es gibt Möglichkeiten in

51:09.720 --> 51:12.840
Software, Compiler, was er machen kann und Möglichkeiten in Hardware,

51:13.080 --> 51:14.160
wie man da was auflösen kann.

51:16.020 --> 51:18.920
In Software heißt das Ganze Delay Branch.

51:18.920 --> 51:21.040
Also es sind sogenannte Delay Slots.

51:21.500 --> 51:27.180
Das soll heißen, dass man als Spezifikation von dem Hardwarehersteller

51:27.180 --> 51:32.160
mit dem Programmierer vereinbart, der eine Befehl, wir haben jetzt

51:32.160 --> 51:35.800
noch mehrere, sagen wir mal der eine, nach einem Sprungbefehl wird

51:35.800 --> 51:36.920
immer ausgeführt.

51:37.580 --> 51:39.820
Egal ob Sprung taken oder not taken.

51:40.380 --> 51:44.880
Wenn der Programmierer, Compiler, das weiß, dann kann er da einen

51:44.880 --> 51:47.180
geeigneten Befehl in den Delay Slot reinschreiben.

51:47.680 --> 51:51.240
Er kann sagen, okay, dann nehme ich halt irgendeinen Befehl, der

51:51.240 --> 51:55.640
logisch gesehen eigentlich vor dem Sprung platziert werden müsste.

51:55.760 --> 51:57.400
Der soll auf jeden Fall gemacht werden.

51:58.120 --> 52:00.500
Aber der ist unabhängig von dem Sprung.

52:00.640 --> 52:03.240
Also ich brauche das Berechnungsergebnis nicht, um den Sprung ja,

52:03.360 --> 52:04.920
nein, taken, not taken zu entscheiden.

52:05.320 --> 52:07.340
Und ich brauche ihn nicht, um das Sprungziel zu berechnen.

52:08.100 --> 52:10.280
Dann kann ich ihn auch in den Delay Slot reinschieben.

52:10.540 --> 52:13.220
Dann habe ich diesen einen Delay Slot sinnvoll genutzt.

52:13.220 --> 52:17.700
Ist kompliziert für den Compiler, wird nicht so gut angenommen.

52:19.000 --> 52:22.220
Aber da kann man halt eben zumindest mal diesen einen Delay Slot mit

52:22.220 --> 52:23.280
sinnvoller Arbeit füllen.

52:28.260 --> 52:30.100
Ja, das ist im Wesentlichen das hier gewesen.

52:31.860 --> 52:35.200
Was immer gut funktioniert, also beim If-Then-Else kann es sehr

52:35.200 --> 52:38.380
schwierig sein, je nachdem, wie eng die Datenabhängigkeiten sind.

52:38.920 --> 52:41.460
Was gut funktioniert, ist, wenn ich eine Schleife habe.

52:41.460 --> 52:45.480
Wenn ich eine Schleife habe, habe ich quasi irgendwann mal den Eingang

52:45.480 --> 52:46.120
der Schleife.

52:46.560 --> 52:49.680
Das geht sequenziell nach unten runter bis zum Ende der ersten

52:49.680 --> 52:50.280
Iteration.

52:50.700 --> 52:54.040
Und da ist ein bedingter Sprung zurück an den Anfang, zweite

52:54.040 --> 52:57.320
Iteration, oder nach unten raus, Schleifeende fertig.

52:58.040 --> 53:01.560
Und jetzt kann man, schade, dass ich es nicht schreibe, kann ich Code

53:01.560 --> 53:02.840
-Duplizierung benutzen.

53:03.300 --> 53:07.220
Soll heißen, ich kann ein Stück Code von der Schleife benutzen, vom

53:07.220 --> 53:10.120
Schleifenrumpf, und schreibe den zweimal hin.

53:10.120 --> 53:15.620
Einmal bevor die Schleife ausgeführt wird, und einmal in den Delay

53:15.620 --> 53:16.340
-Slot der Schleife.

53:16.660 --> 53:19.380
Ich kann einfach sagen, der erste Befehl in der Schleife, ich habe

53:19.380 --> 53:22.100
einen gewissen sequenziellen Code, das ist der Schleifenrumpf, und den

53:22.100 --> 53:26.360
ersten Befehl davon schreibe ich einmal vor die Schleife, also vor das

53:26.360 --> 53:29.080
Label, wo der Rücksprung hingeht, und ich kopiere ihn, schreibe ihn

53:29.080 --> 53:30.280
einmal in den Delay-Slot.

53:30.700 --> 53:33.360
Dann habe ich sichergestellt, für die erste Iteration der Schleife

53:33.360 --> 53:37.020
läuft er von oben einmal über den Befehl durch, und danach rechnet er

53:37.020 --> 53:41.340
im Delay-Slot den Befehl für die zweite Iteration und springt dann in

53:41.340 --> 53:42.380
die zweite Iteration rein.

53:42.820 --> 53:45.740
Damit kann ich relativ gut den Delay-Slot mit Sachen füllen.

53:47.260 --> 53:49.600
Es können auch manchmal wirklich mehrere Delay-Slots sein, umso mehr

53:49.600 --> 53:50.100
lohnt sich das.

53:50.300 --> 53:52.280
Wenn es nur einer ist, ist es vielleicht nicht so wichtig, wenn es

53:52.280 --> 53:55.640
zwei oder drei sind, bei Delix sind es drei, dann lohnt sich das schon

53:55.640 --> 53:56.300
ganz gewaltig.

54:00.200 --> 54:03.620
Potenzieller Nachteil, der Code, den ich gerade geschrieben habe, wo

54:03.620 --> 54:08.340
ich diesen Delay-Slot ausnutze, der ist jetzt abhängig davon, wie die

54:08.340 --> 54:09.340
Pipeline gebaut ist.

54:09.580 --> 54:12.960
Der ist abhängig davon, wie viele Delay-Slots ich habe.

54:13.440 --> 54:15.780
Wenn ich die Anzahl der Delay-Slots ändere, wenn ich die Pipeline

54:15.780 --> 54:18.340
-Struktur ändere, dann funktioniert der Code nicht mehr.

54:18.840 --> 54:21.380
Das heißt, für gewöhnlich wird die Anzahl der Delay-Slots festgelegt

54:22.380 --> 54:26.100
in dem ISA-Handbuch, also in dem Handbuch für den Befehlssatz.

54:26.340 --> 54:29.080
Da wird garantiert, es gibt genau N Delay-Slots.

54:30.020 --> 54:33.240
Geht dich nichts an, wie die Pipeline aussieht, es gibt immer genau N

54:33.240 --> 54:33.900
Delay -Slots.

54:34.380 --> 54:35.520
Und dann kann man sich darauf verlassen.

54:35.600 --> 54:38.680
Dann können die Mikroarchitekturentwickler in ihrer Pipeline basteln

54:38.680 --> 54:41.120
und die Softwareprogrammierer können sich darauf verlassen oder der

54:41.120 --> 54:43.980
Compiler, dass es diese Delay-Slots immer geben wird.

54:46.480 --> 54:48.400
Gut, das war die Software-Version.

54:49.740 --> 54:52.840
Hardware-Version, wie immer.

54:53.100 --> 54:55.900
Wenn es nicht anders geht und ich keine Lust habe, Fläche zu

54:55.900 --> 54:57.560
investieren, halte ich die Hardware an.

54:58.620 --> 55:01.840
Wenn ich keinen Delay-Slots haben will und nicht irgendwie was

55:01.840 --> 55:05.080
vorberechnen möchte und ich erkenne, das ist ein Sprungbefehl in der

55:05.080 --> 55:07.800
Decode -Stufe, spätestens weiß ich es ja, dann halte ich die Pipeline

55:07.800 --> 55:10.340
einfach an, bis alles andere berechnet ist.

55:10.440 --> 55:13.020
Dann habe ich immer noch einen Delay-Slot, weil ich habe erst in der

55:13.020 --> 55:14.320
Decode -Stufe gemerkt, dass es ein Sprung war.

55:15.000 --> 55:17.960
Aber ich habe zumindest nicht die weiteren, die danach noch kommen,

55:18.040 --> 55:19.840
bis Sprung, Ziel und Take Not Taken entschieden.

55:20.640 --> 55:23.640
Ist so ähnlich wie bei Datenabhängigkeiten auflösen.

55:24.380 --> 55:27.560
Kostet keine extra Assemblerbefehle, Code wird kleiner, aber schneller

55:27.560 --> 55:28.300
wird es dadurch auch nicht.

55:32.730 --> 55:36.030
Und jetzt kann man sich überlegen, was kann man denn noch machen?

55:38.470 --> 55:44.310
Es ist jetzt eine Idee, die sagt, nach der Decode-Stufe weiß ich, es

55:44.310 --> 55:46.310
ist ein Sprung, mit Sicherheit, ich weiß es.

55:47.910 --> 55:50.630
Das Take Not Taken weiß ich erst später.

55:51.310 --> 55:54.590
Aber ich kann ja, anstatt einfach die Pipeline immer anzuhalten, kann

55:54.590 --> 55:55.370
ich ja mal raten.

55:56.890 --> 55:59.410
Und da gibt es verschiedene gute Versionen von Raten.

56:00.010 --> 56:03.190
Die einfachste erstmal, ich kann ja mal raten, der Sprung wird

56:03.190 --> 56:04.370
bestimmt nicht genommen.

56:05.030 --> 56:08.510
Und wenn der Sprung wirklich nicht genommen wird, dann ist das super

56:08.510 --> 56:09.850
und ich habe null Zeitverlust.

56:10.250 --> 56:11.310
Was heißt denn das, nicht genommen?

56:11.650 --> 56:15.790
Das heißt, ich hoffe, der Sprung wird nicht genommen, die Befehle, die

56:15.790 --> 56:18.930
danach sowieso in die Pipeline kommen, das werden wohl die richtigen

56:18.930 --> 56:19.110
sein.

56:19.190 --> 56:20.590
Ich führe die einfach mal aus.

56:21.150 --> 56:24.470
Wenn ich dann später merke, der Sprung war leider doch taken, der ist

56:24.470 --> 56:26.470
genommen worden, muss ich aufräumen.

56:27.130 --> 56:29.250
Dann gibt es verschiedene Arten von Schwierigkeitsgraden.

56:29.730 --> 56:33.450
Hier ist die Pipeline so kurz, dass ich die Befehle noch rechtzeitig

56:33.450 --> 56:34.190
annullieren kann.

56:34.350 --> 56:37.550
Noch bevor die irgendwie den Systemzustand verändern, sprich ins

56:37.550 --> 56:40.350
Register file reinschreiben oder in den Hauptspeicher reinschreiben,

56:40.350 --> 56:44.630
kann ich sagen, stopp, annullieren, keine Änderung vom System zu

56:44.630 --> 56:45.310
durchführen.

56:45.870 --> 56:49.110
Bei komplexeren Pipelines kann es sein, dass schon Änderungen

56:49.110 --> 56:49.970
durchgeführt wurden.

56:50.110 --> 56:52.070
Es wurden schon Sachen ins Register file reingeschrieben oder

56:52.070 --> 56:55.650
vielleicht sogar an den Speichercontroller weitergegeben, also an die

56:55.650 --> 56:56.950
Memorystage weitergegeben.

56:57.330 --> 57:01.470
Dann muss ich ein Rollback machen im Sinne von, ich muss das Getane

57:01.470 --> 57:02.490
rückgängig machen.

57:02.610 --> 57:04.430
Da gibt es für gewöhnlich beim Schreiben einen Buffer.

57:04.430 --> 57:07.690
Ich schreibe erst in den Buffer rein und erst wenn ich sicher bin,

57:07.770 --> 57:10.190
dass der Schreibbefehl auch echt durchgeführt werden soll, wird er

57:10.190 --> 57:12.190
committed im Sinne von, da wird der Buffer auch echt in den

57:12.190 --> 57:12.830
Hauptspeicher geschrieben.

57:13.450 --> 57:15.850
Aber bei einer einfachen Pipeline-CPU brauche ich das nicht, da kann

57:15.850 --> 57:17.050
ich sie noch rechtzeitig annullieren.

57:18.710 --> 57:22.430
Wenn wir uns zum Beispiel diese Code-Sequenz hier angucken.

57:22.950 --> 57:27.250
Wir haben zwei nacheinander ausgefüllte Schleifen, die jeweils zehn

57:27.250 --> 57:31.290
Iterationen ausrechnen und irgendwas Sinnvolles innen drin tun.

57:33.990 --> 57:38.190
Wenn ich jetzt statisch annehme, der Sprung wird bestimmt nicht

57:38.190 --> 57:38.590
genommen.

57:38.870 --> 57:40.450
Always not taken heißt das.

57:41.930 --> 57:48.510
Dann hätte ich hier leider neunmal falsch gelegen, weil die erste

57:48.510 --> 57:51.350
Iteration kommt so rein und dann wird neunmal nach oben gesprungen für

57:51.350 --> 57:55.070
die nächsten neun Iterationen, nur beim letzten Sprung aus der

57:55.070 --> 57:55.730
Schleife raus.

57:55.950 --> 57:58.930
Da war die Vorhersage richtig, da war es wirklich nicht genommen.

57:58.930 --> 58:01.130
Dann kommt die nächste Schleife und genau dasselbe nochmal.

58:01.590 --> 58:03.910
Ich liege neunmal falsch und einmal richtig.

58:05.990 --> 58:10.950
Alternative Annahme ist, dass man vermutet, der Sprung ist always

58:10.950 --> 58:11.450
taken.

58:11.870 --> 58:16.130
Das klappt bei Schleifen viel besser, bei Kontrollflows im Sinne von

58:16.130 --> 58:21.630
if -then-else bringt es unterschiedlich, hängt komplett vom Programm

58:21.630 --> 58:21.910
ab.

58:22.690 --> 58:26.670
Der Switchcase wird übrigens komplett ohne Sprünge implementiert.

58:27.210 --> 58:30.490
Wenn einer mal Lust hat, sich ein Switchcase im GCC anzugucken, da

58:30.490 --> 58:32.750
braucht man keine Sprünge für, also keine bedingten Sprünge.

58:32.810 --> 58:34.950
Sprüngen man schon, aber keine bedingten Sprünge.

58:35.870 --> 58:39.570
Das ist quasi, wenn ich fünf, zehn, wie auch immer Case Statements

58:39.570 --> 58:44.790
habe, dann wird im Speicher ne Tabelle angelegt mit so vielen

58:44.790 --> 58:48.350
Einträgen, wie es Case Statements gab und in jedem Eintrag im Speicher

58:48.350 --> 58:52.290
steht drin, das ist die Adresse, wohin gesprungen werden soll und dann

58:52.290 --> 58:57.270
macht der Assembler-Code nur noch den Anfang von der Tabelle laden,

58:57.550 --> 59:01.550
plus welcher Case war es denn, da steht die Adresse, wo es hingeht und

59:01.550 --> 59:02.550
an die Adresse springen.

59:02.650 --> 59:05.190
Also es ist ein bedingter Sprung, keine unbedingten Sachen.

59:05.990 --> 59:06.670
Es ist sehr nett.

59:08.290 --> 59:13.330
Gut, also always taken, always not taken als Sprungvorhersagen, naja,

59:13.430 --> 59:16.330
das ist schon so trivial, dass man schon ahnen kann, dass es bessere

59:16.330 --> 59:16.830
geben muss.

59:18.330 --> 59:22.550
Da gibt es den Ein-Bit-Prediktor für die Sprungvorhersage.

59:23.190 --> 59:26.790
Der ist immer noch trivial, aber der ist schon, naja, in dem Beispiel

59:26.790 --> 59:28.170
ist er nicht besser, aber prinzipiell ist er besser.

59:29.790 --> 59:34.990
Und zwar ein Bit im Sinne von, ich habe einen Zustandsautomaten, wo

59:34.990 --> 59:37.390
ich den Zustand in einem Bit codieren kann, so gesehen gibt es

59:37.390 --> 59:41.190
offensichtlich zwei Zustände, das sind die beiden Zustände, taken und

59:41.190 --> 59:44.570
not taken, und die machen einfach die Vorhersage, wird der nächste

59:44.570 --> 59:46.610
Sprung genommen, ja oder nein.

59:47.090 --> 59:50.830
Und die gucken sich einfach die History, die Vergangenheit der

59:50.830 --> 59:51.810
bisherigen Sprünge an.

59:52.250 --> 59:56.470
Sprich, egal in welchem Zustand ich war, zum Beispiel hier, wenn ein

59:56.470 --> 01:00:00.210
Sprung genommen wird, also tatsächlich taken ist, dann wechsle ich

01:00:00.210 --> 01:00:02.630
danach in die Vorhersage, naja, dann wird der nächste wohl auch

01:00:02.630 --> 01:00:03.250
genommen werden.

01:00:03.650 --> 01:00:06.570
Genauso, wenn ich in taken war, wenn ein Sprung genommen wird, dann

01:00:06.570 --> 01:00:07.170
bleibe ich hier.

01:00:08.110 --> 01:00:11.390
Umgekehrt, wenn ein Sprung nicht genommen wird, egal in welchen der

01:00:11.390 --> 01:00:14.810
beiden Zustände ich war, ich gehe danach in den not taken Zustand.

01:00:14.810 --> 01:00:17.530
Also einfach nur, das, was zuletzt passiert ist, wird wohl als

01:00:17.530 --> 01:00:18.290
nächstes passieren.

01:00:19.930 --> 01:00:20.990
Wie gut klappt das?

01:00:21.750 --> 01:00:25.370
Hier wieder die beiden nacheinander ausgeführten Schleifen.

01:00:25.950 --> 01:00:27.230
Jetzt müssen wir ein bisschen genauer reingucken.

01:00:27.590 --> 01:00:31.450
Wir haben Iteration 1 und sagen wir mal, diese Sprungvorhersage ist

01:00:31.450 --> 01:00:34.490
initialisiert mit irgendeinem Wert, zum Beispiel, unglücklicherweise,

01:00:34.810 --> 01:00:35.250
not taken.

01:00:36.150 --> 01:00:39.470
Das heißt, die Vorhersage war, der Sprung wird nicht genommen.

01:00:40.190 --> 01:00:43.070
Leider wird der erste Sprung, also der erste von der Schleife hier,

01:00:43.070 --> 01:00:43.810
wieder nach oben.

01:00:43.970 --> 01:00:44.930
Der wird natürlich genommen.

01:00:45.030 --> 01:00:46.050
Das heißt, die Vorhersage war falsch.

01:00:46.930 --> 01:00:49.210
Aber danach ändert sich die Vorhersage auf taken.

01:00:49.910 --> 01:00:54.510
Und jetzt habe ich die nächsten Sprünge, Iteration 2 bis 9, habe ich

01:00:54.510 --> 01:00:55.550
die richtige Vorhersage.

01:00:56.930 --> 01:01:00.810
Das kann ich dann nutzen, um die Sprünge schneller auszuführen.

01:01:01.130 --> 01:01:03.470
Ich weiß, muss ich die Pipeline anhalten, muss ich sie nicht anhalten.

01:01:03.990 --> 01:01:06.550
Wenn ich konservativ wäre, würde ich immer sagen, Pipeline anhalten,

01:01:06.670 --> 01:01:07.470
bloß nicht weiterrechnen.

01:01:07.790 --> 01:01:10.750
Und so kann ich sagen, lass sie mal weiterlaufen und falls die

01:01:10.750 --> 01:01:13.250
Vorhersage falsch war, müssen wir aufräumen, müssen wir annullieren.

01:01:13.710 --> 01:01:16.530
Also gute Vorhersage hilft dabei, Geschwindigkeit zu gewinnen.

01:01:17.250 --> 01:01:20.090
Wenn ich irgendwann die letzte Iteration von der ersten Schleife habe,

01:01:20.510 --> 01:01:22.430
das ist ja die einzige, wo die Schleife verlassen wird.

01:01:22.530 --> 01:01:24.590
Die einzige, wo wirklich der Sprung nicht genommen wird.

01:01:26.010 --> 01:01:29.150
Dann ist die Vorhersage von den vorherigen Iterationen immer noch

01:01:29.150 --> 01:01:31.070
gewesen, dass der Sprung genommen werden soll.

01:01:31.750 --> 01:01:33.690
Das heißt, hier war dann die Vorhersage wieder falsch.

01:01:34.230 --> 01:01:35.310
Hier gehe ich aus der Schleife raus.

01:01:37.550 --> 01:01:41.210
Danach korrigiere ich meine Vorhersage unglücklicherweise auf Not

01:01:41.210 --> 01:01:41.610
Taken.

01:01:41.970 --> 01:01:44.110
Weil der letzte Sprung war ja nicht genommen.

01:01:44.390 --> 01:01:45.670
Also denke ich mal, der nächste wird auch nicht genommen.

01:01:46.050 --> 01:01:50.050
Aber der nächste ist gerade der Eingangspunkt für die zweite Schleife.

01:01:50.370 --> 01:01:51.350
Und der Sprung wird genommen.

01:01:51.510 --> 01:01:53.090
Also habe ich direkt zwei falsche nacheinander.

01:01:53.490 --> 01:01:55.890
Aber danach habe ich wieder ziemlich häufig recht.

01:01:56.370 --> 01:01:57.470
Ich denke, es wird gesprungen.

01:01:57.590 --> 01:01:58.370
Es wird auch gesprungen.

01:01:58.790 --> 01:02:00.770
Und am Ende habe ich halt wieder so einen Ausreißer.

01:02:00.770 --> 01:02:05.430
Das heißt, mit so einer 1-Bit-adaptiven Sprungvorhersage kann man

01:02:05.430 --> 01:02:07.650
schon so ein bisschen das Pattern verfolgen.

01:02:09.150 --> 01:02:11.590
Es gibt natürlich auch viele Erweiterungen.

01:02:11.710 --> 01:02:13.630
Eine sehen wir noch, eine mal kurz angerissen.

01:02:14.970 --> 01:02:20.010
Hier ist jetzt die Idee gewesen, dass es ein Sprungvorhersage-Bit

01:02:20.010 --> 01:02:20.290
gibt.

01:02:20.630 --> 01:02:21.750
Eine State Machine.

01:02:22.290 --> 01:02:25.910
In Wirklichkeit ist es eher so, dass es ganz viele von diesen

01:02:25.910 --> 01:02:28.230
Sprungvorhersage -Zuständen gibt.

01:02:28.230 --> 01:02:31.330
Es gibt quasi für jeden, wobei nicht für jeden, weil man weiß ja

01:02:31.330 --> 01:02:32.110
nicht, wie viel es geben könnte.

01:02:32.210 --> 01:02:39.450
Für viele Sprünge gibt es so eine Vorhersage-Bit, wo gemerkt wird, wo

01:02:39.450 --> 01:02:40.210
war der Sprung?

01:02:40.370 --> 01:02:42.730
Also an welcher Adresse ist der Sprung aufgetreten?

01:02:43.010 --> 01:02:45.690
Wenn ich den Sprung beobachte, trage ich ihn in diese Struktur ein,

01:02:45.770 --> 01:02:47.190
merke mir, da war ein Sprung.

01:02:47.850 --> 01:02:50.290
Und dann habe ich für jeden von diesen Einträgen, habe ich dann dieses

01:02:50.290 --> 01:02:52.870
eine Bit, taken oder not taken, die Vorhersage.

01:02:53.270 --> 01:02:56.290
Und ich merke mir auch, wo ging der Sprung denn hin?

01:02:56.290 --> 01:02:59.170
Das heißt, wenn ich den Sprung das erste Mal ausführe, muss ich

01:02:59.170 --> 01:03:02.930
wirklich berechnen mit ExecuteStage und so weiter, wie das Sprungziel

01:03:02.930 --> 01:03:03.190
ist.

01:03:03.450 --> 01:03:07.270
Wenn ich den Sprung das zweite Mal erwische, dann habe ich mir das

01:03:07.270 --> 01:03:08.170
Sprungziel gemerkt.

01:03:08.690 --> 01:03:11.650
Das heißt, da muss ich nicht bis zu ExecuteStage warten, bis ich weiß,

01:03:12.350 --> 01:03:13.170
wo die Adresse ist.

01:03:13.710 --> 01:03:17.150
Ich muss nicht bis zu ExecuteStage warten, bis ich weiß, ob der Sprung

01:03:17.150 --> 01:03:18.150
taken oder not taken ist.

01:03:18.230 --> 01:03:21.510
Sondern ich habe eine Vorhersage, taken, not taken, ja oder nein, und

01:03:21.510 --> 01:03:24.470
ich habe schon das gerechnete Sprungziel von früher.

01:03:24.470 --> 01:03:27.150
Und damit kann man dann wirklich das Ganze beschleunigen.

01:03:29.190 --> 01:03:32.650
Na gut, statt ein Bit, wenn man ein Bit kann, kann man auch zwei Bit.

01:03:33.210 --> 01:03:35.290
Drei und vier könnte man auch, macht aber irgendwo keinen Sinn mehr.

01:03:36.450 --> 01:03:41.490
Zwei-Bit-Prediktoren haben nicht nur offensichtlich die Zustände taken

01:03:41.490 --> 01:03:46.470
und not taken, sondern die deutlich auf den Folien lesbaren Zustände

01:03:46.470 --> 01:03:52.610
strongly not taken, also garantiert nicht genommen, weakly not taken,

01:03:52.850 --> 01:03:55.890
vermutlich, vielleicht nicht genommen, und dann die positiven

01:03:55.890 --> 01:03:58.830
Versionen weakly taken und strongly taken.

01:03:59.190 --> 01:04:02.730
Also ich habe verschiedene Abstufungen, wie sicher ich mir bin, ob der

01:04:02.730 --> 01:04:03.890
Sprung genommen wird oder nicht.

01:04:04.890 --> 01:04:07.970
Und die Vorhersage, ich meine die Vorhersage muss ja dann irgendwie

01:04:07.970 --> 01:04:10.710
eindeutig sein, was glaubst du, genommen oder nicht genommen.

01:04:11.050 --> 01:04:16.270
Und ich sage einfach, sowohl strongly not taken als auch weakly not

01:04:16.270 --> 01:04:19.990
taken haben die Vorhersage not taken und die beiden positiven haben

01:04:19.990 --> 01:04:21.890
die Vorhersage doch taken.

01:04:22.250 --> 01:04:25.490
Aber wenn ich nochmal auf die Folie vorhergehe, dieser Wechsel hier,

01:04:25.670 --> 01:04:29.870
wo ich die letzte Iteration und die erste Iteration, die gerade das

01:04:29.870 --> 01:04:32.210
umgedreht hat, das kann ich vermeiden.

01:04:34.310 --> 01:04:37.970
Sprich, hier war die letzte Iteration kein Sprung, deswegen habe ich

01:04:37.970 --> 01:04:40.050
angenommen, dann wird der nächste wohl auch kein Sprung sein.

01:04:40.450 --> 01:04:42.190
Und das wäre genau falsch, der war ja wieder einer.

01:04:42.510 --> 01:04:45.590
Bei dem nächsten sehen wir gleich, wird so sein, der hier ist kein

01:04:45.590 --> 01:04:51.170
Sprung, deswegen gehe ich von strongly not taken, gehe ich von

01:04:51.170 --> 01:04:55.030
strongly taken, was es vorher war, auf weakly taken.

01:04:55.350 --> 01:04:57.450
Aber die Vorhersage ist immer noch vermutlich wieder genommen.

01:04:57.770 --> 01:04:59.630
Also vielleicht, nicht strongly, aber vielleicht.

01:04:59.990 --> 01:05:02.390
Und deswegen ist die zweite Vorhersage hier besser.

01:05:02.770 --> 01:05:03.950
Das schauen wir uns hier ein Beispiel an.

01:05:05.310 --> 01:05:07.190
Ungeschickterweise ist es wieder dumm initialisiert.

01:05:07.710 --> 01:05:11.930
Es ist dumm initialisiert auf strongly not taken, auf keinen Fall

01:05:11.930 --> 01:05:12.250
genommen.

01:05:12.250 --> 01:05:15.590
Wir haben Iteration 1 von der ersten Schleife.

01:05:15.890 --> 01:05:18.690
Naja, die ersten neun Iterationen, da wird immer gesprungen.

01:05:19.110 --> 01:05:22.190
Das heißt, nicht genommen ist leider eine falsche Vorhersage gewesen.

01:05:22.630 --> 01:05:24.430
Danach ändere ich auf vielleicht nicht genommen.

01:05:24.690 --> 01:05:25.750
Ist immer noch falsch gewesen.

01:05:26.530 --> 01:05:28.270
Danach korrigiere ich auf vielleicht genommen.

01:05:28.710 --> 01:05:31.530
Jetzt bin ich im positiven Teil, also die Vorhersage ist taken.

01:05:32.170 --> 01:05:32.930
Das stimmt.

01:05:33.310 --> 01:05:35.410
Danach bin ich auf strongly taken, bin mir sicher.

01:05:35.950 --> 01:05:36.770
Das stimmt auch.

01:05:36.810 --> 01:05:37.550
Und das geht auch so weiter.

01:05:38.650 --> 01:05:40.750
Hier oben habe ich jetzt leider zwei Fehler gehabt.

01:05:40.750 --> 01:05:42.070
Beim anderen hatte ich nur einen.

01:05:42.350 --> 01:05:44.230
Das lag an dieser ungeschickten Initialisierung.

01:05:44.370 --> 01:05:45.410
Das ist ein Beispiel halt eben.

01:05:45.810 --> 01:05:48.050
Normalerweise würde man es eher mit weakly initialisieren, weil beim

01:05:48.050 --> 01:05:49.210
Start, man weiß es nicht.

01:05:49.270 --> 01:05:51.210
Warum soll man, wenn man es nicht weiß, strongly vorhersagen?

01:05:51.570 --> 01:05:52.350
Das wäre eher weakly.

01:05:52.850 --> 01:05:53.090
Egal.

01:05:53.550 --> 01:05:58.450
Zumindest habe ich jetzt hier den Punkt angekommen, die fünf bis neun

01:05:58.450 --> 01:06:00.290
Sprünge waren richtig vorhergesagt, taken.

01:06:03.890 --> 01:06:05.990
Dann habe ich Iteration 10.

01:06:06.130 --> 01:06:09.610
Die Vorhersage ist immer noch strongly taken, aber die zehnte

01:06:09.610 --> 01:06:10.490
Iteration ist die letzte.

01:06:10.490 --> 01:06:11.810
Also da kommt kein Sprung.

01:06:12.190 --> 01:06:13.610
Also war das eine falsche Vorhersage.

01:06:14.170 --> 01:06:17.790
Und jetzt ändert sich meine Vorhersage von strongly taken auf

01:06:17.790 --> 01:06:19.230
vielleicht gesprungen.

01:06:19.590 --> 01:06:21.970
Aber vielleicht gesprungen heißt immer noch, ja, wahrscheinlich

01:06:21.970 --> 01:06:22.650
springst du doch.

01:06:22.770 --> 01:06:24.450
Nicht mehr ganz so sicher, aber stimmt, wird schon.

01:06:24.990 --> 01:06:26.870
Und das war dann wieder eine richtige Vorhersage.

01:06:27.330 --> 01:06:29.510
Das heißt, dieser Wechsel von der einen Schleife auf die andere

01:06:29.510 --> 01:06:32.610
Schleife hat nur noch eine falsche Vorhersage im Vergleich zu zwei

01:06:32.610 --> 01:06:34.490
falschen Vorhersagen bei dem Einbildprediktor.

01:06:35.270 --> 01:06:36.830
Das ist im Wesentlichen der Hauptvorteil.

01:06:38.010 --> 01:06:41.330
Das Ganze klappt noch besser, wenn man, wie gesagt, für jeden Sprung

01:06:41.330 --> 01:06:45.470
oder nicht für jeden, aber für sehr viele einen Eintrag hat und nicht

01:06:45.470 --> 01:06:46.430
nur einen globalen.

01:06:47.890 --> 01:06:51.370
Es gibt eine unglaubliche Anzahl an weiteren

01:06:51.370 --> 01:06:54.350
Sprungvorhersageverfahren, die wahrscheinlich alleine die Vorlesung

01:06:54.350 --> 01:06:54.870
sprengen würden.

01:06:54.970 --> 01:06:56.730
Ich meine nicht nur diese heute, sondern generell.

01:06:57.410 --> 01:06:59.310
Wenn man sich zum Beispiel überlegt, ich hatte das vorhin schon

01:06:59.310 --> 01:07:03.090
angerissen, das kommt auch später noch auf die Folie, dass der Pentium

01:07:03.090 --> 01:07:08.910
4 zu seiner Hitzezeit 31 Pipeline-Stufen hatte.

01:07:09.570 --> 01:07:13.170
Wenn man da einen Sprung falsch vorhersagt, das ist die Hölle auf

01:07:13.170 --> 01:07:13.410
Erden.

01:07:13.850 --> 01:07:17.110
Diese 31 Pipeline-Stufen machen dann was Falsches, muss alles wieder

01:07:17.110 --> 01:07:17.870
aufgeräumt werden.

01:07:17.930 --> 01:07:19.950
Das Aufräumen kostet dann auch noch extra Zeit, weil man dann

01:07:19.950 --> 01:07:22.110
annulieren nicht mehr reicht, sondern wirklich rollback gemacht werden

01:07:22.110 --> 01:07:22.310
muss.

01:07:22.890 --> 01:07:23.790
Das ist sehr unangenehm.

01:07:23.790 --> 01:07:26.730
Ich habe von der damaligen Zeit, also Pentium 4 gibt es zum Glück

01:07:26.730 --> 01:07:32.850
nicht mehr, Assembler-Code-Schnippel gesehen, die haben ein Maximum

01:07:32.850 --> 01:07:34.750
ausgerechnet, Maximum von zwei Zahlen.

01:07:34.830 --> 01:07:37.430
Das ist normalerweise Vergleich, bedingter Sprung, zuweisen, fertig.

01:07:38.190 --> 01:07:41.630
Die haben ein Maximum ausgerechnet mit einer 10 plus bisschen was

01:07:41.630 --> 01:07:45.410
Assembler -Befehlen hin- und herschieben, komplett unverständlich,

01:07:45.490 --> 01:07:49.590
aber hat funktioniert, nur um keinen Sprung drin zu haben und war im

01:07:49.590 --> 01:07:52.030
Schnitt schneller als einfach nur Vergleich und Springen.

01:07:52.030 --> 01:07:56.130
Das ist so die Extreme gewesen, die glücklicherweise in der

01:07:56.130 --> 01:07:56.790
Vergangenheit liegen.

01:07:57.650 --> 01:08:00.170
Aber trotzdem, Sprungversage ist immer noch wichtig, sie war halt nur

01:08:00.170 --> 01:08:01.470
nie wichtiger als von Pentium 4.

01:08:04.290 --> 01:08:08.810
Ja, um es nochmal kurz anzureißen, es gibt, als nächstes kommt hier

01:08:08.810 --> 01:08:10.470
nicht vor, kommt in Rechnerstrukturen dann vor,

01:08:10.930 --> 01:08:12.450
Korrelationsprediktoren.

01:08:12.970 --> 01:08:17.290
Da ist die Idee, warum soll jeder Sprung einzeln betrachtet werden?

01:08:17.710 --> 01:08:21.270
Warum soll man nicht die Sequenz der zuletzt durchgeführten Sprünge,

01:08:21.270 --> 01:08:25.550
also zeitlich vorher durchgeführte Sprünge, berücksichtigen, um den

01:08:25.550 --> 01:08:27.130
jetzigen Sprung vorherzusagen?

01:08:27.530 --> 01:08:30.450
Vielleicht habe ich irgendwo einen C-Code, der sagt, if a kleiner b,

01:08:30.610 --> 01:08:32.990
dann, dann kommt es wieder zusammen, rechne, rechne, rechne und dann

01:08:32.990 --> 01:08:35.110
nochmal if a kleiner b und a und b haben sich nicht geändert.

01:08:35.410 --> 01:08:38.890
Was auch immer oben die Entscheidung war, ist unten wieder die

01:08:38.890 --> 01:08:39.270
Entscheidung.

01:08:39.410 --> 01:08:41.330
Die können zusammenhängen, die beiden Sprünge.

01:08:41.850 --> 01:08:44.730
So was kann man dann erkennen, wenn man einen Korrelationsprediktor

01:08:44.730 --> 01:08:47.970
hat, der sich die Vergangenheit, wie kam ich zu dem Sprung hin, mit

01:08:47.970 --> 01:08:48.550
berücksichtigt.

01:08:48.550 --> 01:08:51.230
Aber die werden dann echt unterhaltsam.

01:08:54.810 --> 01:08:59.050
Gut, ich hatte schon gesagt, es gibt in der Instruction Fetch-Stufe

01:08:59.050 --> 01:09:03.110
einen kleinen extra Block, heißt üblicherweise BranchTargetAdressCache

01:09:03.110 --> 01:09:07.670
oder einfach BranchTargetBuffer, wo gespeichert wird für die bisher

01:09:07.670 --> 01:09:11.870
beobachteten Sprungbefehle, wo geht es denn hin und wo man dann im

01:09:11.870 --> 01:09:14.450
Idealvergleich noch den Prediktor mit reinschreiben kann, falls es

01:09:14.450 --> 01:09:16.510
nicht wie in dem Beispiel gerade ein globaler Prediktor ist.

01:09:16.510 --> 01:09:19.350
Und beim ersten Mal muss es erst gefüllt werden, da muss man die

01:09:19.350 --> 01:09:20.750
Pipeline anhalten, bis es ausgerechnet ist.

01:09:20.830 --> 01:09:24.230
Beim folgenden Mal kann man eben das Sprungziel aus diesem

01:09:24.230 --> 01:09:27.910
BranchTargetAdressCache rausnehmen und mit der Sprungvorhersage dann

01:09:27.910 --> 01:09:31.130
direkt da weitermachen, wo man glaubt, dass es weitergeht, bis dann

01:09:31.130 --> 01:09:33.870
feststeht, ob es man richtig geraten hatte oder falsch geraten.

01:09:35.330 --> 01:09:38.850
Die Beispiele gerade hatten glaube ich so 80% Vorhersagerichtigkeit.

01:09:39.270 --> 01:09:42.930
Bei richtigen Anwendungen und den aktuellen Sprungvorhersagetechniken

01:09:42.930 --> 01:09:50.310
bei über 90, Pension4 war bei 96 bis zu 98% der Sprünge richtig

01:09:50.310 --> 01:09:50.930
vorhergesagt.

01:09:51.050 --> 01:09:53.110
Also sehr, sehr hohe Zuverlässigkeit.

01:09:56.830 --> 01:10:00.790
Ja, dann gucken wir uns die Pipelines auch mal an.

01:10:02.890 --> 01:10:06.730
Wir haben jetzt eine ziemlich einfache MIPS, LELIX, whatever Pipeline

01:10:06.730 --> 01:10:08.050
mit nur fünf Stufen.

01:10:09.750 --> 01:10:13.990
Bei heutigen CPUs, die laufen ja mit einer relativ hohen Taktfrequenz,

01:10:14.350 --> 01:10:16.170
immer noch zwischen ein und vier Gigahertz.

01:10:16.890 --> 01:10:19.630
Also das war zwischendurch mal erreicht beim Pension4, dann ging es

01:10:19.630 --> 01:10:21.410
drastisch runter, also schlechter mit der Frequenz.

01:10:21.510 --> 01:10:23.250
Inzwischen sind wir ja wieder bei vier Gigahertz angekommen.

01:10:23.630 --> 01:10:26.150
Was aber daran liegt, dass die Herstellungstechnologie so viel

01:10:26.150 --> 01:10:29.130
geschrumpft ist, dass sie bei ihren weniger Stufen trotzdem die hohe

01:10:29.130 --> 01:10:29.830
Frequenz erreichen.

01:10:30.590 --> 01:10:34.330
Und ein Gigahertz ist immer so eine Gegend, also ein Gigahertz ist

01:10:34.330 --> 01:10:37.810
gerade eine Nanosekunde, aber das ist schon nicht mehr mehr

01:10:37.810 --> 01:10:40.810
Nanosekunden, das sind Pikosekunden, die man dafür gewöhnlich als

01:10:40.810 --> 01:10:41.610
Zeitangabe hat.

01:10:41.690 --> 01:10:44.010
Das sind schon wirklich kurz.

01:10:44.450 --> 01:10:49.150
Ein Wimpernaufschlag ist Millisekunde, das ist wirklich verdammt kurz.

01:10:50.090 --> 01:10:54.450
Zusätzlich können die modernen Pipelines nicht nur einen Befehl pro

01:10:54.450 --> 01:10:55.010
Takt ausrechnen.

01:10:56.970 --> 01:11:00.870
Die jonglieren mit teilweise über 100 Befehlen gleichzeitig.

01:11:00.870 --> 01:11:05.430
Wobei jonglieren hier heißen soll, nicht, dass die 100 Befehle

01:11:05.430 --> 01:11:09.390
gleichzeitig rechnen, also 100 ALUs, die gleichzeitig rechnen.

01:11:09.550 --> 01:11:11.150
Das machen normale CPUs nicht.

01:11:12.050 --> 01:11:17.170
Aber in ihrer Pipeline, die ja lang sein kann, tummeln sich bis zu

01:11:17.170 --> 01:11:18.570
oder über 100 Befehle.

01:11:18.910 --> 01:11:21.730
Teilweise werden sowieso mehr als ein Befehl gefetscht.

01:11:21.810 --> 01:11:23.750
Wenn ich nur ein Befehl pro Takt fetsche, dann kriege ich das ganze

01:11:23.750 --> 01:11:24.330
Ding nicht gefüllt.

01:11:24.830 --> 01:11:27.370
Ich kann nochmal acht Befehle pro Takt reinfetschen, kann acht Befehle

01:11:27.370 --> 01:11:30.990
parallel dekodieren und dann kann ich mir angucken, haben die zufällig

01:11:30.990 --> 01:11:34.350
Datenabhängigkeiten, ist die Ressource gerade frei und dann werden die

01:11:34.350 --> 01:11:38.230
Befehle einfach in der Reihenfolge, wie die Datenabhängigkeiten es

01:11:38.230 --> 01:11:41.250
vorgeben und wie die Ressourcen frei sind, auf die Einheiten zur

01:11:41.250 --> 01:11:42.090
Ausführung gebracht.

01:11:42.590 --> 01:11:44.470
Ist doch völlig egal, was der Programmierer immer wollte.

01:11:44.570 --> 01:11:46.810
Der hat irgendwie eine Reihenfolge der Befehle hingeschrieben, who

01:11:46.810 --> 01:11:47.130
cares.

01:11:47.410 --> 01:11:49.290
Wenn die Ressource gerade frei ist, dann rechne ich es schon mal

01:11:49.290 --> 01:11:49.510
früher.

01:11:50.070 --> 01:11:52.930
Es sei denn, da sind Datenabhängigkeiten drin, die der Programmierer

01:11:52.930 --> 01:11:53.490
angegeben hat.

01:11:53.550 --> 01:11:54.190
Die muss ich berücksichtigen.

01:11:54.990 --> 01:11:59.190
Aber ansonsten werden die out of order, nicht mehr in der Reihenfolge,

01:11:59.250 --> 01:12:00.870
wie es im Programmcode steht, ausgeführt.

01:12:00.990 --> 01:12:03.910
Und deswegen insgesamt in der Pipeline sind dann sehr viele 100

01:12:03.910 --> 01:12:06.970
Befehle, die irgendwo teilweise in der Ausführung, teilweise in der

01:12:06.970 --> 01:12:10.510
Vorbereitung, teilweise warten, bis es sicher ist, dass der Sprung

01:12:10.510 --> 01:12:11.390
noch wirklich genommen ist.

01:12:11.610 --> 01:12:12.150
Da muss ich überlegen.

01:12:12.270 --> 01:12:15.530
Da sind dann Dutzende Befehle, die sind schon fertig gerechnet und die

01:12:15.530 --> 01:12:18.810
warten nur noch, hat die Sprungförse jetzt recht gehabt oder nicht?

01:12:18.890 --> 01:12:20.770
Ich würde es gerne zurückschreiben, aber ich traue mich noch nicht.

01:12:20.870 --> 01:12:23.210
Die warten nur, ja, Sprung ist genommen, dann zack, schreiben die alle

01:12:23.210 --> 01:12:23.470
zurück.

01:12:24.130 --> 01:12:27.730
Ja, Pentium 4 war sicherlich ein Negativbeispiel.

01:12:28.490 --> 01:12:31.450
Die Core-I-Generation, die aktuelle, sind sicherlich ein

01:12:31.450 --> 01:12:32.230
Positivbeispiel.

01:12:32.870 --> 01:12:34.830
Und Atom tummelt sich so irgendwo um den Niemandsland.

01:12:36.410 --> 01:12:39.130
Pentium 4 gab es in verschiedenen Geschmacksstufen.

01:12:40.590 --> 01:12:45.790
Die ersten Pentium 4s hatten eine nur 20-stufige Pipeline, das war der

01:12:45.790 --> 01:12:46.290
Willamette.

01:12:47.150 --> 01:12:48.570
Das waren wirklich die ersten aus der Generation.

01:12:49.090 --> 01:12:53.250
Und die letzten, Prescott war der vorletzte, aber ab da hatten sie

01:12:53.250 --> 01:12:54.990
eine 31-stufige Pipeline.

01:12:55.610 --> 01:12:58.970
Und auch schon diese 20-stufigen Pipeline, ich habe da meine zwei

01:12:58.970 --> 01:13:03.410
Lieblingsstufen, Stufe 5 und Stufe 20, sind total unterhaltsam.

01:13:04.070 --> 01:13:06.310
Die heißen nämlich beide Drive.

01:13:06.930 --> 01:13:10.010
Und Drive soll jetzt nicht heißen, dass da irgendwas fährt, sondern

01:13:10.010 --> 01:13:13.510
die treiben, so wie man elektrischen Strom treiben kann.

01:13:13.810 --> 01:13:16.050
Sprich, da kommt ein Signal an, es ist ein bisschen schwach, dann wird

01:13:16.050 --> 01:13:17.910
es verstärkt und irgendwo anders hingeschickt.

01:13:17.910 --> 01:13:20.570
Diese beiden Stufen rechnen nicht.

01:13:21.090 --> 01:13:22.190
Die tun überhaupt nichts.

01:13:22.470 --> 01:13:26.570
Die sind nur dafür verantwortlich, ein Datum von der einen Ecke des

01:13:26.570 --> 01:13:28.890
Chips in die andere Ecke des Chips zu schicken.

01:13:29.170 --> 01:13:32.530
Weil die Taktfrequenz war so hoch, das hat er nicht geschafft, in

01:13:32.530 --> 01:13:34.350
einem Takt schicken und rechnen.

01:13:34.810 --> 01:13:37.810
Die Stufen machen gar nichts, die schicken nur Daten in der Gegend

01:13:37.810 --> 01:13:37.990
rum.

01:13:38.530 --> 01:13:41.490
Und der 31-stufige hat noch mehr von diesen Drive-Stufen.

01:13:41.930 --> 01:13:45.690
Das zeigt sicherlich, dass da irgendwo eine Grenze erreicht worden

01:13:45.690 --> 01:13:47.850
ist, irgendwo die Sinnhaftigkeit verloren gegangen ist.

01:13:48.270 --> 01:13:50.630
Und das haben Sie am Ende von Pentium 4 auch recht nachdeutlich

01:13:50.630 --> 01:13:51.410
gemerkt.

01:13:53.930 --> 01:13:57.310
Hier sind es 126 Instruktionen, die gleichzeitig in irgendwelchen

01:13:57.310 --> 01:13:59.290
dieser Stufen aufgehalten werden können.

01:14:00.130 --> 01:14:00.610
Wir können mal gucken.

01:14:00.910 --> 01:14:04.290
Das ist hier der Trace Cache, der den nächsten Befehl heranholt.

01:14:04.810 --> 01:14:09.070
Also, was ich nicht gesagt habe, ist, bei unserer Pipeline war der

01:14:09.070 --> 01:14:12.310
nächste Befehl, also die Adresse für den nächsten Befehl, kam immer

01:14:12.310 --> 01:14:13.330
aus dem Program Counter.

01:14:13.330 --> 01:14:16.750
In Wirklichkeit kommt die, also bei solchen CPUs, aus dem Trace Cache.

01:14:16.810 --> 01:14:19.810
Trace Cache war dieses Ding, was sich die Adresse von Sprüngen, also

01:14:19.810 --> 01:14:21.450
die Sprungzieladresse merkt.

01:14:21.910 --> 01:14:24.250
Und die wird einfach immer gefragt, was ist denn die nächste Adresse?

01:14:24.610 --> 01:14:26.770
Und wenn es kein Sprung war, macht sie auch Plus 4.

01:14:26.870 --> 01:14:30.370
Und wenn es doch ein Sprung war, gibt sie das Sprungziel einfach raus.

01:14:32.150 --> 01:14:33.610
Also hier wird berechnet, was ist der nächste?

01:14:34.050 --> 01:14:36.790
Hier Fetch, man kann schon sehen, das sind immer zwei Stufen, die nur,

01:14:37.470 --> 01:14:40.590
frag mal den Trace Cache und hol die Daten aus dem Trace Cache.

01:14:40.590 --> 01:14:42.730
Sind schon vier Takte rum, wir haben den Befehl noch überhaupt nicht.

01:14:43.470 --> 01:14:46.470
Jetzt schicken wir den Befehl an die andere Ecke des Chips und da

01:14:46.470 --> 01:14:49.470
werden jetzt Ressourcen reserviert, allokiert.

01:14:50.230 --> 01:14:52.850
Der braucht eine Recheneinheit, der braucht Quellregister, der braucht

01:14:52.850 --> 01:14:55.070
Zielregister, da muss man mal gucken, wo sind denn die alle, die muss

01:14:55.070 --> 01:14:55.690
man mal reservieren.

01:14:56.490 --> 01:15:01.190
Wenn es Namensabhängigkeiten gibt, Namensabhängigkeiten waren gerade

01:15:01.190 --> 01:15:04.930
diese Output Dependencies oder Anti-Dependencies, dann kann man die

01:15:04.930 --> 01:15:07.670
auflösen, indem man einfach dem Ding einen anderen Namen gibt.

01:15:07.670 --> 01:15:10.510
Sprich, die CPUs haben innen drin viel mehr Register, als der

01:15:10.510 --> 01:15:11.670
Programmierer von außen sieht.

01:15:12.110 --> 01:15:14.750
Und wenn eine Namensabhängigkeit besteht, dann nimmt man eins von den

01:15:14.750 --> 01:15:16.810
anderen Register, die von außen sowieso nicht sichtbar sind.

01:15:17.170 --> 01:15:19.930
Das macht diese Rename-Stufe, also wieder zwei Stufen eigentlich.

01:15:20.630 --> 01:15:22.190
Dann wird es in eine Warteschlange eingehangen.

01:15:22.350 --> 01:15:26.930
Schedule ist einfach warten, bis eine Ressource verfügbar wird.

01:15:27.730 --> 01:15:31.490
Also das sind Warteschlangen vor jeder Ressource und da einsortieren

01:15:31.490 --> 01:15:33.110
in der Warteschlange nach den Datenabhängigkeiten.

01:15:34.650 --> 01:15:37.490
Dispatch ist dann das Abschicken an die Einheit.

01:15:44.570 --> 01:15:48.410
Was man auf jeden Fall sehen kann, ist, es wird auch noch gerechnet.

01:15:49.030 --> 01:15:51.870
Hier ist sogar noch eine Stufe, in der echt mal gerechnet wird.

01:15:52.270 --> 01:15:54.110
Ist ja eigentlich nett, weil man will ja eigentlich rechnen.

01:15:55.310 --> 01:15:58.750
Und dann geht das Ganze wieder einsammeln, aufräumen und

01:15:58.750 --> 01:15:59.110
zurückschicken.

01:15:59.870 --> 01:16:01.690
Drive wieder zurückschicken, wo es herkam.

01:16:02.530 --> 01:16:04.990
Und wie gesagt, Out of Order, die werden in der Reihenfolge

01:16:04.990 --> 01:16:08.790
ausgeführt, wie Datenabhängigkeiten und Ressourceverfügbarkeit es

01:16:08.790 --> 01:16:09.170
erlauben.

01:16:09.450 --> 01:16:11.910
Nicht in der Reihenfolge, wie der Compiler sich das gedacht hat.

01:16:12.790 --> 01:16:14.810
Also es sind sehr viele Stufen, sehr kleine Stufen.

01:16:15.350 --> 01:16:19.470
Damals schon 3,8 Gigahertz, das war die offizielle Angabe.

01:16:20.050 --> 01:16:22.750
Und dann gab es die wassergekühlten Version mit 6 Gigahertz.

01:16:23.230 --> 01:16:26.110
Also nicht offiziell, sondern so Toms Hardware oder irgendwer.

01:16:26.730 --> 01:16:30.270
Und dann gab es die Pelletier-Elemente, sprich Pelletier-Elemente ist

01:16:30.270 --> 01:16:32.810
so ein Ding, wenn man da Strom dran gibt, wird die eine Seite heiß und

01:16:32.810 --> 01:16:33.410
die andere kalt.

01:16:33.770 --> 01:16:35.430
Und kalt im Sinne von, das kann auch Minus sein.

01:16:35.850 --> 01:16:38.990
Wenn man die Teile auf die CPU draufklebt, dann sind die CPUs wirklich

01:16:38.990 --> 01:16:41.930
negative Temperaturen und nach oben muss man mit der Wasserkühlung die

01:16:41.930 --> 01:16:42.750
Wärme wegmachen.

01:16:43.030 --> 01:16:44.090
Die waren bei 8 Gigahertz.

01:16:44.890 --> 01:16:47.830
Das geht heute glaube ich nicht mehr mit 8, aber das war damals noch,

01:16:48.330 --> 01:16:51.190
weil die halt so extremen Pipeline-Stufen hatten, möglich.

01:16:57.290 --> 01:17:00.630
Ja, kann man jetzt möglicherweise erkennen, das ist offensichtlich ein

01:17:00.630 --> 01:17:01.190
Pentium 4.

01:17:02.410 --> 01:17:04.570
Das ist noch der alte, also der mit den 20 Stufen.

01:17:06.330 --> 01:17:08.250
Schauen wir mal, ob wir da irgendwas erkennen können.

01:17:11.050 --> 01:17:13.670
System-Bus ist die Anbindung nach außen.

01:17:13.910 --> 01:17:16.970
Also da hängt dann der DRAM-Speicher dran, da hängt irgendwer eine

01:17:16.970 --> 01:17:18.170
zweite CPU oder sowas dran.

01:17:18.570 --> 01:17:19.510
Alles, was weit weg ist.

01:17:19.510 --> 01:17:23.450
Vom System-Bus gibt es eine Schnittstelle, um Daten reinzuschaffen,

01:17:23.530 --> 01:17:25.250
also Befehle, Daten reinzuschaffen.

01:17:26.390 --> 01:17:30.790
Vierfach getaktet kann insgesamt immerhin 3,2 Gigabyte pro Sekunde in

01:17:30.790 --> 01:17:31.830
die CPU reinholen.

01:17:32.010 --> 01:17:35.230
Wobei in die CPU heißt, erstmal in den L2-Cache.

01:17:37.730 --> 01:17:42.090
Von da haben wir hier einen L1 für Daten-Cache.

01:17:42.950 --> 01:17:45.310
Wo ist denn der L1 für den Befehls-Cache?

01:17:49.570 --> 01:17:52.210
Eventuell ist der Lookahead-Buffer hier.

01:17:52.770 --> 01:17:56.670
Wahrscheinlich werden die Befehle dann hier oben, also über den 2,56

01:17:56.670 --> 01:17:59.550
Bit breiten Bus mehrere Befehle hier oben reingeholt.

01:18:01.730 --> 01:18:03.370
Sprungvorhersage hängt auch hier oben mit drin.

01:18:03.810 --> 01:18:06.330
Und daraus werden jetzt mehrere Befehle rausgeholt, die dekodiert

01:18:06.330 --> 01:18:10.870
werden und dann nachanalysiert, um die ganzen Abhängigkeiten zu gucken

01:18:10.870 --> 01:18:12.430
und zu schauen, dass es keine Konflikte werden.

01:18:15.570 --> 01:18:18.450
Achso, was man vielleicht auch noch sagen könnte, das Ganze ist micro

01:18:18.450 --> 01:18:18.810
-coded.

01:18:19.030 --> 01:18:23.290
Soll heißen, x86 ist ja ein CISC-Befehlssatz.

01:18:23.490 --> 01:18:24.610
CISC, RISC hattet ihr ja schon.

01:18:25.990 --> 01:18:27.250
CISC ist sehr ärgerlich.

01:18:28.050 --> 01:18:32.570
Es sind seit Pentium Pro, glaube ich, keine CISC-CPUs mehr, das sind

01:18:32.570 --> 01:18:33.390
RISC -CPUs.

01:18:33.870 --> 01:18:37.970
Das sind innen drin RISC-CPUs, die nach außen den Befehlssatz einer

01:18:37.970 --> 01:18:39.130
CISC -CPU haben.

01:18:39.530 --> 01:18:41.110
Und irgendwo dazwischen wird es übersetzt.

01:18:41.470 --> 01:18:43.790
Und das ist genau diese micro-code-Einheit.

01:18:43.790 --> 01:18:48.630
Sprich, da kommt ein CISC-Befehl von außen rein, der wird übersetzt in

01:18:48.630 --> 01:18:52.810
eine Sequenz von RISC-Befehlen und diese RISC-Befehle werden danach

01:18:52.810 --> 01:18:53.830
zur Ausführung gebracht.

01:18:54.430 --> 01:18:57.490
Das ist auch ganz nett, weil diese vielen RISC-Befehle, also von zwei

01:18:57.490 --> 01:19:01.230
verschiedenen CISC-Befehlen, die jeweils vielen RISC-Befehle, das gibt

01:19:01.230 --> 01:19:03.990
eine Menge, also einen hohen Grad an Parallelität, um danach die

01:19:03.990 --> 01:19:06.290
vielen Ausführungseinheiten auch busy zu halten.

01:19:06.290 --> 01:19:09.790
Und der CISC-Befehl hat den Vorteil, dass es ein ziemlich dichter Code

01:19:09.790 --> 01:19:13.230
ist, also mit wenig Speicherzugriffen kann man da sehr viele Befehle

01:19:13.230 --> 01:19:14.070
heranschaffen.

01:19:14.890 --> 01:19:16.030
Hat aber auch einen Nachteil.

01:19:20.130 --> 01:19:25.750
Der CISC-Befehlssatz von Pentium 4 ist ja ein variabler Befehlslänger.

01:19:25.970 --> 01:19:29.410
Das heißt nicht wie bei unserer DLX-Pipeline, jeder Befehl ist 32 Bit

01:19:29.410 --> 01:19:33.570
lang, sondern es gibt Befehle, die sind kurz, bis runter zu einem Byte

01:19:33.570 --> 01:19:36.710
nur, und Befehle, die sind lang, 64 Bit lang.

01:19:37.030 --> 01:19:38.790
Also verschieden lange Befehle.

01:19:39.010 --> 01:19:42.510
Das heißt, der Decoder muss erstmal herausfinden, wie lang ist

01:19:42.510 --> 01:19:45.390
eigentlich der nächste Befehl, sprich, wo hört der Befehl überhaupt

01:19:45.390 --> 01:19:46.030
wieder auf.

01:19:46.630 --> 01:19:49.490
Da gibt es eine Einheit für, die ist nur dafür verantwortlich zu

01:19:49.490 --> 01:19:51.670
sagen, der Befehl geht bis dahin.

01:19:52.290 --> 01:19:54.890
Und diese Einheit ist ungefähr so groß wie unsere MIPS-CPU.

01:19:55.550 --> 01:19:57.910
Einfach nur um so eine Idee zu geben, wie viel Overhead in diesen

01:19:57.910 --> 01:20:00.530
Konzepten drinsteckt, aber es lohnt sich halt irgendwo dann auch

01:20:00.530 --> 01:20:02.830
wieder für so Desktop-große Systeme.

01:20:04.810 --> 01:20:07.310
Gut, jetzt haben wir hier die verschiedenen Ausführungseinheiten.

01:20:07.470 --> 01:20:09.570
Das kann man gut sehen, das sind parallele Ausführungseinheiten.

01:20:10.110 --> 01:20:13.950
Es gibt verschieden schnelle, im Sinne von, manchmal sind Rechnungen

01:20:13.950 --> 01:20:16.090
da, da hängen sehr viele andere Befehle von ab.

01:20:16.150 --> 01:20:17.950
Die warten aufs Ergebnis, die sind datenabhängig.

01:20:18.470 --> 01:20:21.130
Und dann gibt es halt eben auch langsamere Ausführungseinheiten, die

01:20:21.130 --> 01:20:22.290
sparen Strom und Fläche.

01:20:22.910 --> 01:20:25.090
Und wenn gerade keine Abhängigkeiten sind, kann man es auch dahin

01:20:25.090 --> 01:20:25.530
schedulen.

01:20:26.350 --> 01:20:28.750
Genauso gibt es für Floating Point extra Einheiten, sowohl

01:20:28.750 --> 01:20:31.630
Speicherzugriff als auch die eigentlichen Rechneinheiten.

01:20:31.630 --> 01:20:34.390
Wir haben auch extra Register-File mit Copy-Befehlen zwischen normalen

01:20:34.390 --> 01:20:35.710
Register -File und Floating Point Register-File.

01:20:36.210 --> 01:20:37.370
Und hier unten sind dann die ALUs.

01:20:37.530 --> 01:20:41.810
Die langsame, hier zwei für normale Befehle und zwei

01:20:41.810 --> 01:20:46.170
Adressgenerierungseinheiten, also einfach nur x86 oder sehr

01:20:46.170 --> 01:20:49.370
komplizierte Adressmodi, um die unterstützen zu können.

01:20:49.950 --> 01:20:54.510
Also man kann sehen, ziemlich komplexe Mikroarchitektur.

01:20:55.250 --> 01:20:58.750
Der Core i, also die dritte Generation von den Cores, also Core i3,

01:20:58.910 --> 01:21:01.750
Core i5, Core i7, sind deutlich einfacher aufgebaut.

01:21:02.070 --> 01:21:05.890
Die haben nur 14 Stufen, was ja signifikant weniger ist als diese 30

01:21:05.890 --> 01:21:06.170
gerade.

01:21:07.090 --> 01:21:09.890
Das ist auch meiner Meinung nach ein ziemlich guter Kompromiss.

01:21:10.610 --> 01:21:12.270
Also es funktioniert ja zumindest erstaunlich gut.

01:21:13.610 --> 01:21:17.670
Da ist halt eher, dass die mehr auf Parallelität gelegt haben, diese

01:21:17.670 --> 01:21:20.590
Analysefähigkeit, was kann man Out of Order ausführen, noch weiter

01:21:20.590 --> 01:21:24.970
verbessert haben, um mehr Befehle gleichzeitig ausführen zu können und

01:21:24.970 --> 01:21:29.050
deswegen trotzdem schneller zu sein, obwohl man viele Gigahertz am

01:21:29.050 --> 01:21:30.910
Anfang zumindest langsamer war.

01:21:31.190 --> 01:21:34.190
Inzwischen gibt es ja auch wieder welche Core i3, Core i5, Core i7 mit

01:21:34.190 --> 01:21:38.630
bis zu 4 Gigahertz, also da wo Pentium 4 irgendwann mal Gehäuse

01:21:38.630 --> 01:21:39.310
geschmolzen hat.

01:21:39.410 --> 01:21:39.870
Das war unglaublich.

01:21:39.910 --> 01:21:40.710
Ich habe noch einen zu Hause.

01:21:40.850 --> 01:21:42.970
Wenn mir Winter kalt ist, ich mache nur den Rechner an, ich brauche

01:21:42.970 --> 01:21:43.610
keine Heizung.

01:21:44.030 --> 01:21:45.090
Die sind echt unglaublich gewesen.

01:21:45.770 --> 01:21:50.270
Naja, diese Core i Sachen sind deutlich energieeffizienter, einfach

01:21:50.270 --> 01:21:53.410
weil die halt mehr Rechnung pro Takt durchführen können.

01:21:54.610 --> 01:21:56.670
Wir haben entsprechend auch mehr Recheneinheiten, mal gucken, ob wir

01:21:56.670 --> 01:21:57.130
die finden.

01:21:57.890 --> 01:22:02.210
Hier haben wir so ALUs, 256-Bit-Multiplier, also es gibt sehr viele

01:22:02.210 --> 01:22:04.270
Rechenoperationen, die hier parallel ausgeführt werden können.

01:22:04.670 --> 01:22:08.630
Und natürlich, die Caches sind das Wichtige an der Sache, um die CPUs

01:22:08.630 --> 01:22:11.690
beschäftigt zu halten, um genug Daten und Befehle ran schaffen zu

01:22:11.690 --> 01:22:11.910
können.

01:22:13.610 --> 01:22:16.230
Atom, wobei das ist noch die erste Generation von Atom gewesen.

01:22:16.230 --> 01:22:19.370
Ja, die erste war jetzt nicht so super.

01:22:19.830 --> 01:22:21.570
Die Nachfolgenden werden ja echt immer besser momentan.

01:22:22.590 --> 01:22:27.030
Die waren eigentlich direkte Nachfolger von dem alten Pentium 3.

01:22:28.450 --> 01:22:34.790
Sprich, der Pentium 3, von dem Pentium, also Pentium nur, also eins

01:22:34.790 --> 01:22:39.630
sozusagen, der war extrem einfach gestrickt.

01:22:39.870 --> 01:22:43.610
Also gut, es war ein CISC, in Ordnung, aber der hatte wirklich nur

01:22:43.610 --> 01:22:44.450
eine Pipeline.

01:22:44.450 --> 01:22:46.730
Kein Out-of-Order, keine komplexen Sachen.

01:22:47.530 --> 01:22:49.410
Und das haben die für Atom benutzt.

01:22:49.790 --> 01:22:53.950
Die Idee war, dieses Out-of-Order, also Befehle außerhalb der vom

01:22:53.950 --> 01:22:57.070
Programmierer vorgegebenen Reihenfolge ausführen zu können, hat einen

01:22:57.070 --> 01:23:00.330
unglaublich hohen Analyseaufwand, um sicherzustellen, man kann die

01:23:00.330 --> 01:23:01.050
Befehle ausführen.

01:23:01.130 --> 01:23:01.790
Welche darf man?

01:23:02.590 --> 01:23:05.030
Das kostet sehr viel Fläche und sehr viel Energie.

01:23:05.690 --> 01:23:09.310
Und das ist für tragbare Geräte, also wenn es irgendwie um Low-Power

01:23:09.310 --> 01:23:10.230
geht, ist das nicht gut.

01:23:11.270 --> 01:23:14.450
Und da war die alte Architektur von Pentium, die war sehr viel

01:23:14.450 --> 01:23:17.850
einfacher gestrickt und durch die heutigen Herstellungstechnologien

01:23:17.850 --> 01:23:20.430
war die auch viel schneller als die damaligen Pentiums, die waren ja

01:23:20.430 --> 01:23:24.730
nur bei 100 bisschen was Megahertz, war die gleiche Architektur sehr

01:23:24.730 --> 01:23:27.990
viel schneller und dabei sehr viel energiesparender als die aktuellen

01:23:27.990 --> 01:23:28.470
Out -of-Orders.

01:23:28.810 --> 01:23:32.110
Und das war die Idee, dann machen wir so eine einfache Architektur und

01:23:32.110 --> 01:23:35.490
die für die tragbaren Low-Power-Anwendungen.

01:23:35.490 --> 01:23:39.070
So wie die normalen ARM-CPUs ja auch alle eine normale In-Order

01:23:39.070 --> 01:23:41.970
-Pipeline haben, wo jeder Befehl schön nacheinander ausgeführt wird.

01:23:42.270 --> 01:23:45.910
Und nur die großen ARMs, die Cortex-Ms, da gibt es ein paar Out-of

01:23:45.910 --> 01:23:46.570
-Order -Varianten.

01:23:48.510 --> 01:23:54.170
Was sie aber dann trotzdem hinzugebaut haben, er kann zwei Befehle pro

01:23:54.170 --> 01:23:57.530
Takt fetchen, dekodieren und zur Ausführung anstoßen.

01:23:57.910 --> 01:24:01.710
Also eine gewisse Art von Abhängigkeitsanalyse ist da auch mit drin,

01:24:02.090 --> 01:24:03.270
keine sehr ausgeprägte.

01:24:03.270 --> 01:24:06.630
Wenn einer der beiden Befehle nicht weiter kann, weil er wartet auf

01:24:06.630 --> 01:24:09.150
andere Abhängigkeiten, stallt einfach alles.

01:24:09.330 --> 01:24:10.650
An der Stelle wird es halt eben einfach.

01:24:10.890 --> 01:24:14.170
Man muss nicht gucken und der übernächste könnte der vielleicht, das

01:24:14.170 --> 01:24:15.910
machen sie nicht, da hören sie einfach auf.

01:24:17.930 --> 01:24:23.330
Gut, das soweit von den Pipelines, was es da für Abhängigkeiten gibt.

01:24:23.410 --> 01:24:27.690
Wir haben gesehen, es gibt Datenabhängigkeiten, echte Anti-Output, die

01:24:27.690 --> 01:24:29.090
können zu Konflikten führen.

01:24:29.090 --> 01:24:32.190
Die Konflikte kann man auf Software-Ebene lösen, mit Knops, mit

01:24:32.190 --> 01:24:33.110
cleveren Compilern.

01:24:33.430 --> 01:24:36.930
Die kann man auf Hardware-Ebene lösen, mit Anhalten der Pipeline, mit

01:24:36.930 --> 01:24:37.930
Data Forwarding.

01:24:38.190 --> 01:24:40.590
Wir haben Ressourcen-Konflikte gesehen, wo die gleiche Ressource

01:24:40.590 --> 01:24:41.410
benutzt werden soll.

01:24:41.670 --> 01:24:45.330
Wieder das gleiche Anhalten oder extra Hardware und Steuerkonflikte

01:24:45.330 --> 01:24:49.190
bei Sprüngen, der mit Sprungvorhersagen und Caches für Sprünge

01:24:49.190 --> 01:24:50.650
aufheben kann.

01:24:50.950 --> 01:24:54.130
Das waren so die nächsten Schritte für die etwas komplexere Pipeline

01:24:54.130 --> 01:24:57.530
und damit bedanke ich mich und nächste Woche geht es dann weiter.

01:24:57.770 --> 01:24:58.070
Dankeschön.

