WEBVTT

00:06.970 --> 00:11.350
Hallo, ich begrüße Sie zur Vorlesung Rechenorganisation.

00:12.550 --> 00:17.310
Wir sind zur Zeit bei der Instruktionssatzarchitektur ISA.

00:17.830 --> 00:22.030
Ich hatte das letzte Mal gesagt, dass es hier nicht um eine Harte

00:22.030 --> 00:22.730
Architektur geht.

00:23.050 --> 00:26.110
Es geht darum, wie sieht ein Instruktionssatz aus?

00:26.190 --> 00:27.530
Wie ist der zusammengebaut?

00:28.550 --> 00:33.410
Und was war der Hintergrund für eine Instruktionssatzarchitektur?

00:33.410 --> 00:37.990
Was hatte ich da als Hauptgrund genannt, warum es Sinn macht, so etwas

00:37.990 --> 00:38.750
festzulegen?

00:40.370 --> 00:42.230
Unter anderem gibt es viele Gründe.

00:46.530 --> 00:49.830
Also der wichtigste Grund dabei war, man kann es auf verschiedenen

00:49.830 --> 00:51.570
Hardware -Plattformen implementieren.

00:52.090 --> 00:56.650
Es gibt also unterschiedliche Mikroprozessoren, die ein und dieselbe

00:56.650 --> 01:00.050
Instruktionssatzarchitektur ausführen können.

01:00.050 --> 01:04.730
Das heißt, man legt diese Architektur also fest und der Hardware

01:04.730 --> 01:08.450
-Entwickler ist dann völlig frei zu entscheiden, wie ein

01:08.450 --> 01:13.770
Mikroprozessor intern aussieht, solange er diese

01:13.770 --> 01:15.750
Instruktionssatzarchitektur ausführen kann.

01:16.550 --> 01:18.250
Es gibt dann natürlich Unterschiede.

01:18.510 --> 01:21.490
Also man kann es ausführen, aber was könnte dann zum Beispiel

01:21.490 --> 01:22.490
unterschiedlich sein?

01:26.400 --> 01:29.860
Also sozusagen, was legt die Instruktionssatzarchitektur da nicht

01:29.860 --> 01:30.300
fest?

01:30.300 --> 01:32.880
Was sie gerade festlegt, habe ich versucht zu sagen.

01:33.940 --> 01:35.380
Und was legt sie nicht fest?

01:38.890 --> 01:40.870
Worüber gibt sie keine Auskunft?

01:45.880 --> 01:46.860
Genau, sehr gut.

01:46.960 --> 01:49.580
Also wieviel Takte, wie schnell läuft das Ganze, was hat das für eine

01:49.580 --> 01:50.060
Performance?

01:50.760 --> 01:53.120
Also ich habe hin und wieder mal Beispiele gegeben, habe gesagt, da

01:53.120 --> 01:55.400
wird irgendwo so ein Load gemacht, das dauert vielleicht 18

01:55.400 --> 01:55.960
Taktzyklen.

01:56.020 --> 01:58.620
Da habe ich immer gesagt, vielleicht, weil ich es eben auch nicht

01:58.620 --> 02:02.520
weiß, weil es davon abhängt, auf welche Architektur das dann wirklich

02:02.520 --> 02:02.860
läuft.

02:02.860 --> 02:06.920
Also das können wir dem Code der Instruktionssatzarchitektur nicht

02:06.920 --> 02:07.480
ansehen.

02:08.700 --> 02:10.040
Das ist so gewollt.

02:10.480 --> 02:14.060
Man kann also sozusagen größere oder kleinere Prozessoren bauen.

02:14.600 --> 02:16.920
Die können all dasselbe ausführen.

02:17.440 --> 02:20.300
Aber, wie so richtig gesagt, die Performance ist unterschiedlich.

02:20.880 --> 02:23.600
Und zum Beispiel auch Dinge wie Leistungsverbrauch und solche Dinge

02:23.600 --> 02:25.320
können auch unterschiedlich sein.

02:25.320 --> 02:30.320
Also wir haben hier eine ganz klare Abgrenzung von Dingen.

02:32.180 --> 02:34.560
Instruktionssatzarchitektur auf der einen Seite, Hardwarearchitektur

02:34.560 --> 02:35.020
auf der anderen.

02:36.300 --> 02:37.500
Das ist also ganz wichtig.

02:38.100 --> 02:41.280
Wir lernen also nicht Dinge, die spezifisch für eine Architektur sind,

02:41.440 --> 02:43.800
auch wenn wir dafür hin und wieder ein paar Beispiele geben.

02:45.520 --> 02:47.720
Übrigens ist das Mikro überall gut zu verstehen.

02:47.840 --> 02:50.020
Ich habe die Lautstärke jetzt so versucht einzustellen, dass es gut

02:50.020 --> 02:50.200
ist.

02:50.200 --> 02:52.140
Es klingt für mich okay von vorne.

02:52.220 --> 02:53.540
Wie sieht es vorne hinten aus?

02:53.640 --> 02:54.440
Zu laut, zu leise?

02:55.440 --> 02:57.080
Also wenn es nicht okay ist, sagen Sie es uns.

02:58.280 --> 03:02.140
Gut, dann haben wir angefangen und haben uns mit Ausführungsmodellen

03:02.140 --> 03:03.020
beschäftigt.

03:04.040 --> 03:07.240
Und da hatte ich gesagt, die Ausführungsmodelle, die hängen natürlich

03:07.240 --> 03:10.480
dann davon ab, was an Architektur vorhanden ist.

03:10.540 --> 03:14.500
Aber das sind sehr Standard-Dinge, die hier aufgelistet sind.

03:14.880 --> 03:16.420
So etwas hat jede Architektur.

03:16.420 --> 03:18.000
Aber da ist nichts Besonderes dabei.

03:20.640 --> 03:24.760
Entsprechend der Ausführungsmodelle hatte ich dann die Frage gestellt,

03:25.100 --> 03:33.620
wie sieht das denn aus, wenn ich einen Code habe, wie sieht das

03:33.620 --> 03:34.960
Adressformat aus?

03:35.440 --> 03:39.440
Also wie viele Adressen brauche ich zum Beispiel, um eine Zahl zu

03:39.440 --> 03:40.120
addieren?

03:41.620 --> 03:44.400
Da bräuchte ich erstmal ein Ziel und zwei Quellen.

03:45.200 --> 03:51.500
Und wie schlägt sich das Ganze dann nieder im Adressformat?

03:51.740 --> 03:52.960
Das war die große Preisfrage.

03:54.320 --> 03:57.000
Und da sind wir dann hergekommen und haben gesagt, gut, drei klingt

03:57.000 --> 04:01.140
plausibel, das ist offensichtlich sozusagen, aber es geht auch mit

04:01.140 --> 04:03.600
zwei, mit eins und sogar mit null.

04:05.420 --> 04:10.240
Das heißt, ich kann ein Adressformat haben, wo eben null Adressen

04:10.240 --> 04:11.100
angegeben sind.

04:11.620 --> 04:14.340
Das sind natürlich die Operanten dann irgendwo vorhanden.

04:14.460 --> 04:17.360
Nur der Trick dabei ist, das Ganze ist implizit.

04:18.820 --> 04:20.320
Und das wollen wir uns nochmal anschauen.

04:20.500 --> 04:22.580
Die Folie, das hatten wir uns schon angeschaut, gehe ich nochmal

04:22.580 --> 04:23.160
drüber.

04:23.280 --> 04:31.040
Drei Adressformat, es werden zwei Zahlen addiert, zwei Register, zwei

04:31.040 --> 04:33.380
Quellregister und ein Zielregister zum Beispiel.

04:36.200 --> 04:38.900
Dann kann man das Ganze mit zwei haben, das hatten wir alle schon.

04:38.900 --> 04:42.260
Dann hatten wir das Ganze mit eins und hier haben wir dann aufgehört

04:42.260 --> 04:43.900
in der letzten Vorlesung.

04:45.860 --> 04:49.520
Hier war die Sache dabei, dass das Ganze sich immer auf den

04:49.520 --> 04:50.880
Akkumulator bezieht.

04:51.440 --> 04:56.760
Also bei Default auf den Akkumulator und zusätzlich in diesem Fall

04:56.760 --> 05:00.600
hier auf ein Speicherregister.

05:00.600 --> 05:06.080
Add A heißt dann also, nehme die Adresse, den Inhalt der Adresse

05:06.080 --> 05:12.740
Speicher A zusammen mit dem Akku und schreibe es in den Akku.

05:15.220 --> 05:19.440
Und hier haben wir auch das, was man unter Überdeckung versteht,

05:19.540 --> 05:20.960
überdeckte Adressierung.

05:21.660 --> 05:27.120
Der Akku, der wird als Ziel hier und als Quelle benutzt.

05:34.270 --> 05:36.810
Dann schauen wir uns mal an, wie das mit Null geht, das Ganze.

05:52.560 --> 05:53.840
Hier haben wir einen Stack.

05:56.460 --> 06:03.990
Und was wir hier machen, wir addieren zwei Werte vom Stack und

06:03.990 --> 06:05.210
schreiben das wieder auf den Stack.

06:05.950 --> 06:07.490
Ein Stack, was ist das?

06:07.750 --> 06:10.490
Ich versuche das mal anzumalen.

06:15.300 --> 06:16.380
Wir haben einen Wert.

06:16.800 --> 06:19.920
Nehmen wir das wie einen Wert, den wir auf den Stack legen.

06:20.640 --> 06:25.140
Um den Stack zu anschaulichen, was es ist, schreiben wir noch was

06:25.140 --> 06:25.560
drauf.

06:25.660 --> 06:29.600
Das ist also ein Stapel, wir schreiben da noch was drauf, das ist ein

06:29.600 --> 06:30.340
weiterer Wert.

06:30.500 --> 06:32.740
Wir schreiben noch was drauf, ein weiterer Wert.

06:33.260 --> 06:35.420
Dann kann es natürlich auch sein, wir holen was runter.

06:36.040 --> 06:40.960
Dann würden wir das hier oben zuerst runterholen und dann wird das

06:40.960 --> 06:42.680
Ganze gelöscht.

06:46.560 --> 06:48.600
Oder wir schreiben wieder was drauf.

06:54.950 --> 06:56.130
Also machen wir das nochmal.

06:56.270 --> 06:59.890
Wir haben drei Einträge auf dem Stack, haben das drauf geschoben.

07:00.870 --> 07:02.750
Dann zum Beispiel würden wir was wegnehmen.

07:03.870 --> 07:05.990
Holen wir runter, dann nehmen wir wieder was weg.

07:06.490 --> 07:08.310
Dann schreiben wir wieder was drauf.

07:11.940 --> 07:13.780
Dann wieder was wegnehmen und so weiter.

07:13.780 --> 07:15.260
Also Sie sehen das Prinzip.

07:16.440 --> 07:19.620
Ein Stack ist etwas, was nach dem Prinzip folgt,

07:28.800 --> 07:33.840
das in First Out.

07:36.820 --> 07:37.680
Macht das Sinn?

07:37.800 --> 07:42.180
Also das, was ich zuletzt auf den Stack hier drauf geschrieben habe,

07:43.240 --> 07:44.840
hole ich mir als erstes wieder runter.

07:46.040 --> 07:49.840
Nach diesem Prinzip funktioniert dann der Add-Befehl.

07:50.600 --> 07:57.500
Das ist nämlich, den Top of Stack nehme, los was da drunter ist, diese

07:57.500 --> 08:01.320
beiden addiere und dann es zurück auf den Stack schreibe.

08:03.400 --> 08:11.660
Also in diesem Fall würde das heißen, ich nehme das plus das und

08:11.660 --> 08:13.120
schreibe es wieder hier zurück.

08:13.120 --> 08:16.120
Das heißt diese Addition jetzt.

08:17.960 --> 08:21.600
Also alles implizit angegeben, man muss halt wissen, was es heißt.

08:22.620 --> 08:25.680
So jetzt hätte ich hier gesagt, Last in First Out.

08:26.140 --> 08:28.200
Gibt es auch andere Dinge, offensichtlich.

08:30.220 --> 08:32.760
Was ich zuletzt drauf schreibe, das ist ein ganz wichtiges Prinzip,

08:32.900 --> 08:34.720
wenn Sie es nicht verstanden haben, müssen Sie fragen natürlich.

08:35.780 --> 08:38.760
Was ich zuletzt hier drauf schiebe, hole ich mir als erstes wieder

08:38.760 --> 08:40.880
runter, weil ich nur von oben drauf zugreife.

08:43.180 --> 08:46.620
Und in Englisch halt Last in First Out.

08:47.160 --> 08:49.320
Meine Frage ist, gibt es andere Prinzipien?

08:52.820 --> 08:53.740
Oder ist das immer so?

08:54.940 --> 08:55.980
Gibt es nur Stacks?

08:56.320 --> 08:58.480
Ich lege irgendwas oben drauf, hole es mir von oben runter.

09:02.410 --> 09:05.630
First in First Out, genau, also sowas gibt es auch.

09:08.250 --> 09:13.110
Also es gibt auch sowas, wo man etwas, was man zuerst reinschiebt oder

09:13.110 --> 09:18.350
speichert, als erstes wieder rauskommt.

09:19.550 --> 09:20.610
Was wäre das?

09:21.730 --> 09:26.230
Das wäre zum Beispiel ein Register, was so aussieht.

09:29.390 --> 09:30.730
Nehmen wir an, ich habe so ein Register.

09:31.590 --> 09:33.690
Nehmen wir an, ich habe so ein paar Speicherzählen.

09:34.590 --> 09:38.050
Jedes Quadrat oder Rechteck soll eine Speicherzähle darstellen.

09:39.030 --> 09:42.730
Und dann würde ich in das Register hier einen Wert reinschreiben, hier

09:42.730 --> 09:43.910
kommen die Werte raus.

09:44.930 --> 09:47.950
Und jedes Mal, wenn ich einen Wert hier reinschiebe, passiert

09:47.950 --> 09:48.750
Folgendes.

09:49.270 --> 09:50.490
Der von hier geht nach da.

09:51.550 --> 09:52.670
Der von hier geht nach da.

09:52.790 --> 09:53.930
Der von hier geht nach da.

09:54.050 --> 09:55.210
Der von hier geht nach da.

09:56.610 --> 10:01.630
Und das heißt, das Ganze wird in diesem Beispiel von links nach rechts

10:01.630 --> 10:02.410
durchgeschoben.

10:03.270 --> 10:07.710
Wie Sie sehen, was hier zuerst reinkommt, kommt hier auch wieder

10:07.710 --> 10:08.630
zuerst raus.

10:10.090 --> 10:15.450
Und das ganze Prinzip nennt sich dann entsprechend First In First Out.

10:23.360 --> 10:28.850
Also First In First Out.

10:31.750 --> 10:33.750
Da haben wir jetzt keinen Befehl für.

10:34.010 --> 10:38.650
Ich wollte es nur mal zeigen, damit dieses Prinzip, dieses Last In

10:38.650 --> 10:43.250
First Out, dann auch klar wird.

10:43.490 --> 10:47.110
Oder um einfach zu sehen, es gibt auch andere Dinge, wie man Daten

10:47.110 --> 10:48.010
speichern kann.

10:49.290 --> 10:51.070
Gut, dann haben wir das verstanden.

10:51.070 --> 10:57.610
Dann haben wir uns angeschaut, die verschiedenen Adressformate und

10:57.610 --> 10:59.010
Beispiele dafür.

10:59.190 --> 11:01.550
Das sind natürlich immer Beispielbefehle, da gibt es noch mehr

11:01.550 --> 11:02.050
Befehle.

11:02.430 --> 11:04.090
Aber vor allen Dingen wollen wir uns jetzt auch mal ein Programm

11:04.090 --> 11:09.950
anschauen, das für diese verschiedenen Architekturen hier geschrieben

11:09.950 --> 11:10.390
ist.

11:10.710 --> 11:14.270
Ich kann nämlich für all diese Architekturen das Gleiche machen.

11:14.370 --> 11:16.770
Ich habe öfters das Beispiel, wo irgendwas addiert wird.

11:16.770 --> 11:20.110
Die Frage ist natürlich jetzt, wie mache ich es?

11:20.170 --> 11:22.130
Mache ich es so, mache ich es so, mache ich es so oder mache ich es

11:22.130 --> 11:22.350
so?

11:24.370 --> 11:28.890
Und die Frage, die da vorkommt ist, wie mache ich das überhaupt?

11:29.250 --> 11:30.910
Wie schaut das dann überhaupt aus?

11:30.990 --> 11:33.090
Und dafür haben wir so ein kleines Beispiel hier irgendwo.

11:33.910 --> 11:34.970
Schauen wir mal, hier genau.

11:35.850 --> 11:40.550
Hier haben wir einfach nur ein Beispiel, wo ein Programm, das ist

11:40.550 --> 11:43.970
vielleicht ein bisschen übertrieben, wo ein paar Zahlen hier addiert

11:43.970 --> 11:44.350
werden.

11:45.150 --> 11:51.550
Und diese Zahlen werden addiert in diesen verschiedenen Formaten, in

11:51.550 --> 11:54.290
diesen verschiedenen Adressformaten, die mit verschiedenen

11:54.290 --> 11:57.770
Architekturen, wie wir es eben gesehen haben, verbunden, also

11:57.770 --> 11:59.110
assoziiert sind.

11:59.850 --> 12:01.870
Hier geht es nur um Register, Register.

12:02.470 --> 12:04.630
Ich gehe es nicht im Einzelnen durch, ich versuche es Ihnen

12:04.630 --> 12:05.430
anzudeuten.

12:05.910 --> 12:07.190
Das ist eigentlich offensichtlich.

12:07.730 --> 12:11.970
Hier mache ich folgendes, ich habe den Wert A, der aus dem Speicher

12:11.970 --> 12:14.890
kommt, lade den Register, dasselbe mache ich mit dem Wert B.

12:15.650 --> 12:20.910
So, und jetzt habe ich genau das, hierum geht es uns, nämlich um das

12:20.910 --> 12:27.110
Adressformat 3, also Register, Register, und entsprechend drei

12:27.110 --> 12:28.430
Operanten hier in diesem Fall.

