WEBVTT 00:00.250 --> 00:01.710 So, schönen guten Morgen. 00:01.790 --> 00:04.810 Ich begrüße Sie zur Fortsetzung der Vorlesung Grundlagen der 00:04.810 --> 00:05.530 Informatik II. 00:05.690 --> 00:08.730 Letztes Mal Mittwochmorgen hier im Audimax. 00:08.890 --> 00:12.950 Ansonsten machen wir das dann für den Rest der Vorlesung nur noch 00:12.950 --> 00:13.690 montags. 00:13.850 --> 00:17.750 Einmal wird noch eine Saalübung sein, weil das eine zusätzliche Termin 00:17.750 --> 00:17.850 ist. 00:17.950 --> 00:20.470 Kann das sein, dass der nochmal irgendwie dann Mittwoch ist oder wir 00:20.470 --> 00:21.630 da nochmal hin und her schieben. 00:21.790 --> 00:26.270 Aber im Prinzip ist also heute letztes Mal eine vierstündige Woche. 00:26.270 --> 00:31.270 Kurzer Hinweis nochmal auf die Anmeldung zur Hauptklausur. 00:31.950 --> 00:34.070 Sie können sich bis zum 28.01. 00:34.490 --> 00:43.370 anmelden im üblichen Studierendenportal für die Klausur nach Ende der 00:43.370 --> 00:44.830 Vorlesungszeit am Montag. 00:45.650 --> 00:48.930 Und auch nochmal ein Hinweis zur Bonusklausur, 19.01. 00:48.930 --> 00:52.110 Sie wissen, dass Sie sich anmelden konnten bis Ende des Jahres. 00:52.990 --> 01:00.010 Und dass diese Bonusklausur am Samstag der nächsten Woche um 9 Uhr 01:00.010 --> 01:00.830 stattfinden wird. 01:00.890 --> 01:05.290 25 Minuten, 3 Aufgaben, 2 davon müssen Sie vollständig gemacht haben, 01:05.370 --> 01:06.210 dann bekommen Sie den Bonus. 01:07.310 --> 01:12.290 Und haben dann etwas Vorteil bei der Hauptklausur, sofern Sie die 01:12.290 --> 01:12.970 bestehen. 01:12.970 --> 01:18.510 Was sich ja von allen eigentlich erwartet, aufgrund der guten 01:18.510 --> 01:20.970 Vorbereitung durch Übungen und ähnliches. 01:21.110 --> 01:23.690 Und durch das, was wir Ihnen hier ansonsten präsentieren. 01:25.130 --> 01:28.750 So, zur Vorlesung, was haben wir letztes Mal gemacht? 01:28.850 --> 01:32.130 Da ging es nochmal um die Codierungen, Zahlendarstellungen und 01:32.130 --> 01:32.690 ähnliches. 01:32.790 --> 01:35.850 Wir hatten da nochmal alles mögliche durchgeguckt. 01:35.850 --> 01:39.330 Vor allem hatte ich letztes Mal Ihnen etwas erzählt über 01:39.330 --> 01:42.510 Zahlendarstellungen von ganzen Zahlen. 01:42.830 --> 01:47.750 Und zwar ging das letzte Mal um das Zweierkomplement. 01:47.970 --> 01:51.470 Sie erinnern sich, das Komplement zur Zahl 2 hoch N. 01:51.550 --> 01:56.850 Wenn ich N mit Zahlen betrachte, kann ich 2 hoch N minus 1 negative 01:56.850 --> 02:01.490 und 2 hoch N minus 1 positive so in etwa plus minus 1 darstellen. 02:01.490 --> 02:05.090 Und das eine war das Zweierkomplement, bei dem man eben die 02:05.090 --> 02:08.150 Zweierkomplemente einer Zahl bilden kann, also die negativen Werte, 02:08.330 --> 02:11.210 die man bilden kann, dadurch, dass man die Bits alle kippt und nochmal 02:11.210 --> 02:12.310 eine 1 drauf addiert. 02:13.350 --> 02:14.930 Sie haben gesehen, wie man dann addiert. 02:15.350 --> 02:22.190 In dem Fall, wie die Arithmetik läuft, wie das aussieht mit 02:22.190 --> 02:26.650 Überlaufbehandlung und ähnlichen Dingen, dass man die Überlaufeignung 02:26.650 --> 02:30.570 einfach ignoriert und dadurch dann die richtigen Ergebnisse bekommt. 02:30.570 --> 02:35.510 Hier waren diese Beispiele, minus 2 plus 3, minus 2, minus 3. 02:36.870 --> 02:43.190 Und es ist halt einfach so, wenn ich eine Subfraktion machen will, 02:43.270 --> 02:44.490 addiere ich einfach das Komplement. 02:45.210 --> 02:51.310 Das war eben auch eine wichtige Sache, dass man sich das überlegt. 02:51.450 --> 02:54.670 Dann die Sache mit der Bereichsüberschreitung. 02:54.670 --> 02:58.290 Wir haben festgestellt, wenn der Bereich überschnitten wird, dann ist 02:58.290 --> 03:03.210 das Vorzeichen des Ergebnisses, gerade unterschiedlich von den 03:03.210 --> 03:05.630 Vorzeichen beider Argumente. 03:06.430 --> 03:10.430 Das heißt, wir sind aus dem Bereich rausgelaufen, dann muss es zu 03:10.430 --> 03:15.130 einer Ausnahmebehandlung kommen, damit man das im Programm auch merkt. 03:16.270 --> 03:22.010 Wir haben uns dann die Einer-Komplement-Darstellung angeguckt. 03:22.010 --> 03:26.450 Einer-Komplement steht dafür, dass wir das Komplement 2 auf n-1 03:26.450 --> 03:27.110 betrachten. 03:27.770 --> 03:30.010 Da war die Bildung des Komplementes etwas einfacher. 03:30.830 --> 03:35.010 Wir brauchten nur noch die Bits zu kippen, weil eben die Referenz 2 03:35.010 --> 03:38.890 auf n-1 gerade das bewirkt, dass die Bits der Zahl alle gekippt 03:38.890 --> 03:40.650 werden, alle negiert werden. 03:40.970 --> 03:46.430 Das Problem war, dass wir dann bei der Arithmetik etwas mehr machen 03:46.430 --> 03:46.750 mussten. 03:46.870 --> 03:51.130 Wir mussten den Überlauf noch einmal drauf addieren. 03:52.450 --> 03:57.470 Das, was wir bei der Bildung des Zweier-Komplementes machen, muss n-1 03:57.470 --> 03:57.870 addieren. 03:58.010 --> 04:01.090 Das passiert jetzt hier in ähnlicher Form, dass wir bei der Addition 04:01.090 --> 04:04.430 auf einmal den Überlauf addieren müssen, damit wir die richtige 04:04.430 --> 04:08.670 Darstellung der Zahlen bekommen, die beim Einer-Komplement um 1 04:08.670 --> 04:09.530 verschoben sind. 04:11.670 --> 04:14.370 Das war die Zweier-Komplement-Einer-Komplement-Darstellung, die 04:14.370 --> 04:16.550 Standarddarstellung für ganze Zahlen. 04:16.710 --> 04:18.590 Wir haben uns dann die reellen Zahlen angeschaut. 04:18.590 --> 04:22.170 Zunächst die Festpunktdarstellung, die für die Darstellung nach außen 04:22.170 --> 04:24.050 ganz sinnvoll ist, nach innen eigentlich nicht. 04:24.490 --> 04:26.730 Insbesondere kann ich eben nur einen relativ kleinen Bereich 04:26.730 --> 04:27.470 darstellen. 04:27.930 --> 04:31.730 Gleitpunktdarstellung ist wichtiger, ist sinnvoller und dort haben wir 04:31.730 --> 04:35.690 uns insbesondere dann zu überlegen, dass wir, wenn wir Zahlen 04:35.690 --> 04:40.210 darstellen, als Mantisse mal Basis hoch Exponent, dass wir dann 04:40.210 --> 04:43.490 aufpassen müssen, wie wir bei normierten Gleitpunkt-Zahlen 04:43.490 --> 04:47.390 -Darstellungen die Arithmetische Operation ausführen. 04:47.390 --> 04:50.670 Da waren einige Punkte zu klären, nämlich wir mussten erstmal die 04:50.670 --> 04:56.470 Exponenten angleichen, dann die Mantissen entsprechend addieren und 04:56.470 --> 04:59.790 anschließend dafür sorgen, dass das Ergebnis wieder normiert ist. 05:00.270 --> 05:01.270 Also mehrere Schritte. 05:01.690 --> 05:05.490 Das führt dazu, dass die Gleitpunkt-Addition deutlich aufwendiger 05:05.490 --> 05:08.490 wird, als man zunächst mal so dramatisch erwartet. 05:09.050 --> 05:11.270 Ich habe dort einige Schritte zu machen. 05:11.690 --> 05:15.150 Das führt dazu, dass wir im Rechner zum Beispiel extra Gleitpunkt 05:15.150 --> 05:18.610 -Arithmetik einhalten haben, damit diese Operation schneller wird, 05:18.690 --> 05:20.930 ansonsten wird sie halt deutlich langsamer. 05:22.090 --> 05:24.610 Langsamer als die ganzteilige Modifikation. 05:25.230 --> 05:26.930 Können Sie ausprobieren, wie das aussieht. 05:27.010 --> 05:30.950 Man schreibt ein kleines Programm, wo Sie einfach drauf finden, wie 05:30.950 --> 05:34.310 stark sich die Ausführungszeiten von Gleitpunkt-Addition, Gleitpunkt 05:34.310 --> 05:38.390 -Modifikation, Integer-Addition, Integer-Modifikation unterscheiden. 05:38.850 --> 05:41.350 Können Sie feststellen, was da im Rechner intern passiert. 05:41.350 --> 05:45.170 Ich habe Ihnen dann die Dual-Darstellung von normierter Gleitpunkt 05:45.170 --> 05:46.270 -Zahl vorgestellt. 05:46.470 --> 05:52.630 Nämlich diese Standard-Darstellung, bei der man die Mantisse 05:52.630 --> 06:00.230 Vorzeichen behaftet, Vorzeichen und dann Mantisse. 06:00.610 --> 06:03.730 Da das eine normierte Zahl ist und das erste Bit immer 1 ist, kann man 06:03.730 --> 06:04.830 auf die 1 verzichten. 06:04.830 --> 06:08.510 Stellt dann nur noch die erstlichen Bits nach dem Komma oder nach dem 06:08.510 --> 06:10.150 Punkt dar, dass das entspricht. 06:10.890 --> 06:16.170 Und der Exponent wurde nicht direkt als Exponent, sondern als 06:16.170 --> 06:19.330 Charakteristik dargestellt in einer sogenannten XSQ-Darstellung. 06:19.470 --> 06:23.710 Also verschoben gerade um die Hälfte des Zahlenbereichs, sodass man 06:23.710 --> 06:28.850 hier den Größenvergleich von Exponenten, gewesen wurde eine wichtige 06:28.850 --> 06:34.490 Operation bei den arithmetischen Operationen, sehr schnell und direkt 06:34.490 --> 06:38.990 ausführen kann in der codierten Darstellung, ohne da aufpassen zu 06:38.990 --> 06:41.570 müssen, wie das aussieht mit negativen und positiven Zahlen. 06:42.230 --> 06:45.670 Also das hat einfach mit der Effizienz der Ausführung der 06:45.670 --> 06:48.870 arithmetischen Operationen zu tun, dass man diese Darstellung wählt, 06:48.910 --> 06:51.110 Vorzeichen, Charakteristik, Mantisse. 06:51.110 --> 06:56.310 Man bekommt dann eben diese Zahlen, die man dargestellt hat. 06:56.390 --> 06:59.190 Minus eins, Hochvorzeichen, mal eins plus entspricht. 06:59.510 --> 07:02.570 Entspricht halt diese etwas reduzierte Mantisse. 07:03.010 --> 07:07.050 Und dann mal zwei Hochcharakteristik, Minus Verschiebungswert. 07:07.690 --> 07:09.730 Das ist dann halt gerade der richtige Exponent. 07:09.730 --> 07:17.530 Und damit hat man dann eine, also die Zahl sich ermittelt aus dem 07:17.530 --> 07:20.770 Bitspring, der diese Zahl repräsentiert. 07:21.350 --> 07:25.090 Das heißt dann, dass natürlich die Zahlen unterschiedlich dargestellt 07:25.090 --> 07:25.450 werden. 07:25.550 --> 07:30.110 Das war dann, Sie hatten da nochmal diese Leitpunktdaten. 07:31.990 --> 07:36.750 Einfach lange, doppelt lange, vierfache Genauigkeit, wobei dann 07:36.750 --> 07:38.450 jeweils Standardaufteilungen sind. 07:38.450 --> 07:42.890 Zwischencharakteristik, Bit und Mantissenbit, sodass man eben auf 07:42.890 --> 07:49.270 jedem Rechner weiß, dass die Zahlen gleichartig dargestellt werden. 07:49.390 --> 07:53.670 Das heißt, wir haben gleichartig mit Fehlern umzugehen, die bei den 07:53.670 --> 07:55.050 Berechnungen auftauchen können. 07:56.230 --> 08:00.110 Und es gab noch ein paar Sonderfälle, die wir betrachtet haben. 08:00.110 --> 08:05.910 Also die Sonderfälle der Null, denormalisierte Zahlen, also Zahlen, 08:06.070 --> 08:13.750 bei denen man eine Mantisse Nullpunkt, also eine Nullpunkt-Komma hat 08:13.750 --> 08:16.330 und dann kleinere Zahlen nochmal darstellt. 08:16.590 --> 08:20.470 Und die Behandlung von Null und Endlich und Not a Number. 08:20.470 --> 08:25.770 Die sind halt einfach wichtige Repräsentationen von Sonderfällen bei 08:25.770 --> 08:29.530 der Bearbeitung der LR-Zahlen, die man in Programmen durch 08:29.530 --> 08:32.690 entsprechende Exceptions, zum Beispiel Java, abrufen kann. 08:33.270 --> 08:38.690 Das heißt, Sie müssen, wenn Sie mit L-Wertigen Variablen zu tun haben, 08:39.070 --> 08:45.050 immer auf solche Sonderfälle Ihre Berechnungen abtragen, damit Sie 08:45.050 --> 08:48.830 geeignet reagieren und die Programme robust werden, auch bei solchen 08:48.830 --> 08:50.930 Sonderfällen in die Berechnung. 08:51.630 --> 08:54.930 Ich hatte Sie darauf hingewiesen, dass wir eben dann unterschiedlich 08:54.930 --> 08:57.850 genaue Darstellungen haben, je nachdem, welchen Exponentenbereich wir 08:57.850 --> 08:58.150 haben. 08:58.650 --> 09:01.430 Entweder also sehr eng nebeneinander bei sehr kleinen Exponenten und 09:01.430 --> 09:04.050 dann eben auch sehr weit auseinander, wenn die Exponenten sehr groß 09:04.050 --> 09:09.270 werden, weil halt die Anzahl der Werte pro Exponent gleich ist, 09:09.670 --> 09:14.310 entsprechend der Anzahl der Bits der Mantisse und deswegen halt diese 09:14.310 --> 09:16.610 unterschiedliche Genauigkeit in der Daten und den Zahlen. 09:17.510 --> 09:22.190 Wir hatten dann uns nochmal angeschaut, die Probleme, die auftreten 09:22.190 --> 09:27.470 bei der Berechnung von Ausdrücken oder bei der Auswertung von 09:27.470 --> 09:29.730 Ausdrücken, in denen reelle Zahlen vorkommen. 09:30.330 --> 09:32.870 Und das ist eine ganz wichtige Erkenntnis, die hier nochmal 09:32.870 --> 09:40.430 draufsteht, dass die Ausführungsreihenfolge von arithmetischen 09:40.430 --> 09:48.750 Operationen bei reellwertigen Ausdrücken einen wichtigen Einfluss hat 09:48.750 --> 09:50.330 auf den Wert, der dabei entsteht. 09:50.410 --> 09:53.450 Wir hatten hier ein Beispiel betrachtet, bei dem auf einmal bei der 09:53.450 --> 09:55.730 einen Ausführungsreihenfolge 0 rauskommt, bei der anderen 09:55.730 --> 09:58.550 Ausführungsreihenfolge 10 hoch 14. 09:58.550 --> 10:03.030 Also ein drastischer Unterschied im Ergebnis, nur weil wir eine andere 10:03.030 --> 10:07.030 Reihenfolge gewählt haben, bei der Auswertung dieses Ausdrucks, Y plus 10:07.030 --> 10:07.910 A minus B. 10:08.410 --> 10:10.870 Für bestimmte Werte kann es halt sein, dass wir diese drastischen 10:10.870 --> 10:11.670 Unterschiede haben. 10:12.010 --> 10:17.690 Das heißt, die Ausführung von arithmetischen Operationen auf 10:17.690 --> 10:22.510 reellwertigen Zahlen, also auf Leitfunkzahlen in dieser Darstellung, 10:22.590 --> 10:23.830 ist nicht assoziativ. 10:25.030 --> 10:29.130 Und damit man das genau machen kann, muss man halt Sondermaßnahmen 10:29.130 --> 10:29.810 ergreifen. 10:30.750 --> 10:33.230 Es sei denn, man verlässt sich darauf, dass da schon nichts passiert. 10:33.390 --> 10:36.130 Aber wenn man meint, da passiert schon nichts, dann kann das halt zu 10:36.130 --> 10:39.730 technischen Problemen führen, für die es vielfache Beispiele gibt, 10:39.890 --> 10:44.390 dass wirklich aufgrund vieler der Berechnungen völlig falsche 10:44.390 --> 10:47.750 Ergebnisse berechnet wurden, die dann in der Steuerung von technischen 10:47.750 --> 10:50.970 Systemen zu gravierenden Problemen und Katastrophen geführt haben. 10:50.970 --> 10:55.690 Das waren so diese ganzen Überlegungen zur Zahlendarstellungen. 10:56.410 --> 11:01.150 Und das war dann das Letzte, was ich Ihnen zu den drastischen Zahlen 11:01.150 --> 11:02.190 vorstellen wollte. 11:02.630 --> 11:06.090 Das andere, Codierung zur Geheimhaltung, ist ein interessantes Thema. 11:06.210 --> 11:08.350 Hat auch was mit Codierung von Informationen zu tun. 11:08.830 --> 11:11.510 Habe ich Ihnen als Abschnitt mit dazugefügt, werde ich aber in der 11:11.510 --> 11:15.010 Vorlesung nicht weiter behandeln, weil uns dafür leider einfach die 11:15.010 --> 11:16.270 Zeit fehlt. 11:16.270 --> 11:19.630 Das verhandle ich in der Vorlesung Algorithms for Internet Application 11:19.630 --> 11:24.110 oder in anderen Vorlesungen oder aus der Literatur oder aus dem Modul, 11:24.170 --> 11:27.210 was wir Ihnen bereitgestellt haben, sich nochmal anschauen, was da 11:27.210 --> 11:27.870 eigentlich passiert. 11:28.610 --> 11:38.390 Wir kommen deswegen heute zu einem neuen Abschnitt, nämlich zu der 11:38.390 --> 11:39.650 Rechnerarchitektur. 11:40.370 --> 11:43.150 Architektur von Rechnungssystemen, Rechnerarchitektur und 11:43.150 --> 11:43.650 Organisation. 11:43.650 --> 11:47.810 Es geht darum, wie wir eigentlich die Rechner aufbauen können, damit 11:47.810 --> 11:51.910 sie die vielen Berechnungen ausführen können, mit denen wir 11:51.910 --> 11:54.890 Informationenverarbeitung tatsächlich machen können. 11:55.270 --> 11:58.110 Ich habe Ihnen ja einiges erzählt bereits über theoretische 11:58.110 --> 12:01.590 Grundlagen, formale Modelle für Sprachen, formale Modelle für Rechner. 12:01.690 --> 12:05.190 Wir hatten Schulmaschinen, elftliche Automaten betrachtet, 12:05.370 --> 12:06.910 Kellerautomaten und ähnliches. 12:06.990 --> 12:10.410 Ich habe Ihnen etwas erzählt jetzt über Schaltnetze, Schaltwerke, über 12:10.410 --> 12:12.330 Rechnerarchitektur, Darstellung von Zahlen. 12:12.330 --> 12:15.710 Das Ganze muss im Rechner halt geeignet kombiniert werden. 12:16.030 --> 12:18.550 Jetzt ist die Frage, wie sehen diese Rechner eigentlich aus? 12:18.930 --> 12:24.210 Sie haben alle Rechner in der Tasche, in Ihrem Smartphone, in allen 12:24.210 --> 12:27.110 möglichen Rechnern, in Ihrem Laptop. 12:27.710 --> 12:29.830 Und die Frage ist, wie werden die gestaltet? 12:29.990 --> 12:34.970 Das Interessante ist, alle Rechner, die Sie heutzutage verwenden, sind 12:34.970 --> 12:38.430 im Prinzip immer noch aufgebaut nach dem klassischen Konzept eines 12:38.430 --> 12:42.530 Universalrechners, das von Bergsgottstein und von Neumann 1946 12:42.530 --> 12:43.830 entwickelt wurde. 12:45.010 --> 12:48.970 Der erste richtige, ernstzunehmende Rechner wurde zwar von Konrad Zuh 12:48.970 --> 12:52.030 sich in Deutschland entwickelt, aber dieses Konzept des 12:52.030 --> 12:57.270 Universalrechners ist halt das Konzept, das man dann als den von 12:57.270 --> 12:59.690 Neumann Rechner bezeichnet. 12:59.690 --> 13:04.570 Das ist die Originalversion dieser verschiedenen Komponenten, die man 13:04.570 --> 13:05.030 braucht. 13:05.110 --> 13:10.210 Hier kurz dargestellt in diesen verschiedenen Kästchen, die wir uns 13:10.210 --> 13:11.290 genauer angucken werden. 13:11.630 --> 13:16.490 Wir sehen Linien zwischen diesen Kästchen und diese Linien betreiben 13:16.490 --> 13:21.130 einerseits den Steuerfluss, also wie kann ich die Kommunikation 13:21.130 --> 13:25.470 zwischen denen und die Kooperation zwischen diesen Einheiten steuern, 13:25.650 --> 13:26.350 kontrollieren. 13:26.350 --> 13:30.190 Und das andere ist der Datenfluss, welche Daten wandern eigentlich 13:30.190 --> 13:31.790 zwischen diesen Komponenten hin und her. 13:32.250 --> 13:37.010 Es ist klar, dass Daten wandern müssen vom Eingabewerk irgendwie in 13:37.010 --> 13:38.930 den Rechner, sie müssen irgendwo aufgegeben werden. 13:39.430 --> 13:43.250 Es muss etwas gerechnet werden hier im Kern, es muss etwas gesteuert 13:43.250 --> 13:45.750 werden, deswegen geht die Steuerleitung aus von dem Steuerwerk. 13:46.310 --> 13:49.610 Und wir müssen irgendwelche Informationen abspeichern können im 13:49.610 --> 13:50.030 Rechner. 13:50.970 --> 13:53.310 Und das ist halt dann das sogenannte Speicherwerk. 13:53.390 --> 13:56.890 Das sind die verschiedenen Bestandteile, Speicherwerk, Speicherung von 13:56.890 --> 13:57.950 Programmen und Daten. 13:58.650 --> 14:02.510 Da ist von Neumann über das Konzept von Konrad Zuse hinausgegangen, 14:03.130 --> 14:07.490 weil von Neumann sagte, das kann alles in einem Speicher abgelegt 14:07.490 --> 14:07.850 werden. 14:07.970 --> 14:10.850 Konrad Zuse hatte getrennten Programmspeicher und Datenspeicher. 14:11.370 --> 14:14.170 Er hat gesagt, das kann doch nicht sein, dass man auf dem Programm 14:14.170 --> 14:16.750 noch irgendwelche Veränderungen ausführt zur Laufzeit. 14:16.750 --> 14:19.270 Solche Dinge können wir heutzutage problemlos machen. 14:20.170 --> 14:23.650 Das ist also etwas, was man da hinzubefügt hat. 14:24.770 --> 14:28.250 Rechenwerk, Ausführung aller arithmetischen und logischen Operationen, 14:28.270 --> 14:30.890 die wir brauchen, um halt Informationsverarbeitung zu machen. 14:31.910 --> 14:35.670 Und dann kommt das Leitwerk, das Steuerwerk, das die ganzen Abläufe 14:35.670 --> 14:39.510 dort in sinnvoller Reihenfolge ausführen muss. 14:39.510 --> 14:41.770 Das ist das Ein- und Ausgabewerk. 14:41.950 --> 14:43.990 Wir müssen in der Lage sein, Informationen in den Rechner 14:43.990 --> 14:46.510 hineinzubekommen und aus dem Rechner wieder herauszubekommen. 14:47.290 --> 14:51.310 Diese vier Bestandteile müssen wir uns genauer angucken, was dort 14:51.310 --> 14:52.030 eigentlich drin ist. 14:52.190 --> 14:55.350 Nochmal ein paar grundsätzliche Bemerkungen zum von Neumann Rechner. 14:55.910 --> 14:57.170 Was wird dann eigentlich gemacht? 14:58.370 --> 15:01.030 Zunächst mal ist die Struktur unabhängig von dem zu bearbeitenden 15:01.030 --> 15:01.350 Problem. 15:01.450 --> 15:02.690 Es ist ein Universalrechner. 15:03.870 --> 15:05.570 Wir hatten gesehen, wir kennen schon den Universalrechner. 15:06.110 --> 15:07.570 Das war die universelle Turing-Maschine. 15:08.610 --> 15:11.350 Im Prinzip ist der von Neumann nichts anderes. 15:11.710 --> 15:13.570 Allerdings sind die Strukturen ein bisschen anders. 15:14.410 --> 15:17.490 Wir haben hier kein Arbeitsband, wir haben hier Speicher und 15:17.490 --> 15:18.690 Rechnerwerk und ähnliche Dinge. 15:19.570 --> 15:23.270 Also wir haben für jedes Problem eine Bearbeitungsvorschrift, das 15:23.270 --> 15:27.630 Programm, das von außen eingegeben wird und in den Speicher abgelegt. 15:27.770 --> 15:29.830 Irgendwie muss ich mal die Informationen reinbringen. 15:30.490 --> 15:32.750 Das entspricht bei der universellen Turing-Maschine, dass wir dort 15:32.750 --> 15:34.750 etwas auf das Eingabeband draufschreiben. 15:35.170 --> 15:36.970 Hier haben wir das irgendwo im Speicher abgelegt. 15:36.970 --> 15:42.430 Und dann habe ich eben außerdem Programme und Daten im selben Speicher 15:42.430 --> 15:46.250 unterteilt in gleich große Einheiten. 15:46.370 --> 15:48.270 Wir haben Register, wir haben Speicherzellen. 15:48.450 --> 15:57.090 Also wir haben hier einen Speicher mit den Speicherzellen. 15:57.090 --> 16:04.190 Feste Anzahl von Bits pro Speicherwort und können dann zugreifen auf 16:04.190 --> 16:09.390 die verschiedenen Elemente in dem Speicher durch Adressen. 16:09.710 --> 16:12.610 Das heißt, wir können sagen, ich möchte gerne auf irgendein Element 16:12.610 --> 16:13.290 zugreifen. 16:13.570 --> 16:17.290 Gebe die Adresse an und kann dann unabhängig von der Position im 16:17.290 --> 16:19.550 Speicher auf diese Position zugreifen. 16:19.550 --> 16:23.830 Das ist ein wesentlicher Unterschied zu der Turing-Maschine, dass ich 16:23.830 --> 16:27.050 halt ein wahrfreiem Zugriff habe auf die Speicherzellen. 16:28.230 --> 16:31.630 Direkter Zugriff, wichtiges Element dieser Architektur. 16:33.630 --> 16:36.550 Aufeinanderfolgende Befehle normalerweise in aufeinanderfolgenden 16:36.550 --> 16:36.910 Speicherzellen. 16:37.470 --> 16:42.390 Also ich kann sagen, hier ist irgendein Bereich, da liegt mein 16:42.390 --> 16:42.850 Programm. 16:43.490 --> 16:46.650 Und ich muss mir halt in der Reihe nach die verschiedenen Befehle 16:46.650 --> 16:47.090 angucken. 16:47.090 --> 16:50.170 Dann kann es natürlich sein, dass ich an irgendeiner Stelle ein Befehl 16:50.170 --> 16:50.830 ausführe. 16:51.230 --> 16:53.530 Dann sehen wir hier irgendein Befehl und er sagt, ich muss wieder 16:53.530 --> 16:54.230 durchspringen. 16:54.430 --> 16:58.230 Es kann also sein, dass ich nicht immer aufeinanderfolgende Befehle 16:58.230 --> 16:58.590 habe. 16:59.070 --> 17:02.650 Also wie weiß ich, welcher Befehl als nächstes ausgeführt werden muss? 17:02.710 --> 17:05.730 Ich muss zunächst mal die Adresse des Befehls haben, der jetzt 17:05.730 --> 17:06.830 ausgeführt werden soll. 17:07.390 --> 17:10.730 Wenn genau der nächste an der nächsten Position ausgeführt wird, muss 17:10.730 --> 17:14.550 ich einfach die Adresse des Befehls um 1 erhöhen. 17:15.370 --> 17:18.430 Dann habe ich die Reihenfolge der Befehle genauso ausgeführt. 17:19.030 --> 17:21.510 Aber es kann eben sein, dass ich springen muss. 17:21.690 --> 17:26.150 Und dafür brauche ich Sprungbefehle entweder unbedingt, das heißt in 17:26.150 --> 17:30.410 jedem Fall springe ich auf irgendeine andere Adresse, an einer völlig 17:30.410 --> 17:32.870 anderen Stelle, irgendwo anders in meinem Programm. 17:33.330 --> 17:38.230 Oder ich habe zunächst mal einen Test auszuführen, um festzustellen, 17:38.350 --> 17:41.870 ob ich tatsächlich springen soll, oder ob ich weitermache mit dem 17:41.870 --> 17:42.630 nächsten Befehl. 17:42.630 --> 17:45.530 Das ist also hier ein bedingter Sprungbefehl. 17:45.810 --> 17:49.250 Diese beiden Möglichkeiten muss ich einsetzen, damit ich halt den 17:49.250 --> 17:53.230 Ablauf eines Programms variieren kann, je nachdem welche Daten dort 17:53.230 --> 17:53.970 vorkommen. 17:54.610 --> 17:59.330 Das sind also, ansonsten habe ich halt die Befehle zur Ausführung von 17:59.330 --> 17:59.630 Operationen. 18:00.590 --> 18:01.590 Ich habe Sprungbefehle. 18:01.850 --> 18:04.770 Natürlich brauche ich auch Befehle, um Informationen zwischen den 18:04.770 --> 18:07.370 verschiedenen Einheiten des Rechners hin und her zu finden. 18:08.630 --> 18:11.850 Und die Programme und Daten werden natürlich binär codiert. 18:11.850 --> 18:15.690 Das ist klar, im Kern wird alles so dargestellt in Binärform. 18:15.950 --> 18:17.470 Wie man das macht, wissen wir mittlerweile. 18:19.530 --> 18:21.870 Zweierkomplement, Leitpunktzahlen und Ähnliches. 18:22.490 --> 18:25.150 Dieses von Neumann-Prinzip ist immer noch gültig. 18:25.330 --> 18:26.610 Alle Rechner sind so aufgebaut. 18:26.710 --> 18:30.070 Natürlich nicht genau so, wie ich das gerade dargestellt habe. 18:30.490 --> 18:35.170 Wir haben halt nicht notwendigerweise nur ein Rechenwerk und 18:35.170 --> 18:37.850 Ähnliches, aber im Prinzip ist diese Darstellung immer noch gültig. 18:39.170 --> 18:43.030 Rechenwerk und Steuereinheit werden normalerweise zusammengefasst zu 18:43.030 --> 18:46.530 Central Processing Unit, also als eine Einheit. 18:46.810 --> 18:50.350 Der Speicher ist dann davon getrennt. 18:50.470 --> 18:53.390 In der Regel haben wir auch eine Speicherhierarchie, auf die wir noch 18:53.390 --> 18:54.430 genauer eingehen werden. 18:54.930 --> 18:57.830 Dann haben wir eine Ausgabeeinheit, wobei es da vielfältige 18:57.830 --> 18:58.730 Möglichkeiten gibt. 18:58.730 --> 19:06.330 Die Struktur ist nicht so, wie ich es gerade dargelegt habe, mit 19:06.330 --> 19:08.910 diesen einzelnen Leitungen zwischen den verschiedenen Komponenten, 19:09.370 --> 19:14.550 sondern in der Regel haben wir eine busstrukturierte Architektur, bei 19:14.550 --> 19:19.730 der die einzelnen Komponenten, Rechenwerk, Steuerwerk, Speicher, ein 19:19.730 --> 19:25.290 Ausgabegerät, kombiniert oder verbunden sind durch sogenannte Busse, 19:25.290 --> 19:29.610 durch Datenleitungen, durch Datenwege, die jede Komponente ansprechen 19:29.610 --> 19:30.010 kann. 19:30.650 --> 19:33.370 Und wenn ich also neue Komponenten dazufüge, muss ich einfach 19:33.370 --> 19:37.250 irgendeine neue Komponente hier dazufügen, die sich dort mit ankoppelt 19:37.250 --> 19:37.990 an diesen Bus. 19:38.590 --> 19:39.870 Und dann ist die dort dann eingebaut. 19:40.490 --> 19:42.770 Also eine etwas allgemeinere Architektur. 19:43.290 --> 19:47.870 Nur logisch, die Verbindungen, die Art, die Zugreife auf die 19:47.870 --> 19:51.510 verschiedenen Komponenten, ist genau die Struktur dieses Von-Neumann 19:51.510 --> 19:51.890 -Rechners. 19:51.890 --> 19:55.990 Deswegen ist das Prinzip des Von-Neumann-Rechners, die tatsächliche 19:55.990 --> 19:59.170 physikalische Realisierung, kann sich unterscheiden. 19:59.270 --> 20:04.170 Da gibt es vielfältige, unterschiedliche Standardarten, solche Von 20:04.170 --> 20:07.650 -Neumann -Rechner zu realisieren, die dann zum Teil als ganz große 20:07.650 --> 20:10.770 Innovationen gepriesen werden, weil halt das reale Verhalten sich 20:10.770 --> 20:11.750 dadurch etwas verändert. 20:12.390 --> 20:15.890 Aber vom Prinzip her ist es immer noch dieser Von-Neumann-Rechner. 20:15.890 --> 20:20.110 Wir haben in der Regel eine Speicherhierarchie, die wir noch wieder 20:20.110 --> 20:20.910 eingehen werden. 20:21.950 --> 20:25.550 Kehrspeicher, also interner Speicher, Kehrspeicher, Hauptspeicher, 20:26.270 --> 20:27.230 externer Speicher. 20:27.770 --> 20:31.170 Wir haben in der Regel mehrere Rechen- und Steuerwerke, machen 20:31.170 --> 20:34.610 Parallelverarbeitung, wir haben Kommunikation über den zentralen Bus. 20:35.190 --> 20:38.610 Und der wesentliche Funktionsprinzip der Von-Neumann-Rechner ist, dass 20:38.610 --> 20:44.730 wir eine Folge von Befehlen ausführen, hier im Rechenwerk, also 20:44.730 --> 20:48.370 Befehle interpretiert, im Steuerwerk entsprechend ausgeführt, die 20:48.370 --> 20:53.630 Operation im Rechenwerk, Daten hin- und hergeschoben, aus dem 20:53.630 --> 20:54.850 Speicher, in den Speicher. 20:55.570 --> 21:00.030 Und dieses Daten hin- und herschieben, also lesen aus dem Speicher, 21:00.130 --> 21:04.110 wieder reinschreiben im Speicher, heißt, wir verändern die Inhalte der 21:04.110 --> 21:06.490 Werte, die in den Speicherzellen abgelegt sind. 21:06.490 --> 21:11.710 Und das heißt eigentlich, wir führen eine Folge von Zustandsänderungen 21:11.710 --> 21:12.190 aus. 21:12.730 --> 21:17.030 Der Zustand eines Von-Neumann-Rechners ist der Inhalt der ganzen 21:17.030 --> 21:19.650 Speicherzellen, die dort vorhanden sind. 21:20.790 --> 21:25.130 Im Prinzip werden wir im Von-Neumann-Rechner eine Vollberechnung und 21:25.130 --> 21:27.110 die Folgen von Zustandsänderungen ausführen. 21:27.550 --> 21:31.910 Man muss dafür sorgen, dass man durch geeignete Programme, dafür 21:31.910 --> 21:35.690 sorgt, dass die richtigen Folgen von Befehlen perfekt in den Rechner 21:35.690 --> 21:36.670 ausgeführt werden. 21:36.750 --> 21:41.470 Und wie das funktioniert, dass man tatsächlich Folgen von Befehlen 21:41.470 --> 21:44.650 sinnvoll ausführen kann, das müssen wir uns genauer anschauen. 21:45.230 --> 21:48.910 Fangen wir an mit dem Arbeitsspeicher, also hier Speicherwerk. 21:50.090 --> 21:52.650 Darauf gehen wir nachher noch mit einem besonderen Abschnitt ein. 21:53.350 --> 21:57.950 Das ist also der Ort, wo Daten und Programme abgelegt sind. 21:57.950 --> 22:01.910 Nennt man den auch Main-Memory, Hauptspeicher, Primärspeicher oder 22:01.910 --> 22:03.110 einfach Speicher. 22:03.770 --> 22:08.170 Logisch ist es halt einfach eine Folge von Speicherzellen, hatte ich 22:08.170 --> 22:10.210 schon angedeutet, mit einzelnen Adressen. 22:11.070 --> 22:14.750 Feste Anzahl von Bits, in der Regel habe ich hier also irgendwelche K 22:14.750 --> 22:16.210 -Bits drin stehen. 22:16.870 --> 22:21.850 Und diese Bits sind halt folgende. 22:21.850 --> 22:26.730 Dieses K ist halt standardmäßig festgelegt, in der Regel in Vielfachen 22:26.730 --> 22:28.010 von Bytes. 22:28.630 --> 22:36.170 Byte ist 8-Bit und Speicherwort hat normalerweise 32-64. 22:36.570 --> 22:39.570 Standardwert für ein Wort ist 32-Bit, habe ich schon öfter gesagt. 22:40.150 --> 22:41.850 Das ist also in der Regel die Wortzeite. 22:42.570 --> 22:49.470 Und dann schaue ich mir Halbwörter an, wären 16-Bit Speicherzellen 22:49.470 --> 22:52.590 oder Doppelwörter wären 64-Bit. 22:53.970 --> 22:57.650 Gleich haben Sie noch einen 32-Bit Rechner oder 64-Bit Rechner. 22:57.990 --> 23:01.070 Das bezieht sich auf die Wortbreite in den Speicherzellen bzw. 23:01.610 --> 23:06.370 in den Zellen, in denen Adressen gespeichert werden können im Rechner. 23:06.370 --> 23:10.870 Also die Wortbreite in den Registern in Ihrem Speicherwerk und 23:10.870 --> 23:11.150 Rechner. 23:11.510 --> 23:18.530 Das gibt Ihnen an, welche Werte Sie im Rechner hin und her schieben 23:18.530 --> 23:18.870 können. 23:19.590 --> 23:24.670 Und wenn Sie wissen, wie viele Bits Sie in den Adressregistern haben 23:24.670 --> 23:31.150 können, mit denen Sie also Speicherzellen im Speicher adressieren 23:31.150 --> 23:31.550 können. 23:31.550 --> 23:34.810 Und wenn Sie wissen, wie viele Bits Sie zur Verfügung haben, K-Bits, 23:35.270 --> 23:38.350 dann wissen Sie, Sie haben zwei hoch K-verschiedene Speicherzellen, 23:38.430 --> 23:39.470 die Sie adressieren können. 23:41.890 --> 23:45.390 Das heißt, in dem Augenblick, wo Sie wissen, Sie haben 32-Bit Rechner, 23:45.510 --> 23:50.650 ist es klar, Sie können gar nicht mehr als 4 GB Speicher adressieren. 23:51.330 --> 23:53.710 Sie können sich noch so viele Hauptspeicher reinstecken in Ihren 23:53.710 --> 23:54.790 Rechner, das ist ganz nett. 23:55.190 --> 23:57.650 Der Hersteller freut sich, dass Sie so viele Speicher gekauft haben, 23:57.750 --> 23:58.910 aber Sie können es gar nicht adressieren. 23:58.910 --> 24:02.570 Sie brauchen also 64-Bit Rechner, wenn Sie über 4 GB hinausgehen 24:02.570 --> 24:06.190 wollen in Ihrer Rechnerarchitektur. 24:06.510 --> 24:08.630 Das sind Dinge, auf die kommen wir später nochmal zurück. 24:09.350 --> 24:13.110 Also wichtig ist, feste Anzahl von Bits pro Speicherzelle. 24:13.510 --> 24:16.410 Und alles, was Sie im Rechner machen, muss sich dann entsprechend dort 24:16.410 --> 24:19.190 mit einordnen in diese Art der Speicherarchitektur. 24:22.030 --> 24:25.550 Dass die Nummer des Speicherelements Adresse heißt, habe ich schon 24:25.550 --> 24:25.990 gesagt. 24:26.150 --> 24:29.150 Die Speicherelemente sind die kleinsten adressierbaren Einheiten, auch 24:29.150 --> 24:29.850 das ist richtig. 24:30.030 --> 24:34.870 Wobei man manchmal auch Halbwörter oder Bytes noch unten drunter auf 24:34.870 --> 24:36.530 die natürlich auch zugreifen kann. 24:37.230 --> 24:40.670 Dann ist es so, wir haben ein Speicherhierarchie, wir haben einen 24:40.670 --> 24:41.390 Hauptspeicher. 24:41.510 --> 24:44.830 Der Speicher ist begrenzt in seinem Umfang, einfach durch die Anzahl 24:44.830 --> 24:47.570 der Zellen, die Sie dort in Ihrem Speicherchip drin haben. 24:48.210 --> 24:51.310 Ich möchte aber, wenn ich hier meinen Speicher habe, dann kann es 24:51.310 --> 24:52.130 sein, dass mein... 24:52.130 --> 24:55.130 Hier habe ich die Anzahl der Werte, die dargestellt werden können. 24:55.710 --> 25:00.910 Dann kann es sein, dass die Anzahl, ähm, sag ich mal, die Anzahl M der 25:00.910 --> 25:06.090 Speicherzellen, diese Zahl kann eventuell, also das M könnte ja 25:06.090 --> 25:08.970 kleiner als 2 hoch K sein. 25:09.510 --> 25:13.910 Wenn ich also mehr Speicherzellen adressieren kann, als ich physisch 25:13.910 --> 25:17.270 zur Verfügung habe, dann möchte ich es einfach tun können, unabhängig 25:17.270 --> 25:21.670 davon, an welcher Stelle diese Adressen tatsächlich liegen. 25:22.090 --> 25:25.090 Ob die jetzt im Hauptspeicher liegen oder irgendwo in einem 25:25.090 --> 25:30.910 Speicherbereich dahinter, auf der Festplatte, auf einer DVD oder auf 25:30.910 --> 25:36.570 einem Speicherchip, auf einem Memorystick. 25:36.570 --> 25:40.190 Ich habe also eine Hierarchie von möglichen Speicherzellen. 25:41.370 --> 25:45.710 Die Adressen sind nicht notwendigerweise die realen physischen 25:45.710 --> 25:48.730 Adressen, sondern ich absorbiere davon betrachte virtuelle Adressen. 25:48.850 --> 25:49.830 Darauf kommen wir doch mal zurück. 25:49.930 --> 25:51.990 Ich zeige Ihnen später, wie das funktioniert. 25:52.370 --> 25:58.250 Wie man also virtualisiert von der real vorhandenen Architektur, um 25:58.250 --> 26:02.270 dann über virtuelle Adressen reden zu können. 26:02.270 --> 26:05.930 Das erlaubt eine wesentlich elegantere Art zu programmieren. 26:06.830 --> 26:07.830 Adressen aufeinander folgen. 26:07.930 --> 26:10.870 Speicherelemente unterscheiden sich um eins. 26:11.670 --> 26:13.450 Wir können wahlfrei zugreifen. 26:14.030 --> 26:16.230 Wir haben also ein Random Access Memory. 26:16.830 --> 26:18.870 Speichern mit wahlfreiem Zugriff. 26:19.030 --> 26:22.410 Das ist das wesentliche Merkmal dieser Rechner. 26:23.010 --> 26:26.550 Anders als bei der Turing-Maschine, da konnten wir nur sicheren Zellen 26:26.550 --> 26:27.110 zugreifen. 26:27.110 --> 26:30.270 Also wir haben im Speicher irgendwelche Zahlen stehen. 26:30.490 --> 26:32.250 Das ist hier ein ideales Beispiel. 26:32.530 --> 26:35.110 Irgendwelche Zahlen 513, 515. 26:35.690 --> 26:38.390 Drei verschiedene Speicheradressen. 26:38.910 --> 26:40.690 In dem Speicher stehen irgendwelche Werte. 26:40.870 --> 26:47.210 Hier haben wir halt gerade 16 mit Speicherzellen. 26:48.130 --> 26:50.770 Und da sind halt drei verschiedene Zahlen dargestellt. 26:50.910 --> 26:52.390 28, 36, 33. 26:53.010 --> 26:56.870 Einfach dargestellt hier als Dualzahlen-Darstellungen. 26:58.950 --> 27:01.370 Und das sind Werte, die dort liegen können. 27:01.450 --> 27:02.650 Es können beliebige Werte drin liegen. 27:03.270 --> 27:04.550 Das ist halt der Speicher. 27:06.530 --> 27:10.310 Und die Frage ist jetzt, wie können wir auf die Speicher zugreifen. 27:10.950 --> 27:11.950 Und das stellt man fest. 27:12.910 --> 27:16.190 Also wenn Sie sich die einfache Architektur anschauen. 27:16.270 --> 27:17.770 Sie haben hier Ihre CPU. 27:18.490 --> 27:22.150 Die ist auf irgendeinem Chip drauf. 27:22.310 --> 27:23.750 Und Sie haben jetzt hier einen Speicher. 27:23.850 --> 27:26.390 Ihr Main-Memory-Speicherchip. 27:27.450 --> 27:30.810 Bei Ihrem Rechner können Sie ja einfach Speicherchips noch irgendwo 27:30.810 --> 27:31.550 hinzufügen. 27:32.230 --> 27:36.230 Da müssen Sie aber von Ihrem Prozessor auf den Speicherchip. 27:36.710 --> 27:38.030 Und Sie müssen wieder zurück. 27:39.350 --> 27:43.710 Und Sie wissen, das sind alles irgendwelche CMOS-Schaltkreise. 27:43.710 --> 27:46.830 Wenn ich einen CMOS-Schaltkreis habe, dann weiß ich, ich habe da drin 27:46.830 --> 27:47.750 Möglichkeiten. 27:48.390 --> 27:51.830 Also wenn ich da rein gucke, dann habe ich hier irgendwelche Elemente, 27:51.930 --> 27:52.850 irgendwelche Schaltzellen. 27:53.150 --> 27:54.690 Da kann ich ganz schnell schalten. 27:55.310 --> 27:58.550 Ich habe aber dann am Rand meine einen Ausgabebereiche. 27:58.990 --> 28:02.870 Da habe ich Pins, über die ich dann kommunizieren kann mit den 28:02.870 --> 28:04.550 benachbarten Komponenten. 28:05.410 --> 28:08.670 Wenn ich aber kommuniziere über die Pins zu benachbarten Komponenten, 28:08.670 --> 28:11.170 dann muss ich hier solche großen Bereiche erstmal mit dem 28:11.170 --> 28:17.750 entsprechenden Wert belegen, den Wert dort reinladen. 28:18.750 --> 28:22.350 Das ist eine wesentlich größere Kapazität, die ich hier laden muss, 28:22.450 --> 28:25.510 als wenn ich nur in meinen kleinen Transistoren hier drin irgendwelche 28:25.510 --> 28:26.570 Berechnungen ausführe. 28:27.010 --> 28:31.190 Das heißt, die Zeit für Kommunikation über Chipgrenzen hinweg ist 28:31.190 --> 28:34.750 wesentlich länger, als wenn ich innerhalb des Chips irgendwelche 28:34.750 --> 28:35.810 Berechnungen ausführe. 28:35.810 --> 28:40.070 Das heißt, jeder Zugriff auf einen Speicher kostet Zeit. 28:41.410 --> 28:44.850 Größenordnung mehr Zeit, als wenn ich im Chip selber etwas mache. 28:45.210 --> 28:47.250 Deswegen muss ich sehen, dass ich möglichst viel innerhalb des Chips 28:47.250 --> 28:47.590 mache. 28:48.190 --> 28:50.190 Ich habe aber meinen Speicherchip außerhalb. 28:51.050 --> 28:56.790 Und deswegen sorgt man dafür, dass einige Speicherelemente direkt in 28:56.790 --> 29:00.410 der CPU sind, also auf dem Prozessorchip drauf sind. 29:01.010 --> 29:04.610 Register, auf die man sehr schnell zugreifen kann. 29:04.610 --> 29:08.790 Und dann habe ich gewisse Bereiche unter dem Cache-Speicher, der zum 29:08.790 --> 29:11.230 Teil hier auf meiner CPU noch mit drauf sitzt. 29:11.890 --> 29:14.290 Und dann auch auf externen Einheiten. 29:15.390 --> 29:18.030 Und ich möchte dafür sorgen, dass der Cache-Speicher möglichst schnell 29:18.030 --> 29:18.290 ist. 29:18.410 --> 29:21.610 Der Arbeitsspeicher kann etwas langsamer sein. 29:21.850 --> 29:24.390 Das hat auch mit der Architektur, mit den Kosten zusammen. 29:24.470 --> 29:28.490 Beim Arbeitsspeicher habe ich in der Regel DRAM-Speicher. 29:30.190 --> 29:34.630 Dynamic RAM ist einfacher zu produzieren, hat weniger Hardwareaufwand. 29:35.290 --> 29:37.410 Ich kriege also mehr Speicher rein auf einen Chip. 29:37.990 --> 29:42.510 Habe aber mehr Kosten, mehr Zeit für den Zugriff, weil ich den Wert 29:42.510 --> 29:45.710 wieder rein schreiben muss. 29:46.330 --> 29:50.530 Weil es ein dynamischer Speicher ist, muss ich den Wert wieder 29:50.530 --> 29:51.330 herstellen. 29:51.330 --> 29:57.790 Im Gegensatz zum SRAM, Static RAM, statische Speicherzellen. 29:58.170 --> 30:00.950 Da habe ich mehr Aufwand für die Realisierung der einzelnen 30:00.950 --> 30:01.690 Speicherzellen. 30:01.810 --> 30:03.810 Hatten wir bei dem CMOS-Kapitel uns angeguckt. 30:04.330 --> 30:09.430 Ist natürlich teurer, also der Preis pro Bit ist höher als beim 30:09.430 --> 30:10.150 Arbeitsspeicher. 30:10.230 --> 30:12.290 Aber die Zugriffszeit ist niedriger. 30:12.870 --> 30:15.710 Ich muss natürlich sehen, dass ich meine Berechnungen in der CPU 30:15.710 --> 30:17.010 möglichst schnell machen kann. 30:17.010 --> 30:19.550 Möglichst wenig hier hinten drauf zugreifen. 30:20.390 --> 30:21.650 Möglichst viel nur auf Register. 30:21.850 --> 30:23.930 Aber ich muss halt manchmal etwas auf den Speicher holen. 30:24.270 --> 30:26.090 Und das ist einer der wesentlichen Punkte. 30:26.230 --> 30:29.590 Wie kann ich dafür sorgen, dass ich trotz dieser unterschiedlichen 30:29.590 --> 30:33.010 Zeiten für den Zugriff auf die einzelnen Komponenten in so einem 30:33.010 --> 30:37.630 Reckner dafür sorgen kann, dass ich meine schnell arbeitenden 30:37.630 --> 30:42.270 Einheiten ohne Verlangsamung wirklich ausnutzen kann. 30:42.270 --> 30:46.110 Wie kann ich dafür sorgen, dass die CPU immer ausgelastet ist und 30:46.110 --> 30:48.850 nicht warten muss darauf, dass ich ein Element langsam aus dem 30:48.850 --> 30:50.750 Arbeitsspeicher rausnehme. 30:50.830 --> 30:55.210 Und Sie wissen, wenn Sie sich einen Rechner anschauen, dann haben Sie 30:55.210 --> 31:02.770 manchmal sowas wie eine Angabe zu dem Frontside Bus. 31:03.590 --> 31:08.910 Frontside Bus heißt, das ist die Verbindung Ihres Prozessorchips zum 31:08.910 --> 31:09.690 Speicherchip. 31:09.690 --> 31:14.230 Wenn Sie einen 3 GHz Rechner haben und Ihr Frontside Bus, der hat 31:14.230 --> 31:18.410 gerade ein paar Megahertz, dann heißt das, Sie arbeiten in Bezug auf 31:18.410 --> 31:22.390 die Zugriffe auf den Speicher im Megahertz-Bereich und nicht im 31:22.390 --> 31:23.350 Gigahertz -Bereich. 31:25.030 --> 31:28.430 Und das heißt, wenn Sie mit jedem Befehl zugreifen müssten auf den 31:28.430 --> 31:32.270 Speicher, könnten Sie eben gar nicht in der Taktfrequenz arbeiten, die 31:32.270 --> 31:35.250 so schön hoch ist, sondern müssten also immer auf den Speicher 31:35.250 --> 31:35.810 zugreifen. 31:36.830 --> 31:38.430 Der Rechner wird ganz langsam. 31:39.110 --> 31:41.850 Deswegen muss man immer dafür sorgen, dass der Front, das Sie also in 31:41.850 --> 31:46.930 den Rechner kaufen, dass Sie einen kaufen, bei dem dieser Zugriff auf 31:46.930 --> 31:51.510 den Speicher, also das, was ich hier angegeben habe, von der CPU auf 31:51.510 --> 31:53.230 den Speicher zugreifen und wieder zurück. 31:53.450 --> 31:56.050 Diese Zeit muss aufstellen sein. 31:56.190 --> 31:59.110 Wir brauchen eine Rechnerarchitektur, wo die Komponenten gut 31:59.110 --> 32:03.550 aufeinander abgestimmt sind, wo Sie diese Hierarchie von CPU über 32:03.550 --> 32:08.170 Register und Cache auf Arbeitsspeicher, wo das gut abgestimmte 32:08.170 --> 32:13.850 aufeinander sind, dass Sie in der CPU nicht warten müssen auf diese 32:13.850 --> 32:15.150 Zugriffe auf den Speicher. 32:15.630 --> 32:17.350 Das sieht aus wie ein Widerspruch, der gar nicht geht. 32:17.490 --> 32:20.090 Sie werden gleich mal sehen, dass wir tatsächlich bei jeder Ausführung 32:20.090 --> 32:22.450 eines Befehls Informationen brauchen auf den Speicher. 32:23.050 --> 32:24.650 Und das muss einfach schnell gemacht werden. 32:24.810 --> 32:27.650 Das ist also die wesentliche Herausforderung bei der Gestaltung einer 32:27.650 --> 32:28.530 Rechnerarchitektur. 32:28.530 --> 32:32.970 Wie kann ich dafür sorgen, dass ich das unterschiedliche Zeitverhalten 32:32.970 --> 32:38.530 organisiere, oder die Ausführung von Operationen so organisiere, dass 32:38.530 --> 32:43.990 ich nicht verlangsamt werde durch diese unabweisbaren langsamen Zeiten 32:43.990 --> 32:46.010 beim Zugriff auf den Arbeitsspeicher. 32:46.810 --> 32:50.370 Also, das sind hier die unterschiedlichen Randbedingungen. 32:50.490 --> 32:53.170 Die Preise sind hier oben sehr hoch, da sind die niedrigen 32:53.170 --> 32:54.750 Zugriffszeiten, hier niedrig, da hoch. 32:54.750 --> 32:57.850 Kapazität oben niedrig, unten hoch. 32:58.410 --> 33:01.430 Und man versucht halt möglichst viel auf einen Chip aufzukriegen. 33:01.490 --> 33:04.310 Wir haben heutzutage schon einige Speicherbereiche direkt auf dem 33:04.310 --> 33:04.470 Chip. 33:04.950 --> 33:10.070 Sie können sich dann natürlich diese Zeiten zum Teil sparen oder das 33:10.070 --> 33:10.670 reduzieren. 33:11.090 --> 33:15.510 Aber der Hauptspeicher ist in der Regel auf dem extra Chip drauf. 33:15.510 --> 33:19.970 Für sich können Sie ihn ja auch bedienlich noch hinzufügen und dadurch 33:19.970 --> 33:23.690 die Speicherkapazität erhöhen. 33:24.250 --> 33:28.210 Also, der Arbeitsspeicher besteht in der Regel aus verschiedenen 33:28.210 --> 33:29.590 Komponenten, verschiedenen Bereichen. 33:30.250 --> 33:35.610 Wenn ein Problem ist, der Arbeitsspeicher, der enthält nur Daten, 33:36.330 --> 33:41.270 irgendwelche Informationen, wenn er mit Strom versorgt. 33:41.270 --> 33:46.550 Sobald Sie Strom abschalten, ist der Speicherzustand weg. 33:48.250 --> 33:51.850 Bis auf einen Bereich, also den Read-Only-Memory, wurde der 33:51.850 --> 33:53.750 Speicherinhalt fest eingebrannt. 33:54.730 --> 33:58.150 Sie wollen ja den Rechner aufklappen und dann sollte er wieder 33:58.150 --> 33:59.010 anfangen zu arbeiten. 33:59.890 --> 34:03.390 Dazu braucht er Informationen, die müssen irgendwo abgelegt sein, die 34:03.390 --> 34:06.150 müssen in den Arbeitsspeicher rein, die müssen in die CPU rein, die 34:06.150 --> 34:07.950 müssen dort, es muss eine Zähle ausgefüllt werden. 34:08.350 --> 34:13.150 Und diese Informationen liegen in dem Read-Only-Memory, in einem Nur 34:13.150 --> 34:16.710 -Lese -Speicher, in dem einmal zu Beginn etwas reingeschrieben wurde 34:16.710 --> 34:20.890 und die Informationen, die man da drin hat, die wird verwendet, um 34:20.890 --> 34:25.190 dann alles andere aus den externen Speichern reinzuladen in den 34:25.190 --> 34:28.550 Hauptspeicher und dann entsprechend die Programme wieder zu starten. 34:28.990 --> 34:32.790 Das ist das, was man macht, wenn man also einen Rechner anschaltet. 34:32.790 --> 34:35.790 Dann werden die Informationen aus dem Read-Only-Memory geholt, 34:35.930 --> 34:39.430 entsprechend aus dem externen Speicher in den Hauptspeicher rein und 34:39.430 --> 34:42.450 dann kann man wieder arbeiten und das muss wirklich schnell passieren. 34:43.370 --> 34:48.690 Also das ist das sogenannte Booten eines Rechners, also ein 34:48.690 --> 34:49.830 Bootstrapping. 34:50.490 --> 34:53.630 Sie kennen das Bootstrapping, der Münchhausen hat sich an seinem 34:53.630 --> 34:55.690 eigenen Shop aus dem Sumpf wieder rausgeholt. 34:55.690 --> 34:59.230 Man hat also eine kleine Information, die man nimmt, eine kleine 34:59.230 --> 35:03.450 Information im Read-Only-Memory, die wird erstmal verwendet, um dann 35:03.450 --> 35:07.750 größere Bereiche aus seinem Speicher zu holen und damit wieder alles 35:07.750 --> 35:11.010 herzustellen, was man vorher bereits in der Information dort gehabt 35:11.010 --> 35:11.250 hat. 35:11.610 --> 35:18.030 Hätte man Speicher, die die Informationen auch behalten, wenn ich die 35:18.030 --> 35:22.690 Stromversorgung abschalte, dann könnte ich sofort weiterarbeiten. 35:23.490 --> 35:28.210 Es gibt solche Speicher, die aber sehr teuer sind und die Technologien 35:28.210 --> 35:30.670 entwickeln sich weiter, wir werden irgendwann solche Speicher in den 35:30.670 --> 35:33.690 Rechnern haben, aber haben im Augenblick nicht und deswegen dauert es 35:33.690 --> 35:38.230 eine Weile, bis ein Rechner-Zustand wieder richtig da ist und wir 35:38.230 --> 35:42.090 sehen Unterschiede zwischen verschiedenen Rechnern, wie schnell wir in 35:42.090 --> 35:45.190 der Lage sind, tatsächlich aus einem kleinen Fern von Informationen 35:45.190 --> 35:47.430 diesen größeren Bereich wieder hinzukriegen. 35:48.370 --> 35:48.850 Okay. 35:52.050 --> 35:57.810 Dann haben wir also, wie gesagt, den Cache-Speicher, das Bindeglied 35:57.810 --> 36:01.310 zwischen CPU und Arbeitsspeicher ist zum Teil direkt auf dem Deck am 36:01.310 --> 36:05.410 Prozessor, zum Teil sind das Stufen beim Arbeitsspeicher, da gehen wir 36:05.410 --> 36:06.710 später nochmal genauer drauf ein. 36:07.370 --> 36:12.370 Der Cache-Speicher hat einen assoziativen Zugriff, auf den kommen wir 36:12.370 --> 36:12.930 auch noch gleich. 36:13.790 --> 36:18.090 Wir haben im Cache-Speicher Folgendes, wir wissen, die Daten liegen 36:18.090 --> 36:19.430 eigentlich alle im Hauptspeicher. 36:20.270 --> 36:24.170 Aber manchmal weiß ich, naja, in meinem großen Hauptspeicher, da habe 36:24.170 --> 36:25.150 ich mein Programm liegen. 36:25.690 --> 36:29.170 Und ich weiß, ich muss jetzt einen bestimmten Befehl ausführen und 36:29.170 --> 36:31.710 werde als nächstes sicherlich den Befehl ausführen, der direkt 36:31.710 --> 36:32.830 dahinter liegt. 36:33.610 --> 36:36.590 Und ich greife auf irgendeinen Bereich auf dem Speicher zu, wo meine 36:36.590 --> 36:40.950 Daten liegen und ich weiß, ich werde voraussichtlich noch weitere 36:40.950 --> 36:42.470 Daten aus diesem Bereich brauchen. 36:43.610 --> 36:46.210 Und ich möchte nicht jedes Mal auf den Hauptspeicher zugreifen, wo 36:46.210 --> 36:48.530 diese Daten liegen, sondern ich hole mir einfach einen größeren Block 36:48.530 --> 36:52.890 von Daten aus meinem Hauptspeicher und packe diese Daten in den Cache 36:52.890 --> 36:53.650 -Speicher rein. 36:55.850 --> 36:58.410 Und wenn ich jetzt zugreifen muss auf diese Daten, dann gucke ich erst 36:58.410 --> 37:01.130 mal im Cache-Speicher nach, ob das woanders liegt, was ich gebrauchen 37:01.130 --> 37:01.470 kann. 37:01.470 --> 37:03.990 Das heißt, der Cache-Speicher ist schneller. 37:04.650 --> 37:07.250 Der enthält also eine Teilmenge der Daten, die im Hauptspeicher 37:07.250 --> 37:08.050 vorgesehen sind. 37:08.810 --> 37:13.350 Und ich habe also dort die vermutlich nächsten Befehle, sowie häufig 37:13.350 --> 37:14.430 referenzierte Daten. 37:14.550 --> 37:18.170 Ich muss dafür sorgen, dass ich weiß, was ich abschätzen kann. 37:18.570 --> 37:20.990 Was sind wohl die Daten, die ich als nächstes brauche? 37:22.050 --> 37:25.190 Bilddaten oder irgendwelche sonstigen Daten. 37:25.710 --> 37:27.310 Und dann kann ich schnell zugreifen. 37:27.370 --> 37:30.410 Ich kann mich auf den Cache zugreifen, habe hier diesen sehr schnellen 37:30.410 --> 37:30.910 Zyklus. 37:32.530 --> 37:37.250 Und dann kann ich mir diesen langsamen Schreibzyklus auf den 37:37.250 --> 37:38.250 Arbeitsspeicher sparen. 37:39.590 --> 37:42.410 Also, Cache ist ganz wichtig. 37:42.610 --> 37:44.810 Nehmen wir später noch drauf ein, wie man den organisiert. 37:46.030 --> 37:49.710 Das Interessante ist, da die Zugriffszeiten auf den Cache wirklich um 37:49.710 --> 37:52.970 Größenordnung, also so in Ordnung 10 und Faktor 10 oder sowas, 37:53.070 --> 37:58.270 vielleicht mal noch größer, schneller sind als auf den Hauptspeicher, 37:59.610 --> 38:04.230 heißt das, wenn Sie bei der Ausführung von Berechnungen häufig ganz 38:04.230 --> 38:08.290 runter müssen auf den Arbeitsspeicher, dauert das wesentlich länger, 38:08.650 --> 38:10.870 als wenn Sie immer auf den Cache-Speicher zugreifen. 38:12.390 --> 38:17.170 Wenn Sie ein Programm haben, das es leider nicht schafft, dafür zu 38:17.170 --> 38:20.410 sorgen, dass die Daten, die als nächstes gebraucht werden, immer im 38:20.410 --> 38:22.830 Cache -Speicher liegen, dann dauert das sehr lange. 38:23.550 --> 38:26.490 Und ein anderes Programm, das dafür sorgt, dass die meistens vorhanden 38:26.490 --> 38:28.850 sind, wird deutlich schneller laufen. 38:29.130 --> 38:30.450 Faktor 10 oder so schneller. 38:31.950 --> 38:36.030 Das heißt, Sie können beeinflussen, wie schnell Ihre Programme 38:36.030 --> 38:39.650 ausgeführt werden, in Bezug auf die Art, wie Sie auf den Speicher 38:39.650 --> 38:40.230 zugreifen. 38:41.130 --> 38:45.010 Das werden Sie in der Regel gar nicht unbedingt machen, aber wenn man 38:45.010 --> 38:49.810 dabei ist, das zu optimieren, wie ich jetzt meine Programme ausführe, 38:49.890 --> 38:52.550 wenn es wirklich auf Hochleistung ankommt, in Bezug auf das 38:52.550 --> 38:55.810 Speicherhalten, dann muss man sehen, dass man den Cache ordentlich 38:55.810 --> 38:56.310 ausführt. 38:58.110 --> 39:04.270 Ein anderer Punkt ist, wenn Daten in den Cache vorhanden sein können 39:04.270 --> 39:09.930 oder auch nicht, und der Zugriff auf den Cache schneller ist, als der 39:09.930 --> 39:13.010 Zugriff auf den Hauptspeicher, dann heißt das, wenn ich Pech habe, 39:13.110 --> 39:13.990 muss ich lange warten. 39:14.510 --> 39:17.770 Wenn ich mal die Zugriffszeit anschaue, sage ich, in der Regel kann 39:17.770 --> 39:20.690 ich hier ganz schnell zugreifen, wenn ich Pech habe, brauche ich aber 39:20.690 --> 39:21.390 lange Zeit. 39:22.430 --> 39:26.970 Und ich habe eine Echtzeitanforderung für die Ausführung meiner 39:26.970 --> 39:31.630 Programme, gehen also Prozesssteuerung und Ähnliches, dann muss ich 39:31.630 --> 39:38.250 bei einer Worst-Case-Execution-Time immer davon ausgehen, dass ich 39:38.250 --> 39:38.970 lange brauche. 39:40.230 --> 39:42.150 Und da kann ich mir den Cache auch sparen. 39:42.630 --> 39:47.170 Deswegen haben viele Prozesssteuerungen keinen Cache. 39:47.890 --> 39:50.950 Wenn es auf die Worst-Case-Execution-Time nicht ankommt, die 39:50.950 --> 39:54.990 Ausführungszeit im schlechtesten Fall, dann nutzt man das auch, dass 39:54.990 --> 39:59.010 man Cache haben kann und im günstigen Fall sehr schnelle 39:59.010 --> 40:02.110 Ausführungszeit, im günstigen Fall hier halt nüchtige Zugriffszeiten 40:02.110 --> 40:03.750 hat und schnell arbeiten kann. 40:04.490 --> 40:08.010 Das heißt, auf einmal muss man sich anschauen, was ist eigentlich das 40:08.010 --> 40:10.090 Einsatzprofil meines Rechners. 40:10.590 --> 40:12.870 Wenn ich einen Rechner brauche, mit viel Prozesssteuerung, mit 40:12.870 --> 40:16.570 Echtzeitanwendungen, muss ich gar nicht auf den Cache achten. 40:16.710 --> 40:20.030 Wenn Sie bei Ihrem Laptop nicht geschaffen, dann sollten Sie schon 40:20.030 --> 40:23.710 gucken, ob da ein Cache vorhanden ist und ob der groß genug ist, um 40:23.710 --> 40:27.210 auch immer genügend Daten zu enthalten, die als nächstes gebraucht 40:27.210 --> 40:27.490 werden. 40:28.070 --> 40:32.010 Denn wenn der Cache zu klein ist, im Verhältnis zu Ihrem Hauptspeicher 40:32.010 --> 40:35.810 und zu Ihren vielen Prozessoren, die Sie da mittlerweile haben, dann 40:35.810 --> 40:39.270 wird die Leistungsfähigkeit Ihres Rechners, obwohl da steht irgendwie 40:39.270 --> 40:43.570 mehrere Gigahertz Taktfrequenz, wird die Leistungsfähigkeit deutlich 40:43.570 --> 40:44.050 runtergehen. 40:44.650 --> 40:47.830 Die ist dann halt in der Größenordnung wie Ihr Frontside-Bus sein. 40:49.330 --> 40:52.870 Und das heißt, da haben Sie eine deutliche Reduktion der 40:52.870 --> 40:57.770 Leistungsfähigkeit, je nachdem wie die Dimensionierung zwischen diesen 40:57.770 --> 41:00.170 verschiedenen Speicherarten gemacht wurde. 41:00.170 --> 41:03.250 Wir gehen darauf noch genauer ein in dem Kapitel über Speicher 41:03.250 --> 41:03.790 -Hierarchien. 41:05.390 --> 41:07.610 Aber das ist eben Ihr wichtiger Punkt. 41:08.050 --> 41:11.270 Die schlechte Ausnutzung des Caches kann den Rechner deutlich 41:11.270 --> 41:12.510 verlangsamen. 41:13.590 --> 41:18.630 Wenn Sie eine Betrachtung des schlechtesten Falles machen müssen, wird 41:18.630 --> 41:23.210 eine Cache-Architektur sogar schlechteres Verhalten haben, als ein, 41:23.310 --> 41:26.610 was Sie dann mit dem Aufwand haben, für das Nachbauen im Cache. 41:27.050 --> 41:28.330 Dann werden Sie auch im Cache verzichten. 41:28.330 --> 41:31.890 Wenn Sie aber diese Prozesssteuerung, diese Echtzeitanforderung nicht 41:31.890 --> 41:35.410 haben, dann machen Sie etwas mit Cache und werden dann in den Rechner 41:35.410 --> 41:36.070 deutlich beschlossen. 41:37.330 --> 41:37.630 Okay. 41:38.190 --> 41:39.730 Wir gehen auf den Speicher später nochmal ein. 41:40.930 --> 41:44.730 Nächstes Mal, heute, gucken wir uns das Rechen gleich nochmal genauer 41:44.730 --> 41:44.950 an. 41:45.410 --> 41:47.610 Wie können wir also Befehle ausführen? 41:47.670 --> 41:48.550 Was machen wir dann eigentlich? 41:48.670 --> 41:52.170 Wir wollen Daten verarbeiten, beziehungsweise wenn wir sagen 41:52.170 --> 41:56.110 Datenverarbeitung, wir wollen Operationen auf Daten ausführen, 41:56.630 --> 41:58.530 arithmetische und logische Operationen. 41:59.410 --> 42:03.330 Also arithmetisch, Plus, Mal, also Einigung, Modifikation, 42:03.710 --> 42:04.670 Subtraktion, Division. 42:05.590 --> 42:08.090 Wir wollen Vergleiche ausführen können. 42:08.350 --> 42:11.590 Wir müssen Werte der Größenordnung vergleichen können. 42:12.310 --> 42:14.310 Wir müssen logische Entscheidungen durchführen können. 42:14.410 --> 42:15.370 Wir müssen testen können. 42:15.830 --> 42:18.290 Wir haben also dafür Register und Funktionseinheiten. 42:18.290 --> 42:22.170 In den Registern speichern wir etwas und da speichern wir halt die 42:22.170 --> 42:22.850 Operanten. 42:25.830 --> 42:31.270 Und, das ist irgendwie seltsam dargestellt, das ist ein Akkumulat-Core 42:31.270 --> 42:31.540 -Register. 42:32.150 --> 42:33.650 Der Zwischenraum sollte nicht da sein. 42:34.590 --> 42:36.850 Ist auch im Original nicht vorhanden. 42:36.950 --> 42:40.110 Ist nur in der Darstellung so eingebaut worden, was ich hoffe. 42:41.190 --> 42:45.690 Und die Zustandsbeschreibungen der Funktionseinheiten kommen mit 42:45.690 --> 42:46.730 irgendwelchen Statusregistern. 42:46.730 --> 42:55.650 Also wir haben hier irgendeine Einheit, die Ihnen aus irgendwelchen 42:55.650 --> 43:00.690 Operanten, Operant A, Operant B, ein Ergebnis C bringen kann. 43:01.110 --> 43:05.210 Und auf diesem Weg hier, das ist halt irgendein Schaltnetz F, das 43:05.210 --> 43:08.970 vielleicht ein Addierwerk ist oder ein Modifizierwerk oder was immer. 43:09.110 --> 43:11.870 Wir hatten uns solche Einheiten angeschaut, seriellen Addierer, 43:11.970 --> 43:14.890 parallelen Addierer, Modifizierer und ähnliches. 43:14.890 --> 43:21.410 Da muss man halt sehen, wie wird solche eine arithmetische Einheit 43:21.410 --> 43:24.830 oder arithmetisch-logische Einheit ausgeführt. 43:25.410 --> 43:28.810 Man nennt das also auch ALU für Arithmetic Logic Unit. 43:29.790 --> 43:34.230 Und damit jeweils die richtige Operation ausgeführt wird, muss ich 43:34.230 --> 43:37.030 hier irgendwelche Steuerinformationen reinbekommen können. 43:37.530 --> 43:41.630 Ich habe die Register, da steht hier, Speicherung von Operanten und 43:41.630 --> 43:43.650 das sind die Ergebnisse, das waren das A, B und C. 43:43.650 --> 43:48.930 Und es kann sein, dass ich irgendwelche Statusregister brauche, um 43:48.930 --> 43:54.210 bestimmte Effekte darstellen zu können, wie ich habe eine Division 43:54.210 --> 44:00.230 durch 0 oder ich habe einen Wert von Endlich rausgefunden oder Not a 44:00.230 --> 44:01.450 Number oder Ähnliches. 44:01.670 --> 44:04.610 Oder ich habe einen Überlauf, ich bin aus dem Bereich raus, eine 44:04.610 --> 44:06.070 Preisüberschreitung und Ähnliches. 44:06.410 --> 44:10.650 Das muss per Statusregister gemeldet werden an die anderen Einheiten. 44:11.410 --> 44:16.010 Also muss Zustandsbeschreibungen dieser Einheiten auch irgendwo 44:16.010 --> 44:16.730 ablegen werden. 44:18.670 --> 44:20.170 Was für Operationen mache ich? 44:20.310 --> 44:22.010 Also arithmetisch-logische Operationen. 44:22.530 --> 44:26.250 Und ich muss natürlich auch in der Lage sein, Informationen zwischen 44:26.250 --> 44:27.850 den Einheiten hin und her zu bewegen. 44:28.210 --> 44:31.610 Ich muss etwas aus dem Speicherwerk in das Rechenwerk hineinbekommen. 44:32.370 --> 44:34.610 Das muss über einen Befehl gesteuert werden, das sind 44:34.610 --> 44:37.070 Transferoperationen für Laden und Speichern. 44:37.070 --> 44:42.110 Ich brauche Busch-Operationen, arithmetische Verknüpfungen, Schiebe 44:42.110 --> 44:42.950 -Operationen. 44:42.990 --> 44:46.530 Ich möchte also irgendetwas modifizieren mit 2 hoch irgendwas. 44:47.230 --> 44:51.050 Verschieben hatten wir gesehen, oder Sie erinnern sich, wenn wir in 44:51.050 --> 44:54.130 Leistungszahlen agieren, müssen wir jemand wissen, ob Stellen gerecht 44:54.130 --> 44:54.870 verschieben können. 44:55.350 --> 44:58.750 Das muss halt entsprechend über Schiebe-Operationen realisiert werden. 44:58.750 --> 45:03.710 Also das sind die üblichen Operationen, die wir brauchen, um Rechen 45:03.710 --> 45:07.430 -Operationen in einem Reckner ausführen zu können. 45:07.570 --> 45:10.710 Entsprechend brauche ich Befehle, die genau diese verschiedenen 45:10.710 --> 45:11.790 Operationen anbieten. 45:14.320 --> 45:19.080 So, dann wird die Reihenfolge der Operationen, die Art der Operationen 45:19.080 --> 45:20.380 über das Steuerwerk bestimmt. 45:20.980 --> 45:26.240 Ich habe also hier mein Steuerwerk, das Steuersignale angibt und 45:26.240 --> 45:29.240 festlegt, ob jetzt hier drin eine Addition oder Multiplikation 45:29.240 --> 45:33.000 ausgeführt wird oder welche Funktionsseinheit, wenn ich also mehrere 45:33.000 --> 45:37.580 ALUs habe, digitalisierte ALUs, welche angestoßen werden muss, wo die 45:37.580 --> 45:40.920 Befehle, wo die Operationen hingeschrieben werden. 45:41.520 --> 45:47.980 Ich habe jetzt meine Meldesignale hier, die Statusregister und muss 45:47.980 --> 45:52.020 halt über die jetzt Steuerung oder über die Steuersignale dafür 45:52.020 --> 45:55.480 sorgen, dass hier alles sinnvoll abläuft. 45:56.480 --> 46:00.740 Schauen wir uns dann das Steuerwerk ein bisschen genauer an. 46:00.880 --> 46:02.780 Das muss das Ganze organisieren. 46:03.480 --> 46:09.800 Wir müssen also alle im Programm vorgeschriebenen Operationen sinnvoll 46:09.800 --> 46:11.360 im Reckner ausführen können. 46:12.180 --> 46:16.820 Und dafür muss ich wissen, was ist der Befehl, der gerade ausgeführt 46:16.820 --> 46:17.060 wird. 46:17.180 --> 46:22.100 Ich brauche ein Instruktionsregister und ich brauche einen Zeiger auf 46:22.100 --> 46:23.620 den aktuellen Befehl. 46:23.620 --> 46:27.280 Der wird im Speicherhof abgelegt und muss wissen, was ist die aktuelle 46:27.280 --> 46:29.700 Adresse meines Befehls. 46:30.080 --> 46:31.820 Das ist der sogenannte Befehlszähler. 46:32.300 --> 46:36.660 Der hat die Adresse des aktuell auszuführenden Befehls. 46:37.380 --> 46:41.360 Ich muss also wissen, wo bin ich gerade bei der Abarbeitung meines 46:41.360 --> 46:41.960 Programms. 46:43.300 --> 46:50.040 Jetzt kommt der wesentliche Teil, wie eine Ausführung von Befehlen im 46:50.040 --> 46:51.080 Rechner gesteuert wird. 46:51.080 --> 46:56.620 Das ist der sogenannte Maschinenbefehlszyklus, der Ihnen die 46:56.620 --> 47:01.480 elementare Art darstellt, wie man Befehle im Rechner ausführt. 47:01.840 --> 47:06.580 Fundamentale Eigenschaft der von Neumann Rechners, wie das Steuerwerk 47:06.580 --> 47:10.960 dafür sorgt, dass Befehle, die im Programm so abgelegt sind, im 47:10.960 --> 47:14.660 Rechenwerk ausgeführt werden können. 47:14.660 --> 47:21.140 Dadurch, dass dort entsprechen die Angaben über die ausgeführten 47:21.140 --> 47:24.880 Operationen und die Daten, die verwendet werden sollen, geeignet 47:24.880 --> 47:25.640 kombiniert werden. 47:25.980 --> 47:27.500 Also was muss ich wirklich machen? 47:28.100 --> 47:30.220 Ich muss zunächst mal den Befehl holen. 47:31.440 --> 47:35.400 Ich weiß, wo ich ihn holen muss, dadurch, dass ich den Befehlszähler 47:35.400 --> 47:36.520 habe, meinen Programm-Counter. 47:36.800 --> 47:41.760 Ich gehe in die entsprechende Stelle im Speicher, hole mir den Befehl 47:41.760 --> 47:42.500 dort raus. 47:43.700 --> 47:47.860 Lade den aus dem Speicher ein und Sie sehen, wenn ich ein Befehl 47:47.860 --> 47:51.320 ausführen möchte im Rechner, muss ich den Befehl erstmal aus dem 47:51.320 --> 47:52.800 Speicher holen. 47:54.140 --> 47:57.860 Und Sie erinnern sich, Zugriffe auf den Speicher können lange dauern. 47:58.220 --> 48:00.980 Also zunächst mal muss ich einen Befehl holen. 48:01.680 --> 48:05.100 Dann habe ich den Befehl in meinem Instruktionsregister drin stehen. 48:07.280 --> 48:10.400 Befehl im Instruktionsregister, das kann jetzt ein einfach langes oder 48:10.400 --> 48:12.800 doppelt langes oder vierfach langes Wort sein. 48:14.520 --> 48:17.480 Das heißt, der Befehl kann eventuell über mehrere Speicherzellen 48:17.480 --> 48:18.000 entsprechen. 48:20.060 --> 48:22.080 Den habe ich jetzt geholt, habe den im Rechner. 48:22.140 --> 48:24.860 Jetzt muss ich wissen, was steht eigentlich drin in meinem Befehl? 48:24.980 --> 48:25.840 Was ist das eigentlich? 48:26.020 --> 48:29.500 Das sind ja irgendwelche Folgen von Nullen und Einsen, die ich 48:29.500 --> 48:31.380 irgendwie geeignet interpretieren möchte. 48:31.380 --> 48:32.920 Da steht irgendwas drin. 48:33.280 --> 48:34.200 Was steht da eigentlich? 48:36.160 --> 48:38.380 Ich soll das Ganze erstmal entschlüsseln. 48:39.040 --> 48:40.160 Das ist nicht verschlüsseln. 48:40.400 --> 48:42.900 Ich muss aber wissen, was ist eigentlich die Struktur. 48:43.240 --> 48:48.340 Und in der Regel habe ich hier vorne einen Teil, das ist der 48:48.340 --> 48:50.620 sogenannte Opcode. 48:52.020 --> 48:54.460 Operationscode, der gibt mir an, was getan werden muss. 48:54.460 --> 48:59.300 Also muss ich agieren oder subtrahieren oder muss ich etwas laden, 48:59.400 --> 49:01.300 etwas schieben oder was soll eigentlich geschehen? 49:03.320 --> 49:04.900 Die Befehlsart muss ich erkennen. 49:05.020 --> 49:06.140 Das ist der sogenannte Opcode. 49:07.300 --> 49:08.960 Und, das habe ich hier oben angedeutet. 49:09.180 --> 49:14.180 Und dann kommt die Zerlegung in die Befehlsbestandteile, Operations 49:14.180 --> 49:15.420 -Operanten -Teile. 49:15.640 --> 49:17.600 Die Operanten, wo kommen die denn her? 49:17.600 --> 49:19.460 Ich habe eventuell mehrere Operanten. 49:19.960 --> 49:24.300 Das heißt, es kann sein, dass ich hier mehrere Bereiche habe, in denen 49:24.300 --> 49:29.240 Operationen -Daten spezifiziert werden, die mit der Operation 49:29.240 --> 49:30.480 vergrifft werden sollen. 49:32.600 --> 49:41.880 Naja, das heißt, ich habe hier jeweils Operanten, Op1, Op2 usw. 49:42.020 --> 49:43.040 bis OpK. 49:44.440 --> 49:46.560 Dieses K ist in der Regel klein. 49:47.400 --> 49:49.360 1, 2 oder 3. 49:50.160 --> 49:50.980 Größer ist das nicht. 49:51.760 --> 49:54.260 Ich habe also in der Regel nur wenige Operanten da drin. 49:54.860 --> 49:56.760 Und die Frage ist, wie werden die eigentlich spezifiziert? 49:56.880 --> 49:58.260 Stehen die im Befehl alle drin? 49:59.880 --> 50:03.280 Wir haben doch in der Regel irgendwelche Daten irgendwo abgelegt im 50:03.280 --> 50:06.520 Befehl, sodass Daten zugreifen, die irgendwo im Speicher abgelegt 50:06.520 --> 50:06.840 sind. 50:08.400 --> 50:12.180 Das heißt, ich werde dort Spezifikationen von Operanten haben. 50:13.080 --> 50:17.440 Und wenn ich jetzt den Befehl ausführen möchte, muss ich zunächst mal 50:17.440 --> 50:19.720 die Operanten tatsächlich holen. 50:20.740 --> 50:29.640 Das heißt, die Operanten sind irgendwelche Adressen von Daten. 50:30.780 --> 50:32.340 Also Adressen von Speicherzellen. 50:32.440 --> 50:35.320 Und ich muss erstmal aus dem Speicher die Daten holen, aus denen ich 50:35.320 --> 50:36.080 arbeiten soll. 50:36.560 --> 50:38.000 So wieder ein Zugriff auf den Speicher. 50:38.960 --> 50:42.480 Und dann muss ich die Operation ausführen in meiner ALU, in dem 50:42.480 --> 50:43.160 Rechenwerk. 50:43.960 --> 50:49.240 Das Ergebnis habe ich in meinem Rechenwerk dann erzeugt. 50:49.580 --> 50:52.800 Ich muss das Ergebnis eventuell wieder in den Speicher laden, 50:54.620 --> 50:59.660 durchschreiben und anschließend den Befehlszähler, den Programm 50:59.660 --> 51:00.480 -Counter verändern. 51:02.280 --> 51:03.640 Abhängig vom Befehl. 51:03.760 --> 51:10.160 Das ist entweder einfach nur um 1 erhöht, oder es ist ein Wert, der 51:10.160 --> 51:13.040 durch den Befehl selbst festgelegt wurde, wenn es einen Sprung gibt. 51:14.080 --> 51:17.860 Also ich habe hier diese verschiedenen Sachen, also im Wesentlichen 51:17.860 --> 51:21.000 das Holen, das Entschlüsseln, das Ausführen. 51:22.720 --> 51:24.700 Fetch, Decode, Execute. 51:24.800 --> 51:29.300 Das sind die drei aufeinanderfolgenden Schritte, die ich bei jeder 51:29.300 --> 51:33.460 Ausführung eines Befehls, eines Programms durchführen muss. 51:34.260 --> 51:39.920 Informationen aus dem Speicher holen, geeignet interpretieren und dann 51:39.920 --> 51:42.240 entsprechend dieser Interpretation ausführen. 51:42.540 --> 51:45.140 Das Ausführen kann eben heißen, dass ich zunächst mal Operationen 51:45.140 --> 51:49.640 holen muss, also nochmal aus dem Speicher zugreifen, Daten holen, dem 51:49.640 --> 51:53.560 Rechenwerk entsprechend die Funktionseinheit anstoßen, das Ergebnis 51:53.560 --> 51:57.220 mehr anschauen, entsprechend den Statusregister eventuell noch weitere 51:57.220 --> 51:58.720 Aktivitäten ausführen usw. 51:59.460 --> 52:03.640 Und was Sie hier sehen ist eben, dass eine ziemlich komplexe Folge von 52:03.640 --> 52:04.920 Einzeloperationen ist. 52:06.260 --> 52:12.060 Und wenn Sie einen Rechner haben, der mit 3 Gigahertz arbeitet, dann 52:12.060 --> 52:17.940 arbeitet der sehr schnell, die Ausführung eines Befehls kann aber 52:17.940 --> 52:18.580 länger dauern. 52:19.680 --> 52:23.820 Mit 3 Gigahertz heißt, wir haben hier eine Folge von Befehlen, 52:24.300 --> 52:30.680 nacheinander, die sehr schnell nacheinander angestoßen werden. 52:31.360 --> 52:34.280 Jeder einzelne Befehl kann aber ziemlich lange dauern. 52:35.960 --> 52:40.120 Und die werden in der Regel so zeitlich überlappend ausgeführt. 52:40.220 --> 52:44.780 Das heißt, Sie können im Prinzip mit einem sehr hohen Durchsatz Ihre 52:44.780 --> 52:48.380 Befehle ausführen, aber setzen dabei voraus, dass Sie eben nicht 52:48.380 --> 52:52.900 warten müssen, bis Sie den Befehl vollständig ausgeführt haben, bevor 52:52.900 --> 52:55.400 Sie mit dem nächsten anfangen, sondern dass Sie das schon überlappend 52:55.400 --> 52:55.960 machen können. 52:56.500 --> 53:00.100 Das können Sie dann mit einer hohen Taktfrequenz machen, so in diesem 53:00.100 --> 53:02.940 Pipelining -Verfahren, das wir gleich noch eingehen werden. 53:04.580 --> 53:11.020 Aber wenn Sie Pech haben, müssen Sie warten, bis diese ganze Aktivität 53:11.020 --> 53:12.200 hier ausgeführt worden ist. 53:12.860 --> 53:14.400 Und das kann lange dauern. 53:14.540 --> 53:18.380 Es kann sein, dass das 20 reisen Taktzyklen sind, die da ausgeführt 53:18.380 --> 53:18.700 werden. 53:18.700 --> 53:20.420 Bis sie fertig sind. 53:21.400 --> 53:25.100 Wenn Sie also Pech haben, arbeiten Sie entsprechend mit einer deutlich 53:25.100 --> 53:29.140 niedrigeren Geschwindigkeit, weil Ihre Befehle viel Abhängigkeit 53:29.140 --> 53:32.600 voneinander haben, sodass Sie jeweils warten müssen, bis ein Befehl 53:32.600 --> 53:35.120 ausgeführt wurde, bevor der nächste beginnen kann. 53:35.540 --> 53:36.780 Und dann dauert das deutlich länger. 53:37.260 --> 53:40.620 Also die Ausführung eines Befehls dauert länger als ein Takt. 53:41.160 --> 53:43.920 Sie müssen eine ganze Reihe von Aktivitäten erstmal ausführen. 53:43.920 --> 53:51.180 Dieser Maschinenbefehlszyklus ist also ein wesentlicher Bestandteil 53:51.180 --> 53:52.680 jedes Rechners. 53:52.780 --> 53:57.380 So werden Informationsverarbeitungen durchgeführt im Rechner. 53:58.020 --> 54:00.980 Im Endeffekt wird alles zurückgeführt auf diesem 54:00.980 --> 54:02.220 Maschinenbefehlszyklus. 54:02.360 --> 54:05.140 Sie müssen die Informationen in den Prozessor reinholen, 54:05.260 --> 54:08.600 interpretieren und entsprechend dafür sorgen, dass die richtige 54:08.600 --> 54:12.480 Operation auf den spezifizierten Daten ausgeführt werden kann. 54:12.480 --> 54:18.080 Das ist der Maschinenbefehlszyklus und also ein ganz wesentlicher 54:18.080 --> 54:20.180 Bestandteil der Rechner-Architekturen. 54:20.760 --> 54:24.900 Wenn man sich das klar gemacht hat, weiß man, welche Aufgabe man hat 54:24.900 --> 54:28.960 bei der Organisation der ganzen Informationsverarbeitung. 54:29.100 --> 54:32.340 Man muss dafür sorgen, dass dieser Maschinenbefehlszyklus möglichst 54:32.340 --> 54:33.940 effizient ausgeführt werden kann. 54:34.640 --> 54:39.380 Ohne irgendwelche sonstigen Dinge, die den irgendwo aufhalten. 54:39.380 --> 54:41.380 Ich muss das Ganze möglichst schnell machen. 54:41.740 --> 54:44.700 Möglichst so, dass ich mit hohem Durchsatz arbeiten kann. 54:45.280 --> 54:48.000 Nicht aufgehalten durch irgendwelche kürzlichen Abhängigkeiten. 54:49.160 --> 54:54.300 Das ist also die Kunst, diese Architektur auszunutzen, obwohl ich 54:54.300 --> 54:57.260 unterschiedliches Zeitverhalten habe in den Komponenten, dafür zu 54:57.260 --> 55:01.240 sorgen, dass ich nicht verlangsamt werde in den schnellen Einheiten 55:01.240 --> 55:02.400 durch die langsame Einheit. 55:03.480 --> 55:05.540 Schauen wir uns das mal ein kleines Beispiel an. 55:06.160 --> 55:12.200 Wenn ein Befehl zum Beispiel so aussieht, dass wir den Inhalt der 55:12.200 --> 55:15.140 Speicherzelle 500 um 16 erhöhen sollen. 55:16.040 --> 55:16.640 Okay. 55:17.600 --> 55:22.040 Damit ein solcher Befehl ausgeführt werden kann, das soll ja ein 55:22.040 --> 55:22.960 Befehl sein. 55:23.740 --> 55:24.680 Ein Agierbefehl. 55:25.020 --> 55:28.880 Also, das muss ein Agierbefehl sein, der irgendwo im Speicher abgelegt 55:28.880 --> 55:29.260 ist. 55:30.120 --> 55:35.120 Und da muss irgendwo vorne ein Opcode drinstehen, der sagt, ich soll 55:35.120 --> 55:36.320 hier etwas agieren. 55:37.720 --> 55:39.200 Das muss da ja drinstehen. 55:40.260 --> 55:42.900 Jetzt nehmen wir an, das steht irgendwo in der Speicherzelle 1000, das 55:42.900 --> 55:44.000 ist ja völlig egal, wo das steht. 55:45.380 --> 55:46.840 Und da ist also der Befehl drin. 55:47.700 --> 55:51.560 Der Befehl soll irgendwie bedeuten, ich soll den Inhalt der 55:51.560 --> 55:53.860 Speicherzelle 500 um 16 erhöhen. 55:54.200 --> 55:57.780 Ich muss also irgendwo hinschreiben, dass es um die Speicherzelle 500 55:57.780 --> 55:58.220 geht. 56:00.360 --> 56:04.240 Und jetzt soll dieser Wert um 16 erhöht werden. 56:04.920 --> 56:08.220 Ein fester Wert, der soll im Befehl drinstehen. 56:08.280 --> 56:09.540 Das zeige ich mal so an. 56:09.920 --> 56:12.280 Ich sage, ich habe hier ein Doppelkreuz davor und dann schreibe ich 56:12.280 --> 56:13.200 hier 16. 56:14.620 --> 56:16.320 Das ist schon alles in dem Fall. 56:18.540 --> 56:25.780 Agiere auf den Inhalt der Speicherzelle mit Adresse 500 den Wert 16. 56:26.540 --> 56:26.820 So. 56:30.770 --> 56:33.490 Und wir nehmen mal an, hier in der Speicherzelle 500 steht halt 56:33.490 --> 56:34.150 irgendwer drin. 56:34.250 --> 56:35.510 Steht der Wert 17 gerade drin? 56:35.870 --> 56:36.990 Okay, steht irgendwer drin. 56:37.730 --> 56:38.690 Was passiert also? 56:38.750 --> 56:41.610 Ich muss diesen Inhalt meiner Speicherzelle erstmal holen. 56:42.530 --> 56:47.370 Ich muss also den, in der Aufführung von Fetch, aus dem Speicherwerk 56:47.370 --> 56:52.890 zugreifen auf das Speicherwerk, muss den Wert entsprechend holen und 56:52.890 --> 56:55.610 den hier in das Instruktionsregister reinschreiben. 56:55.610 --> 56:59.250 Das ist also der Inhalt, an dem meine Instruktion steht. 57:00.250 --> 57:05.730 Hier im Programme-Counter steht also der Wert 1000. 57:08.750 --> 57:10.450 Dadurch konnte ich überhaupt darauf zugreifen. 57:11.070 --> 57:13.110 Dann muss ich den Wert interpretieren. 57:13.550 --> 57:14.570 Habe ich gerade eben schon gemacht. 57:14.690 --> 57:16.570 Habe ich hier reingeschrieben, das sind die Bestandteile. 57:16.610 --> 57:17.570 Das muss ich erstmal erkennen. 57:19.730 --> 57:22.090 Und das lege ich eben daran, dass die einfach mit Zahl steht. 57:22.090 --> 57:24.710 Und hier steht zum Doppelkreuz vor der 16. 57:24.970 --> 57:26.650 Das heißt, ich muss direkt den Wert nehmen. 57:28.150 --> 57:30.610 Solche Konventionen gibt es halt bei den Befehlen. 57:31.350 --> 57:33.610 Und dann muss ich entsprechend dafür sorgen, dass der Befehl 57:33.610 --> 57:34.730 ausgeführt werden kann. 57:34.830 --> 57:38.650 Ich muss erstmal den Inhalt von Speicherzelle 500 holen. 57:38.710 --> 57:42.970 Ich muss also auf den Speicher zugreifen, auf Speicherzelle 500. 57:44.150 --> 57:45.630 Ich muss den Wert holen. 57:45.690 --> 57:48.050 Der wird also jetzt reingeschrieben in mein Rechenwerk. 57:49.050 --> 57:53.890 Die 16 muss ich reinschreiben in das zweite Register bei dem Addierer. 57:54.830 --> 57:57.950 Ich muss die Addition ausführen, muss das Ergebnis wieder zurück. 57:58.070 --> 58:01.790 Ich soll den Inhalt der Speicherzelle erhöhen, muss also das Ergebnis 58:01.790 --> 58:04.370 wieder reinschreiben in die Speicherzelle 500. 58:05.110 --> 58:09.970 Nochmal den Speicher adressieren, den Wert dort reinschreiben aus dem 58:09.970 --> 58:11.490 Rechenwerk. 58:11.930 --> 58:13.490 Der muss also da reingeschrieben werden. 58:15.010 --> 58:19.270 Und ich muss anschließend den Befehlszähler erhöhen, in dem Fall auf 58:19.270 --> 58:20.010 den nächsten Wert. 58:20.170 --> 58:21.510 Dann steht da also 1000 um 1. 58:22.490 --> 58:24.330 Und das wäre dann der nächste Befehl. 58:24.470 --> 58:25.590 Das Ganze geht nochmal von vorne. 58:25.930 --> 58:29.010 Und Sie sehen, ich habe hier eine Reihe von Operationen, die ich 58:29.010 --> 58:29.650 ausführen muss. 58:30.290 --> 58:32.350 Anzahl der Speicherzugriffe in dem Fall. 58:33.210 --> 58:34.690 Wie oft haben wir zugegriffen? 58:35.230 --> 58:39.350 Wir haben einmal auf den Speicherzelle 1000 zugegriffen. 58:40.190 --> 58:41.110 Den Befehl geholt. 58:41.830 --> 58:45.370 Dann haben wir intern etwas getan, dann dekodieren. 58:46.150 --> 58:49.410 Anschließend haben wir auf Speicherzelle 500 zugegriffen, um den Wert 58:49.410 --> 58:50.130 zu holen. 58:50.970 --> 58:52.070 Wert 17. 58:52.830 --> 58:55.630 Anschließend haben wir die Addition gemacht und das Ergebnis wieder in 58:55.630 --> 58:56.710 den Speicher reingeschrieben. 58:57.270 --> 59:00.990 Das heißt, wir hatten zwei Lesebefehle, ein Schreibbefehl. 59:01.510 --> 59:04.890 Also insgesamt drei Zugriffe auf den Speicher. 59:05.390 --> 59:07.690 Bei der Ausführung eines Befehls. 59:09.150 --> 59:12.370 Jetzt sehen Sie schon, was da alles so intern ablaufen muss. 59:12.910 --> 59:16.330 Wir müssen dafür sorgen, dass diese Zugriffe geeignet funktionieren. 59:17.370 --> 59:21.990 Dass das Speicherwerk, wenn es Anstöße macht, sagt, ich möchte auf das 59:21.990 --> 59:23.630 Speicherwerk zugreifen, ich möchte dort lesen. 59:24.090 --> 59:26.710 Das Speicherwerk muss wissen, es wird gelesen usw. 59:27.090 --> 59:30.270 Dazu gibt es wiederum eine Reihe von internen Steuerbefehlen, 59:30.370 --> 59:33.230 Statusregistern und Ähnliches, die ich hier ausgeblendet habe. 59:33.830 --> 59:34.570 Die sind jetzt irrelevant. 59:35.520 --> 59:37.430 Aber ich habe im Prinzip diesen Ablauf. 59:37.590 --> 59:40.710 Das ist der wesentliche Ablauf bei der Ausführung von Befehlen im 59:40.710 --> 59:41.110 Rechner. 59:41.830 --> 59:44.150 So werden Programme in Rechnern ausgeführt. 59:46.150 --> 59:51.250 Solche einfachen Maschinenbefehlszyklen, das läuft im Rechner ab. 59:52.170 --> 59:54.490 So, jetzt wissen wir, wie das Steuerwerk funktioniert, wie das 59:54.490 --> 59:58.130 Rechensack funktioniert, wie das Speicherwerk im Prinzip funktioniert. 59:58.850 --> 01:00:00.890 Das habe ich zumindest kurz geschrieben. 01:00:00.890 --> 01:00:03.730 Das nächste ist jetzt die eine Ausgabeeinheit. 01:00:04.110 --> 01:00:08.410 Ich muss Daten in den Rechner hineinbekommen und wieder auslesen 01:00:08.410 --> 01:00:08.610 können. 01:00:08.710 --> 01:00:10.230 Ansonsten nützt mir der Rechner nichts. 01:00:12.230 --> 01:00:14.770 Also, wie kann ich Daten und Programme dort hineinbekommen? 01:00:15.330 --> 01:00:19.190 Es gibt eine Vielfalt von Komponenten, mit denen ich Daten in den 01:00:19.190 --> 01:00:20.130 Rechner hineinbekomme. 01:00:20.690 --> 01:00:26.310 Ich kann es über die Tastatur machen, ich kann es über meinen Maus 01:00:26.310 --> 01:00:28.410 machen, ich kann es über einen Stift machen, wie ich das hier mache, 01:00:28.450 --> 01:00:30.350 indem ich hier einfach auf den Bildschirm schreibe. 01:00:31.190 --> 01:00:32.930 Sie können einfach sprechen. 01:00:34.610 --> 01:00:37.370 Sie können auch über Sprache etwas eingeben. 01:00:38.490 --> 01:00:41.490 Zukünftig werden wir immer weniger über Tastaturen arbeiten, sondern 01:00:41.490 --> 01:00:44.830 immer mehr über Taktik, also über Sensoren. 01:00:45.350 --> 01:00:49.530 Druck, Temperatur, Sie werden also Rechner steuern durch Gesten, durch 01:00:49.530 --> 01:00:51.810 Bildbearbeitung. 01:00:52.430 --> 01:00:57.650 Über Sprache, über verschiedenste Arten, wie Sie Informationen in den 01:00:57.650 --> 01:00:58.490 Rechner hineinbekommen. 01:00:58.490 --> 01:01:03.310 Aber im Rechner muss eine Einheit da sein, die diese externen Signale, 01:01:03.390 --> 01:01:07.130 die externen Informationen geeignet aufnimmt und interpretiert. 01:01:08.130 --> 01:01:12.630 Also, diese Sensoren, die angegeben werden, Druck, Temperatur usw., 01:01:12.630 --> 01:01:16.310 tauschen sich insbesondere bei eingefetteten Systemen, in technischen 01:01:16.310 --> 01:01:16.970 Anlagen. 01:01:17.570 --> 01:01:19.990 Wenn Sie eine Heizungssteuerung machen, müssen Sie etwas über die 01:01:19.990 --> 01:01:20.790 Temperatur wissen. 01:01:20.890 --> 01:01:22.750 Sie brauchen einen Temperatursensor. 01:01:22.750 --> 01:01:26.150 Die Information muss entsprechend gemessen und an den Rechner 01:01:26.150 --> 01:01:29.110 weitergeleitet werden, damit er darauf reagieren kann. 01:01:30.210 --> 01:01:35.570 Und wenn Sie einen Roboter steuern, der irgendwie in der Lage sein 01:01:35.570 --> 01:01:40.270 soll, mit einer Hand, mit mehreren Fingern hier irgendein Glas zu 01:01:40.270 --> 01:01:46.670 fassen, damit man also irgendetwas anfassen kann, eine Roboterhand 01:01:46.670 --> 01:01:48.110 soll ein Glas fassen. 01:01:49.110 --> 01:01:51.890 Dann müssen Sie dafür sorgen, dass die Roboterhand nicht das Glas 01:01:51.890 --> 01:01:57.430 sofort zerbricht und zu stark zugreift, dass aber die Roboterhand auch 01:01:57.430 --> 01:02:00.030 nicht zu wenig zugreift, dass das Glas runterfällt. 01:02:00.730 --> 01:02:03.350 Das geht nur über Sensorik, über Drucksensoren usw. 01:02:04.430 --> 01:02:07.110 Vielfältige Sensoren brauchen eine vielfältige Information, die sie 01:02:07.110 --> 01:02:07.810 eingeben können. 01:02:08.510 --> 01:02:10.650 Entsprechend wollen Sie Informationen ausgeben können, über 01:02:10.650 --> 01:02:13.870 Bildschirme, über Drucker, über Lautsprecher, verschiedene Arten und 01:02:13.870 --> 01:02:18.210 Weisen, wie Sie Informationen aus dem Rechner herausbekommen können. 01:02:18.710 --> 01:02:20.950 Wir haben eine Vielfalt weiterer Möglichkeiten. 01:02:21.330 --> 01:02:24.810 Wir haben Geräte, die für eine Grundausgabe zur Verfügung stehen. 01:02:25.430 --> 01:02:30.450 Wir haben Verbindungen zu anderen Rechnern, über verschiedenste 01:02:30.450 --> 01:02:36.210 Komponenten, über Modem, über DSL-Leitungen, über Ethernet, Firewire, 01:02:36.370 --> 01:02:36.790 WLAN. 01:02:37.910 --> 01:02:40.490 Verschiedenste Stichworte sind hier wichtig, wenn es um die 01:02:40.490 --> 01:02:42.810 Kommunikation mit anderen Komponenten geht. 01:02:44.130 --> 01:02:48.210 Ich hatte schon gesagt, Kommunikation über Chip-Grenzen hinweg ist 01:02:48.210 --> 01:02:48.950 langsam. 01:02:49.790 --> 01:02:52.390 Stellen Sie sich mal vor, Sie wollen mit einem anderen Rechner 01:02:52.390 --> 01:02:57.370 kommunizieren, über eine Leitung, über eine Glasfaserleitung oder 01:02:57.370 --> 01:02:59.510 sonst irgendetwas, oder über eine Luftschnittstelle. 01:03:00.250 --> 01:03:05.990 Das dauert dann noch viel länger, als wenn man zugreift auf eine 01:03:05.990 --> 01:03:07.830 Speicherzelle, auf einen Chip. 01:03:08.750 --> 01:03:11.370 Also, Zeitverhalten spielt hier wieder eine große Rolle. 01:03:11.790 --> 01:03:14.830 Eine Ausgabe ist also möglich für verschiedenste Komponenten. 01:03:15.710 --> 01:03:20.390 Sie können auf einen Sekundärspeicher zugreifen, auf Festplatte, auf 01:03:20.390 --> 01:03:25.150 SSD, also Querspeicher, CDs, Kassetten, Magnetband, was immer Sie als 01:03:25.150 --> 01:03:28.790 extra, externe Speicher dort hinzufügen. 01:03:29.670 --> 01:03:35.750 Und Sie können sich auf eines denken, je nachdem, wie Sie und wo Sie 01:03:35.750 --> 01:03:41.370 Informationen ablegen, werden Sie wissen müssen, in welcher 01:03:41.370 --> 01:03:43.370 Reihenfolge werden Sie eigentlich abgelegt. 01:03:44.230 --> 01:03:45.370 Ist das immer die gleiche? 01:03:45.410 --> 01:03:47.670 Sie müssen die Reihenfolge kennen, Sie müssen wissen, was ist die 01:03:47.670 --> 01:03:48.690 Datenstruktur dort? 01:03:49.130 --> 01:03:51.190 Welche Formate habe ich eigentlich in den verschiedenen 01:03:51.190 --> 01:03:51.990 Speichermedien? 01:03:52.950 --> 01:03:58.410 Ich habe einen 64-Bit-Rechner, jetzt werden Daten geschoben auf einen 01:03:58.410 --> 01:04:02.550 32 -Bit-Rechner, dann werden die Daten anders abgelegt, werden anders 01:04:02.550 --> 01:04:03.190 organisiert. 01:04:03.610 --> 01:04:07.630 Ich habe Daten in einem Flash-Speicher oder auf einer Festplatte. 01:04:08.310 --> 01:04:14.150 Auf einer Festplatte habe ich hier irgendwelche Sektoren, irgendwelche 01:04:14.150 --> 01:04:16.810 Ringe, in denen hier meine Daten liegen. 01:04:17.950 --> 01:04:22.670 Völlig anderes Format, als wenn Sie einen Speicher haben, wo Sie feste 01:04:22.670 --> 01:04:26.270 Bereiche haben, auf die Sie irgendwie zugreifen können. 01:04:29.120 --> 01:04:33.400 Oder Sie haben ein Band, Sie können auf dieses Magnetband zugreifen. 01:04:34.140 --> 01:04:37.080 Wie Sie die Daten darstellen, wie Sie sie organisieren, wird völlig 01:04:37.080 --> 01:04:40.480 unterschiedlich sein, je nachdem, ob Sie etwas im Hauptspeicher 01:04:40.480 --> 01:04:44.540 darstellen, auf der Festplatte, auf dem Magnetband, auf der Kassette, 01:04:45.280 --> 01:04:46.240 auf einer DVD. 01:04:47.220 --> 01:04:50.240 Das heißt, Sie müssen Datenkonvertierungen machen, wenn Sie auf 01:04:50.240 --> 01:04:51.800 Dateien zugreifen und ähnliche Dinge. 01:04:51.860 --> 01:04:54.780 Sie müssen wissen, wie die Informationen eigentlich dargestellt 01:04:54.780 --> 01:04:55.280 werden. 01:04:56.480 --> 01:04:58.980 Und wieder ein Punkt, dass man wissen muss, wie kann ich eigentlich 01:04:58.980 --> 01:05:01.860 dafür sorgen, dass diese unterschiedlichen Komponenten mit den 01:05:01.860 --> 01:05:05.740 unterschiedlichen Anforderungen in einer effizienten Art und Weise 01:05:05.740 --> 01:05:08.160 miteinander kommunizieren können. 01:05:08.160 --> 01:05:12.300 Und diese Reihenfolgen, Formate, Geschwindigkeiten der 01:05:12.300 --> 01:05:15.580 Datenübertragung sind sehr unterschiedlich, je nach Gerät, mit dem Sie 01:05:15.580 --> 01:05:15.940 arbeiten. 01:05:17.120 --> 01:05:19.220 Das ist also etwas, was man sich angucken muss. 01:05:19.860 --> 01:05:22.980 Wir hatten gerade einen Bezug auf die Datenablage, später noch ein 01:05:22.980 --> 01:05:24.200 bisschen genauer zum Anfang. 01:05:25.880 --> 01:05:29.880 Wie kann ich jetzt tatsächlich auf die eine Ausgabe einhalten, 01:05:30.000 --> 01:05:30.500 zugreifen? 01:05:30.620 --> 01:05:34.220 Ich hatte schon darauf hingewiesen, dass das Einausgeben in der Regel 01:05:34.220 --> 01:05:34.480 lange dauert. 01:05:35.300 --> 01:05:38.260 Wenn Sie darauf warten, dass jemand über die Tastatur ein Programm 01:05:38.260 --> 01:05:41.800 eingegeben hat, dann hat der Rechner eigentlich nichts mehr zu tun. 01:05:41.920 --> 01:05:46.200 Er wird alle paar Millionen Taktbüchle mal irgendwie eine kleine 01:05:46.200 --> 01:05:47.100 Information bekommen. 01:05:48.380 --> 01:05:50.780 Also wir müssen unterschiedliche Dinge machen. 01:05:50.860 --> 01:05:55.220 Wenn Sie eine feste Zuordnung haben, der CPU auf das Ein-Ausgabe 01:05:55.220 --> 01:06:00.720 -Gerät, dann ist die CPU nur noch am Arbeiten in der Geschwindigkeit 01:06:00.720 --> 01:06:01.920 das Ein-Ausgabe-Gerät. 01:06:02.820 --> 01:06:06.200 Und das heißt, sehr, sehr, sehr langsam. 01:06:07.440 --> 01:06:13.360 Die andere Art ist, meine CPU arbeitet und ich habe einen Ausgabe 01:06:13.360 --> 01:06:14.840 -Vorgang, der abläuft. 01:06:15.520 --> 01:06:19.940 Und wenn der fertig ist, dann wird die CPU auf das Ergebnis zugreifen. 01:06:20.060 --> 01:06:21.940 Kann aber in der Zwischenzeit etwas anderes machen. 01:06:23.340 --> 01:06:28.480 Also Sie haben hier Ihre CPU, die was tut, und Sie haben irgendein IA 01:06:28.480 --> 01:06:28.980 -Gerät. 01:06:28.980 --> 01:06:32.440 Die CPU soll möglichst viel tun können. 01:06:32.800 --> 01:06:36.800 Sie stößt ab und zu mal hier einen Ein-Ausgabe-Vorgang an. 01:06:37.680 --> 01:06:41.920 Und während der Ein-Ausgabe-Vorgang läuft, macht die CPU irgendwas 01:06:41.920 --> 01:06:42.440 anderes. 01:06:42.900 --> 01:06:46.540 Und anschließend kriegt sie ein Signal an die CPU, dass da 01:06:46.540 --> 01:06:47.960 Informationen vorliegen. 01:06:48.160 --> 01:06:50.220 Und dann wird diese Information verwendet. 01:06:51.620 --> 01:06:55.900 Das heißt, unterbrechungsgesteuert bedeutet, die CPU kann etwas 01:06:55.900 --> 01:06:58.600 machen, während Ein-Ausgaben laufen. 01:06:59.900 --> 01:07:03.820 Und sobald die Daten zur Verfügung stehen aus diesem angestoßenen Ein 01:07:03.820 --> 01:07:07.580 -Ausgabe -Vorgang, wird die CPU darauf wieder zugreifen, kann das dann 01:07:07.580 --> 01:07:08.160 schnell machen. 01:07:08.660 --> 01:07:10.960 Und diese langsamen Vorgänge laufen irgendwo im Hintergrund. 01:07:12.440 --> 01:07:16.080 Der Grund ist halt, dass wir wesentlich langsamer sind mit der Ein 01:07:16.080 --> 01:07:17.400 -Ausgabe als mit der CPU. 01:07:17.740 --> 01:07:18.640 Kleines Beispiel. 01:07:20.340 --> 01:07:23.000 Stellen Sie sich vor, Sie haben hier einen schnellen Rechner. 01:07:23.760 --> 01:07:26.960 Also einen PC mit 3 GHz Taktfrequenz. 01:07:28.280 --> 01:07:30.520 Und nehmen wir mal an, Sie können ihn tatsächlich voll ausnutzen. 01:07:30.620 --> 01:07:33.540 Sie können mit 3 GHz Befehle ausführen. 01:07:34.240 --> 01:07:37.700 Und Sie haben Ihren Rechner angeschlossen mit einer DSL-Leitung ans 01:07:37.700 --> 01:07:38.020 Netz. 01:07:38.520 --> 01:07:41.040 16 MBit pro Sekunde. 01:07:41.860 --> 01:07:42.800 Was passiert denn eigentlich? 01:07:42.920 --> 01:07:47.140 Die Kommunikation mit der Außenseite passiert über IP-Pakete, Internet 01:07:47.140 --> 01:07:48.160 -Protokoll -Pakete. 01:07:48.160 --> 01:07:54.680 Diese Pakete haben eine gewisse Mindestgröße, mindestens 576 Byte. 01:07:56.100 --> 01:08:08.260 Ein Byte hat 8 Bit, das sind also etwa 4500 Bit pro Paket, mindestens. 01:08:08.960 --> 01:08:10.440 Meistens haben wir sogar noch deutlich mehr. 01:08:10.560 --> 01:08:16.460 Da haben wir irgendwie 1,5 KB oder auch mehrere Kilobyte Inhalt. 01:08:16.460 --> 01:08:17.760 Die können unterschiedlich groß sein. 01:08:18.280 --> 01:08:21.460 Das ist also Ihr Datenpaket, das Sie normalerweise lesen, wenn Sie 01:08:21.460 --> 01:08:22.880 zugreifen aufs Netz. 01:08:24.200 --> 01:08:25.160 Ein Paket. 01:08:25.660 --> 01:08:27.420 Ein Datenpaket. 01:08:27.860 --> 01:08:30.740 Sie wollen normalerweise auf viel mehr Daten zugreifen. 01:08:31.740 --> 01:08:35.460 Das wissen wir, diese IP-Pakete, Datagramme, nennt man die auch, 01:08:35.680 --> 01:08:36.320 organisiert. 01:08:36.960 --> 01:08:38.660 Jetzt schauen wir uns an, wie viel Zeit wir eigentlich brauchen. 01:08:38.660 --> 01:08:44.520 Na gut, ich habe also meine Leitung, die kann 16 Megabit pro Sekunde 01:08:44.520 --> 01:08:48.740 oder mit der Geschwindigkeit mehr Daten liefern, mit der Bandbreite. 01:08:50.000 --> 01:08:51.360 Wie lange dauert das? 01:08:51.380 --> 01:08:52.700 16 Megabit pro Sekunde. 01:08:52.800 --> 01:08:58.700 Ich brauche etwa 4500 Bit, die müssen erstmal geliefert werden. 01:08:59.560 --> 01:09:03.360 Dann weiß ich, wie viele IP-Pakete ich pro Sekunde bekommen kann. 01:09:03.480 --> 01:09:07.240 Ich weiß, wie viele Befehle ich ausführen könnte pro Sekunde. 01:09:07.240 --> 01:09:11.660 Und da stellen Sie fest, Sie können etwa 900.000 Maschinenbefehle 01:09:11.660 --> 01:09:12.280 ausführen. 01:09:12.720 --> 01:09:18.540 In der Zeit, in der Sie ein IP-Paket einlesen. 01:09:21.900 --> 01:09:28.160 Das heißt, wenn Sie die CPU daran koppeln würden, direkt an das 01:09:28.160 --> 01:09:33.940 Einlesen von IP-Paketen, könnten Sie nur deutlich langsamer arbeiten. 01:09:33.940 --> 01:09:38.700 Das würde deutlich reduziert werden, weil Sie halt nur auf diese 01:09:38.700 --> 01:09:40.000 wenigen Daten zugreifen. 01:09:40.160 --> 01:09:41.620 Sie werden deutlich reduziert. 01:09:41.860 --> 01:09:45.980 In der Zeit, in der Sie auf einen Wert zugreifen außerhalb, könnten 01:09:45.980 --> 01:09:50.600 Sie größenordentlich, nämlich rund eine Million Befehle ausführen. 01:09:52.600 --> 01:09:55.920 Also wenn man sagt, ich mache einfach alles in der Cloud, ganz toll. 01:09:55.920 --> 01:09:58.300 In der Cloud, ich habe hier meinen Rechner. 01:09:59.000 --> 01:10:01.800 Und irgendwo in der Cloud habe ich irgendwo einen Rechner, der 01:10:01.800 --> 01:10:02.680 irgendwas machen kann. 01:10:04.460 --> 01:10:09.900 Nur um ein IP-Paket dort hinzusenden, wieder zurückzuholen, in der 01:10:09.900 --> 01:10:12.900 Zeit könnten Sie lokal ein paar Millionen Befehle ausführen. 01:10:14.480 --> 01:10:18.000 Das könnte also wesentlich schneller lokal sein, als Sie sind, wenn 01:10:18.000 --> 01:10:20.020 Sie hier irgendwo extern das machen. 01:10:20.440 --> 01:10:21.560 Das muss man berücksichtigen. 01:10:22.580 --> 01:10:24.200 Wir haben diese riesigen Zeitunterzüge. 01:10:24.940 --> 01:10:30.180 Natürlich kann man sich das Ganze auch angucken mit höheren 01:10:30.180 --> 01:10:33.000 Geschwindigkeiten, höheren Übertragungsraten, wenn Sie im Festnetz 01:10:33.000 --> 01:10:33.260 sind. 01:10:33.800 --> 01:10:36.540 Also hier bin ich angeschlossen ans Festnetz. 01:10:37.100 --> 01:10:38.560 Da haben wir so 100 Megabit pro Sekunde. 01:10:38.900 --> 01:10:42.040 Vielleicht habe ich auch eine Leitung, die 1 Gigabit pro Sekunde 01:10:42.040 --> 01:10:42.290 unterstützt. 01:10:43.320 --> 01:10:45.560 Dann ist das Verhältnis ein bisschen besser. 01:10:46.380 --> 01:10:49.160 Aber selbst wenn ich 100 Megabit pro Sekunde habe, wären es in dem 01:10:49.160 --> 01:10:52.160 Fall immer noch 140.000 Befehle, die ich dann gleichzeitig ausführen 01:10:52.160 --> 01:10:55.840 könnte, in denen ich ein Amtspaket legen kann. 01:10:56.600 --> 01:11:00.040 Das heißt, Kommunikation ist teuer. 01:11:00.880 --> 01:11:04.680 Und ich muss sehen, dass ich entsprechend den Rechner nicht 01:11:04.680 --> 01:11:07.180 verlangsame, dadurch dass ich zu viel kommuniziere. 01:11:08.440 --> 01:11:11.500 Deswegen macht man das eben so, dass man während der 01:11:11.500 --> 01:11:16.960 Programmausführung einen Ausgabebefehl anstößt. 01:11:18.140 --> 01:11:26.120 Sobald die durchgeführt worden sind, kriegt man eine Information, dass 01:11:26.120 --> 01:11:29.640 die Daten zur Verfügung stehen. 01:11:29.880 --> 01:11:33.360 Dann greift die CPU auf die entsprechenden Werte zu. 01:11:34.160 --> 01:11:36.680 Das, was gerade gemacht wird, wird unterbrochen. 01:11:37.300 --> 01:11:39.480 Und es wird dann entsprechend die nächste Ausgabe der 01:11:39.480 --> 01:11:42.040 Informationseinheit verarbeitet. 01:11:42.040 --> 01:11:46.180 Und das Programm kann dann entsprechend mit der Ausführung des 01:11:46.180 --> 01:11:47.080 Programms fortfahren. 01:11:48.020 --> 01:11:51.540 Das muss halt alles geeignet organisiert sein im Rechner, damit wir 01:11:51.540 --> 01:11:55.200 die Geschwindigkeitsvorteile der schnellen Komponenten nutzen können. 01:11:56.180 --> 01:11:56.860 Gut. 01:11:57.560 --> 01:12:00.860 Jetzt muss man sehen, also deswegen wird eben der Prozessor 01:12:00.860 --> 01:12:02.460 angestoßen, wenn es erforderlich ist. 01:12:02.680 --> 01:12:03.940 Die arbeiten dann nebeneinander. 01:12:04.480 --> 01:12:07.720 Wir haben halt die CPU, die arbeitet hier in einem Ausgabeprozessor 01:12:07.720 --> 01:12:08.360 unter das Datennetz. 01:12:08.360 --> 01:12:12.580 Wir müssen entsprechend dafür sorgen, dass die schön nebeneinander 01:12:12.580 --> 01:12:13.360 arbeiten können. 01:12:13.500 --> 01:12:17.400 Und ab und zu mal Informationen dann schnell zwischen diesen 01:12:17.400 --> 01:12:19.540 Komponenten ausgetauscht werden können. 01:12:22.200 --> 01:12:23.920 Die Übertragungsbandbreiten wachsen. 01:12:24.340 --> 01:12:27.180 Die gehen jetzt immer stärker hoch. 01:12:27.260 --> 01:12:31.200 Wir sind im normalen Datennetz, so auf dem Campus, sind wir bei 100 01:12:31.200 --> 01:12:32.160 Megabit pro Sekunde. 01:12:33.280 --> 01:12:39.620 Wir haben in einigen Bereichen bereits 1 Gigabit Übertragungsraten. 01:12:40.200 --> 01:12:44.560 Man ist in der Lage, auch Terabit-Übertragungsraten zu unterstützen. 01:12:46.640 --> 01:12:52.400 Das heißt, diese Kommunikationsengpässe, die werden kleiner. 01:12:53.560 --> 01:12:57.580 Wenn das noch stärker wächst, muss man in der Lage sein, mit den 01:12:57.580 --> 01:13:01.500 Daten, die dort ankommen, auch schnell genug zu bearbeiten. 01:13:01.500 --> 01:13:05.240 Aber ich hatte Ihnen gezeigt, wie da im Augenblick die Verhältnisse 01:13:05.240 --> 01:13:05.560 sind. 01:13:05.880 --> 01:13:11.400 Das dauert noch, bis der Engpass tatsächlich in den Prozessoren liegt 01:13:11.400 --> 01:13:13.940 und nicht mehr in der Kommunikation. 01:13:15.560 --> 01:13:20.360 Da muss man bewusst sein, was für einen Rechner man hat, wie lange es 01:13:20.360 --> 01:13:24.680 dauert, bis der zugreifen kann auf die externen Informationen. 01:13:25.500 --> 01:13:28.240 Und da muss man entscheiden, was man lokal macht und was man irgendwo 01:13:28.240 --> 01:13:28.840 extern macht. 01:13:30.680 --> 01:13:35.340 Das ist auch ein Teil der einen Ausgabe der Kommunikation von Daten. 01:13:35.380 --> 01:13:38.780 Ich hatte Ihnen erzählt, wie man Rechner-Architekturen organisiert, 01:13:38.820 --> 01:13:40.880 heutzutage mit dem Bus-Konzept. 01:13:41.460 --> 01:13:46.160 Ich habe dort Daten, ich muss Befehle ausführen, ich muss 01:13:46.160 --> 01:13:50.100 Steuerinformationen schicken, Statusinformationen abrufen. 01:13:50.620 --> 01:13:53.220 Das Ganze macht man halt alles über Busse. 01:13:53.220 --> 01:14:00.060 Hier, ich habe also meinen Bus, der die verschiedenen Geräte 01:14:00.060 --> 01:14:01.100 miteinander verbindet. 01:14:02.200 --> 01:14:05.340 Jetzt habe ich also hier eine solche Datensammelschiene. 01:14:07.420 --> 01:14:10.440 Jetzt wollen die alle gleichzeitig zugreifen, meine N-Geräte, die 01:14:10.440 --> 01:14:11.640 wollen alle drauf zugreifen. 01:14:13.360 --> 01:14:15.420 Das muss man auch geeignet organisieren. 01:14:16.020 --> 01:14:17.900 Die können ja nicht alle gleichzeitig drauf zugreifen. 01:14:17.900 --> 01:14:21.860 Wenn einer drauf zugreift, wird die Information sich über den ganzen 01:14:21.860 --> 01:14:22.580 Bus verbreiten. 01:14:23.600 --> 01:14:26.860 Wenn das noch einer macht, soll die Information sich auch verbreiten. 01:14:26.960 --> 01:14:27.980 Das geht aber nicht gleichzeitig. 01:14:29.540 --> 01:14:32.740 Wie kann ich dafür sorgen, dass die Information von einem Gerät 01:14:32.740 --> 01:14:36.840 sinnvoll auf dem Bus landet, sodass ein anderes Gerät das lesen kann? 01:14:37.260 --> 01:14:39.840 Und nicht gestört wird dadurch, dass zwei gleichzeitig zugreifen. 01:14:39.840 --> 01:14:42.920 Das heißt, ich muss diese Zugriffe geeignet organisieren. 01:14:43.900 --> 01:14:47.220 Ich muss dafür sorgen, dass der Bus wieder möglichst mit einer guten 01:14:47.220 --> 01:14:48.600 Bandbreite arbeiten kann. 01:14:49.160 --> 01:14:51.040 Ich muss diese mehr oder weniger ausnutzen können. 01:14:51.700 --> 01:14:55.180 Ich muss natürlich dafür sorgen, dass der Zugriff auf den Bus geeignet 01:14:55.180 --> 01:14:55.920 gesteuert wird. 01:14:56.100 --> 01:14:57.600 Dafür gibt es verschiedenste Verfahren. 01:14:58.040 --> 01:14:59.820 Einige stelle ich Ihnen jetzt ganz kurz vor. 01:15:00.760 --> 01:15:02.400 Ich habe also verschiedene Arten von Bussen. 01:15:02.720 --> 01:15:03.700 Ich muss auch noch darauf achten. 01:15:03.860 --> 01:15:05.760 Ich habe natürlich Daten, die ich verschicke. 01:15:05.880 --> 01:15:06.640 Ich habe Befehle. 01:15:07.400 --> 01:15:08.600 Ich muss Adressen verschicken. 01:15:08.600 --> 01:15:12.600 Die werden häufig über verschiedene Busse nebeneinander übertragen. 01:15:13.240 --> 01:15:16.860 Aber in der Regel fassen wir die einfach zu einem Bus zusammen. 01:15:17.220 --> 01:15:20.000 Logisch geht es darum, wie kann ich auf den Bus zugreifen. 01:15:20.720 --> 01:15:23.820 Tatsächlich muss ich diese verschiedenen Busarten natürlich im Rechner 01:15:23.820 --> 01:15:24.400 unterzeichnen. 01:15:25.980 --> 01:15:29.540 Also Datenübertragung, Adressen muss ich Ihnen herschicken können. 01:15:29.920 --> 01:15:31.700 Ich muss sagen können, was geschehen soll. 01:15:32.100 --> 01:15:36.040 Unterschiedliche Arten von Informationen, die man tatsächlich 01:15:36.040 --> 01:15:37.360 voneinander trennen kann. 01:15:37.360 --> 01:15:43.040 Aber logisch kann ich es auch als einen gemeinsamen Bus betrachten. 01:15:43.880 --> 01:15:46.920 Und mir jetzt überlegen, wie kann ich dafür sorgen, dass die 01:15:46.920 --> 01:15:51.240 Informationen über diese Bündel von Bussen geeignet werden. 01:15:52.760 --> 01:15:55.360 Also wie geschieht eigentlich die Buszuteilung? 01:15:55.420 --> 01:15:58.540 Wie kann ich dafür sorgen, dass eine Komponente sinnvoll auch 01:15:58.540 --> 01:15:59.240 zugreifen kann? 01:15:59.400 --> 01:16:01.020 Also hier sind unsere Komponenten. 01:16:01.060 --> 01:16:04.480 Gerät 1, 2, 3 bis irgendwie N. 01:16:04.480 --> 01:16:08.680 Und jetzt müssen die geeignet drauf zugreifen können. 01:16:09.720 --> 01:16:10.780 Wie macht man das? 01:16:11.700 --> 01:16:13.400 Ich kann es unterschiedlich machen. 01:16:13.560 --> 01:16:17.480 Ich kann eine zentrale Steuereinheit konstruieren. 01:16:18.360 --> 01:16:22.100 Eine Steuereinheit, die dafür sorgt, dass alles wohlgeordnet passiert. 01:16:23.980 --> 01:16:27.000 Und dazu muss die Bussteuereinheit natürlich etwas wissen. 01:16:27.800 --> 01:16:33.460 Ich muss wissen, was will der Teilnehmer eigentlich, was will dieser 01:16:33.460 --> 01:16:34.240 einzelne Gerät. 01:16:35.040 --> 01:16:38.000 Das ist etwas, was also... 01:16:39.180 --> 01:16:40.740 Ich kann das getrennt machen. 01:16:40.820 --> 01:16:47.180 Ich könnte also von jedem Gerät eine Leitung zu meiner Steuereinheit 01:16:47.180 --> 01:16:48.520 haben, zu Bussteuereinheit. 01:16:49.940 --> 01:16:57.540 Und dann muss die Bussteuereinheit sagen, wer jetzt tatsächlich 01:16:57.540 --> 01:16:58.700 zugreifen darf. 01:17:00.080 --> 01:17:03.500 Also das ist hier dieses Abtragen der Teilnehmerwünsche und 01:17:03.500 --> 01:17:06.820 anschließend Zuteilung des Puzzles. 01:17:07.100 --> 01:17:11.000 Zyklisch würde bedeuten, ich habe hier meinetwegen meine Zeitscheibe. 01:17:11.380 --> 01:17:12.280 Hier fange ich an. 01:17:12.920 --> 01:17:16.020 Jetzt teile ich einfach meine Zeitscheibe ein in irgendwelche 01:17:16.020 --> 01:17:16.540 Segmente. 01:17:16.540 --> 01:17:22.100 Hier darf in dem Zeitintervall Gerät 1 zugreifen, da Gerät 2, da Gerät 01:17:22.100 --> 01:17:23.940 3, da Gerät 4, da Gerät 5. 01:17:24.340 --> 01:17:26.360 Das wäre so eine zyklische Buszuteilung. 01:17:27.840 --> 01:17:29.560 Unabhängig von Übertragungswünschen. 01:17:30.700 --> 01:17:35.740 Eine andere Möglichkeit wäre zu fragen, wer möchte denn, sobald ich 01:17:35.740 --> 01:17:38.740 weiß, wer zugreifen möchte, gebe ich dem das Recht. 01:17:40.940 --> 01:17:45.340 Und kann also aus dieser Art und Weise den Zugriff steuern. 01:17:46.160 --> 01:17:48.220 Ich kann es auch ganz dezentral machen. 01:17:50.460 --> 01:17:54.320 Jeder Sender soll für sich entscheiden können, ob der Bus verfügbar 01:17:54.320 --> 01:17:54.620 ist. 01:17:55.900 --> 01:18:00.380 Wenn ich eine gemeinsame Meldeleitung habe, diese rote Leitung hier, 01:18:01.540 --> 01:18:05.240 dann schicke ich also meinen Sendewunsch darauf. 01:18:06.240 --> 01:18:11.880 Und anschließend kommt ein Verfügbarkeitssignal über eine gemeinsame 01:18:11.880 --> 01:18:12.340 Leitung. 01:18:12.440 --> 01:18:15.540 Hier kommt also ein Verfügbarkeitssignal an. 01:18:16.600 --> 01:18:21.720 Und wenn also dieses Komponente 1 senden möchte, wird dieses 01:18:21.720 --> 01:18:23.420 Verfügbarkeitssignal gesendet. 01:18:24.360 --> 01:18:28.460 Und der erste Sendewillige Teilnehmer verschluckt einfach dieses 01:18:28.460 --> 01:18:30.460 Signal und fängt an zu senden. 01:18:31.680 --> 01:18:35.040 Wenn einer nicht senden möchte, gibt er das weiter zum nächsten. 01:18:35.960 --> 01:18:39.300 Und der entscheidet, und der will jetzt vielleicht Nummer 3 nur 01:18:39.300 --> 01:18:39.780 senden. 01:18:40.840 --> 01:18:45.480 Und wenn dieses Senden vorbei ist, das Nutzen des Buses, muss ein 01:18:45.480 --> 01:18:47.040 Freigabesignal geschickt werden. 01:18:47.100 --> 01:18:48.820 Das sind diese drei verschiedenen Farben hier. 01:18:49.400 --> 01:18:53.600 Ein Sendewunsch, hier in rot gekennzeichnet, das ist der Request. 01:18:55.000 --> 01:18:56.760 Das Verfügbarkeitssignal ist das Grant. 01:18:56.760 --> 01:19:00.680 Und Release ist also dann die Freigabe. 01:19:01.700 --> 01:19:04.740 Wenn ich es freigegeben habe und es kommt ein Sendewunsch, dann kann 01:19:04.740 --> 01:19:06.320 ich das Verfügbarkeitssignal schicken. 01:19:07.000 --> 01:19:11.160 Und das Problem ist natürlich, wenn jetzt immer dieser, der mehrfach 01:19:11.160 --> 01:19:18.280 nacheinander das Gerät Nummer 3 senden möchte, hat das Gerät hier am 01:19:18.280 --> 01:19:21.760 Ende überhaupt keine Chance auf den Bus zuzugreifen, weil das 01:19:21.760 --> 01:19:24.880 Verfügbarkeitssignal immer schon vorher verschluckt worden ist. 01:19:24.880 --> 01:19:30.140 Das heißt, ich habe bei diesem Verfahren eventuell ein Problem, dass 01:19:30.140 --> 01:19:32.340 die Zuteilung nicht fair passiert. 01:19:32.780 --> 01:19:36.140 Das heißt, es hat nicht jeder Gelegenheit irgendwann auf den Bus 01:19:36.140 --> 01:19:36.800 zuzugreifen. 01:19:37.740 --> 01:19:41.260 Das muss sich regeln, dass jeder irgendwann zugreifen kann. 01:19:41.480 --> 01:19:44.740 Deswegen ist diese Art der sogenannten Data Chain zwar eine 01:19:44.740 --> 01:19:48.400 Möglichkeit, aber wenn ich viele Zugriffe habe, wird es dazu führen, 01:19:48.520 --> 01:19:52.740 dass einige verhungern, beziehungsweise nicht Zugriff auf den Datenbus 01:19:52.740 --> 01:19:53.040 bekommen. 01:19:54.260 --> 01:19:56.440 Deswegen macht man das zum Teil auch anders. 01:19:56.620 --> 01:20:00.140 Es gibt also die parallele Abfrage, bei der ich den Sendern 01:20:00.140 --> 01:20:01.320 Prioritäten gebe. 01:20:01.460 --> 01:20:05.280 Das war so, jetzt kann man dieses Polling machen, oder wie immer, man 01:20:05.280 --> 01:20:10.560 gibt den Sendern Priorität, sammelt die Übertragungswünsche und 01:20:10.560 --> 01:20:15.600 derjenige mit der höchsten Priorität darf dieses Verfügbarkeitssignal 01:20:15.600 --> 01:20:17.000 nur nehmen. 01:20:17.000 --> 01:20:22.400 Und wenn also hier ein Verfügbarkeitssignal kommt, hat es eine 01:20:22.400 --> 01:20:25.980 Prioritätsangabe und die eigene Priorität ist kleiner als das, was in 01:20:25.980 --> 01:20:29.560 dem Verfügbarkeitssignal drinsteht, muss man es weitergeben zunächst. 01:20:30.180 --> 01:20:34.320 Dann kann man etwas fair organisieren, dass jeder irgendwann die 01:20:34.320 --> 01:20:35.640 Möglichkeit hat, zuzugreifen. 01:20:36.780 --> 01:20:40.680 Wenn immer der Sender höchste Priorität senden darf, dann kann die 01:20:40.680 --> 01:20:43.480 Priorität durch Wartezeiten auch erhöht werden, also damit kriegt man 01:20:43.480 --> 01:20:46.560 dann das hin, dass jeder tatsächlich auch irgendwann eine Zugriff 01:20:46.560 --> 01:20:46.960 bekommt. 01:20:48.200 --> 01:20:50.120 Das andere ist die zyklische Buszuteilung. 01:20:50.580 --> 01:20:55.420 Da würde ich einfach das Berechtigungssignal, einfach zyklisch hier 01:20:55.420 --> 01:20:58.440 durchlaufen lassen, dieses Verfügbarkeitssignal. 01:20:58.900 --> 01:21:01.120 Das heißt, jeder bekommt dieses Signal. 01:21:01.540 --> 01:21:04.120 Wenn er senden will, sendet er einfach, wenn er nicht senden will, 01:21:04.180 --> 01:21:05.140 gibt das einfach weiter. 01:21:05.660 --> 01:21:08.980 Auf diese Art und Weise wandert also das Token hier durch, durch meine 01:21:08.980 --> 01:21:13.360 Geräte und die können nacheinander, je nach Bedarf, den Bus nutzen. 01:21:13.920 --> 01:21:15.900 Das ist der sogenannte Token Ring. 01:21:16.660 --> 01:21:21.040 Eine klassische Architektur für die Kommunikation zwischen Rechnern in 01:21:21.040 --> 01:21:21.580 einem Netz. 01:21:22.440 --> 01:21:25.480 Und das Verfahren, das wir heute überall sehen, ist das sogenannte 01:21:25.480 --> 01:21:28.940 Carrier Sense Multiple Access Verfahren, CSMA-Verfahren. 01:21:29.600 --> 01:21:31.960 Das ist das Verfahren, das im Ethernet zugrunde liegt. 01:21:33.380 --> 01:21:38.020 Alle LANs, Local Area Networks, die meisten arbeiten heutzutage nach 01:21:38.020 --> 01:21:38.920 Ethernet -Prinzip. 01:21:39.460 --> 01:21:44.900 Dabei ist es so, dass jeder Teilnehmer einfach guckt, ist der Bus 01:21:44.900 --> 01:21:45.660 gerade frei. 01:21:47.020 --> 01:21:48.500 Wenn er frei ist, sendet er einfach. 01:21:49.180 --> 01:21:53.700 Jetzt habe ich hier mehrere Geräte, die gucken, ist der Bus frei. 01:21:54.800 --> 01:21:56.580 Wenn der Bus frei ist, ist der für alle frei. 01:21:57.440 --> 01:22:01.060 Und wenn jetzt zwei gleichzeitig sagen, ich möchte senden, dann senden 01:22:01.060 --> 01:22:03.880 sie gleichzeitig und sie haben eine Kollision. 01:22:04.100 --> 01:22:06.820 Das heißt, sie müssen dann Kollisionserkennung machen in der Handlung. 01:22:06.820 --> 01:22:10.700 Wenn wir bei einem Rechner schauen, der verbunden ist mit dem 01:22:10.700 --> 01:22:17.080 Ethernet, mit dem Kabel verbunden ist, dann sehen sie da zwei Lampen 01:22:17.080 --> 01:22:17.820 normalerweise. 01:22:19.040 --> 01:22:20.840 Sie sehen eine grüne Lampe und eine gelbe Lampe. 01:22:21.740 --> 01:22:27.420 Die grüne Lampe leuchtet, wenn sie erfolgreich Daten geschickt haben. 01:22:27.920 --> 01:22:29.900 Gelb leuchtet es auch, wenn sie einen Konflikt haben. 01:22:31.100 --> 01:22:35.420 Konflikt heißt, sie warten oder sie müssen also das Datenvergeben 01:22:35.420 --> 01:22:36.100 nochmal schicken. 01:22:36.780 --> 01:22:41.700 Wenn also nur das gelbe Licht leuchtet, dann haben sie ganz viele 01:22:41.700 --> 01:22:48.040 Kollisionen auf ihrem Ethernet und sie müssen immer wieder Kollisionen 01:22:48.040 --> 01:22:48.560 behandeln. 01:22:49.080 --> 01:22:51.460 Wenn das immer schön nur grün ist, dann haben sie ganz schnelle 01:22:51.460 --> 01:22:52.740 Kommunikationen. 01:22:54.100 --> 01:22:58.020 Dieses Carrier-Sense-Multiple-Access-Verfahren ist das 01:22:58.020 --> 01:23:01.440 Standardverfahren mittlerweile, das natürlich etwas komplizierter ist 01:23:01.440 --> 01:23:04.480 als das, was ich hier sehr vereinfacht dargestellt habe. 01:23:04.480 --> 01:23:09.680 Aber das ist das wesentliche Prinzip, nach dem dieses Verfahren 01:23:09.680 --> 01:23:10.280 arbeitet. 01:23:10.980 --> 01:23:15.620 Ich sende dann, wenn ich feststelle, da ist gerade keine Nutzung da, 01:23:15.740 --> 01:23:17.360 der Kanal ist frei. 01:23:18.160 --> 01:23:20.840 Und wenn mehrere gleichzeitig senden, habe ich eine Kollision. 01:23:22.040 --> 01:23:25.000 Okay, das also zu diesen verschiedenen Busverfahren, 01:23:25.480 --> 01:23:26.340 Zugriffsverfahren. 01:23:27.100 --> 01:23:31.820 Und das Problem ist eben, wenn einer darauf zugreift, ist der gesamte 01:23:31.820 --> 01:23:33.740 Bus dann auch belegt. 01:23:34.880 --> 01:23:41.800 Weil eben bei einem Draht, wenn elektrische Informationen dort drauf 01:23:41.800 --> 01:23:46.360 waren, also Informationsschichten heißen, ich muss eine 1 oder eine 0 01:23:46.360 --> 01:23:46.800 darstellen. 01:23:46.900 --> 01:23:51.340 Eine 1 ist hohe Potenzial, 0 ist niedriges Potenzial. 01:23:51.440 --> 01:23:55.780 Ich muss die gesamte Leitung auf das hohe Potenzial bringen, damit 01:23:55.780 --> 01:23:57.620 dort diese Informationen drauf sind. 01:23:58.700 --> 01:24:01.200 Beim optischen Bus sieht das anders aus. 01:24:01.200 --> 01:24:07.480 Beim optischen Bus, da kann ich Informationen reinschicken, in einer 01:24:07.480 --> 01:24:08.880 bestimmten Richtung laufen lassen. 01:24:09.040 --> 01:24:12.780 Und da kann ich tatsächlich optische Signale nacheinander 01:24:12.780 --> 01:24:13.440 raufschicken. 01:24:13.880 --> 01:24:16.500 Die laufen in einer bestimmten Richtung darüber, ich kann also 01:24:16.500 --> 01:24:17.480 zugreifen hier drauf. 01:24:17.620 --> 01:24:25.120 Ich kann gleichzeitig von mehreren Komponenten, i und j, zugreifen auf 01:24:25.120 --> 01:24:27.510 diesen Bus, kann Informationen reinschieben. 01:24:27.510 --> 01:24:31.390 Ich muss dafür sorgen, dass eben nicht, wenn hier schon was 01:24:31.390 --> 01:24:34.150 durchläuft, da was anderes reingeschrieben wird. 01:24:34.730 --> 01:24:37.630 Also ich muss auch dafür sorgen, dass was da eigentlich passiert, 01:24:37.770 --> 01:24:38.810 keine Konflikte auftreten. 01:24:39.330 --> 01:24:42.910 Aber ich kann auf diesem Bus, der unidirektional ist, beim optischen 01:24:42.910 --> 01:24:45.830 Bus, Informationen übertragen. 01:24:45.950 --> 01:24:50.830 Und ich kann eben insbesondere eine Datenübertragung anstoßen und dann 01:24:50.830 --> 01:24:51.570 die nächste machen. 01:24:51.710 --> 01:24:54.990 Und die nächste kann mehrere nebenläufig aufeinander laufen lassen. 01:24:54.990 --> 01:24:58.550 Ich kann also mehrere Datenpakete hier drauf haben, die nacheinander 01:24:58.550 --> 01:24:59.350 dort durchlaufen. 01:24:59.470 --> 01:25:01.390 Das heißt, der Bus kann anders ausgenutzt werden. 01:25:02.210 --> 01:25:04.850 Aber er ist eben unidirektional, nicht bidirektional. 01:25:05.650 --> 01:25:10.830 Er ist deutlich schneller, hat diese Möglichkeit des Pipelining, also 01:25:10.830 --> 01:25:15.250 gleichzeitigkeit, hier angedeutet, mehrere Operationen, mehrere 01:25:15.250 --> 01:25:16.530 Datenübertragungen gleichzeitig. 01:25:17.530 --> 01:25:21.270 Und ich habe über optische Busse um Größenordnung bessere 01:25:21.270 --> 01:25:25.510 Kommunikationsmöglichkeiten als über elektrische Busse. 01:25:26.090 --> 01:25:30.290 Habe aber auch natürlich den Aufwand, von elektrischen Informationen 01:25:30.290 --> 01:25:32.490 auf optische Informationen umzuwandeln. 01:25:33.210 --> 01:25:36.690 Auch das kostet wieder Zeit, muss man berücksichtigen, muss geeignet 01:25:36.690 --> 01:25:37.190 passieren. 01:25:38.190 --> 01:25:40.110 Dazu gibt es interessante Technologien. 01:25:40.110 --> 01:25:42.930 Die zum Teil auch hier in Karlsruhe entwickelt werden in 01:25:42.930 --> 01:25:43.770 Elektrotechnik. 01:25:44.930 --> 01:25:51.630 Da sind einige der Gruppen, die weltweit führende Technologien bei der 01:25:51.630 --> 01:25:52.870 optischen Kommunikation entwickeln. 01:25:53.830 --> 01:25:57.870 Also das sind sehr interessante Technologien, die die Kommunikation 01:25:57.870 --> 01:25:58.970 deutlich verbessern. 01:25:59.870 --> 01:26:04.430 Aber in der Regel haben wir es halt mit Kommunikation zu tun über 01:26:04.430 --> 01:26:08.450 elektrische Leitungen, über ein Draht oder über die Luftschnittstelle. 01:26:08.450 --> 01:26:12.070 Und entsprechend dauert das dann länger und wir müssen die 01:26:12.070 --> 01:26:15.250 Eigenschaften dieser Datenkommunikation geeignet durchführen. 01:26:16.930 --> 01:26:19.890 So, jetzt kommen wir schon zum nächsten Abschnitt. 01:26:20.530 --> 01:26:24.430 Nämlich dazu, dass wir dafür sorgen müssen, dass wir mit diesem 01:26:24.430 --> 01:26:30.250 Problem, das ich Ihnen gerade immer wieder betont habe, nicht wirklich 01:26:30.250 --> 01:26:31.390 viel zu tun haben. 01:26:31.390 --> 01:26:37.130 Das Problem war, dass wir von der CPU immer wieder zugreifen müssen 01:26:37.130 --> 01:26:41.610 auf unseren Arbeitsspeicher und vom Arbeitsspeicher Informationen 01:26:41.610 --> 01:26:42.010 brauchen. 01:26:42.150 --> 01:26:44.990 Das heißt, wir haben hier viele Informationen, die hin und her 01:26:44.990 --> 01:26:47.570 geschoben werden müssen und das dauert halt einfach länger. 01:26:48.270 --> 01:26:50.590 Das ist der sogenannte Von-Neumann-Engpass durch diesen 01:26:50.590 --> 01:26:55.390 Maschinenbefehlszyklus mit dem Hin-und-Her-Schieben von Informationen, 01:26:55.390 --> 01:27:00.370 von Befehlsinformationen aus dem Speicher in die CPU und das Ausführen 01:27:00.370 --> 01:27:04.750 der Befehle in der CPU, dass das einfach lange dauert. 01:27:05.890 --> 01:27:08.770 Da muss man sich überlegen, kann man das irgendwie anders machen? 01:27:09.630 --> 01:27:12.650 Wäre es möglich, das anders zu organisieren? 01:27:12.810 --> 01:27:18.210 Ja, also das kann ja nur sein, dass ich vielleicht Operationen nicht 01:27:18.210 --> 01:27:21.410 nur in der CPU ausführe, sondern auch im Speicher. 01:27:22.230 --> 01:27:25.650 Wie kann ich im Speicher Informationen ausführen? 01:27:26.550 --> 01:27:29.690 Da muss ich ja Verarbeitungseinheiten im Speicher haben. 01:27:30.390 --> 01:27:31.590 Viele kleine Prozessoren. 01:27:32.430 --> 01:27:33.030 Macht das Sinn? 01:27:33.830 --> 01:27:37.890 Auf jeden Fall habe ich diesen Engpass und ich muss damit geeignet 01:27:37.890 --> 01:27:38.150 umgehen. 01:27:38.230 --> 01:27:40.790 Das ist der sogenannte physikalische Von-Neumann-Engpass. 01:27:40.930 --> 01:27:45.930 Durch die Architektur bedingt, der Maschinenbefehlszyklus hat diese 01:27:45.930 --> 01:27:48.230 strenge Sequenzialisierung aller Berechnungen. 01:27:48.230 --> 01:27:54.490 Und das führt dazu, wenn ich ein Programm mir ausdenke, dass ich ja 01:27:54.490 --> 01:27:56.290 weiß, alles wird sequenziell ausgeführt. 01:27:56.350 --> 01:27:59.150 Ich muss mir die richtige Reihenfolge meiner Befehle ausdenken. 01:28:00.150 --> 01:28:03.350 Und auf einmal schreibe ich meine Programme so, dass ich jede 01:28:03.350 --> 01:28:07.350 Reihenfolge der Ausführungen von Befehlen schon mal vorgebe. 01:28:07.870 --> 01:28:10.730 Und ich habe dann den sogenannten intellektuellen Von-Neumann-Engpass, 01:28:11.330 --> 01:28:14.730 der einfach dazu führt, dass ich mir viel zu viel überlege. 01:28:15.850 --> 01:28:19.610 Eine ganz strenge Sequenzialisierung, wenn ich also Zahlen addieren 01:28:19.610 --> 01:28:20.010 will. 01:28:20.490 --> 01:28:26.750 A plus B plus C plus D plus E und so weiter. 01:28:28.110 --> 01:28:31.550 Da sage ich erst diese Operation, dann die, dann die, dann die. 01:28:32.510 --> 01:28:38.470 Das heißt, ich mache so etwas wie A, B, die beiden werden addiert. 01:28:40.350 --> 01:28:44.710 Dann wird addiert, dann wird wieder addiert, da kommt ein C drauf. 01:28:45.630 --> 01:28:48.630 Und dann wird wieder addiert, da kommt ein D drauf. 01:28:48.810 --> 01:28:52.130 Wird wieder addiert, kommt ein E drauf und so weiter. 01:28:54.010 --> 01:28:55.050 Muss das wirklich so sein? 01:28:55.130 --> 01:28:56.550 Ich könnte es ja auch anders organisieren. 01:28:56.690 --> 01:29:00.450 Ich könnte ja auch A und B addieren, A und B addieren. 01:29:01.010 --> 01:29:03.470 Ich könnte C und D addieren. 01:29:04.570 --> 01:29:06.210 Ich könnte die beiden dann addieren. 01:29:06.870 --> 01:29:09.550 Ich könnte auch einen Baum anordnen. 01:29:09.750 --> 01:29:13.850 Ich hätte das gleiche Ergebnis, es sei denn, ich habe die 11-wertigen 01:29:13.850 --> 01:29:15.750 Daten und hätte da diese Probleme. 01:29:16.050 --> 01:29:18.570 Aber zunächst einmal habe ich ja Freiheitsgrade. 01:29:19.270 --> 01:29:23.090 Warum muss ich mir Gedanken machen darüber, in welcher Reihenfolge 01:29:23.090 --> 01:29:26.690 diese Operationen ausgeführt werden, wenn es doch völlig egal ist? 01:29:27.250 --> 01:29:31.070 Dann soll doch bitte der Rechner das machen, dass er festlegt, ob ich 01:29:31.070 --> 01:29:34.970 so ausführe oder so ausführe, wenn er in der Lage ist, solche 01:29:34.970 --> 01:29:37.130 Operationen parallel zu machen, soll er das bitte tun. 01:29:37.990 --> 01:29:39.430 Und ich will mir nicht die Gedanken machen. 01:29:39.890 --> 01:29:43.250 Wenn ich es aber im Programm vorgegeben habe, dann kann der Rechner 01:29:43.250 --> 01:29:44.730 nicht anders vorgehen als so. 01:29:46.510 --> 01:29:52.730 Das heißt, dieser intellektuelle Phenomenenpass kann dazu führen, dass 01:29:52.730 --> 01:29:56.250 ich unnötige Reihenfolgen festlege, die gar nicht notwendig sind. 01:29:57.150 --> 01:30:00.890 Man sollte also dafür sorgen, dass man sich möglichst wenig darauf 01:30:00.890 --> 01:30:04.890 tatsächlich bezieht, sondern möglichst viel der internen Optimierung 01:30:04.890 --> 01:30:05.230 wert ist. 01:30:06.230 --> 01:30:06.510 Okay. 01:30:07.070 --> 01:30:11.650 Also diese beiden Engpässe physikalisch, bedingt durch die 01:30:11.650 --> 01:30:15.930 tatsächlichen physikalischen Strukturen, intellektuell, ich muss gar 01:30:15.930 --> 01:30:20.310 nicht auf der Problemebene mich zu sehr mit diesen Reihenfolgen 01:30:20.310 --> 01:30:20.870 beschäftigen. 01:30:20.870 --> 01:30:25.110 Manchmal ist es sinnvoll, aber bitte nur dann, wenn es aufgrund der 01:30:25.110 --> 01:30:26.250 Randbedingungen möglich erfordert. 01:30:27.270 --> 01:30:31.330 Und jetzt gibt es also eine ganze Reihe von Konzepten, um diesen 01:30:31.330 --> 01:30:32.850 Engpass zu beseitigen. 01:30:33.930 --> 01:30:38.130 Es gibt die Möglichkeit, komplexe Datentypen schon in der Hardware 01:30:38.130 --> 01:30:45.430 anzugeben, dass ich also nicht einfach jede Datenstruktur, ich habe 01:30:45.430 --> 01:30:51.290 einen Baum, ich habe einen Graphen, ich habe irgendeine Rekordliste in 01:30:51.290 --> 01:30:55.310 Programmiersprachen, im Rechner habe ich immer meine sequenzielle 01:30:55.310 --> 01:30:58.350 Folge von einzelnen Details oder einzelnen Daten. 01:30:59.710 --> 01:31:03.710 Eine komplexe Struktur immer so abzubilden, ist nicht unbedingt 01:31:03.710 --> 01:31:04.330 sinnvoll. 01:31:05.050 --> 01:31:06.750 Dann kann ich das ja in der Hardware unterstützen. 01:31:07.950 --> 01:31:11.510 Deswegen möchte man das irgendwie geeignet machen, das unterstützen 01:31:11.510 --> 01:31:12.870 durch entsprechende Strukturen. 01:31:13.690 --> 01:31:18.490 Und dann kann ich dafür sorgen, dass ich in der Hardware bereits 01:31:18.490 --> 01:31:22.430 Informationen habe über die Struktur und kann dann besser darauf 01:31:22.430 --> 01:31:22.930 zugreifen. 01:31:23.850 --> 01:31:28.070 Also, wenn ich weiß, ich habe ganze Zahlen, ich habe Rekorde oder 01:31:28.070 --> 01:31:33.790 Matrizen, ich habe eine verkettete Liste, einfach verkettet oder 01:31:33.790 --> 01:31:36.170 doppelt verkettet oder was immer, ich habe eine Schlange, ich habe 01:31:36.170 --> 01:31:39.770 einen Keller, ich habe eine Datei, ich habe irgendein Objekt, dann 01:31:39.770 --> 01:31:42.750 möchte ich eigentlich beim Zugriff auf meinen Speicher wissen, ich 01:31:42.750 --> 01:31:46.330 greife auf ein Objekt zu, auf den ganzen Bereich, und möchte dieses 01:31:46.330 --> 01:31:51.170 Objekt in einem Zugriff sinnvoll daraus holen können und nicht 01:31:51.170 --> 01:31:53.750 sequenziell jede einzelne Einheit daraus holen. 01:31:54.570 --> 01:31:58.470 Also die Serialisierung will ich möglichst vermeiden. 01:31:59.330 --> 01:32:02.070 Und wie man das geeignet macht, wie man also die Leistungssteigerung 01:32:02.070 --> 01:32:04.130 hinbekommt, das schauen wir uns dann am Montag an. 01:32:04.270 --> 01:32:06.170 Vielen Dank für die Aufmerksamkeit, wir sehen uns am Montag.