12:28.590 --> 12:31.510
Hier addiere ich die jetzt, und jetzt kommt ein Store-Befehl, jetzt

12:31.510 --> 12:33.730
schreibe ich es ins Speicher zurück, dann hole ich mir wieder was vom

12:33.730 --> 12:34.490
Speicher usw.

12:35.130 --> 12:38.650
und führe den zweiten Teil dieser Berechnung hier.

12:38.650 --> 12:43.310
So, und jetzt kann man das Ganze mit Register-Speicher machen.

12:46.510 --> 12:50.090
Register-Speicher, diese Namen beziehen sich immer jeweils auf diesen

12:50.090 --> 12:52.970
Befehlen hier, auf diesen Hauptbefehl, auf die Addition.

12:53.110 --> 12:54.990
Register, Register, hier geht es nur um Register.

12:55.910 --> 12:59.830
Register-Speicher, hier habe ich jetzt offensichtlich in dem Befehl,

12:59.890 --> 13:02.930
hier ist er, Add B und Register.

13:02.930 --> 13:05.890
Also hier haben wir einen Befehl, einen Additionsbefehl, der in der

13:05.890 --> 13:12.570
Lage ist, auf den Hauptspeicher zuzugreifen, nämlich mit dem B und auf

13:12.570 --> 13:19.030
einen Register und hier entsprechend eine Addition auszuführen.

13:20.530 --> 13:24.250
Hier passiert das Ganze über einen bestimmten Speicher, nämlich über

13:24.250 --> 13:24.830
den Akku.

13:27.110 --> 13:29.550
Das heißt, hier habe ich irgendeinen Register und hier ist das

13:29.550 --> 13:30.870
Implizite immer der Akku.

13:30.870 --> 13:36.330
Das heißt, der Akku dient dafür, den Input für den Befehl zu haben und

13:36.330 --> 13:40.510
dient dann dafür auch, das Ergebnis darauf abzuspeichern.

13:41.750 --> 13:45.250
Und wenn man hier das nachverfolgt, das hier einfach gemacht, A, B, C

13:45.250 --> 13:47.630
sind immer dieselben, dann kann man das hier nachvollziehen.

13:48.910 --> 13:51.630
Hier zum Kellerspeicher kann man vielleicht noch Folgendes sagen, da

13:51.630 --> 13:55.330
gibt es dann eben bestimmte Befehle, da sagt man nicht, dass man

13:55.330 --> 14:00.690
irgendwas speichert, also lädt oder speichert.

14:01.030 --> 14:04.430
Bei dem Stack sagt man, man macht einen Push oder Pop.

14:11.220 --> 14:16.140
Das heißt, man bringt es auf den Stack drauf oder bei dem Pop holt es

14:16.140 --> 14:17.920
von dem Stack herunter.

14:19.500 --> 14:25.080
Sie sehen, hier haben wir wieder den Befehl, die Addition, die sich

14:25.080 --> 14:29.960
auf den Stack bezieht, nämlich bei diesem Beispiel, was wir hier

14:29.960 --> 14:32.820
hatten, oder bei dem Stack, den wir hier hatten, wo war es?

14:36.160 --> 14:39.740
Dann nehme ich die zwei hier oben, den und den, und schreibe es dann

14:39.740 --> 14:40.820
wieder da oben drauf.

14:42.940 --> 14:45.320
Gibt es hierzu Fragen oder irgendwelche Kommentare?

14:45.620 --> 14:48.420
Ist das soweit klar, warum da überhaupt der Unterschied ist?

14:49.540 --> 14:51.760
Ich meine, erstmal ist es ein Unterschied, weil man die Architektur

14:51.760 --> 14:54.580
hat, man kann verschiedene Dinge ausnutzen, da sind natürlich riesige

14:54.580 --> 14:56.000
Unterschiede in dem Programm drin.

14:56.440 --> 14:58.760
Machen wir es einfach mal so, was fällt Ihnen hier zu den

14:58.760 --> 14:59.800
Unterschieden auf?

15:00.100 --> 15:04.960
Weil das sollte man schon immer herausstellen.

15:05.500 --> 15:10.020
Es gibt hier Unterschiede und die Frage als Programmierer würde sich

15:10.020 --> 15:13.400
ja stellen, tue ich es jetzt nach A, B, C oder D?

15:13.400 --> 15:22.500
Wenn ich viele Optionen habe, dann heißt das nicht, dass ich zufällig

15:22.500 --> 15:27.120
dabei vorangehe, sondern mir irgendwas dabei überlege.

15:27.960 --> 15:29.880
Und zwar haben diese verschiedenen Optionen verschiedene

15:29.880 --> 15:30.400
Eigenschaften.

15:31.320 --> 15:34.120
Ein paar sieht man, ein paar sieht man direkt mit dem Auge, sage ich

15:34.120 --> 15:35.200
mal, die Eigenschaften.

15:35.780 --> 15:37.060
Ein paar andere sieht man nicht.

15:39.680 --> 15:41.240
Also was sieht man mit dem Auge hier?

15:42.820 --> 15:43.860
Von Unterschieden.

15:49.700 --> 15:50.440
Also was sieht man?

15:50.680 --> 15:51.940
Jeder sieht irgendwas.

15:52.400 --> 15:53.000
Was sieht man hier?

15:53.100 --> 15:53.740
Was ist der Unterschied?

15:58.870 --> 16:00.150
Diesen Kürzer, genau.

16:00.570 --> 16:03.790
Was so viel heißt wie, wenn ich dieses Programm im Speicher

16:03.790 --> 16:07.450
abspeichere, dann benötige ich weniger Speicherplatz.

16:08.070 --> 16:13.050
Speicherplatz ist limitiert, gerade bei eingebetteten Systemen, wo ich

16:13.050 --> 16:15.830
kleine Geräte habe, die sehr billig sein müssen, vielleicht nur ein

16:15.830 --> 16:20.290
paar Cent kosten, dann habe ich nicht viel Speicher und dann kann es

16:20.290 --> 16:24.230
durchaus Sinn machen, das kürzere Programm zu wählen, weil der

16:24.230 --> 16:26.470
Speicher vielleicht nur ein paar hundert Bytes groß ist.

16:27.770 --> 16:28.730
Das ist einfach kürzer.

16:31.270 --> 16:34.230
Die anderen wiederhole ich nochmal, weil das eben schon in anderen

16:34.230 --> 16:35.370
Antworten auch gefallen ist.

16:35.470 --> 16:37.870
Natürlich gilt auch hier wieder, dass die Ausführungszeit

16:37.870 --> 16:39.210
unterschiedlich groß ist.

16:40.210 --> 16:44.790
Und als generelle Anleitung kann ich hierzu sagen, dass solche

16:44.790 --> 16:50.310
Befehle, die auf den Speicher zugreifen, wie hier oder hier, das Load

16:50.310 --> 16:52.810
usw., die sind besonders zeitaufwendig.

16:53.710 --> 16:57.230
Das heißt, das ist typischerweise nicht zu machen mit einem

16:57.230 --> 17:02.430
Taktzyklus, sondern es dauert typischerweise viele Taktzyklen, weil

17:02.430 --> 17:07.290
ich außerhalb des Prozessors gehen muss, auf den Hauptspeicher und mir

17:07.290 --> 17:10.790
von dort die Daten holen muss und vielleicht kann ich zur Zeit gar

17:10.790 --> 17:13.210
nicht auf den Hauptspeicher zugreifen, weil irgendein anderer

17:13.210 --> 17:17.430
Prozessor, wir haben ja auch Multi-Core, Multi-Prozessor-Systeme, die

17:17.430 --> 17:19.730
zur selben Zeit auf den Speicher zugreifen, vielleicht muss ich

17:19.730 --> 17:21.410
warten, vielleicht habe ich Wartezyklen.

17:22.130 --> 17:27.490
Also als generelle Regel geht, Dinge zu vermeiden, Befehle zu

17:27.490 --> 17:30.970
vermeiden, die viel auf den Hauptspeicher zugreifen.

17:32.570 --> 17:35.230
Natürlich, wenn ich große Datensätze habe, habe ich überhaupt keine

17:35.230 --> 17:37.870
Möglichkeit, das zu vermeiden, weil nicht alles in den Prozessor

17:37.870 --> 17:39.510
reinpasst, auf den Registersatz.

17:40.350 --> 17:45.330
Aber wenn ich die Möglichkeit habe, mache ich es so nah an der

17:45.330 --> 17:46.270
Berechnung wie möglich.

17:46.610 --> 17:51.970
Also wenn die Daten, die ich berechnen möchte, mit denen ich irgendwas

17:51.970 --> 17:56.110
tun möchte, die ich verbinden möchte, wenn die möglichst nah an dem

17:56.110 --> 18:00.290
Ort sind, wo sie verarbeitet werden, das sind die Faustregel, dann ist

18:00.290 --> 18:01.210
es auch am günstigsten.

18:01.650 --> 18:03.910
Dann ist es am günstigsten für die Ausführungszeit, dann ist es am

18:03.910 --> 18:11.130
günstigsten für den Leistungsverbrauch zum Beispiel, es hat also sehr

18:11.130 --> 18:11.930
viele Vorteile.

18:12.130 --> 18:15.930
Das Problem ist ganz einfach, dass die Ressourcen, die nah an dem Ort

18:15.930 --> 18:19.890
sind, wo eben ausgeführt wird, die sind sehr limitiert.

18:20.970 --> 18:24.410
Also muss ich in meinem Programm, wenn ich irgendetwas programmiere,

18:24.950 --> 18:29.230
stellt sich typischerweise nicht die Frage, ob ich A, B, C oder D

18:29.230 --> 18:33.190
wähle, sondern es stellt sich die Frage, für welchen Teil des

18:33.190 --> 18:37.150
Programmes wende ich das an, für welchen Teil des Programms das und

18:37.150 --> 18:38.470
für welchen Teil des Programms das.

18:38.470 --> 18:43.310
Das heißt, jedes Programm hätte eigentlich im besten Fall eine

18:43.310 --> 18:49.550
Mischung aus verschiedenen Stilen der Programmierung hier, um alles,

18:49.650 --> 18:53.170
was ich zur Verfügung habe, möglichst gut einzusetzen.

18:53.750 --> 18:58.330
Es würde also keinen Sinn machen, nur dies zu benutzen, weil ich

18:58.330 --> 19:00.330
denke, ich habe auf dem Stack nicht viel Platz.

19:00.510 --> 19:03.010
Na gut, so viel Platz ich habe, den kann ich dann entsprechend

19:03.010 --> 19:03.530
benutzen.

19:03.670 --> 19:04.130
Warum nicht?

19:05.630 --> 19:09.130
Also das Intelligente ist sozusagen Programmieren, bzw.

19:09.750 --> 19:12.610
so intelligent steckt letzten Endes ein Compiler, der das hier

19:12.610 --> 19:13.050
abnimmt.

19:13.190 --> 19:16.630
Sie würden dann typischerweise in Hochspare programmieren, also ein C

19:16.630 --> 19:22.490
z.B., C++, und der Compiler würde sich überlegen, ob er das, das, das

19:22.490 --> 19:23.690
oder das hier annimmt.

19:24.930 --> 19:27.410
Natürlich hat der Compiler auch nicht die Möglichkeit, sich das alles

19:27.410 --> 19:30.750
zu überlegen, denn bestimmte Daten, die sind halt mal irgendwo im

19:30.750 --> 19:32.650
Hauptspeicher und die müssen da geholt werden.

19:33.650 --> 19:35.850
Und das ist dann ganz einfach ein Fakt, da hat man dann keine

19:35.850 --> 19:36.790
Freiheitskarten mehr.

19:38.050 --> 19:42.010
Aber ich hoffe, Sie kriegen zumindest eine Idee, dass das sinnvolle

19:42.010 --> 19:47.230
Optionen sind und es nicht geht darum, sich für eines zu entscheiden,

19:47.450 --> 19:52.530
sondern dass das Sinnvolle darin besteht, alles möglichst sinnvoll

19:52.530 --> 19:54.290
zusammen einzusetzen.

19:56.270 --> 19:56.790
Gut.

19:57.890 --> 20:02.490
Und da wir jetzt natürlich unterschiedliche Adressformate und so ein

20:02.490 --> 20:05.330
Zeugs alles haben, dann sind natürlich auch die Codierungen der

20:05.330 --> 20:06.590
Befehle unterschiedlich.

20:07.490 --> 20:10.310
Das heißt, es wäre natürlich einerseits schön, wenn ich sage, ich habe

20:10.310 --> 20:17.470
ein Befehlswort, das hat immer 32 Bits, und das Bit 17 bis 21 gibt mir

20:17.470 --> 20:24.170
immer den Opcode wieder, und das Bit 21 bis 29 gibt mir immer z.B.

20:24.790 --> 20:29.830
den Datenwert eines Quelloperanten oder irgend sowas.

20:30.350 --> 20:34.550
Das wäre schön, wenn ich nur ein Befehlsformat hätte und darin alles

20:34.550 --> 20:35.530
codieren könnte.

20:37.070 --> 20:37.910
Aber ich kann das nicht.

20:38.690 --> 20:42.050
Und so sagen wir uns jetzt später noch ansehen, warum das nicht so

20:42.050 --> 20:42.330
ist.

20:44.070 --> 20:46.470
Einerseits ist es natürlich so, wir haben verschiedene Datentypen.

20:46.470 --> 20:48.770
Da möchte ich nicht nochmal im Einzelnen drauf eingehen, das hatten

20:48.770 --> 20:49.830
wir das letzte Mal schon.

20:50.530 --> 20:54.390
Aber hier ist es nochmal aufgelistet mit Hinblick darauf, ich habe

20:54.390 --> 20:58.110
verschiedene Datentypen und da ich verschiedene Datentypen habe, sieht

20:58.110 --> 21:00.330
mein Befehlsformat unterschiedlich aus.

21:01.010 --> 21:06.310
Es macht einen Unterschied, ob ich in einem Befehlswort einen Byte

21:06.310 --> 21:11.870
unterbringen muss oder ein Wort von zwei Byte oder vier Byte.

21:16.470 --> 21:19.450
Also es gibt unterschiedliche Datentypen, das wissen wir schon.

21:21.830 --> 21:24.990
Und wir haben auch Gleitkammerzahlen das letzte Mal gesehen.

21:25.130 --> 21:26.110
Auch sowas gibt es.

21:28.470 --> 21:33.270
Natürlich kann ein Prozessor auch mit Gleitkammerzahlen rechnen, wenn

21:33.270 --> 21:36.870
es dafür keinen Befehl gibt, also keinen Hardwarebefehl.

21:37.350 --> 21:46.050
Das heißt keine ALU, die eine Addition direkt ausführt, sondern eine

21:46.050 --> 21:50.470
Operation mit einer Gleitkammerzahl, die kann natürlich auch

21:50.470 --> 21:52.470
zurückgeführt werden auf Addition.

21:54.050 --> 21:58.310
Also der Punkt hier ist, selbst wenn die Hardware keine Multiplikation

21:58.310 --> 22:04.270
mit Gleitkammerzahlen kann, dann kann ich das zum Beispiel, da brauche

22:04.270 --> 22:06.350
ich noch ein bisschen mehr für, da brauche ich auch Shifter und solche

22:06.350 --> 22:10.310
Sachen, Adderer und so weiter, kann ich das mit Bewerkstelligen.

22:10.850 --> 22:14.690
Der Nachteil natürlich ist, wenn ich so ein Hardware Hartford Trated

22:14.690 --> 22:17.990
nicht zur Verfügung habe, dauert es sehr viel länger.

22:18.490 --> 22:21.150
Keine Frage, da gibt es dann Mikroprogrammationen.

22:22.750 --> 22:29.570
Gut, also wir hatten so Datenformate von 8-Bit, 16-Bit, 64-Bit, 32-Bit

22:29.570 --> 22:30.210
und so weiter.

22:31.010 --> 22:33.630
Hier braucht man nicht drüber gehen, das ist alles selbsterklärend.

22:33.630 --> 22:38.450
Das zeigt eigentlich nur, wie typischerweise Daten in einem Speicher

22:38.450 --> 22:40.810
oder in einem Speicherwort abgelegt sind.

22:41.470 --> 22:47.410
Das heißt, wenn ich zum Beispiel ein Datenformat habe, wenn ich ein

22:47.410 --> 22:53.510
Byte habe, und möchte das ablegen im Speicher, dann sieht das

22:53.510 --> 22:58.510
typischerweise so aus, und ich sage typischerweise, dass das least

22:58.510 --> 23:00.950
significant bit ganz rechts ist.

23:00.950 --> 23:03.130
Sie erinnern sich, wir hatten das neulich schon gemacht, da hat man

23:03.130 --> 23:04.910
gesagt MSB, LSB.

23:05.590 --> 23:13.790
Also das Bit, das den geringsten Wert hat, also 2 hoch 0 hier in

23:13.790 --> 23:17.030
diesem Falle, steht ganz rechts, das ist einfach eine Konvention.

23:18.710 --> 23:22.590
Und so gilt es dann auch, wenn man zum Beispiel zwei Worte oder zwei

23:22.590 --> 23:24.910
Bytes in einem Wort abspeichert.

23:26.370 --> 23:31.270
Das untere Wort, also das low byte, steht rechts, also unten, rechts

23:31.270 --> 23:35.210
ist unten in diesem Falle, und das nächst höherwertige kommt

23:35.210 --> 23:36.770
schließlich links an, und so weiter.

23:36.910 --> 23:38.410
Und so gilt das dann für Worte auch.

23:39.230 --> 23:44.050
Das sind Dinge, das sind Konventionen, die muss man sich einmal merken

23:44.050 --> 23:45.790
und weiß es dann letztendlich.

23:45.950 --> 23:49.810
Und wenn ein Prozessor das anders tut, dann würde das im Datenblatt

23:49.810 --> 23:53.110
eines Prozessors, also im Datenblatt oder Datenbuch, würde das

23:53.110 --> 23:53.930
beschrieben werden.

23:55.490 --> 24:01.810
Also das so viel dazu, wie Daten im Rechner abgespeichert werden,

24:02.530 --> 24:05.390
beziehungsweise wie der Prozessor die Daten interpretiert.

24:05.910 --> 24:09.730
Also der Mikroprozessor interpretiert da so, hier finde ich mein

24:09.730 --> 24:12.370
niedrigstes Byte, hier das höchste Byte, und so weiter und so fort.

24:12.430 --> 24:13.690
Das ist die Interpretation.

24:14.450 --> 24:18.710
Wenn meine Interpretation als Programmierer anders ist als die des

24:18.710 --> 24:22.010
Mikroprozessors, dann ist klar, dann habe ich ein falsches Ergebnis

24:22.010 --> 24:22.890
vorliegen.

24:22.950 --> 24:23.950
Deswegen muss ich das wissen.

24:27.350 --> 24:29.150
So, hier sind jetzt nochmal Datentypen.

24:29.250 --> 24:30.050
Es gibt natürlich Bits.

24:30.150 --> 24:30.890
Was ist ein Bit?

24:32.370 --> 24:33.790
Wie wird das adressiert?

24:33.930 --> 24:35.070
Oder ein Bitvektor?

24:35.630 --> 24:39.190
Ein Bitvektor ist eben eine Abfolge von Bits.

24:40.070 --> 24:43.190
Wofür man das braucht, sieht man dann als Programmierer.

24:43.870 --> 24:45.950
Da kann man die verschiedensten Dinge mitmachen.

24:46.250 --> 24:48.130
Da haben wir dann später auch noch Beispiele für.

24:49.230 --> 24:51.130
Vorzeichen, Lose, Dual, Zahl, Zweierkompliment.

24:51.750 --> 24:54.110
Das Zweierkompliment haben wir das letzte Mal gesehen.

24:55.250 --> 24:59.350
Wird so dargestellt, wie da rechts das LSB, links das MSB,

24:59.490 --> 25:00.810
Vorzeichenbit und so weiter.

25:01.870 --> 25:04.910
Dann hat man das BCD, da möchte ich gar nicht so nah drauf eingehen,

25:04.970 --> 25:07.490
weil wie gesagt, das ist eigentlich ein Datenformat, was man sehr

25:07.490 --> 25:08.270
selten noch benutzt.

25:08.870 --> 25:10.810
Oftmals aus Kompatibilitätsgründen.

25:12.910 --> 25:15.390
Wir hatten das neulich schon herausgefunden, das hatte jemand von

25:15.390 --> 25:19.910
Ihnen gesagt, das ist an sich viel weniger effizient, weil ich kann

25:19.910 --> 25:26.530
mit einer BCD-Zahl neun Ziffern, brauche ich nur darzustellen, aber

25:26.530 --> 25:30.950
ich könnte 16 verschiedene von 0 bis 15 darstellen.

25:31.150 --> 25:38.890
Das heißt, der Rest, also ungefähr ein Drittel davon, sind Ressourcen,

25:39.110 --> 25:40.750
die nicht genutzt wurden.

25:40.750 --> 25:45.790
Also von daher ist BCD nicht etwas, was sehr effizient ist.

25:47.490 --> 25:50.670
Gut, dass man die dann noch in verschiedener Art und Weise abspeichern

25:50.670 --> 25:54.070
kann, sei auch gegeben, aber interessiert jetzt an sich nicht weiter.

25:55.130 --> 25:58.250
Hier speichert man Gleitkommazahlen ab, auch letzten Endes

25:58.250 --> 25:58.910
Konventionen.

25:58.950 --> 26:02.170
Es geht nicht darum, das letzten Endes auswendig zu lernen, außer man

26:02.170 --> 26:04.830
hat eben eine Aufgabe, muss damit rechnen, dann muss man es wissen.

26:06.050 --> 26:07.930
Ansonsten variiert das natürlich.

26:09.770 --> 26:14.790
Aber es variiert natürlich mit der Größe, der Genauigkeit.

26:15.470 --> 26:19.470
Aber wie viel Bit für Charakteristik und Mantisse hier entsprechend

26:19.470 --> 26:22.170
angegeben sind, das hatte ich gesagt, das kann man sich nicht einfach

26:22.170 --> 26:24.330
so überlegen, das kann sich der Mikroprozessor auch nicht so einfach

26:24.330 --> 26:24.770
überlegen.

26:25.390 --> 26:29.230
Das wird normiert in der IEEE-Norm.

26:29.450 --> 26:32.170
Und Sie erinnern sich auf den letzten Foliensatz, da hatte ich oben

26:32.170 --> 26:35.170
hingeschrieben, welche IEEE-Norm das letzten Endes ist.

26:35.790 --> 26:40.790
Das ist nicht willkürlich festgelegt, das ist normiert, sodass man die

26:40.790 --> 26:45.310
Bits, die man zur Verfügung hat, so darstellen kann, dass man einen

26:45.310 --> 26:49.210
sehr guten Kompromiss findet, zwischen wie groß ist der bewährte

26:49.210 --> 26:53.270
Bereich, den ich darstellen kann, und die Genauigkeit letztendlich.

26:54.270 --> 26:57.190
Also es geht um die Größe, die maximale Größe einer Zahl, die ich

26:57.190 --> 27:01.050
darstellen kann, die maximal kleinste Zahl natürlich auch, also

27:01.050 --> 27:04.290
Wertebereich, und wie genau kann ich das Ganze darstellen.

27:05.390 --> 27:09.630
Danach ist dann aufgeteilt worden, wie man die Charakteristik, also

27:09.630 --> 27:13.270
wieviel von diesen 64 Bit, die ich hier habe, ich für die

27:13.270 --> 27:17.590
Charakteristik pendiere, und wieviel für die Mantisse.

27:18.250 --> 27:21.150
Also hinter diesen Zahlen, das sind natürlich auch keine willkürlichen

27:21.150 --> 27:22.810
Zahlen, da steckt selbst die Mathematik drin.

27:26.380 --> 27:27.360
Gut, was haben wir noch?

27:29.080 --> 27:32.760
Bitfelder, kann man an sich auch nicht viel zu sagen, außer dass man

27:32.760 --> 27:37.880
natürlich die Bitfelder im Speicher so ablegen kann, dass sie zum

27:37.880 --> 27:39.540
Beispiel auf Byte-Grenzen liegen.

27:40.260 --> 27:43.420
Muss aber nicht sein, wenn ich mit Bitfeldern rechne, dann kann es

27:43.420 --> 27:47.600
sich oftmals anbieten, dass ich ein Offset habe, das heißt ein

27:47.600 --> 27:51.100
Bitfeld, da habe ich halt ein Bit gesetzt oder nicht gesetzt, das ist

27:51.100 --> 27:55.020
die Definition eines Bitfeldes, also von hintereinander, nacheinander

27:55.020 --> 27:59.280
auch von den Bits, und dann kann ich natürlich noch sowas haben wie

27:59.280 --> 28:00.020
ein Offset.

28:00.020 --> 28:03.620
Also ich kann sagen, ich meine hier nicht eine 1 oder eine 0, sondern

28:03.620 --> 28:08.360
ich meine eine 365 oder eine 366 oder irgend so was, also ich habe die

28:08.360 --> 28:11.940
Möglichkeit, hier noch ein Offset zum Beispiel anzugeben.

28:12.440 --> 28:17.120
Und dann muss ein Bitfeld eben nicht an einer Byte-Grenze beginnen,

28:17.560 --> 28:18.700
das kann irgendwo beginnen.

28:20.080 --> 28:24.040
Typischerweise gilt als Regel, da war auch jemand bei mir nach der

28:24.040 --> 28:27.380
Vorlesung, da war so die Frage mit Bitfeldern und so weiter,

28:29.240 --> 28:35.600
typischerweise gilt die Regel, man sollte nicht annehmen, dass ein

28:35.600 --> 28:38.000
bestimmter Datentyp eine bestimmte Länge hat.

28:39.020 --> 28:43.500
Und zu tun, sage ich mal, ein Wort hat 16 Bit, und da ich ja angeblich

28:43.500 --> 28:47.600
weiß, dass ein Wort 16 Bit hat, tue ich mal so und behandle das als

28:47.600 --> 28:48.200
Bitvektor.

28:49.100 --> 28:52.040
Dann habe ich 16 Bit zur Verfügung und tue da irgendwas dran.

28:52.480 --> 28:56.660
Das läuft fatal schief, wenn nämlich auf einem anderen Rechner dann

28:56.660 --> 29:04.020
das entsprechende Datum ist 32 Bit groß und nicht 16, wie ich es

29:04.020 --> 29:07.160
vorher angenommen habe, oder umgekehrt ist es nur 8 Bit groß.

29:07.560 --> 29:11.740
Also wenn ich mit Bitvektoren arbeiten möchte, dann sollte ich auch

29:11.740 --> 29:15.160
eine Datenstruktur nehmen, die eben Bitvektor heißt.

29:15.860 --> 29:21.000
Und die weiß dann, wie groß die Datentypen sind, die da drunter

29:21.000 --> 29:23.740
liegen, und dann funktioniert das auch.

29:23.740 --> 29:28.340
Also nie, sage ich mal, Dinge annehmen, die unterschiedlich sein

29:28.340 --> 29:34.260
können und einen Integerwert als einen 16 Bit Bitvektor oder sowas

29:34.260 --> 29:34.780
behandeln.

29:35.220 --> 29:39.160
Ich sage das, weil ich eben auch schon so Dinge gesehen habe, aber das

29:39.160 --> 29:40.040
ist ein super Fehler.

29:41.300 --> 29:44.400
Gut, also soviel zu einem Bitvektor.

29:45.820 --> 29:46.980
Dann gibt es Strings.

29:48.180 --> 29:49.000
Was sind Strings?

29:49.140 --> 29:52.080
Das sind Ketten von Zeichen.

29:53.280 --> 29:56.940
Ketten von Zeichen, zum Beispiel ein Wort, kann als String dargestellt

29:56.940 --> 29:57.320
werden.

29:58.200 --> 30:02.140
Das sind die einzelnen Buchstaben, die ASCII-Codes haben, wie wir das

30:02.140 --> 30:07.380
letztes Mal gesagt hatten, und die werden zusammengebunden als ein

30:07.380 --> 30:07.740
String.

30:09.840 --> 30:15.940
Und das ist eigentlich die Hauptbenutzung von Strings, dass man zum

30:15.940 --> 30:22.720
Beispiel Worte, Schrift oder irgend sowas, Zeichenketten darstellt,

30:23.060 --> 30:24.520
Zeichenketten auch bearbeitet.

30:24.740 --> 30:29.320
Man kann sich ja auch überlegen, dass man Operationen auf

30:29.320 --> 30:30.500
Zeichenketten hat.

30:30.840 --> 30:34.080
Zum Beispiel zwei Zeichenketten addieren.

30:34.880 --> 30:36.580
Oder drei Zeichenketten addieren.

30:36.640 --> 30:37.720
Was würde das zum Beispiel heißen?

30:37.780 --> 30:39.920
Ich habe drei Worte, ich addiere die und dann habe ich einen Satz.

30:41.140 --> 30:41.960
Zum Beispiel.

30:42.460 --> 30:45.740
Und da gibt es dann auch wieder Bibliotheken, die eben auf Strings

30:45.740 --> 30:46.480
arbeiten.

30:46.480 --> 30:51.080
Da brauche ich mich dann nicht mehr, um das einzelne Byte eines

30:51.080 --> 30:54.820
Strings zu kümmern und mit dem irgendetwas zu tun, also dieses zu

30:54.820 --> 30:55.400
verschieben.

30:55.960 --> 30:56.840
Das können wir einfach addieren.

30:57.080 --> 31:00.520
Es gibt spezielle Operationen für Strings, für Zeichenketten.

31:01.920 --> 31:03.040
Das ist also sehr sinnvoll.

31:03.180 --> 31:07.360
Das heißt, das ist auch eine Abstraktionsebene, um effizienter

31:07.360 --> 31:08.500
arbeiten zu können.

31:10.080 --> 31:14.840
Ein technisch gesehen ist ein String eine Abfolge, eine

31:14.840 --> 31:21.160
zusammenhängende Serie von Bytes, die im Speicher typischerweise

31:21.160 --> 31:22.480
hintereinander abgelegt sind.

31:22.800 --> 31:24.080
Aber das soll mich nicht interessieren.

31:26.860 --> 31:27.320
Gut.

31:28.500 --> 31:30.160
Hier ist jetzt einfach mal so ein Beispiel.

31:30.940 --> 31:34.780
Eine Inseleichtektur mit 32 Bit, die es irgendwann mal gab in den 80er

31:34.780 --> 31:38.160
Jahren, als man damit angefangen hat 32 Bit zu haben.

31:38.240 --> 31:39.220
Und ich möchte hier nicht durchgehen.

31:39.300 --> 31:43.200
Es macht überhaupt keinen Sinn, zu lernen, was das Ding für Features

31:43.200 --> 31:43.620
hat.

31:44.490 --> 31:48.920
Außer, dass Sie die ganzen Dinge, die wir jetzt zuvor besprochen

31:48.920 --> 31:54.340
haben, nämlich Integer und Zweierkomplementarstellung, BCD, Packed

31:54.340 --> 31:59.340
oder nicht, Pointer hatten wir auch schon, Strings, Floating Point,

31:59.740 --> 32:01.320
das kann dieser Rechner alles.

32:02.400 --> 32:04.380
Das sind alles Features dieses Rechners.

32:06.040 --> 32:09.760
Und er kann auch Bytes, Halbworte, Vollworte und so weiter.

32:10.940 --> 32:16.260
Und das nur so als Beispiel, was die Leistungsfähigkeit eines

32:16.260 --> 32:18.260
Mikroprozessors ist, und das vor 30 Jahren.

32:18.420 --> 32:23.460
Also das war die erste IA32, das war die erste Inseleichtektur, das

32:23.460 --> 32:30.180
war der Intel 386, der der erste 32 Bit, Voll-32 Bit Mikroprozessor

32:30.180 --> 32:30.400
war.

32:31.320 --> 32:31.840
Gut.

32:33.540 --> 32:34.460
Dann habe ich Speicher.

32:35.220 --> 32:36.960
Jetzt haben wir zwei verschiedene Dinge.

32:36.960 --> 32:42.800
Erstmal haben wir die verschiedenen Datenformate und die nächste

32:42.800 --> 32:46.040
Frage, die kommt, wie ist das Ganze denn im Speicher wirklich

32:46.040 --> 32:50.060
abgespeichert oder wie greife ich darauf zu?

32:52.040 --> 32:57.720
Die typische Weise, Daten im Speicher abzulegen oder adressieren, ist

32:57.720 --> 32:58.680
über das Byte.

33:00.000 --> 33:06.720
Das heißt, ich habe eine Adresse im Speicher für jedes Byte.

33:07.720 --> 33:11.480
Das heißt, selbst wenn ich nur mit Worten rechne, also 32 Bit oder 16

33:11.480 --> 33:18.020
Bit oder von mir aus 64 Bit, kann ich auf jedes Byte zugreifen.

33:20.440 --> 33:23.200
Also das ist gar nicht so offensichtlich, denn ich muss ja eine

33:23.200 --> 33:29.560
Adresse generieren, um zum Beispiel 32 Bit adressieren zu können.

33:30.280 --> 33:40.400
Um 32 Bit, das sind 4 Gigabyte, da brauche ich entsprechend 32 Bit, um

33:40.400 --> 33:41.660
das zu adressieren.

33:44.320 --> 33:47.140
Wenn ich auf Byteadresse adressiere.

33:49.580 --> 33:52.160
Warum ist das nicht so offensichtlich?

33:53.160 --> 33:54.160
Warum ist das nicht so offensichtlich?

33:54.160 --> 33:57.000
Zum Beispiel Wort, wortorganisierter Speicher.

33:58.180 --> 34:00.700
Nehmen wir mal an, wir haben ein Wort.

34:00.840 --> 34:03.620
Hier steht, hier ist ein Wort, das 32 Bit.

34:05.200 --> 34:10.700
Und wir wollen nicht die Möglichkeit haben, auf jedes Byte

34:10.700 --> 34:12.320
zuzugreifen, sondern nur als Wort.

34:12.400 --> 34:14.180
Und Wort ist 32 Bit.

34:15.720 --> 34:18.140
Wie viel weniger Bit brauche ich dann, um auf den Speicher

34:18.140 --> 34:18.800
zuzugreifen?

34:18.800 --> 34:25.480
Also ich brauche 32 Bit, um 4 Gigabyte zu adressieren.

34:29.140 --> 34:35.160
Und ich brauche wie viel Bit, um nur auf der Wortgrenze zu

34:35.160 --> 34:40.660
adressieren, also ein 32 Bit Wort zu adressieren.

34:41.160 --> 34:46.240
Also wenn ich ein Byte nicht mehr adressieren möchte, dann kann ich

34:46.240 --> 34:47.920
mir natürlich auch irgendetwas einsparen.

34:50.820 --> 34:54.120
Eine Idee, wie viele Bits ich da einsparen kann, bei der Adressierung.

34:55.060 --> 34:58.080
Sie müssen so sehen, die Adressierung, das geht ja nicht im Spielchen

34:58.080 --> 35:00.380
im Sinne von, ach, dann mache ich es mit ein paar weniger Bitten, dann

35:00.380 --> 35:00.780
bin ich happy.

35:01.280 --> 35:03.760
Sie müssen so sehen, letzten Endes 2 Bit ist eine ganze Menge.

35:04.260 --> 35:09.040
Denn ich brauche 2 Träte sozusagen, von dem Prozessor zum

35:09.040 --> 35:09.760
Hauptspeicher.

35:09.760 --> 35:15.320
Und wenn da schon 32 sind, dann macht 2 oder 4, mehr oder weniger,

35:15.720 --> 35:16.780
einen riesigen Unterschied.

35:17.320 --> 35:21.000
Denn so ein Bus hat dann auch eine richtige Breite, der nimmt ganz

35:21.000 --> 35:23.520
einfach Chipfläche weg, ich kann damit sparen.

35:24.060 --> 35:29.560
Ich behaupte jetzt einfach, wenn ich nur 32 Bit Worte adressieren

35:29.560 --> 35:33.940
möchte, dann brauche ich weniger Bits dafür.

35:36.100 --> 35:38.100
Also ich frage jetzt nicht, das ist halt Hausaufgabe.

35:40.160 --> 35:41.500
Also wie viel weniger Bits?

35:41.640 --> 35:45.860
Ich brauche für, wenn ich einen Speicher habe von 4 Gigabyte, brauche

35:45.860 --> 35:52.160
ich 32 Bit, also 2 hoch 32, um auf jedes Byte zuzugreifen.

35:52.640 --> 35:53.700
Und Sie haben jetzt gesagt,

35:59.340 --> 36:01.540
also mit 8 sind das Problem.

36:01.860 --> 36:03.780
Ich habe es vielleicht nicht richtig ausgedrückt.

36:03.780 --> 36:06.820
Das Problem ist, wir haben jetzt zwei Dinge mit 32.

36:07.580 --> 36:12.280
Deswegen sage ich es nochmal, 32 soll einerseits sein, 2 hoch 32 ist

36:12.280 --> 36:13.600
die Größe des Speichers.

36:15.160 --> 36:20.240
Und 32 Bit ist auch die Größe dieses Wort, was in dem Speicher

36:20.240 --> 36:21.380
gespeichert ist.

36:22.420 --> 36:28.440
Das heißt, ich brauche, um einen Speicher der Größe 2 hoch 32 zu

36:28.440 --> 36:30.500
adressieren, brauche ich 32 Bit.

36:30.500 --> 36:33.160
Wenn ich auf jedes einzelne Byte zugreifen will.

36:34.500 --> 36:38.620
Aber wenn ich jetzt nur auf einen Block von 4 Bytes zugreifen will,

36:39.700 --> 36:42.780
also nicht nur auf jedes einzelne zugreifen, sondern nur noch auf

36:42.780 --> 36:46.800
einen Block von 4 Bytes, nämlich 32 Bit, dann brauche ich weniger Bit,

36:47.940 --> 36:50.840
um dort zuzugreifen.

36:50.840 --> 36:56.100
Also um es so zu sagen, als Beispiel,

36:59.870 --> 37:06.730
ich habe hier, ich habe das, ich habe hier so ein Wort.

37:07.930 --> 37:09.510
Das ist das eine Wort.

37:09.670 --> 37:12.050
Und dann habe ich im Speicher noch viele solcher Worte.

37:15.250 --> 37:20.170
Und jedes dieser Worte, es geht natürlich noch weiter, jedes dieser

37:20.170 --> 37:23.990
Worte soll 4 Bytes haben.

37:26.810 --> 37:29.230
Also hier habe ich ein Byte, hier habe ich ein Byte, hier habe ich ein

37:29.230 --> 37:31.110
Byte, hier habe ich ein Byte und das ist dann ein Wort.

37:31.750 --> 37:33.550
Dann habe ich hier ein Byte, hier ein Byte, hier ein Byte, hier ein

37:33.550 --> 37:34.510
Byte und das ist dann ein Wort.

37:35.750 --> 37:41.570
Und von diesen Bytes, von diesen hier, das sind Bytes, da möchte ich 2

37:41.570 --> 37:46.310
auf 32 Stück haben, also 4 Milliarden, 2 auf 32, 4 Giga.

37:47.550 --> 37:51.010
Und wenn ich dann jedes einzelne dieser 4 Milliarden, also wir haben

37:51.010 --> 37:53.470
hier eine Reihe von 4 Milliarden, so groß ist der Speicher.

37:53.610 --> 37:57.950
Wenn ich hier 4 Milliarden von habe und möchte auf jedes einzelne hier

37:57.950 --> 38:00.250
zugreifen können, dann brauche ich 32 Bit.

38:01.230 --> 38:05.750
Und was ich vorher sagen wollte, das ist nicht ganz klar geworden, wie

38:05.750 --> 38:09.650
viel Bit brauche ich, wenn ich nur hier zugreifen muss, nur hier

38:09.650 --> 38:11.290
zugreifen muss, nur hier zugreifen muss.

38:11.370 --> 38:16.090
Also ich habe nicht mehr die Ambition, genau hier zuzugreifen oder

38:16.090 --> 38:19.050
hier zuzugreifen, ich will nur noch an diesen Punkten zugreifen.

38:21.050 --> 38:23.850
Dann brauche ich weniger Bit, das war meine Frage.

38:24.730 --> 38:29.310
Also ich brauche 32 minus ein paar Bit.

38:31.830 --> 38:34.290
Genau, also ich brauche 2 weniger Bit.

38:34.670 --> 38:37.130
Also ich habe das nicht so ganz richtig eben erklärt und jetzt haben

38:37.130 --> 38:38.110
Sie es auch sehr gut verstanden.

38:38.530 --> 38:39.690
Ich brauche 2 weniger Bit.

38:40.230 --> 38:41.610
Und das macht einen riesigen Unterschied.

38:42.110 --> 38:45.910
Das macht einen riesigen Unterschied, nämlich ich habe 2 weniger

38:45.910 --> 38:50.510
Leitungen auf dem Prozessor zum Hauptspeicher, ich habe einen

38:50.510 --> 38:54.570
kleineren Leistungsverbrauch, ich habe mehr Platz für andere Dinge.

38:54.790 --> 38:58.030
Ich kann zum Beispiel Register unterbringen, nicht der ganze Platz

38:58.030 --> 39:04.710
geht mit Bitlines verloren, also mit Leitungen, mit Vertratung

39:04.710 --> 39:05.170
sozusagen.

39:07.130 --> 39:09.690
Und davon wird natürlich auch Gebrauch gemacht.

39:10.830 --> 39:13.510
Jetzt gibt es einen Nachteil, jetzt gibt es einen Nachteil dieser

39:13.510 --> 39:13.770
Sache.

39:13.950 --> 39:16.990
Jetzt haben wir eben genau das, wir greifen entweder hier drauf zu,

39:17.130 --> 39:18.750
hier drauf zu oder hier drauf zu.

39:19.870 --> 39:24.150
Was ist jetzt der Nachteil davon, den ich mir dadurch jetzt einfange?

39:30.710 --> 39:32.190
Genau, sehr richtig.

39:32.770 --> 39:37.290
Also es wurde gesagt, wenn ich nur mit Daten rechne, die nur ein Byte

39:37.290 --> 39:40.950
belegen, und das passiert ja, ich führe ja durchaus Arithmetik aus,

39:41.010 --> 39:46.170
die nur ein Byte benötigen, dann muss ich hier ein Byte abspeichern

39:46.170 --> 39:49.110
und ich kann auf dieses und dieses und dieses überhaupt nicht einzeln

39:49.110 --> 39:49.730
zugreifen.

39:49.730 --> 39:53.090
Das heißt, ich vergeude meinen Speicher.

39:53.670 --> 39:57.350
Ich lege hier ein Byte ab, kann auf dieses zugreifen, das ist leer,

39:57.470 --> 39:58.530
das ist leer, das ist leer.

39:58.650 --> 40:01.010
Hier liegt was, das ist leer, das ist leer und das ist leer.

40:03.290 --> 40:07.970
Sie sehen, man hat also hier wieder sich den folgenden Nachteil mit

40:07.970 --> 40:08.710
eingekauft.

40:10.770 --> 40:12.390
Was nimmt man jetzt, was hat man?

40:12.990 --> 40:16.550
Die große Preisfrage ist natürlich dann wieder ein Trade-off, wie man

40:16.550 --> 40:19.230
sagt, wie man irgendwo eingeben muss.

40:19.410 --> 40:22.950
Aber ich wollte hier nur klar machen, es gibt verschiedene Arten und

40:22.950 --> 40:26.950
Weisen der Adressierung und diese Adressierungen können Sinn machen

40:26.950 --> 40:29.450
oder können auch zum Nachteil sein.

40:31.450 --> 40:33.450
Gut, jetzt schauen wir uns was an.

40:34.250 --> 40:37.010
Das ist das Data Alignment, das habe ich jetzt gerade erklärt.

40:39.590 --> 40:42.310
Die ausgerichteten Daten, Lücken nutzen.

40:42.310 --> 40:45.650
Sehen Sie, hier steht genau das, was Sie gesagt haben.

40:46.910 --> 40:53.190
Es werden Daten verschwendet, beziehungsweise hier werden Lücken

40:53.190 --> 40:54.930
genutzt oder eben nicht genutzt.

40:56.030 --> 41:00.270
Eine andere Frage ist noch, wie legt man die Bytes im Speicher

41:00.270 --> 41:01.130
überhaupt ab?

41:01.370 --> 41:06.350
Eben, vor 10 Minuten ging es noch darum, wie sind die Bits organisiert

41:06.350 --> 41:11.650
im Speicher, wie gesagt, von rechts nach links, von 2 hoch 0 bis 2

41:11.650 --> 41:12.670
hoch n-1.

41:13.730 --> 41:20.110
Und hier ist die Frage, wie ist ein Wort, also 32 Bit, was aus 4 Byte

41:20.110 --> 41:26.910
besteht, zum Beispiel, wie sind diese Bytes im Speicher organisiert?

41:28.090 --> 41:32.530
Und in dem Fall ist es wieder, wie wir es eben gelernt haben, hier ist

41:32.530 --> 41:33.510
jetzt jedes ein Byte.

41:33.510 --> 41:35.350
Jetzt nicht verwechseln, das geht hier nicht mit.

41:35.830 --> 41:39.710
Hier ist das niederwertigste Byte, dann das höher und höher und hier

41:39.710 --> 41:40.890
das höchstwertige Byte.

41:41.250 --> 41:43.870
Sie sind dann auch von rechts nach links angeordnet.

41:44.790 --> 41:48.150
Und das Ganze, hier ist schon rot angestrichen, ich unterstreiche es

41:48.150 --> 41:49.600
nochmal kurz, um Sie darauf hinzuweisen.

41:50.750 --> 41:51.950
Dies nennt sich Little Indian.

41:57.320 --> 41:59.220
Das letzte Ende ist einfach nur Name.

41:59.720 --> 42:02.560
Es gibt dann noch eine Folie nach dem Motto, wo kommt der Name

42:02.560 --> 42:03.720
überhaupt her dafür.

42:03.720 --> 42:09.780
Aber es spielt keine Rolle, wenn in einem Speicher die Worte so

42:09.780 --> 42:14.680
angeordnet sind, dass das niederwertigste Byte rechts ist und dann so

42:14.680 --> 42:18.500
aufsteigen, wie es hier geschrieben ist, dann nennt man das Little

42:18.500 --> 42:18.840
Indian.

42:19.780 --> 42:21.780
Und das ist dann entsprechend so kodiert.

42:22.540 --> 42:27.180
Das ist nur die Kodierung dafür, also 0, 1, 2, 3, 4, 5, 6, 7, so ist

42:27.180 --> 42:27.800
das kodiert.

42:28.240 --> 42:29.960
Man muss es ja irgendwie adressieren, wenn man es will.

42:31.220 --> 42:34.560
Also, wenn es ein Little Indian gibt, gibt es offensichtlich auch noch

42:34.560 --> 42:35.340
etwas anderes.

42:36.800 --> 42:39.200
Und zwar den Big Indian.

42:40.740 --> 42:42.880
Und da ist es einfach umgekehrt.

42:43.220 --> 42:48.600
Das größte Byte ist hier rechts abgespeichert, dann kommt das kleinere

42:48.600 --> 42:49.240
und so weiter.

42:49.800 --> 42:53.200
Und das kleinste ist dort abgespeichert, wo das MSB ist.

42:55.220 --> 42:58.580
Man kann auch wieder fragen, okay, warum macht man das so oder so?

42:59.060 --> 43:00.240
Das ist einfach eine Konvention.

43:00.800 --> 43:04.420
Hier könnte ich jetzt nicht argumentieren, dass man sagt, man braucht

43:04.420 --> 43:06.040
weniger Bits, um zu adressieren.

43:06.140 --> 43:06.840
Das stimmt nicht.

43:07.380 --> 43:11.740
Man vergeudet Speicher, bestimmt letzten Endes auch nicht.

43:12.060 --> 43:13.280
Das ist einfach andersherum.

43:14.880 --> 43:19.440
Es kommt darauf an, wie man die Adressberechnungsarithmetik intern

43:19.440 --> 43:20.000
aufbaut.

43:20.100 --> 43:22.620
Ob man von oben nach unten, von unten nach oben zählt und so.

43:22.620 --> 43:25.960
Das sind Kleinigkeiten, aber es sind nicht Dinge, die hier jetzt

43:25.960 --> 43:28.640
offensichtlich wären, wo man sagen könnte, es hat einen

43:28.640 --> 43:29.980
offensichtlichen Vorteil.

43:30.680 --> 43:33.460
Was man sich hier nur merken muss, ist Folgendes.

43:34.020 --> 43:36.500
Es gibt Prozessoren, die funktionieren nach diesem Prinzip.

43:37.600 --> 43:40.580
Und es gibt Prozessoren, die funktionieren nach diesem Prinzip.

43:41.680 --> 43:46.340
Und es ist natürlich auch wieder klar, ich habe einen Op-Code, ich

43:46.340 --> 43:51.060
habe einen Maschinen-Code, und ich speichere den ab im Binärformat.

43:51.060 --> 43:54.180
Also den vollkompilierten Code speichere ich ab.

43:54.800 --> 43:59.640
Es ist klar, dass was hier läuft, nicht da läuft, nicht umgekehrt.

44:00.040 --> 44:03.920
Die Bytes werden dann ganz anders interpretiert.

44:04.100 --> 44:05.380
Das ist also nicht kompatibel.

44:07.960 --> 44:09.040
Das muss man wissen.

44:09.120 --> 44:12.520
Es ist nicht kompatibel, es gibt verschiedene Vorteile, sind jetzt

44:12.520 --> 44:16.520
nicht notwendigerweise offensichtlich von dem, was wir zur Zeit hier

44:16.520 --> 44:19.040
im Wissen haben und hier beurteilen.

44:21.860 --> 44:24.920
Okay, das lese ich jetzt nicht vor, das können Sie sich selber

44:24.920 --> 44:25.500
durchlesen.

44:25.560 --> 44:26.460
Woher kommt der Name?

44:29.020 --> 44:29.420
Adressierungsarten.

44:29.860 --> 44:33.540
Jetzt kommen wir zu dem Punkt, wir sind jetzt beim nächsten Teil der

44:33.540 --> 44:36.720
Instruktionssatzarchitektur.

44:37.840 --> 44:41.580
Jetzt ist die Preisfrage, wie greife ich auf die Daten zu?

44:42.440 --> 44:45.300
Wie komme ich an die Daten ran, die im Speicher liegen?

44:48.560 --> 44:50.320
Da gibt es eine ganze Menge.

44:53.860 --> 44:57.660
Ich kann natürlich unterschiedliche Daten haben.

44:58.360 --> 44:59.860
Ich kann mir vorstellen, ich habe eine Konstante.

44:59.940 --> 45:05.120
Stellen Sie sich vor, Sie haben im Programm eine Konstante Pi.

45:06.500 --> 45:10.100
Die brauche ich eigentlich nicht im Register abzulegen, als

45:10.100 --> 45:12.100
Programmierer, denn Pi ist immer Pi.

45:12.100 --> 45:14.220
Oder es gibt auch andere Zahlen, die sind halt fix.

45:15.460 --> 45:18.060
Warum soll ich die als Variable im Speicher abgeben?

45:18.400 --> 45:18.960
Brauche ich nicht.

45:19.380 --> 45:23.920
Dann kann ich das direkt in den Code reinschreiben, Pi als feste Zahl.

45:25.260 --> 45:26.780
Und das kann ich dann eben auch machen.

45:27.280 --> 45:29.840
Ich kann zum Beispiel direkt eine Konstante angeben.

45:30.140 --> 45:32.240
Und dann wäre die Adressierung auch entsprechend.

45:32.680 --> 45:34.840
Ich brauche also nicht erst auf einem Register zuzugreifen.

45:34.840 --> 45:38.620
Da ist die Konstante Teil des Codes.

45:40.180 --> 45:44.160
Und damit habe ich dann auch eine Adressierungsart, die sich auf eine

45:44.160 --> 45:45.140
Konstante bezieht.

45:45.280 --> 45:50.340
Das mag Ihnen trivial erscheinen, hat aber einen Unterschied in der

45:50.340 --> 45:53.120
Art und Weise, wie ich auf das Datum zugreife.

45:53.240 --> 45:56.420
Und Sie werden auch hier wieder sehen, die ganzen Adressierungsarten,

45:56.540 --> 46:01.940
die wir hier lernen, unterscheiden sich signifikant darin, wie

46:01.940 --> 46:04.820
schwierig es ist, auf ein Datum zuzugreifen.

46:08.080 --> 46:11.400
Und das jetzt schon mal, um es vorwegzunehmen, das kommt dann alles

46:11.400 --> 46:13.460
noch in den Folien, aber ich möchte nicht so gerne durch die Folien

46:13.460 --> 46:16.620
durchgehen, ich möchte dann noch so mit Ihnen sozusagen arbeiten.

46:18.740 --> 46:24.040
Wenn ich adressiere, dann ist ja damit irgendetwas, irgendein Aufwand

46:24.040 --> 46:24.700
verbunden.

46:24.700 --> 46:29.140
Also, ich kann auf einen Speicher zugreifen, auf einen Hauptspeicher,

46:29.720 --> 46:34.060
ich kann auf einen Register zugreifen, ich greife auf einen konstanten

46:34.060 --> 46:34.860
Wert zu.

46:35.680 --> 46:36.880
Was passiert denn dann?

46:36.980 --> 46:39.700
Was passiert denn dann, was ich als Programmierer eigentlich gar nicht

46:39.700 --> 46:40.200
mitkriege?

46:40.280 --> 46:44.820
Als Programmierer sage ich nur, ich will den Inhalt des Registers, ich

46:44.820 --> 46:49.760
will den Inhalt des Speichers, ich will, dass diese Konstante mit zwei

46:49.760 --> 46:51.680
multipliziert wird oder irgend sowas.

46:53.160 --> 46:56.900
Aber was macht denn der Rechner, was ich als Programmierer, also

46:56.900 --> 47:00.800
meinem Algorithmus, den ich schreibe, überhaupt nicht mitbekomme?

47:01.700 --> 47:02.660
Was passiert denn da?

47:06.990 --> 47:12.410
Und das führt dann letzten Endes auch zu der Frage, warum ich unter

47:12.410 --> 47:15.130
Umständen unterschiedliche Adressierungsmodi habe.

47:17.050 --> 47:19.930
Also, was macht eine ANU, die Daten haben will?

47:19.930 --> 47:21.010
Wo kommen die her?

47:21.990 --> 47:24.670
Woher weiß die ANU, wo die Daten herkommen?

47:25.010 --> 47:28.210
Also, wenn ich als Programmierer sage, was muss der Rechner tun?

47:28.430 --> 47:29.430
Muss der irgendwas tun?

47:30.090 --> 47:37.070
Muss der vielleicht zusätzlich was tun, um A und B miteinander zu

47:37.070 --> 47:37.510
addieren?

47:37.630 --> 47:40.410
Muss der noch irgendetwas anderes tun, um das zu bewerkstelligen?

47:40.730 --> 47:43.910
Also gibt es irgendwas, das ist eigentlich die große Frage hier, gibt

47:43.910 --> 47:48.250
es irgendwas, wenn wir uns diese Sache hier anführen, wo war das

47:48.250 --> 47:48.610
Beispiel?

47:49.250 --> 47:49.990
Hier ist das Beispiel.

47:50.130 --> 47:52.190
Das sehe ich als Programmierer.

47:53.010 --> 47:57.650
Und das, denke ich, ist alles, was der Rechner hier letzten Endes tut,

47:58.050 --> 48:01.490
aber was tut der Rechner zusätzlich noch, um dies wirklich

48:01.490 --> 48:02.110
auszuführen?

48:02.210 --> 48:03.230
Das ist eigentlich die Frage.

48:09.140 --> 48:10.500
Also irgendwelche Vorschläge.

48:12.120 --> 48:12.960
Was passiert da?

48:13.100 --> 48:14.020
Es geht um Adressen.

48:14.820 --> 48:16.480
Wo kommen die Adressen her, frage ich.

48:17.620 --> 48:18.480
Wo kommen die her?

48:22.520 --> 48:25.680
Sehr gut, es ist ganz einfach, die Adressen müssen berechnet werden.

48:26.220 --> 48:29.420
Es ist so einfach wie, die Adressen müssen berechnet werden.

48:30.360 --> 48:32.960
Die Adressen müssen berechnet werden, die sind nicht da.

48:33.920 --> 48:35.380
Die müssen berechnet werden.

48:36.180 --> 48:41.740
Das heißt, es gibt, irgendwo im Rechner gibt es zum Beispiel einen

48:41.740 --> 48:46.400
Multiplizierer oder eine ALU, die macht nichts anderes, als Adressen

48:46.400 --> 48:47.080
zu berechnen.

48:47.980 --> 48:52.040
Die steht für mich als Programmierer gar nicht zur Verfügung, um zwei

48:52.040 --> 48:57.300
Zahlen zu addieren oder sonst was zu tun, sondern da gibt es eine AGU,

48:57.460 --> 49:03.000
Adress Generation Unit, das heißt eine Einheit, die die Adressen

49:03.000 --> 49:03.420
berechnet.

49:05.780 --> 49:09.120
Und die Adressberechnung, die dauert natürlich offensichtlich auch

49:09.120 --> 49:10.180
selber wieder Zeit.

49:12.220 --> 49:15.320
Der Trick bei der Sache ist zumindest, dass ich Folgendes tue.

49:15.320 --> 49:19.740
Ich habe Recheneinheiten, um meine Aufgabe zu berechnen, meinen

49:19.740 --> 49:23.040
Algorithmus zu berechnen, und ich habe Recheneinheiten, die ich als

49:23.040 --> 49:27.720
Programmierer nicht sehe, die berechnen gleichzeitig die Adressen.

49:29.860 --> 49:32.520
Aber es muss halt gemacht werden, das wollte ich hier nur sagen.

49:33.160 --> 49:38.700
Und da es gemacht werden muss, und wie es gemacht werden muss, das

49:38.700 --> 49:39.420
bestimmen die Adressierungsarten.

49:40.260 --> 49:42.820
Deswegen beschäftigen wir uns unter anderem mit Adressierungsarten.

49:42.820 --> 49:45.800
Natürlich haben wir auch deshalb unterschiedliche Adressierungsarten,

49:45.960 --> 49:50.140
und zwar hauptsächlich, weil wir ein Programm schreiben möchten, was

49:50.140 --> 49:51.220
möglichst elegant ist.

49:51.820 --> 49:54.500
Ich kann ein Programm schreiben, um ein Programm zu schreiben,

49:55.100 --> 49:57.060
benötige ich relativ wenige Befehle.

49:57.220 --> 50:02.000
Um ein effizientes Programm zu schreiben, benötige ich sehr viel mehr.

50:04.360 --> 50:07.520
Effizient heißt dabei, kann dabei auch heißen, kann dabei mehr heißen.

50:07.640 --> 50:10.480
Es kann heißen einerseits, das Programm soll schnell ausführen, wenn

50:10.480 --> 50:14.960
es einmal kompiliert ist, oder ich als Programmierer soll wenig Zeit

50:14.960 --> 50:16.380
haben, dieses Programm zu schreiben.

50:16.500 --> 50:18.000
Das ist ja auch durchaus ein Faktor.

50:18.720 --> 50:23.460
Wenn ich primitive Befehle habe, muss komplexe Operationen ausführen,

50:23.600 --> 50:27.200
und mein Instruktionssatz unterstützt mich nicht dazu, dann sitze ich

50:27.200 --> 50:31.620
ewig da, um zum Beispiel eine Größenordnungstransformation

50:31.620 --> 50:32.520
auszurechnen.

50:32.620 --> 50:36.500
Wenn ich aber Befehle habe, die mir Teile davon schon zum größten Teil

50:36.500 --> 50:40.560
abnehmen, zum Beispiel wie elegant ich den Speicher adressiere, dann

50:40.560 --> 50:41.740
kann ich das viel schneller machen.

50:42.200 --> 50:44.980
Also das ist die Idee dabei, warum ich verschiedene Adressierungsmodi

50:44.980 --> 50:45.360
habe.

50:46.140 --> 50:49.740
Wir werden im Folgenden durch alle Adressierungsmodi durchgehen.

50:50.940 --> 50:54.900
Ich werde die erläutern und wollte Ihnen als Vorab schon die

50:54.900 --> 50:55.900
Informationen geben.

50:56.760 --> 51:00.580
Diese gibt es, um mehr Optionen zu haben, um den Programmierer zu

51:00.580 --> 51:01.440
entlasten.

51:01.980 --> 51:07.880
Und wir werden dann auch sehen, wie die Berechnungen, welche die

51:07.880 --> 51:12.680
Berechnungen sind, die zur Adressgenerierung benötigt werden.

51:13.680 --> 51:15.380
Und das schauen wir uns dann im Folgenden an.

51:15.940 --> 51:18.560
Aber erstmal, es gibt verschiedene Adressen, schauen Sie mal.

51:18.800 --> 51:20.060
Hier gibt es eine Programmadresse.

51:22.260 --> 51:24.060
Warum gibt es überhaupt verschiedene Adressen?

51:24.120 --> 51:25.560
Das ist auch ein ganz wichtiges Konzept.

51:25.680 --> 51:30.080
Wenn ich hier von Adressen rede, dann meine ich nicht nur, da ist eine

51:30.080 --> 51:33.680
Adresse, sondern es gibt verschiedene Arten von Adressen.

51:36.020 --> 51:37.680
Und die Frage müssen Sie beantworten.

51:37.760 --> 51:42.700
Warum ist eine Adresse im Programm eine andere als eine Adresse, die

51:42.700 --> 51:45.860
dann letzten Endes, die ich mit einem Oszilloskop zum Beispiel am

51:45.860 --> 51:49.320
Speicher am Bus feststellen könnte?

51:49.520 --> 51:51.960
Warum ist die im Programm, im Software-Code eine andere?

51:52.500 --> 51:54.560
Die nenne ich mal, oder die haben wir hier mal genannt,

51:54.720 --> 51:55.700
Programmadressen.

51:57.160 --> 51:59.920
Warum gibt es verschiedene Adressen?

52:03.120 --> 52:05.540
Da müssen Sie mir jetzt helfen, das wollte ich jetzt selber nicht

52:05.540 --> 52:05.760
sagen.

52:11.570 --> 52:16.870
Also der Programmierer kann nicht wissen, wo sich das Programm während

52:16.870 --> 52:19.190
der Laufzeit im Speicher befindet.

52:20.050 --> 52:21.090
Das weiß ich nicht.

52:21.190 --> 52:25.490
Ich schreibe ein Programm und als Programmierer würde ich angeben,

52:25.990 --> 52:32.330
eine Adresse würde ich sagen, bitte springe, wenn die Bedingung falsch

52:32.330 --> 52:36.430
ist, bitte springe an das Ende des Programmes.

52:37.570 --> 52:41.630
Dann wäre meine Adresse, die ich angebe, Ende des Programmes.

52:41.990 --> 52:44.430
Und da steht vielleicht so ein Label und dann steht dann End of

52:44.430 --> 52:45.710
Programme oder irgend sowas.

52:46.170 --> 52:48.570
Und das ist meine Adresse, die ich als Programmierer angebe.

52:49.750 --> 52:51.690
Aber was hat das jetzt mit dem Speicher zu tun?

52:51.790 --> 52:54.390
Speicher ist irgendwo ein Stück Hardware, da steht das dann.

52:54.810 --> 52:56.510
Oder gehen wir einen Schritt voraus.

52:57.490 --> 53:00.510
Der Prozessor, sagen wir mal so, der Prozessor kennt ja eigentlich

53:00.510 --> 53:01.350
nicht mein Programm.

53:01.350 --> 53:07.790
Der kennt eine Abfolge von Opcodes, von Adressen, weiß, was er mit

53:07.790 --> 53:10.430
diesen Adressen machen soll, wie er diese verknüpfen muss.

53:10.830 --> 53:15.350
Aber dem Prozessor ist ja sozusagen ein Programm als solches überhaupt

53:15.350 --> 53:15.990
nicht bekannt.

53:16.090 --> 53:18.850
Das sind ja nur Opcodes und Adressen und Verknüpfungen, die da

53:18.850 --> 53:19.350
stattfinden.

53:23.610 --> 53:28.250
Also, es gibt offensichtlich eine Programmadresse, die ich als

53:28.250 --> 53:32.290
Programmierer angebe, wie Sie richtig gesagt haben.

53:33.030 --> 53:34.770
Und es gibt eine Prozessadresse.

53:34.930 --> 53:39.390
Das ist die effektive Adresse, die der Prozessor verwendet.

53:45.900 --> 53:48.600
Ja, der Prozessor verwendet die.

53:51.120 --> 53:52.840
Aber ich habe noch mehr Fragen an Sie.

53:52.940 --> 53:54.300
Der Prozessor verwendet die.

53:55.600 --> 53:57.980
Jetzt behaupte ich, es gibt noch andere Adressen.

53:58.980 --> 54:01.280
Gibt es Adressen, die selbst der Prozessor nicht kennt?

54:02.500 --> 54:05.580
Wenn ein Programmierer, der kennt die Adressen nicht, wie Sie richtig

54:05.580 --> 54:12.140
gesagt haben, und dann wird das transformiert in Adressen, die der

54:12.140 --> 54:15.960
Prozessor kennt, nennt sich Prozessadresse.

54:18.800 --> 54:21.540
Und dann behaupte ich, es gibt Adressen, die kennt nicht mal der

54:21.540 --> 54:22.060
Prozessor.

54:24.140 --> 54:24.660
Warum?

54:27.960 --> 54:29.860
Auf der Prozessor weiß nicht alles sozusagen.

54:32.160 --> 54:36.180
Na gut, die Antwort ist natürlich so ein bisschen ähnlich, wie Sie sie

54:36.180 --> 54:37.000
eben genannt haben.

54:37.100 --> 54:40.440
Im Falle des Programmierers ist es analog dazu.

54:41.040 --> 54:42.220
Also, Sie müssen schon weiterhelfen.

54:42.420 --> 54:43.200
Das ist einfach.

54:43.320 --> 54:45.140
Das kann man sich einfach überlegen.

54:45.800 --> 54:47.920
Warum weiß der Prozessor die Adresse nicht?

54:49.220 --> 54:50.040
Nicht unbedingt.

54:50.580 --> 54:53.860
Warum gibt es noch eine andere Art von Adressen?

54:55.580 --> 54:56.140
Keine Idee.

54:57.180 --> 54:58.960
Das war doch sehr gut, was Sie eben gesagt haben.

54:58.960 --> 55:03.460
Jetzt muss man sich nur sozusagen in den Prozessor reindenken.

55:04.980 --> 55:06.120
Die Sichtweise des Prozessors.

55:06.680 --> 55:08.380
Was ist die Sichtweise des Prozessors?

55:13.350 --> 55:15.090
Wir haben doch eben gesehen, was ein Prozessor ist.

55:15.130 --> 55:19.890
Ein Prozessor weiß zum Beispiel, mein Speicher ist 4 Gigabyte groß.

55:19.970 --> 55:25.630
Das weiß der Prozessor, weil er eine bestimmte Anzahl von Adressbits

55:25.630 --> 55:29.350
hat, um diesen Speicher zu adressieren.

55:31.250 --> 55:32.450
Das weiß der.

55:33.950 --> 55:36.230
Und dafür braucht er seine Prozessadresse.

55:37.370 --> 55:39.050
Aber was weiß der Prozessor nicht?

55:39.190 --> 55:39.730
Das ist die Frage.

55:42.310 --> 55:43.910
Oh, virtuelle Adressen.

55:44.510 --> 55:45.210
Super, genau.

55:45.430 --> 55:47.630
Es gibt so Dinge wie virtuelle Adressen.

55:49.150 --> 55:53.430
Es gibt Adressen, das sind virtuelle Adressen, mit denen kann man

55:53.430 --> 55:53.770
rechnen.

55:53.890 --> 55:57.550
Die sind dann offensichtlich noch nicht die physikalischen Adressen.

55:57.550 --> 56:02.970
Das heißt, wenn ich das mal so frei übersetzen darf, es gibt Adressen,

56:03.430 --> 56:07.430
die kann der Prozessor nicht wissen, weil der Prozessor weiß ja nicht,

56:07.530 --> 56:10.010
in welches Computersystem er eingebaut ist.

56:10.710 --> 56:16.390
Wenn ein Prozessor 32 Bit hat, um den Hauptspeicher zu adressieren,

56:16.530 --> 56:18.870
dann heißt das ja noch lang nicht, dass ich mir einen Computer

56:18.870 --> 56:22.290
zusammenbaue, der genauso viel Speicher hat, der kann ja weniger

56:22.290 --> 56:23.110
Speicher haben.

56:25.910 --> 56:31.090
Und vielleicht kann der Computer, den ich habe, sogar mehr Speicher

56:31.090 --> 56:33.490
haben, als was der Prozessor adressieren kann.

56:33.590 --> 56:34.670
Das kann ich mir auch vorstellen.

56:35.210 --> 56:39.030
Der hat mehr oder weniger Speicher, der Prozessor weiß es nicht.

56:39.090 --> 56:42.690
Der rechnet einfach so und tut so, als hätte er einen Speicher, der

56:42.690 --> 56:45.230
immer 4 Gigabyte groß ist.

56:45.330 --> 56:46.750
Der kann kleiner oder größer sein.

56:46.750 --> 56:50.290
Und dann ist völlig richtig, wie Sie sagten, dann gibt es so Dinge wie

56:51.410 --> 56:54.990
virtuelle Adressen, physikalische Adressen.

56:55.330 --> 57:00.750
Das sind dann wirklich die physikalischen, die dann die Speicherzellen

57:00.750 --> 57:03.770
dastehen, wo mein Bit wirklich drin steht.

57:04.930 --> 57:07.350
Und darüber geht es über virtuelle Adressen, das schauen wir uns alle

57:07.350 --> 57:09.130
später in Vorlesungen nochmal an.

57:09.790 --> 57:13.530
Es ist aber jetzt schon wichtig zu wissen, denn das ist der Grund

57:13.530 --> 57:18.770
dafür, dass ich Programmadressen habe, dass ich Prozessadressen habe

57:18.770 --> 57:23.010
und dass ich, wie man zusammenfassend sagt, auch Maschinenadressen

57:23.010 --> 57:23.330
habe.

57:24.970 --> 57:26.370
Gibt es dazu noch Fragen?

57:26.850 --> 57:29.070
Also wir haben natürlich noch nicht genau erklärt, was das ist, aber

57:29.070 --> 57:33.150
es ist klar, dass es dafür eine Hierarchie gibt, dass das Sinn macht.

57:37.500 --> 57:41.000
Gut, damit haben wir also drei verschiedene Arten von Adressen.

57:43.020 --> 57:48.120
Und jetzt wollen wir uns mal angucken, bevor wir in 4.3 zu

57:48.120 --> 57:52.180
Adressierungsarten gehen, wollen wir uns jetzt überlegen, welche Arten

57:52.180 --> 57:53.560
von Befehlen gibt es denn?

57:55.680 --> 57:58.220
Und das hätte ich jetzt vielleicht eher ausblenden sollen, aber

57:58.220 --> 57:59.660
vielleicht können wir es so einfach erklären.

58:00.300 --> 58:01.920
Es gibt zum Beispiel Transportbefehle.

58:02.000 --> 58:03.240
Nennen Sie mir einen Transportbefehl.

58:03.300 --> 58:07.180
Hat man heute schon auf irgendeiner Folie drauf.

58:07.260 --> 58:08.000
Was ist ein Transportbefehl?

58:10.000 --> 58:12.000
Ein Beispiel für ein Transportbefehl.

58:14.900 --> 58:16.680
Mit Beispielen lässt sich es einfacher merken.

58:16.980 --> 58:17.360
Das ist der Trick.

58:18.320 --> 58:21.020
Also wenn jetzt einer von Ihnen was nennt, können sich das alle später

58:21.020 --> 58:21.800
besser merken.

58:24.000 --> 58:25.320
Ein Load, genau.

58:25.560 --> 58:29.440
Wir haben eben ein Load gesehen, wo ein Wert in den Speicher, von dem

58:29.440 --> 58:31.220
Hauptspeicher in das Register geladen wurde.

58:31.360 --> 58:32.260
Das ist ein Transportbefehl.

58:32.320 --> 58:33.040
Was passiert da?

58:33.780 --> 58:40.940
Ein Datum wird je laden, wird verschoben im Computersystem vom

58:40.940 --> 58:43.580
Hauptspeicher in ein Register.

58:43.940 --> 58:45.740
Das nennt man ein Transportbefehl.

58:45.900 --> 58:47.300
Es wird also etwas transportiert.

58:47.380 --> 58:48.580
Ein Datum wird transportiert.

58:50.060 --> 58:51.600
Arithmetische, logische Befehle.

58:52.480 --> 58:53.720
Also ein paar Beispiele dafür.

58:54.080 --> 58:56.380
Eins hatte ich dauernd genannt, arithmetisch ist ein Add.

58:56.500 --> 59:00.260
Was sind noch andere arithmetische, logische Befehle?

59:03.280 --> 59:04.840
Ein Add hatte ich genannt, genau.

59:05.060 --> 59:05.820
Was könnte man sich...

59:08.220 --> 59:09.140
Subtraktion, genau.

59:09.480 --> 59:09.840
Was noch?

59:09.940 --> 59:11.080
Also ein paar Sachen sammeln.

59:11.160 --> 59:13.300
Man kann sich besser merken, wenn man sich Dinge sammelt, wo man

59:13.300 --> 59:14.160
sie...

59:14.160 --> 59:17.400
Was sind arithmetische, auch logische Befehle?

59:21.500 --> 59:26.200
Ein bitweises Und, also eine Undverknüpfung von Bit.

59:26.840 --> 59:29.200
Bitweise zum Beispiel über ein Wort, richtig.

59:29.780 --> 59:30.220
Was noch?

59:33.500 --> 59:35.500
Man kann regieren und so weiter.

59:37.900 --> 59:40.820
Dann gibt es Biberotationsbefehle.

59:41.060 --> 59:42.320
Das sagt eigentlich der Name.

59:42.460 --> 59:44.680
Was wird da geschoben oder was wird da rotiert?

59:48.910 --> 59:50.090
Und warum könnte es...

59:55.760 --> 59:56.240
Genau.

59:56.940 --> 59:59.040
Ich kann Bits nach links oder rechts verschieben.

59:59.160 --> 01:00:03.660
Ich habe ein Wort und verschiebe in einem Takt zum Beispiel alle Bits

01:00:03.660 --> 01:00:04.500
nach links oder rechts.

01:00:04.620 --> 01:00:07.200
Sie erinnern sich, es geht rechts bei 2 hoch 0 los.

01:00:07.200 --> 01:00:12.200
Und jetzt verschiebe ich das, nehmen wir an, ich verschiebe das...

01:00:13.360 --> 01:00:15.880
alles nach rechts um einen Bitwert.

01:00:16.060 --> 01:00:17.820
Was erreiche ich dadurch?

01:00:18.060 --> 01:00:22.060
Was bedeutet das im Sinne einer Operation?

01:00:24.380 --> 01:00:29.120
Alle Bits eines Wortes um einen Bit nach rechts verschoben.

01:00:29.700 --> 01:00:30.420
Was heißt das?

01:00:32.020 --> 01:00:34.480
Eine Division gleich 2, genau.

01:00:36.540 --> 01:00:39.080
Beziehungsweise eine Multiplikation, wenn ich es nach links mache.

01:00:40.340 --> 01:00:42.480
Also das wären zum Beispiel Schiebebefehle.

01:00:43.140 --> 01:00:44.800
Dann gibt es auch noch Rotationsbefehle.

01:00:45.580 --> 01:00:47.560
Da wäre zum Beispiel die Frage, wenn ich das jetzt nach rechts

01:00:47.560 --> 01:00:50.680
verschiebe, dann foliere ich ja unter Umständen ein Bit.

01:00:51.120 --> 01:00:54.720
Wenn ich es durch zwei teile, dann bleibt eins über.

01:00:55.600 --> 01:00:57.460
Und was tue ich mit dem, der über ist?

01:00:58.080 --> 01:01:02.320
Da gibt es zum Beispiel die Möglichkeit, ich rotiere das, ich nehme

01:01:02.320 --> 01:01:06.960
das Bit, was über bleibt, und lasse es von links wieder reinkommen,

01:01:07.100 --> 01:01:07.680
zum Beispiel.

01:01:09.240 --> 01:01:11.980
Wie weit das sinnvoll ist, oder was ich damit für Operationen machen

01:01:11.980 --> 01:01:14.460
kann, ist eine andere Sache, da kann man was mit machen, aber das wäre

01:01:14.460 --> 01:01:16.140
dann ein Rotationsbefehl.

01:01:17.160 --> 01:01:21.140
Ich schmeiße das Bit also nicht weg, was ich rausrotiert habe, was ich

01:01:21.140 --> 01:01:23.960
rausgeschoben habe, sondern ich rotiere es und nutze es.

01:01:24.940 --> 01:01:27.560
Dann gibt es Dinge wie Multimediabefehle.

01:01:28.140 --> 01:01:32.660
Das gab es hauptsächlich, das gibt es mittlerweile seit 25, 30 Jahren

01:01:32.660 --> 01:01:33.040
oder so.

01:01:33.160 --> 01:01:36.460
Irgendwann hat man sich überlegt, mit Computern möchte man mehr machen

01:01:36.460 --> 01:01:40.280
wollen als Textverarbeitung oder irgendwelche wissenschaftlichen

01:01:40.280 --> 01:01:40.900
Berechnungen.

01:01:42.600 --> 01:01:46.040
Vielleicht kann man das auch für Multimedia einsetzen, was heute

01:01:46.040 --> 01:01:50.460
eigentlich fast der Hauptanwendungsbereich ist, bei verschiedenen

01:01:50.460 --> 01:01:53.760
Anwendungen, und dafür bestimmte Befehle haben.

01:01:53.900 --> 01:01:54.940
Also auch sowas gibt es.

01:01:56.200 --> 01:02:01.360
Zum Beispiel eine Fast-Fourier-Transformation, da kommen so Dinge vor

01:02:01.360 --> 01:02:04.960
wie Multipliant Add.

01:02:05.140 --> 01:02:10.420
Das heißt, eine Multiplikation, eine Addition, wird dort immer wieder

01:02:10.420 --> 01:02:12.940
aufeinanderfolgend ausgeführt.

01:02:13.800 --> 01:02:17.960
Und wenn ich jetzt eine Operation habe, die das sozusagen zusammentut,

01:02:19.040 --> 01:02:24.400
ohne das Datum zwischendurch abzuspeichern, dann habe ich natürlich

01:02:24.400 --> 01:02:24.920
was gewonnen.

01:02:25.140 --> 01:02:28.840
Das heißt, ich habe eine Folge von Befehlen, die ich als neuen Befehl

01:02:28.840 --> 01:02:35.100
definiere, und damit habe ich Zwischenschritte wie Abspeichern

01:02:35.100 --> 01:02:35.600
gespart.

01:02:36.560 --> 01:02:39.640
Und Multimedia-Befehle zum Beispiel tun solche Dinge.

01:02:42.700 --> 01:02:45.340
Kleidkammerbefehle haben wir gesehen, Programmsteuerbefehle.

01:02:46.940 --> 01:02:50.340
Das ist halt ein Jump zum Beispiel, ich springe irgendwo ein Programm

01:02:50.340 --> 01:02:50.780
hin.

01:02:52.000 --> 01:02:55.580
Da kann ich so Dinge haben, bedingte, unbedingte Sprünge.

01:02:56.800 --> 01:02:57.920
Also sowas kennen wir eigentlich schon.

01:02:58.720 --> 01:03:02.720
Was wäre zum Beispiel ein Systemsteuerbefehl?

01:03:03.880 --> 01:03:05.340
Was wäre ein Systemsteuerbefehl?

01:03:05.720 --> 01:03:07.880
Also System ist der Mikroprozessor.

01:03:08.740 --> 01:03:10.700
Was wäre ein Systemsteuerbefehl?

01:03:14.220 --> 01:03:15.700
Das hat man eigentlich noch nicht.

01:03:16.700 --> 01:03:19.380
Aber wem fällt was zu ein, was es sein könnte?

01:03:21.360 --> 01:03:23.220
Was muss gesteuert werden im System?

01:03:23.420 --> 01:03:27.660
Es geht jetzt nicht um das Programm offensichtlich, wo ich eine

01:03:27.660 --> 01:03:31.600
Schleife habe, wo ich irgendwo hinspringe und da das Programm steuere,

01:03:32.120 --> 01:03:34.500
sondern es geht um Systemsteuerbefehle.

01:03:39.880 --> 01:03:43.280
Den Computer runterzufahren.

01:03:44.600 --> 01:03:48.360
Okay, ich würde sagen, dass es ein Systemsteuerbefehl ist.

01:03:48.360 --> 01:03:48.780
Das ist richtig.

01:03:49.780 --> 01:03:53.380
Da müsste man eine große Sequenz von Befehlen haben, was teilweise

01:03:53.380 --> 01:03:54.960
auch das Betriebssystem tut.

01:03:55.400 --> 01:03:58.260
Sie haben sozusagen schon zwei, drei Schritte weiter gedacht.

01:03:58.400 --> 01:03:59.380
Das ist völlig richtig.

01:04:00.200 --> 01:04:05.320
Ein naheliegender Systemsteuerbefehl wäre, wenn man dem Mikroprozessor

01:04:05.320 --> 01:04:10.700
sagt, wir haben zwei Zahlen miteinander addiert und da gab es einen

01:04:10.700 --> 01:04:11.280
Overflow.

01:04:11.660 --> 01:04:17.380
Das heißt, der Wertebereich der Addition ist überschritten worden und

01:04:17.380 --> 01:04:21.060
da könnte ich dem Rechner sagen, wir haben hier einen Overflow.

01:04:21.140 --> 01:04:22.880
Wir können das nicht berechnen.

01:04:23.000 --> 01:04:25.240
Dann sage ich also dem System, wir können das nicht berechnen.

01:04:25.940 --> 01:04:30.700
Es ist besser, ich sage das, wir können das nicht berechnen, als wenn

01:04:30.700 --> 01:04:33.100
es dann passiert und es kommt ein falsches Ergebnis raus.

01:04:34.160 --> 01:04:37.140
Oder es könnte doch ein Systemsteuerbefehl sein.

01:04:38.380 --> 01:04:43.160
Wenn man daran denkt, ein System kann ja ein eingebettetes System

01:04:43.160 --> 01:04:48.260
sein, was irgendetwas tut zu einer Zeit und dann kommt irgendetwas

01:04:48.260 --> 01:04:48.620
Wichtigeres.

01:04:49.600 --> 01:04:51.300
Dann müsste das System auch irgendwie steuern.

01:04:52.120 --> 01:04:53.200
Interrupt, genau.

01:04:54.500 --> 01:04:57.560
Interrupt heißt offensichtlich Unterbrechung.

01:04:58.340 --> 01:05:03.080
Ich unterbreche mein Programm so, wie es eigentlich gerade ausgeführt

01:05:03.080 --> 01:05:07.760
hat, also mein Algorithmus, der den größten Wert in einem Feld findet,

01:05:09.240 --> 01:05:11.840
eine FFT ausführt oder irgendetwas.

01:05:11.840 --> 01:05:13.340
Das unterbreche ich.

01:05:15.240 --> 01:05:19.360
Das unterbreche ich und führe ein neues Programm fort.

01:05:20.200 --> 01:05:20.540
Warum?

01:05:21.400 --> 01:05:26.180
Weil dieses unterbrechende Programm oder dieses Signal eine höhere

01:05:26.180 --> 01:05:27.380
Priorität hat.

01:05:31.130 --> 01:05:32.870
Das gibt es, also höhere Prioritäten.

01:05:33.690 --> 01:05:36.530
Fällt Ihnen irgendein Beispiel ein aus dem täglichen Leben, wo wir ein

01:05:36.530 --> 01:05:40.910
System haben, wo ein Interrupt Sinn machen könnte?

01:05:44.960 --> 01:05:46.860
Maus und Tastatur, sehr gut.

01:05:47.560 --> 01:05:52.820
Zum Beispiel, ich gebe, ich tippe an meiner Tastatur oder mache da

01:05:52.820 --> 01:05:57.400
irgendwas mit der Maus, also betätige meine Eingabe, aber das mache

01:05:57.400 --> 01:05:58.680
ich ja nicht die ganze Zeit.

01:05:59.660 --> 01:06:02.180
Das heißt, es wäre eigentlich dumm, wenn der Rechner sich die ganze

01:06:02.180 --> 01:06:07.140
Zeit damit beschäftigen müsste, lebt der Benutzer oder tippt der

01:06:07.140 --> 01:06:07.820
gerade irgendwas.

01:06:09.120 --> 01:06:12.120
Das heißt, es wäre eigentlich besser, wenn das Gerät selber sagt, die

01:06:12.120 --> 01:06:15.560
Tastatur, oh, jetzt kommen wieder ein paar Zeichen, jetzt müssen wir

01:06:15.560 --> 01:06:18.200
gerade mal die andere Ausführung, was auch immer da im Hintergrund

01:06:18.200 --> 01:06:22.580
läuft, unterbrechen, um diese Zeichen, die gerade eingetippt wurden,

01:06:22.740 --> 01:06:25.600
dem Programm zuzuführen.

01:06:27.440 --> 01:06:28.540
Was wären noch andere Sachen?

01:06:28.880 --> 01:06:31.500
Ich behaupte sogar, es gibt Dinge, die sind lebensnotwendig.

01:06:31.660 --> 01:06:33.820
Ja, hier ist vielleicht nicht so lebensnotwendig, das war ein sehr

01:06:33.820 --> 01:06:36.980
gutes Beispiel, aber...

01:06:37.660 --> 01:06:40.220
Airbags, super, genau, sowas wollte ich eigentlich hören.

01:06:40.360 --> 01:06:45.980
Also man fährt im Auto, man fährt im Auto und ja, was macht man im

01:06:45.980 --> 01:06:46.180
Auto?

01:06:46.320 --> 01:06:49.120
Man fährt, das System beschäftigt sich damit, vielleicht Sprit zu

01:06:49.120 --> 01:06:51.740
sparen, vielleicht hört man Musik oder irgend so was.

01:06:52.320 --> 01:06:54.400
Das heißt, da finden natürlich Berechnungen statt.

01:06:55.080 --> 01:06:58.620
Womit ich nicht rechne, ist, dass ich vielleicht sehr scharf bremsen

01:06:58.620 --> 01:06:59.140
muss.

01:07:00.380 --> 01:07:04.420
Dass es irgendeinen Sensor gibt, der sagt, es steht ein Aufprall bevor

01:07:04.420 --> 01:07:08.920
oder hat gerade stattgefunden, ein Airbag muss ausgelöst werden.

01:07:09.460 --> 01:07:10.140
Und das ist ganz klar.

01:07:10.340 --> 01:07:14.740
Und das ist so ein eigentlicher Sinn von so einem Interrat, dass nun

01:07:14.740 --> 01:07:17.100
alle Rechenressourcen gestoppt werden.

01:07:18.120 --> 01:07:22.300
Und dass ich diesem Interrat die höchste Priorität gebe und sage,

01:07:22.980 --> 01:07:26.860
alles, was da läuft, ist nicht so wichtig, jetzt muss der Airbag

01:07:26.860 --> 01:07:27.740
ausgelöst werden.

01:07:30.750 --> 01:07:33.650
Das ist ein sehr gutes Beispiel für einen Interrat.

01:07:35.150 --> 01:07:39.790
Typischerweise gibt es in einem Programm, gibt es in einem

01:07:39.790 --> 01:07:43.490
Mikroprozessor Interrats verschiedener Priorität.

01:07:43.630 --> 01:07:47.070
Also man kann sich vorstellen, es gibt 10 verschiedene Ebenen von

01:07:47.070 --> 01:07:47.870
Prioritäten.

01:07:48.790 --> 01:07:52.150
Die niedrigste Priorität hätte zum Beispiel mein Programm, der Music

01:07:52.150 --> 01:07:53.270
Player, der da spielt.

01:07:53.970 --> 01:07:57.450
Und dann gibt es viele andere Dinge im Hintergrund, die sehr viel

01:07:57.450 --> 01:07:58.590
wichtiger sein können.

01:07:59.690 --> 01:08:04.390
Zum Beispiel irgendwo zwischendrin könnte es sein, die Batterie geht

01:08:04.390 --> 01:08:05.350
gleich zur Neige.

01:08:05.670 --> 01:08:09.190
Wird ein Programm aufgerufen, was mir dann irgendeinen Ton auslöst

01:08:09.190 --> 01:08:13.090
oder in einem Modus 4 etwas weniger Energie benötigt.

01:08:13.750 --> 01:08:19.010
Oder die letzte Energie im Rechner benutzt, im Laptop benutzt, sodass

01:08:19.010 --> 01:08:21.070
ich den Rechner gerade noch runterfahren kann.

01:08:21.250 --> 01:08:23.650
Und die Tabellenkalkulation, die ich im Hintergrund gemacht habe, die

01:08:23.650 --> 01:08:26.450
geht mir nicht verloren, die wird gerade noch abgespeichert, zum

01:08:26.450 --> 01:08:26.790
Beispiel.

01:08:27.890 --> 01:08:35.410
Es gibt also viele Beispiele für Systemsteuerbefehle.

01:08:36.470 --> 01:08:39.510
Es gibt auch Dinge wie Synchronisationsbefehle, das lasse ich mal an

01:08:39.510 --> 01:08:39.970
der Stelle.

01:08:40.510 --> 01:08:42.810
Das sehen wir dann alle später in der weiteren Vorlesung.

01:08:42.950 --> 01:08:44.630
Also nicht heute, aber dann in den nächsten Wochen.

01:08:45.390 --> 01:08:48.890
Gut, jetzt hatten wir also Folgendes.

01:08:48.930 --> 01:08:53.410
Wir haben verschiedene Befehlsformate, weil wir verschiedene Art und

01:08:53.410 --> 01:08:54.310
Weisen haben,

01:08:58.870 --> 01:09:00.690
wie wir das hier zum Beispiel sehen.

01:09:00.790 --> 01:09:03.530
3-Adress-Format, 2-Adress-Format, 1-Adress-Format, 0-Adress-Format.

01:09:03.570 --> 01:09:05.270
Haben wir gesehen, das will ich nicht nochmal wiederholen.

01:09:05.730 --> 01:09:09.890
Aber, da es das gibt, brauche ich auch verschiedene Befehlsformate.

01:09:10.750 --> 01:09:13.610
Und hier sind jetzt zum Beispiel so verschiedene Befehlsformate.

01:09:14.390 --> 01:09:20.410
Und was Sie jetzt hier sehen ist, wir haben wieder 32-Bit, 0 bis 31.

01:09:21.350 --> 01:09:24.290
Und wir haben jetzt in diesem Fall drei verschiedene Quellenformate.

01:09:24.290 --> 01:09:26.790
Das sind die Typen von Befehlsformaten.

01:09:28.150 --> 01:09:31.950
Das heißt, der Typ I, J, R, warum die so heißen, erschließt sich

01:09:31.950 --> 01:09:32.710
später noch.

01:09:34.870 --> 01:09:40.290
Und diese Typen werden genommen für verschiedene Adressierungsmodi,

01:09:41.090 --> 01:09:46.530
für verschiedene Arten, um ein Befehl darzustellen.

01:09:47.650 --> 01:09:51.430
Es gibt zum Beispiel Befehle, die haben nur ein Op-Code.

01:09:51.430 --> 01:09:54.010
Der Op-Code, das kann ich sagen, was das ist, ich möchte nicht alles

01:09:54.010 --> 01:09:54.470
erklären.

01:09:55.070 --> 01:09:58.750
Aber der Op-Code zum Beispiel sagt, in welchen Befehlen sich handelt.

01:09:58.830 --> 01:10:01.890
Der Op-Code sagt zum Beispiel, es ist eine Add-Operation.

01:10:02.570 --> 01:10:06.570
Das sagt mir jetzt noch nicht unbedingt, was die Register dafür sind.

01:10:06.710 --> 01:10:10.710
Aber es sagt mir zumindest, hier wird die ALU gebraucht, um eine

01:10:10.710 --> 01:10:12.070
Addition zu machen.

01:10:14.170 --> 01:10:18.470
Oder der Op-Code sagt mir, dies ist eine Vergleichs-Operation.

01:10:18.470 --> 01:10:21.130
All dies ist in dem Op-Code gespeichert.

01:10:21.250 --> 01:10:24.610
Und Sie sehen, wir haben hier 6-Bit für den Op-Code.

01:10:25.970 --> 01:10:32.290
Wir haben also 2 auf 6 verschiedene Möglichkeiten, ein Op-Code

01:10:32.290 --> 01:10:32.970
darzustellen.

01:10:33.150 --> 01:10:37.970
Also offensichtlich können wir hiermit 64 verschiedene Arten von

01:10:37.970 --> 01:10:39.130
Befehlen codieren.

01:10:40.650 --> 01:10:43.650
Und wie gesagt, das heißt noch lange nicht, das sagt noch lange nichts

01:10:43.650 --> 01:10:46.410
darüber aus, wie ich das Ganze adressiere.

01:10:48.330 --> 01:10:49.810
So, jetzt habe ich hier den Op-Code.

01:10:50.610 --> 01:10:53.890
Und jetzt kann ich mir vorstellen, ich habe einen Befehl, der braucht

01:10:53.890 --> 01:10:58.390
nichts anderes als ein Op-Code und wie hier steht, ein Target.

01:10:59.310 --> 01:11:02.190
Was könnte denn so ein Befehl sein, der nur das braucht?

01:11:02.310 --> 01:11:04.310
Also offensichtlich braucht er hier kein Register.

01:11:06.370 --> 01:11:09.070
Er braucht nur, was hier als Target steht.

01:11:10.330 --> 01:11:15.030
Also er muss nur sagen, was der Befehl tut und braucht dazu so ein

01:11:15.030 --> 01:11:15.350
Target.

01:11:15.570 --> 01:11:16.650
Was wäre so ein Befehl?

01:11:17.270 --> 01:11:18.010
Mehr braucht er nicht.

01:11:23.700 --> 01:11:24.640
Mehr braucht er nicht.

01:11:25.260 --> 01:11:27.820
Wir haben ja eben die verschiedenen Arten Befehle gesehen.

01:11:28.300 --> 01:11:31.840
Diese Liste von zwei Folien, da gab es die verschiedenen Arten von

01:11:31.840 --> 01:11:32.380
Befehlen.

01:11:33.980 --> 01:11:37.520
Und ja, der gehört offensichtlich zu einer Art dieser Befehle hier.

01:11:39.380 --> 01:11:41.220
Also zum Beispiel ein Jump Befehl.

01:11:41.400 --> 01:11:42.400
Ich springe im Programm.

01:11:43.580 --> 01:11:46.780
Ich springe im Programm und sage, hier steht Op-Code Jump.

01:11:47.160 --> 01:11:48.000
Ich springe.

01:11:49.260 --> 01:11:51.580
Ich springe ans Anfang der Schleife.

01:11:52.200 --> 01:11:52.500
Ich springe.

01:11:53.780 --> 01:11:58.240
Und Target ist dann schon die aufgelöste Adresse.

01:11:59.400 --> 01:12:03.700
Das ist dann schon die Maschinenadresse, die wir letzten Endes

01:12:03.700 --> 01:12:04.160
brauchen.

01:12:04.160 --> 01:12:07.680
Das heißt, die hat der Compiler, Assembler, die haben da schon da

01:12:07.680 --> 01:12:08.340
reingeschrieben.

01:12:09.180 --> 01:12:14.640
Und hier stehen dann für 26-Bit die Sprungadresse zum Beispiel.

01:12:18.040 --> 01:12:22.440
Oder hier habe ich den Typ, dass ich hier ein Register wählen kann.

01:12:23.640 --> 01:12:25.960
Hier addiere ich zum Beispiel, hier wähle ich ein Register.

01:12:26.840 --> 01:12:28.080
Und da habe ich 2 auf 5.

01:12:28.420 --> 01:12:33.220
Offensichtlich hat dieser Rechner hier 32 verschiedene Register.

01:12:33.220 --> 01:12:35.160
Die ich hier adressieren kann.

01:12:36.640 --> 01:12:39.020
Und ich habe noch eine Konstante von 16-Bit.

01:12:39.740 --> 01:12:43.060
Die auch eine der Quellen ist.

01:12:44.660 --> 01:12:48.020
Also ich möchte nicht im Einzelnen durchgehen, wie das Ganze codiert

01:12:48.020 --> 01:12:48.380
ist.

01:12:48.980 --> 01:12:50.380
Aber ich möchte Ihnen nur so viel sagen.

01:12:50.500 --> 01:12:55.980
Es gibt einen Grund dafür, dass wir verschiedene Arten von

01:12:55.980 --> 01:12:57.240
Befehlsformaten haben.

01:12:58.100 --> 01:13:02.020
Um die verschiedenen Arten von Befehlen, die wir haben, codieren zu

01:13:02.020 --> 01:13:02.320
können.

01:13:05.220 --> 01:13:06.000
Macht das Sinn?

01:13:08.500 --> 01:13:11.860
Wie würden Sie die Frage beantworten, wenn jemand sagt, naja, ok.

01:13:12.960 --> 01:13:17.280
Ich kann mir doch auch überlegen, bitte zuhören, ich frage Sie jetzt.

01:13:18.220 --> 01:13:21.620
Ich kann mir doch auch überlegen, aus diesen ganzen Feldern, die ich

01:13:21.620 --> 01:13:25.440
hier brauche, um einen Befehl zu codieren, das ist einfach so, kann

01:13:25.440 --> 01:13:29.180
ich mir doch auch überlegen, das alles zusammen in ein Wort

01:13:29.180 --> 01:13:29.940
reinzuschreiben.

01:13:30.200 --> 01:13:31.480
Kann ich das oder kann ich das nicht?

01:13:32.760 --> 01:13:36.020
Das beantwortet jetzt die Frage, warum wir da drei Stück von haben.

01:13:36.400 --> 01:13:37.520
Kann ich es oder kann ich es nicht?

01:13:38.200 --> 01:13:39.080
Oder könnte ich es?

01:13:40.940 --> 01:13:48.980
Also Fakt ist gegeben, ich brauche diese drei Formate, um diese

01:13:48.980 --> 01:13:51.220
verschiedenen Befehlsarten darstellen zu können.

01:13:52.120 --> 01:13:57.380
Und Frage ist, warum brauche ich dann aber diese drei Befehlsformate?

01:13:57.480 --> 01:14:00.040
Warum kann ich das nicht irgendwie alles zusammen codieren?

01:14:00.040 --> 01:14:01.080
Das ist die Frage.

01:14:05.840 --> 01:14:07.840
Warum kann ich es nicht alles zusammen reinpacken?

01:14:12.110 --> 01:14:14.170
Kann ich es oder könnte ich es oder was ist der Drehtor?

01:14:16.690 --> 01:14:19.330
Wenn man das verstanden hat, dann weiß man auch, warum es drei

01:14:19.330 --> 01:14:19.810
verschiedene ist.

01:14:19.850 --> 01:14:21.570
Es könnte auch vier verschiedene geben, darum geht es mir nicht.

01:14:21.690 --> 01:14:23.970
Aber warum gibt es mehrere verschiedene Befehlsformate?

01:14:28.590 --> 01:14:29.130
Irgendeine Idee.

01:14:30.530 --> 01:14:31.770
Warum gibt es...

01:14:31.770 --> 01:14:33.910
Warum kann ich das nicht alles zusammen irgendwie reinpacken?

01:14:39.090 --> 01:14:40.430
Naja, das ist halt ganz einfach.

01:14:40.950 --> 01:14:44.330
Wenn ich alles zusammen in ein Wort reinpacke, was passiert denn dann?

01:14:45.010 --> 01:14:46.350
Hier habe ich 32 Bit.

01:14:46.970 --> 01:14:51.350
Da brauche ich 64 Bit vielleicht oder 48 Bit oder irgend so was.

01:14:52.510 --> 01:14:54.910
Ich kriege es halt nicht in 32 Bit rein.

01:14:55.010 --> 01:14:57.070
So einfach ist die Antwort zu dieser Frage.

01:14:58.710 --> 01:15:01.710
Jetzt könnte aber die nächste Antwort gleich wieder kommen und sagen,

01:15:01.710 --> 01:15:06.750
okay, dann nehme ich halt 64 Bit und dann habe ich aber nur ein

01:15:06.750 --> 01:15:07.670
Befehlsformat.

01:15:08.290 --> 01:15:11.430
Dann steht hier das Immediate, hier kommt dann links das Target dran,

01:15:11.550 --> 01:15:15.570
da drüben beim Fenster irgendwo das ID und so weiter.

01:15:15.770 --> 01:15:17.170
Dann habe ich halt so ein riesenlanges Ding.

01:15:18.190 --> 01:15:21.730
Das wäre die andere Lösung, um dieses Problem hier zu lösen.

01:15:23.910 --> 01:15:25.870
Aber da habe ich wieder welchen Nachteil?

01:15:25.990 --> 01:15:28.630
Der wurde eben in einem anderen Zusammenhang, wurde genau die Antwort

01:15:28.630 --> 01:15:30.510
zu dieser Frage hier gegeben.

01:15:30.510 --> 01:15:31.890
Ich verschwende von Ihnen.

01:15:36.340 --> 01:15:39.040
Ich verschwende einen großen Teil des Platzes.

01:15:39.500 --> 01:15:42.320
Ich verschwende einen großen Teil des Platzes, wenn ich 64 Bit nehme.

01:15:43.160 --> 01:15:48.540
Ich würde für die 64 Bit oftmals eben nur drei, vier Felder benutzen

01:15:48.540 --> 01:15:51.360
und der Rest wäre leer sozusagen.

01:15:53.320 --> 01:15:57.560
Der Vorteil ist, ich habe ein Befehlsformat von einem 64 Bit

01:15:57.560 --> 01:16:04.440
Befehlsformat, der zwar viel Speicher verschwendet, aber welchen

01:16:04.440 --> 01:16:05.940
Vorteil hätte das dann wieder?

01:16:06.380 --> 01:16:12.580
Welchen Vorteil hat es, anstatt einem Befehlsformat drei zu haben?

01:16:13.700 --> 01:16:14.820
Was ist das für ein Vorteil?

01:16:15.260 --> 01:16:18.960
Die ganze Sache, es geht hier immer darum, dass Sie nicht möchten,

01:16:19.060 --> 01:16:22.160
dass Sie irgendetwas auswendig lernen und das irgendjemand bestimmt

01:16:22.160 --> 01:16:23.060
hat aus irgendeinem Grund.

01:16:23.140 --> 01:16:25.400
Das hat alles irgendwelche Gründe und die möchte ich versuchen Ihnen

01:16:25.400 --> 01:16:28.560
zu vermitteln und ich denke, es ist eigentlich trivial.

01:16:28.920 --> 01:16:29.740
Also wer sagt das?

01:16:29.900 --> 01:16:33.800
Warum kodiere ich, zumindest in diesem Beispiel hier nicht, warum

01:16:33.800 --> 01:16:37.280
kodiere ich nicht alles in ein langes Wort hinein?

01:16:38.480 --> 01:16:42.060
Ich verschwende Speicher, aber warum würde ich es tun?

01:16:42.140 --> 01:16:44.040
Was würde wieder dafür sprechen, dass ich es tue?

01:16:44.160 --> 01:16:48.240
Ich verschwende zwar Speicher, aber eine

01:16:54.120 --> 01:16:55.620
Vermutung, eine vage Vermutung.

01:16:55.720 --> 01:16:57.940
Es wird keiner dafür bestraft, irgendwas Falsches zu sagen.

01:16:58.340 --> 01:17:00.600
Also, ich muss das Ganze dekodieren.

01:17:00.600 --> 01:17:05.120
Stellen Sie sich Folgendes vor, Sie bekommen einen Befehl, der Rechner

01:17:05.120 --> 01:17:09.980
bekommt diesen Befehl hier, der kommt aus dem Speicher und jetzt muss

01:17:09.980 --> 01:17:15.920
irgendjemand sagen im Speicher, filtere mir den Op-Code heraus,

01:17:16.800 --> 01:17:24.200
filtere mir den Register-Code heraus, filtere mir das Emitted heraus.

01:17:24.480 --> 01:17:26.900
Also filtern, sage ich mal, so Umgangssprachen.

01:17:26.900 --> 01:17:30.320
Der Ausdruck dafür heißt dekodieren.

01:17:30.780 --> 01:17:36.900
Das ist ein Wort mit 32 Bits, da sind 0 und 1 gesetzt und ich muss das

01:17:36.900 --> 01:17:41.980
dekodieren, ich muss das interpretieren, ich muss sagen, zeige mir

01:17:41.980 --> 01:17:46.060
diese 6 Bits, damit ich weiß, um welche Operation es handelt.

01:17:46.200 --> 01:17:49.720
Zeige mir diese 5 Bits, damit ich weiß, um welchen Registerinhalt es

01:17:49.720 --> 01:17:50.120
sich handelt.

01:17:50.120 --> 01:17:57.320
Das heißt, irgendjemand im Rechner, eine Hardware, die sogenannte

01:17:57.320 --> 01:18:02.820
Dekodier -Logik, die teilt dieses Wort jetzt auch in verschiedene

01:18:02.820 --> 01:18:08.040
Gruppen, nämlich in den, den, den und den und weiß dann, ja, es

01:18:08.040 --> 01:18:11.860
handelt sich um eine Operation, die eine Addition ist, es handelt sich

01:18:11.860 --> 01:18:15.580
um das Register 5 und das Register 7 und die beiden sollen jetzt

01:18:15.580 --> 01:18:17.000
addiert werden oder irgend so was.

01:18:17.920 --> 01:18:20.480
Das heißt, es gibt eine Dekodier-Logik.

01:18:22.740 --> 01:18:26.500
Und die Antwort zu der Frage von eben ist, warum mache ich da nicht

01:18:26.500 --> 01:18:31.380
ein riesengroßes Befehlswort und kodiere all dieses Zeugs dort hinein,

01:18:31.740 --> 01:18:37.900
ist, dann bräuchte ich nur eine Dekodier-Logik für ein Befehlsformat.

01:18:38.300 --> 01:18:43.820
Hier brauche ich drei verschiedene Dekodier-Logiken für drei

01:18:43.820 --> 01:18:45.200
verschiedene Befehlsformate.

01:18:47.140 --> 01:18:49.640
Sie sehen, wir haben wieder einen Trade-Off.

01:18:50.360 --> 01:18:57.620
Wir sparen darin ein, nur eine Dekodier-Logik zu haben, dafür

01:18:57.620 --> 01:19:05.000
vergeuden wir beim 64-Bit-Wort viel an Speicher, da wir immer nur drei

01:19:05.000 --> 01:19:06.920
oder vier Felder benötigen, wie wir hier sehen.

01:19:08.220 --> 01:19:11.680
Und andererseits mache ich es eben so, ich vergeude keinen Speicher,

01:19:12.300 --> 01:19:17.500
ich habe nur kleine Befehlsworte von 32 Bit, aber wie Sie sehen, ist

01:19:17.500 --> 01:19:20.040
hier alles bis zum letzten Bit ausgenutzt.

01:19:21.420 --> 01:19:22.480
Wir haben diesen Trade-Off.

01:19:23.180 --> 01:19:23.980
Darum geht es.

01:19:24.540 --> 01:19:26.580
Und jetzt gebe ich Ihnen noch eine andere Antwort zu dem.

01:19:26.640 --> 01:19:28.820
Es ist nämlich gar nicht so, dass man sich dauernd dafür entscheidet.

01:19:28.940 --> 01:19:32.700
Es gibt tatsächlich Rechner, die haben nur ein Befehlswort.

01:19:33.700 --> 01:19:36.380
Die packen das tatsächlich alles in ein Befehlswort rein.

01:19:36.680 --> 01:19:40.140
Um genau diesen Vorteil Rechnung zu tragen, zu sagen, ich möchte nur

01:19:40.140 --> 01:19:43.720
eine Dekodier-Logik haben, ich möchte sehr wenig Hardware haben, dann

01:19:43.720 --> 01:19:48.580
interessiert mich nicht mal so viel, dass ich damit viel Speicher

01:19:48.580 --> 01:19:49.080
belege.

01:19:50.020 --> 01:19:51.400
Hier ist folgender Trade-Off.

01:19:52.000 --> 01:19:55.700
Da sagt man zum Beispiel, der Mikroprozessor, der soll einfacher

01:19:55.700 --> 01:19:59.980
organisiert sein, da möchte ich weniger Dekodier-Logik haben, aber

01:19:59.980 --> 01:20:02.240
dafür brauche ich einen größeren Speicher.

01:20:03.180 --> 01:20:06.180
Und das Problem verweise ich sozusagen auf den Speicher in diesem

01:20:06.180 --> 01:20:06.540
Falle.

01:20:09.290 --> 01:20:12.130
Kleiner Prozessor, großer Speicher, oder umgekehrt.

01:20:12.130 --> 01:20:16.950
Das könnte man vielleicht so ganz einfach zusammenfassend hier so

01:20:16.950 --> 01:20:17.230
sagen.

01:20:18.090 --> 01:20:20.070
Also, es gibt verschiedene Befehlsformate.

01:20:21.450 --> 01:20:23.830
Mehr sollte die Folie eigentlich gar nicht sagen.

01:20:24.410 --> 01:20:25.550
Hier gehe ich jetzt nicht durch.

01:20:25.690 --> 01:20:30.590
Sowas ist für zu Hause, wo man sich überlegt, welches Bit heißt jetzt

01:20:30.590 --> 01:20:30.750
wie.

01:20:30.850 --> 01:20:33.110
Das lese ich jetzt hier nicht vor.

01:20:36.800 --> 01:20:40.460
Gut, und so sieht das Ganze dann zum Beispiel aus im Rand eines

01:20:40.460 --> 01:20:41.500
Beispiels.

01:20:43.400 --> 01:20:48.960
Ich habe ein Add mit Ziel- und Quellregistern.

01:20:49.520 --> 01:20:51.640
Ich weiß, wie viele Bits dafür benötigt werden.

01:20:52.440 --> 01:20:56.980
Das heißt, dies gibt letzten Endes an, welches Register gemeint ist.

01:20:57.340 --> 01:20:58.700
2 hoch 5, 32.

01:20:59.720 --> 01:21:03.400
Also vielleicht steht da drin eine 17, dann ist das Register 17.

01:21:04.020 --> 01:21:08.000
Und dann heißt das, addiere den Wert des Register 17 und so weiter.

01:21:11.680 --> 01:21:12.680
So ist das zu interpretieren.

01:21:13.320 --> 01:21:17.820
Hier habe ich immediate, das heißt, hier habe ich teststudiert, eine

01:21:17.820 --> 01:21:20.000
Adresse oder einen Konstantenwert.

01:21:20.080 --> 01:21:22.600
Wie ich eben sagte, ich habe zum Beispiel den Wert Pi oder irgend

01:21:22.600 --> 01:21:26.780
sowas, eine Konstante, die immer halt auch als Konstante in dem

01:21:26.780 --> 01:21:29.780
Programm behandelt wird, kann ich direkt hier reinprogrammieren.

01:21:29.860 --> 01:21:31.900
Beziehungsweise nicht ich, das macht der Compiler gut.

01:21:35.360 --> 01:21:41.900
Und so viel eigentlich schon zu den verschiedenen Arten von

01:21:41.900 --> 01:21:43.360
Befehlsformaten.

01:21:45.240 --> 01:21:47.540
Jetzt haben wir noch 10 Minuten, jetzt fangen wir noch ein bisschen an

01:21:47.540 --> 01:21:48.760
mit Adressierungsarten.

01:21:49.080 --> 01:21:51.460
Das heißt, wir sind immer noch bei der Instruktionssatzarchitektur.

01:21:52.820 --> 01:21:57.620
Wir haben uns zuvor angeguckt, wie sieht ein Befehlsformat aus.

01:21:57.620 --> 01:22:03.520
Und jetzt das, wo ich anfangs schon darauf hinwies, was sind denn die

01:22:03.520 --> 01:22:04.220
Adressierungsarten?

01:22:04.740 --> 01:22:06.480
Da will ich jetzt gar nicht mehr so viel sagen, das wäre eine

01:22:06.480 --> 01:22:07.080
Wiederholung.

01:22:07.540 --> 01:22:12.280
Wir möchten adressieren, wir möchten auf den Speicherzug greifen, auf

01:22:12.280 --> 01:22:14.980
den Hauptspeicher, auf die Register und so weiter.

01:22:16.020 --> 01:22:19.360
Und um dies effizient zu machen, brauche ich verschiedene Arten der

01:22:19.360 --> 01:22:19.920
Adressierung.

01:22:21.200 --> 01:22:23.040
Und das schauen wir uns einfach mal an.

01:22:23.040 --> 01:22:26.860
Und hier ist es auch rot, ich habe das Eingang schon erzählt.

01:22:28.120 --> 01:22:32.760
Es hängt damit zusammen, wie viel Programmieraufwand ich da

01:22:32.760 --> 01:22:33.120
reinstecke.

01:22:33.220 --> 01:22:35.380
Das möchte ich wirklich noch mal unterholen, auch wenn ich es schon

01:22:35.380 --> 01:22:36.020
gemacht habe.

01:22:37.420 --> 01:22:41.600
Ich kann alles mit einer Handvoll von Befehlen programmieren.

01:22:42.320 --> 01:22:46.140
Trotzdem habe ich 60 oder 120 oder so viele Befehle in einem Rechner.

01:22:46.840 --> 01:22:51.420
Und die noch kombiniert mit den ganzen Adressierungsarten, die ich

01:22:51.420 --> 01:22:51.760
habe.

01:22:51.760 --> 01:22:55.440
Man kann sich vorstellen, wie viele verschiedene Möglichkeiten es

01:22:55.440 --> 01:22:59.420
zumindest theoretisch gibt, ein Programm zu schreiben.

01:22:59.500 --> 01:23:03.140
Ich kann ein Programm schreiben, wo ich natürlich nicht ein Befehl

01:23:03.140 --> 01:23:04.680
zweimal vorkomme oder so.

01:23:06.720 --> 01:23:09.260
Es hängt mit Programmierzeit zusammen.

01:23:10.000 --> 01:23:11.960
Ich möchte effizient programmieren.

01:23:12.580 --> 01:23:16.200
Also sozusagen meine Zeit als Programmierer ist wertvoll, die kostet

01:23:16.200 --> 01:23:17.240
Zeit, die kostet Geld.

01:23:18.120 --> 01:23:21.860
Da unterstützen mich die Programmierungsarten.

01:23:23.120 --> 01:23:28.680
Aber die Programmierungsarten haben auch eine Auswirkung darauf, wie

01:23:28.680 --> 01:23:31.180
schnell das Programm am Ende ausgeführt werden kann.

01:23:31.520 --> 01:23:33.040
Läuft das schneller, läuft das langsamer.

01:23:34.660 --> 01:23:37.920
Das heißt, es sind also eine ganze Menge Dinge, die daran hängen,

01:23:38.040 --> 01:23:40.740
welche Adressierungsart ich von den vorhandenen auswähle.

01:23:43.510 --> 01:23:44.930
So, wie funktioniert das?

01:23:44.990 --> 01:23:46.590
Jetzt haben wir genau das, was wir eben hatten.

01:23:46.590 --> 01:23:48.910
Wir haben verschiedene Arten von Adressen.

01:23:49.830 --> 01:23:53.610
Wir haben die Adresse im Programm, die nur der Programmierer kennt.

01:23:54.490 --> 01:23:58.570
Wir haben die effektive, logische Adresse, die nur der Prozessor

01:23:58.570 --> 01:23:58.990
kennt.

01:23:59.770 --> 01:24:03.330
Und dann gibt es noch die physikalische Adresse, die nicht mal der

01:24:03.330 --> 01:24:04.310
Prozessor kennt.

01:24:04.750 --> 01:24:08.590
Das waren die drei verschiedenen Arten der Adressen.

01:24:09.710 --> 01:24:13.850
So, Adressen müssen aber berechnet werden.

01:24:13.850 --> 01:24:17.990
Und was wir hier machen wollen, Adressberechnung, geht hierum.

01:24:18.130 --> 01:24:19.870
Geht hierum, diese zu berechnen.

01:24:23.760 --> 01:24:26.000
Wir möchten diese Adresse berechnen, hier die.

01:24:27.100 --> 01:24:29.840
Und zwar, die Frage ist, wie kommt man von hier nach hier?

01:24:30.560 --> 01:24:31.360
Das ist die Frage.

01:24:34.940 --> 01:24:35.980
Das wollen wir berechnen.

01:24:36.280 --> 01:24:38.840
Jetzt können Sie natürlich fragen, wie komme ich auf die physikalische

01:24:38.840 --> 01:24:39.140
Adresse?

01:24:39.620 --> 01:24:41.000
Die Vorlesung geht noch bis Sommer.

01:24:41.620 --> 01:24:45.400
Wir werden uns auch überlegen, wie man von der logischen, effektiven

01:24:45.400 --> 01:24:47.120
Adresse auf die physikalische kommt.

01:24:47.560 --> 01:24:50.260
Das hängt dann offensichtlich nicht mehr mit dem Prozessor zusammen,

01:24:50.360 --> 01:24:53.340
das hängt damit zusammen, wie mein Hauptspeicher aussieht.

01:24:53.500 --> 01:24:54.800
Wie groß mein Hauptspeicher ist.

01:24:54.900 --> 01:24:56.920
Also alles das, was der Prozessor nicht weiß.

01:24:57.700 --> 01:25:00.400
Und da gibt es auch so Dinge, und Sie hatten das da oben eben gesagt,

01:25:00.460 --> 01:25:02.940
es gibt so Dinge wie virtuelle Adressierung.

01:25:03.580 --> 01:25:06.800
Und das schauen wir uns in ein paar Wochen natürlich auch noch an.

01:25:07.700 --> 01:25:10.560
Heute, beziehungsweise in der nächsten Vorlesung geht es darum, wie

01:25:10.560 --> 01:25:12.540
komme ich von hier nach hier?

01:25:13.160 --> 01:25:15.540
Und wie sieht das dazu im Programm aus?

01:25:17.860 --> 01:25:20.360
Was hier steht, habe ich an sich schon alles gesagt.

01:25:21.000 --> 01:25:23.240
Und jetzt ist der Baum der ganzen Adressierungsarten.

01:25:23.540 --> 01:25:25.480
Jetzt kann man sich überlegen, wow, eine ganze Menge.

01:25:27.300 --> 01:25:30.600
Adressierungsarten, grob kategorisiert, kleiner kategorisiert.

01:25:31.140 --> 01:25:35.300
Also, das sind alles Adressierungsarten, die ich natürlich nicht mit

01:25:35.300 --> 01:25:40.160
allen Befehlen kombinieren kann, aber je nach Prozessor schon zum

01:25:40.160 --> 01:25:40.880
größten Teil.

01:25:40.880 --> 01:25:46.260
Sie sehen, Sie haben eine Riesenauswahl an Möglichkeiten, hier Ihren

01:25:46.260 --> 01:25:47.280
Algorithmus zu schreiben.

01:25:48.940 --> 01:25:50.680
Jetzt fangen wir erstmal mit ein paar Stück an.

01:25:51.840 --> 01:25:53.500
Registeradressierung, um es ganz einfach zu machen.

01:25:55.140 --> 01:25:57.880
Dann kommen die einstufige Adressierung, und hier wird es ein bisschen

01:25:57.880 --> 01:25:59.440
haarig mit der zweistufigen.

01:25:59.720 --> 01:26:01.900
Das müssen wir dann sehr gut durchgehen, dass wir es auch alle

01:26:01.900 --> 01:26:02.340
verstehen.

01:26:03.740 --> 01:26:06.960
So, Registeradressierung, implizite Adressierung, Fleckadressierung,

01:26:07.120 --> 01:26:09.620
explizite, für jedes dieser Punkte habe ich eine Folie.

01:26:11.940 --> 01:26:13.780
Ich habe immer zwei Folien.

01:26:14.680 --> 01:26:19.380
Die eine Folie gibt erstmal generell an, wie es in exemplar

01:26:19.380 --> 01:26:20.600
-schreibweise aussieht.

01:26:24.280 --> 01:26:26.440
Also, MNemo, das ist der Code.

01:26:27.380 --> 01:26:31.420
In einem Semplar, da steht sowas, wie zum Beispiel, das haben wir die

01:26:31.420 --> 01:26:33.500
ganze Zeit schon benutzt, aber haben es noch nicht so genannt.

01:26:33.640 --> 01:26:36.720
Da haben wir zum Beispiel so ein addr oder sowas.

01:26:36.920 --> 01:26:37.720
Was ist das überhaupt?

01:26:37.720 --> 01:26:42.180
Das ist ein sogenannter Mnemonic, nennt man das.

01:26:42.640 --> 01:26:44.700
Also sozusagen eine Abkürzung.

01:26:46.000 --> 01:26:47.400
Das ist eine Abkürzung.

01:26:47.660 --> 01:26:53.580
Add, oder Sub, oder Mult, oder Shift-R, Logical-Shift-R, oder sowas.

01:26:54.040 --> 01:27:00.760
Diese Buchstabenkombination ist eine Abkürzung, die sich Mnemonic

01:27:00.760 --> 01:27:01.140
nennt.

01:27:01.240 --> 01:27:02.620
Ein bisschen schwierig auszusprechen.

01:27:03.200 --> 01:27:07.080
Und hier haben wir eben die Schreibweise für die implizite

01:27:07.080 --> 01:27:07.900
Adressierung.

01:27:08.520 --> 01:27:09.740
Die geht auf den Akkumulator.

01:27:10.920 --> 01:27:14.800
Und hier steht, und das wollen wir ja finden, wie wird die effektive

01:27:14.800 --> 01:27:15.880
Adresse berechnet.

01:27:16.840 --> 01:27:20.220
Die effektive Adresse ist kodiert im OpGrid.

01:27:21.000 --> 01:27:24.540
Das heißt, die Berechnung, in Anführungszeichen, die ist so einfach,

01:27:25.220 --> 01:27:27.840
die brauche ich aus dem OpGrid nur rauszuschneiden, nur rausholen.

01:27:27.840 --> 01:27:30.140
Also das wäre genau diese Adressierung.

01:27:30.240 --> 01:27:32.860
Schauen Sie, diese Adressierung von der Folie hier irgendwo vorne.

01:27:33.440 --> 01:27:35.800
Diese Adressierung wäre das hier.

01:27:36.800 --> 01:27:43.960
Die Adresse geht als Bitwert schon im Codeword drin.

01:27:44.300 --> 01:27:46.520
Die brauche ich nur rauszuextrahieren.

01:27:46.860 --> 01:27:48.780
Und damit meine ich diese Adressierung hier.

01:27:52.500 --> 01:27:55.900
Die ist im OpGrid enthalten, ich hole sie einfach raus.

01:27:57.840 --> 01:27:59.600
So, und hier ist ein Beispiel dafür.

01:28:00.400 --> 01:28:03.680
Hier haben wir jetzt wieder diesen Mnemonic LSRA.

01:28:04.100 --> 01:28:07.760
Das ist einfach eine Konvention, die in einem Datenbuch

01:28:07.760 --> 01:28:08.600
festgeschrieben ist.

01:28:08.680 --> 01:28:11.600
Und hier steht Logical Shift Write Accumulator.

01:28:13.000 --> 01:28:17.940
Und die macht genau das, was eine Kommilitone von Ihnen eben gesagt

01:28:17.940 --> 01:28:18.340
hat.

01:28:18.340 --> 01:28:27.560
Nämlich, wir schieben die Werte, die Bitwerte eines Registers, in

01:28:27.560 --> 01:28:28.920
diesem Falle nach rechts.

01:28:29.420 --> 01:28:32.920
Also ich mal das mal an, damit das auch klar ist, was damit gemeint

01:28:32.920 --> 01:28:33.240
ist.

01:28:34.320 --> 01:28:40.920
Ich habe den Akku, ich habe den Akku, das ist der Akku, der aus 8 Bits

01:28:40.920 --> 01:28:44.700
besteht, usw.

01:28:45.380 --> 01:28:51.980
Und was ich hier mache ist, ich schiebe dieses Bit von hier nach hier,

01:28:52.060 --> 01:28:53.720
dieses Bit von hier nach hier.

01:28:54.900 --> 01:28:56.880
Stop, da steht da Write, da steht Write.

01:28:57.400 --> 01:28:58.820
Ich verschiebe das Ganze.

01:29:02.500 --> 01:29:04.020
Nichts anderes passiert hier.

01:29:08.330 --> 01:29:09.910
Logical Shift Write Akku.

01:29:10.730 --> 01:29:13.690
Und das heißt, das bezieht sich offensichtlich auf den Akkumulator.

01:29:14.930 --> 01:29:18.090
Das Register in diesem Falle ist das spezielle Register der

01:29:18.090 --> 01:29:19.510
Akkumulatoren.

01:29:20.370 --> 01:29:22.710
Und hier ist jetzt nochmal angegeben, wir haben auf jeden dieser

01:29:22.710 --> 01:29:29.290
Folien eine Darstellungszeichnung, damit man sieht, was im Rechner

01:29:29.290 --> 01:29:35.310
abgeht, was dort passiert, um diese, wie wir gesagt haben, die erste

01:29:35.310 --> 01:29:41.670
Adresse nochmal, die heißt die effektive logische Adresse zu

01:29:41.670 --> 01:29:42.490
berechnen.

01:29:45.030 --> 01:29:48.790
Gut, jetzt haben wir mit der Adressierung hier kurz angefangen, Sie

01:29:48.790 --> 01:29:53.310
haben zumindest gesehen, es gibt hier noch eine ganze Menge und das

01:29:53.310 --> 01:29:55.270
werden wir dann das nächste Mal durch.

01:29:56.090 --> 01:29:57.390
Bis zum nächsten Mal, tschüss.