Ja, bevor ich jetzt die letzte Woche vor Weihnachten
ein Leute noch kurz zwei Anmerkungen beziehungsweise Ergänzungen.
Zum einen hatte ich jetzt hier auf der Webseite noch irgendwie kurz angemerkt,
weil das jetzt also quasi auch die letzte Übungsaufgabe noch betroffen hatte,
weil mich da so die Übungsgruppenleiter noch darauf angesprochen hatten.
Bei der Klassifikation von Hasarz
Stand auch ursprünglich mal auf den Folien, beziehungsweise steht jetzt immer noch drauf.
Also es gibt immer unterschiedliche Sichtweisen, betrachtet man den,
in Anführungszeichen, falschen Wert als Hazard und sagt, okay,
wenn ich eine Eins haben möchte und es taucht zwischenzeitlich eine Null auf,
dann ist das eine Null Hazard oder betrachte ich den in Anführungszeichen richtigen Wert als das,
was ich da nehme.
Und in dem Fall wäre das dann eben ein Eins-Hazard. Das heißt also,
da gibt es eigentlich zwei unterschiedliche Arten und Weisen,
wie man das interpretieren kann, wenn man so ein bisschen guckt,
in der Literatur wird das eben auch nicht einheitlich verwendet.
Also so hatte ich das dann eigentlich auch entsprechend auf den Folien schon angemerkt.
Trotzdem kamen jetzt also in den Übungsraum teilweise die Frage hoch,
ja, wie ist das denn jetzt eigentlich zu verstehen?
Weil wenn man also jetzt im Internet nachsieht,
ist meistens die Interpretation anders gewesen als das,
was sich da ursprünglich auf den Folien mal drauf hatte.
Letztendlich habe ich jetzt gesagt, für die Übungsgruppenleiter, okay,
ist es egal, ob man das jetzt so oder so rum begründet,
das sollte halt eben nur irgendwie konsistent gehandhabt werden.
Letztendlich kann man eben sagen, der eine Autor macht das so,
der andere macht das so. Ich habe daraufhin also jetzt auch noch mal so ein bisschen bei mir in den Folien,
dass also noch mal kurz umformuliert, muss zugeben,
ich habe jetzt also versucht,
das so ein bisschen zurückzuvollziehen und selbst lange vor meiner Zeit,
also in den 1980er Jahren,
wo das immer schon zumindest hier in Hamburg so gehandhabt,
wie ich das jetzt auch vorgestellt hatte,
was aber wie gesagt dann also teilweise auch anders ist.
Gut, also wie gesagt, nur das einmal als Anmerkung.
Dazu, nicht von da kann ich sagen, keine Angst,
es wird in der Klausur Also nicht gefragt und man gibt da also irgendwie eine falsche Antwort.
Also der Fall wird nicht kommen. Von daher, wie gesagt,
dann hier nur noch mal der Verweis drauf. Gut,
zweite Anmerkung in der, nehmen wir den hier, aktuellen Übungsaufgabe,
die seid heute quasi online ist, gibt es als Weihnachtsgeschenk,
die allgemein übliche Aufgabe, Installation und Testegnood-Toolchain.
Das ist ein bisschen Vorbereitung auf das,
was dann später mal irgendwie so in Richtung Assembler kommen wird
Wo man dann also einfach jetzt mal irgendwie für beispielsweise Programmiersprache 10 Assembler,
also was ich auf dem Rechner oder irgendwas am Laufen haben sollte.
In dem Fall geht es also darum,
also jetzt einfach ein fertig vorgegebenes Programm,
was nichts anderes ist als so ein bisschen Hello World im Prinzip.
Nämlich also Print, meine Marc-Strickel-Nummer ist und dann ist da
nur irgendwie ein passender String einzusetzen.
Dieses Programm einmal selber in Assembler-Code zu übersetzen und sich
den mal kurz anzusehen. Das ist danach eigentlich schon die
gesamte Schwierigkeit bei der Aufgabe
Das kann man jetzt natürlich machen, wenn man irgendwie an
Rechner mit einem lauffähigen Linux und einen GCC installiert hat,
was sicherlich nicht alle von ihnen haben werden.
Das kann man machen, indem man unter Windows
die entsprechende Compiler-Umgebung aufsetzt. Das kann man natürlich machen,
wenn man jetzt also irgendeinen anderen C-Compiler nimmt,
den man jetzt also vielleicht auf seinem Rechner drauf hat,
wobei man dann eben wissen muss,
wie man also quasi daraus den Assembler-Code erzeugt.
Das kann bei uns im Rechenzentrum bzw. bei uns anderen Rechner an
den Poolräumen erfolgen oder als dritte Möglichkeit, und das ist eigentlich,
weswegen ich das Ganze jetzt hier nur noch kurz vorstelle,
Kann man das folgendermaßen machen, dass man eine sogenannte virtuelle Maschine einsetzt?
Das heißt, ein virtuelles komplettes Betriebssystem, Rechner,
CPU-Speicher, alles, was emuliert wird auf dem eigenen Rechner.
Und da ist es dann egal, ob man also ein
Windows oder ein Mac-OS oder ein Linux am Start hat.
Man muss dann eben nur diese entsprechende Emulationssoftware installiert haben.
Deswegen wollte ich da jetzt nur mal darauf hinweisen,
das Ganze ist also auch in Stile verlinkt,
findet sich dann also hier Auch auf der Webseite,
beziehungsweise der Link ins Diene geht dann auch hier drauf,
wo dann also im Prinzip drin steht, was man dafür braucht,
wie man das macht.
Kann man eben mit Oracle Virtual Box oder mit VMware Workstation
Player importieren dort ausführen. Das sind also beides Produkte,
die man quasi frei verfügbar sich runterladen und installieren kann. Und das,
was dann dort als virtuelle Maschine läuft, ist dann eben ein komplettes 32-Bit-Linux,
was ich also versucht habe in der Installation soweit,
also irgendwie abzuspecken, dass man also noch mit einigermaßen wenig Footprint auskommt.
In diesem Fall ist also da die virtuelle Festplatte,
die man sich runterladen muss, also nur 1,4 Gibby bald groß.
Nichtsdestotrotz sollte man das natürlich tunlichst dann,
also irgendwo im Informatikum irgendwo direkt an einem der Rechner dort machen,
um sich das dann also auf den Stick oder sowas runterzuziehen, weil das sonst natürlich, also doch ein bisschen mehr an Daten erfordert. Gut,
anschließend könnte man das dann eben in irgendwelche Virtualisierungssoftware importieren,
also das ist jetzt hier quasi von VM wer,
Und in diesem Fall ist das schon die etwas größere Version,
wo ich dann also hier unter Open dann einfach sagen kann,
okay, ich nehme dann eben diese entsprechende Maschine,
also in diesem Fall wäre, dass jetzt hier irgendwo,
in dem Fall habe ich das System im Datalsystem abgespeichert,
das war jetzt nicht so schlau,
dann habe ich hier also quasi diese Datal würde ich dann entsprechend importieren bei Virtual Box,
sieht das genauso aus und anschließend hat man dann also hier sowas,
wo ich dann eben sagen kann, ein virtueller PC,
Ein Gigabyte Hauptspeicher, zwei Prozessoren, ein bisschen Festplatte,
Netzwerk,
vordefinierten Benutzer namens RS-Demo mit diesem kryptisch schwierigen Passwort.
Und ich kann jetzt also die VM mal starten in der Hoffnung,
dass das jetzt nicht ganz so grausig aussieht, also bei dieser hervorragenden Auflösung,
die ich also hier jetzt nur über den Beamer bekomme.
So, und wenn das dann alles gestartet ist,
hat man also dann hier einen Desktop,
Also natürlich jetzt noch irgendwie zu klein und deswegen scrollbar.
Da habe ich ja so ein kleines Linux-System.
Ich wurde hier automatisch eingeloggt und könnte jetzt hier zum Beispiel Hades
starten mit sämtlichen Wahlspielen, die also hier vorinstalliert sind.
Ich könnte dann aber hier in so einem Terminal dann eben
auch irgendwie jetzt ein Programm mir runterladen und dann mit einem Compiler übersetzen,
habe also hier dann quasi installierten passenden GCC,
um also das, was in dieser Aufgabe gefordert ist,
beispielsweise auszuführen
Gut, also das nur kurz zu dieser Info mit der virtuellen Maschine.
So, jetzt wollen wir das Ganze immer wieder beenden.
Sagt, das System hat sich runtergefahren. Gut,
ja, also wie gesagt, das etwas,
wenn man das ausprobieren möchte, als eine von vielen möglichen Varianten,
wie man also mit diesem C-Code beziehungsweise dieser Aufgabe 10.4 umgehen kann.
Ja, ansonsten hatte ich ja letzte Woche kurz angefangen,
angefangen, also jetzt noch so ein bisschen Hardware-Komponenten zu erläutern,
die man also insgesamt jetzt noch in so einem Computersystem, also zur Verfügung hat.
Ich war, wie gesagt, wir haben kennengelernt,
Schaltnetze, beispielsweise dann eben in Form von Alus,
also den Rechenwerken in dem System. Wir haben kennengelernt,
Schaltwerke, endliche Automaten zur Steuerung von irgendwelchen Abläufen und dann hatte ich gesagt,
braucht man natürlich noch irgendwie sowas wie Speicher,
sah das dann eben Rahmen als Lesbar bzw. schreibbarer Speicher oder sei das Rom,
also speichert der letztendlich dann nur gelesen wird.
Beim Rom hatte ich gesagt, wird das also quasi über,
je nachdem, wie das technologisch ausgelegt wird, aber eben irgendwie fest.
Reinprogrammiert werkseitig beim Rahmen, das ist eigentlich das,
was wir als normalen Speicher-Arbeitsspeicher des Rechners bezeichnen,
den man dann eben entsprechend einzeln weitweise adressieren kann und dort eben seine Werte abspeichern kann.
Von der Grundidee her hatte ich,
das war ja so quasi das Freund mittig,
letzte Woche aufgehört hatte, kann man das Ganze dann eben so sehen,
dass man sagt, okay, ich habe jetzt also hier irgendwie.
Hab recht, dekodierung,
adressieren wir dann eben hier so ein Speicherwort in diesem Fall,
also ein sehr großes mit 4-Bit und hab dann eben sowas für so eine ledgeartige Struktur,
wo ich dann eben die Werte speichern kann und eben über so eine Enable-Leitung eben entweder sagen,
ich möchte reinschreiben oder ansonsten wird eben gelesen und dann hat man hier dann noch so eine Busschnittstelle,
mit der man dann eben sagen kann,
der Ausgangswert geht letztendlich raus.
Das ist erstmal die Grundidee oder das Programmierverständnis,
wie wir jetzt also Speicher sehen würden,
rein technisch ist das meistens dann doch deutlich anders noch realisiert.
Also zum einen hat man das typischerweise so,
dass der Speicher so aufgebaut wird,
dass ich im Prinzip so ein zwar dimensionales RA wie hier habe und dazu nutze,
dass ich die Adresse, mit der ich also meinen Speicher adressiere,
in Zahlenadresse und Spaltenadresse unterteile.
Das heißt, ich habe jetzt nicht insgesamt eine Dekodierung von
Inbit in zwei hoch in Speicherworte,
sondern ich unterteile diese N mit dann eben nochmal einmal in ein zahlenweise Adressierung,
in eine Spaltenweise Adressierung, lese dann also hier quasi letztendlich
nur sowas wie ein Witt oder eben irgendeine Einheit von einigen wenigen Witt.
Habe dafür aber eben den Vorteil,
dass also hier dieser Dekoda dann nicht mehr zwei hoch N unterscheiden muss,
sondern nur noch zwei hoch in halbe,
was natürlich dann entsprechend schon einen riesigen Unterschied in einem Termin technischen Aufwand macht.
Das ist also das, weswegen man das hat.
Führt dann aber eben auch dazu, dass typischerweise dann eben
diese Adressen auch in der Regel zwischengespeichert werden.
Das heißt, da gibt es also Ledges oder Register,
die dann eben diese Adresse noch irgendwo zwischenspeichern.
Da führt dann eben auch dazu was. Also dann gleich noch vorgekommen wird,
dass die meisten Speicher, die wir dann eben so haben,
dann eben jetzt nicht nur als Schaltennetz fungieren. Das heißt,
ich lege eine Adresse an und sage, okay,
das dauert eine Zeit, dann habe ich mein Speicherwort rausgelesen,
sondern die haben dann eben auch noch Taktleitungen,
die dann eben dazu dienen, quasi das Ganze zeitlich zu synchronisieren und eben hier Zeilen und Spaltenadresse irgendwo reinzuspeichern.
Dann wird beim Speicher immer noch unterschieden zwischen statischem und dynamischen Rahmen.
Beim statischen Rahmen sieht das so aus, dass die Informationen gespeichert bleibt, solange die Betriebsspannung da ist. Wenn ich den Rechner ausschalte,
ist die Information weg, wenn ich jetzt nicht gerade noch irgendeinen Flash-Speicher habe,
was man also zum Beispiel jetzt bei Mobilgeräten typischerweise dann auch immer noch irgendwie als Hauptspeicher mit einsetzt,
muss man halt eben dafür sorgen,
dass die Informationen dann vorher irgendwo auf die Festplatte oder eben irgendein anderes Medium dann wieder noch zurückgespeichert wird, um dann wieder beim Einschalten quasi neu geladen werden kann.
Ja, dann ist hier noch kurz beschrieben,
wie das Ganze letztendlich so ein bisschen technisch realisiert wird.
Da will ich jetzt also auch gar nicht größer drauf eingehen
Die Idee ist, ich möchte jetzt ja sowas wie ein Witch speichern.
So, jetzt haben wir also schon kennengelernt,
da gibt es sowas wie dieses Basis-RS-Flip-Flop mit diesen Rückgekoppelten nennt oder Norgattern,
wo ich das machen kann.
Ist aber doch immer noch vergleichsweise aufwendig,
weil da kann ich sagen, naja gut,
also selbst in so einem Basis-RS-Flip-Flop mit zwei Norgattern bräuchte ich
für die Speicherung letztendlich, also schon mal mindestens acht Transistoren.
Dann brauche ich aber noch irgendwie diese ganze Ansteuerung jetzt für diese R&S-Leitung.
Deswegen benutzt man da quasi folgenden Trick für die Speicherung,
dass man sagt,
ich habe einen Inverter
Und dann kommt ein zweiter Endwärter. Und das Ganze ist
immer so auf sich zurückgekoppelt. So, das heißt,
wenn hier irgendwie eine Null steht,
habe ich hier eine Eins, und hier wieder eine Null.
Und das Ganze ist letztendlich stabil. So,
und der Trick ist jetzt, dass man sagt,
okay, dass die eine Möglichkeit anderer Möglichkeit,
ich habe hier eine Eins, hier eine Null und hier eine Eins.
Und jetzt muss ich nur noch dafür sorgen,
dass ich hier diese Werte verändern kann.
Dafür gibt es dann eben die Möglichkeit,
eben quasi hier und hier explizit Werte aufzuzwingen,
die quasi jetzt das, was hier gegebenenfalls gespeichert ist, überschreiben können.
Und das Ganze kriegt man dann eben relativ trickreich dadurch hin,
dass man sagt, ich habe also diese beiden Rückgekoppelten in Wärter.
Das ist diese Struktur in der Mitte. Das sind vier
Transistoren in C-Mods-Technik. Ich habe jeder noch zwei sogenannte Parts-Transistoren.
Und damit kann ich sagen, ich kann eben von hier oder von hier,
beziehungsweise von beiden Seiten muss ich das machen,
diese Werte überschreiben.
Das heißt, damit schafft man das mit sechs Transistoren
Ein Bit zu speichern. Das ist die Art und Weise
, wie in Esram funktioniert. Deswegen findet man dann auch
immer teilweise sechstransistische Speicherzelle oder sechs T. Funktionalität von dem Ganzen
müsste jetzt also ein bisschen in die Seemos-Technik gehen.
Will ich jetzt also nicht weiter erklären, wen es interessiert. Wie gesagt,
das Ganze kann man auch in hartes Laden und simulieren und
in Hardesk gibt es dann auch noch so ein bisschen Beschreibung, wo also diese Switch-Level-Technik drin ist.
Also Grundidee ist, dass man einfach sagt,
also Transistor nutze ich jetzt nicht irgendwie als analoges Bauelement,
sondern das ist ein Schalter, den kann ich aufmachen oder zumachen,
unter bestimmten Bedingungen und damit kann ich dann eben wirklich mit putschen Werten 0 und 1 relativ einfach meiner einfachen Schaltung,
also in Wertern, nennt Gatta Norgatta, entsprechend realisieren.
Gut, das Ganze kann man dann eben auch entsprechend in Harde simulieren,
was man hier dann eben auch schon so ein bisschen sieht,
ist, dass dann typischerweise sowas wie Speicher dann eben noch zusätzliche weitere Leitungen hat,
was ja dann eben auch physikalisch haben,
es gibt dann sowas wie ein Chipselec,
Kann ich jetzt überhaupt das mal ansprechen,
dass der Speicher aktiviert werden oder eingeschaltet werden soll?
Dann muss ich eben sagen, soll geschrieben oder soll gelesen werden.
Dafür gibt es dann eben so eine Wright Enable Leitung und dann
möchte ich gegebenenfalls auch noch irgendwie die Ausgänge hiervon auf so einen Bus schalten.
Dafür gibt es dann eben auch noch so eine entsprechende Leitung.
Gut, wie das Ganze dann immer technisch aussieht,
wie diese Leitung genau heißen, welche es vielleicht noch gibt,
ist dann eben von der Art des Essrahmensparichers dann abhängig.
Deswegen will ich da jetzt also gar nicht größer
Beschreiben. Gut,
auch dazu gibt es dann noch so ein paar Beispiele,
die man also dann irgendwie in Hades simulieren könnte,
wo dann eben auch irgendwie dann so ein fertiger EC irgendwie mal simuliert werden kann.
So im Gegensatz zu dem statischen Rahmen, zu dem Essrahmen
gibt es dann noch derer, dynamisches Rahmen. Das ist das,
was wir eigentlich als Hauptspeicher bei uns in den PCs,
in den Laptops verbaut haben,
weil der Borg zur Speicherung von Informationen nicht mehr
sechs Transistoren,
sondern nur noch
einen einzigen
Die Sache ist, man möchte möglichst viel speichern, möglichst billig.
Also versucht man das Ganze eben technisch irgendwie so auszureizen,
so zu machen,
dass man das natürlich mit minimalem Platz bedarf macht,
damit ich dann eben bei, wenn ich jetzt sage,
also die Förtigung von Silizium kostet pro Fläche so und so viel,
ich dann eben quasi auf dieser Fläche auch möglichst viel an Informationen unterbringen kann,
beziehungsweise für mich als Grunde dann eben quasi der Speicher auch deutlich günstiger wird.
Nachteil bei diesem dynamischen Rahmen ist jetzt aber, dass die Informationen,
die wird dort quasi in so einem kleinen Kondensator gespeichert,
Muss man sich stellen,
also beziehungsweise folgt auch gleich auf der nächsten Folie,
kann man sich dann eben so vorstellen.
Ich habe, also hier so ein Transistor,
das ist nichts anderes als ein Schalter, der kann eben hier auf oder zugehen.
Von hier kommen irgendwo meine Daten rein und irgendwo hier auf der Seite
habe ich letztendlich sowas wie ein Kondensator, der also irgendwie auf Grauen hängt.
Und hiermit schalte ich das an. So und wenn ich diesen Schalter jetzt quasi zumache,
also wir stellen uns das jetzt mal hier als Schalter vor,
der dann eben hier ist,
kann ich also hier entweder eine Null Oder eine Eins, einschreiben.
Das heißt also, entweder dieser Kondensator wird geladen oder wird entladen.
Anschließend kann ich eben diesen Schalter aufmachen. Diese Ladung bleibt
hier eben erhalten und das ist dann eben eine gespeicherte Information.
So, das ist also letztendlich die Grundidee, wie jetzt so ein dynamisches Rahmen funktioniert.
Leider entlädt sich das Ding von der Zeit selber. Das heißt also innerhalb von,
ja, also je nach Technik, irgendwie so einigen Zehntelsekunden,
bis in den Sekundenbereich und dann ist die Ladung also quasi von sich aus verschwunden.
Möchte man natürlich nicht haben, demzufolge müssen hier sogenannte Refreshes gemacht werden,
das heißt, der Speicher wird ausgelesen,
wieder neu eingeschrieben und anschließend habe ich dann eben wieder einige Millisekunden lang Zeit.
Das ist also die Art und Weise, wie dieses funktioniert,
dass es dann eben letztendlich der Nachteil, wenn ich einen Speicher ausgelesen habe,
muss ich ihn auch wieder neu reinschreiben, das ist also auch abwendig.
Das Ganze ist langsamer als diesen S-RAM, also das heißt der Lesezugriff,
wenn ich jetzt irgendwie die Informationen rausgelesen haben möchte, kostet mich zusätzlich was,
aber der Riesenvorteil ist eben für hohe Kapazität optimiert, minimaler Platzbedarf.
Das ist dann die Sache. Gut,
hier sieht man das beides,
also nochmal so grob im Vergleich,
also hier diese Rückgekoppelten Werter mit diesen beiden Transistoren und
hier sieht man eben ungefähr 10 bis 50 Mal so groß
wie so ein dynamisches Rahmen und dort habe ich eben wirklich
nur diesen Cast Transistor und hier quasi diese Kapazität und die
ist rein technisch gesehen eigentlich auch total dieses Transistors,
der das dann so macht.
Gut, hier auch nur kurz zur Info. Ich weiß jetzt nicht,
wie jetzt also der aktuelle Stand ist. Ich meine,
es wird aber auch noch irgendwo so in dem Bereich sein.
Ganz am Anfang hatten wir mal so ein bisschen Moore Slaw
und wie geht das weiter und wie entwickelt sich das, wenn das immer irgendwie weiter skaliert.
Also inzwischen kann man also auch schon sagen, naja,
das, was sich hier an Kapazität habe und was ich speicher,
ist also irgendwie sowas von fünf Fempto-Verrat,
das entspricht Wenn man jetzt also quasi mit Elementarladung arbeitet,
dann also irgendwie so ungefähr 47.000 Elektronen.
So, wenn ich jetzt immer kleiner werde,
immer kleiner skaliere, wird eben letztendlich die Anzahl der Elektronen hier
auch immer irgendwie exponentiell weniger und irgendwann hat man dann eben auch den Single-Electron-Transistro oder Single-Electron-Speicher,
wo ich dann eben wirklich sagen kann, okay,
nur noch einem einzigen Elektron als Information.
Und dann ist also wirklich Schluss mit Moore's Law. Gut,
noch kann man sagen, das wird also innerhalb der nächsten 15,
20 Jahre sein. Aber beziehungsweise Hier ist das Ganze in
letzter Zeit also auch nicht mehr so stark geschrumpft.
Aber da sieht man also auch mal so ein bisschen,
was sich daran entwickelt. Gut, hier sind noch mal
so Schnitte über solche Speicherzellen. Also das kann man entweder
quasi über so eine Art Stapeltechniken in der Fertigung machen.
Also das ist hier so eine Rasselektronen-Mikroskop-Aufnahme, wo da als sogenannte Trendspeicher,
das heißt, der eigentliche Transistor ist hier oben.
Und das, was man hier unten sieht, dieser Graben,
das ist dann die quasi Fläche von dieser Kapazität hier,
die dann eben letztendlich aufgeladen wird und wo dann
die Information drauf ist
Gut, auch da versucht man dann eben,
wie das Ganze möglichst geschickt anzuordnen, möglichst klein zu machen.
Und das ist dann eben auch einer der Tricks,
weswegen man sagen kann, ja, gut,
wenn ich jetzt also hier irgendwie so einen Speicherbaustein kaufe oder
einen Prozessor kaufe und da sind also so und so viele Milliarden Transistoren drauf.
Und wie kann man sowas überhaupt nur entwerfen? Kann man natürlich sagen,
okay, also gerade sowas wie so ein Speicher,
ist natürlich eigentlich ja so eine vergleichsbare,
dankbares Objekt für den Ship-Entwerfer, weil wir uns sagen,
okay,
ich muss mir überlegen,
wie ich
diese Dekoder hier baue
Und ich versuche eben wirklich möglichst auszuknautschen in der Technologie,
wie ich also den Transistor und quasi hier diese Kapazität baue.
So, und alles andere ist, wie man hier sieht, einfach so eine irreartige Struktur.
Und dann baue ich quasi einmal diesen Transistor und dann kann ich sagen,
okay, den setze ich so und so viel mal nebeneinander,
so und so viel mal untereinander, mit Spiegeln, mit Drehen,
mit irgendwelchen geometrischen Transformationen und kann mir dann eben sagen,
ich habe dann so einen Generator,
der mir quasi dann also aus irgendwie so drei,
vier fertigen Bausteinen dann einen Spaß Bereicher generieren kann mit den Größen oder den Größen oder den Größen.
Man kriegt das dann eben relativ schnell hin. Ja gut,
aber das ist eben auch nur so ein bisschen nochmal zu der Art und Weise,
wie das Ganze dann technisch gemacht wird. So,
hier auf dieser Seite sind dann also auch nur so ein paar DRAM-Varianten aufgelistet,
weil wenn man irgendwie ein Datenwetter guckt und sich so ansieht,
na okay, was wird jetzt hier gerade an Rechner verkauft?
Welchen Speicherriegel setze ich ein? Was ist von meiner Grafikkarte
drauf, was auch immer? Dann findet man also
relativ viel an, unterschiedlichen Bezeichnungen,
also diverse Veraltete
Das, was man heute typischerweise hat,
sind dann eben Synchroness-D-Rahmens, beziehungsweise was man hatte.
Synchroness, wie gesagt, Zahlen, Spaltenadresse werden ja irgendwo abgespeichert.
Den zuvor gibt es für die Speicheransteuerung dann eben auch ein Taktsignal.
Das heißt, die Informationen läuft dann eben tagsynchron.
Und das, was man dann typischerweise hat,
sind dann eben Double-Data-Rate. Synchroness, Dynamic, rar random
Access-Memories. Nicht also DDR-SD-Rahmen,
beziehungsweise heute
Ist man dann also irgendwie bei DDR 4. Das ist dann also im Prinzip,
dass man einfach mit immer höheren Takt raten und entsprechend etwas anderen Schnittstellen dort arbeitet. Bei Grafikkarten spricht man dann von GDDR,
Graphics, Double Data Rate, wobei, wie gesagt,
das Double auch nicht so ganz stimmt,
wo man dann eben auch entsprechend versucht,
die Speicher auch immer schneller zu machen,
weil das ist also letztendlich eines der Probleme,
die wir bei uns hier in der Informatik haben oder sagen können,
okay, ich habe einen modernen Prozessor,
der läuft mit Taktfrequenzen von, also irgendwie 4 Gigahertz,
ist dann irgendwie mehr Kerner.
Das heißt, da hat dann also jetzt nicht nur eins,
sondern meinetwegen jetzt also irgendwie zehn Rechenkerne.
So, und jeder von denen möchte jetzt mit der Taktfrequenz
von 4 Gigahertz, also irgendwie seinen Programmdaten haben.
Das heißt, welche Befehle aus meines Assembler-Programms sollen jetzt abgearbeitet werden.
Die stehen also ja irgendwo im Speicher und der möchte dann natürlich
irgendwo und auch Daten haben, die quasi berechnet werden. Also sprich,
das, was ich als Programmierer jetzt irgendwo als Indiger-Reel oder was auch immer,
irgendwo als Objekt ablege, was irgendwo ja gespeichert wird und als eine Repräsentation im Speicher hat, was sowohl gelesen als auch geschrieben werden soll. So,
das heißt, wenn ich das jetzt noch mal hochrechne und dann eben sage, okay,
also wie viel an Daten muss ich jetzt eben quasi innerhalb der Taktrate oder innerhalb eines Zeitraumes aus dem Speicher lesen bzw. reinschreiben,
ist, dass eben zurzeit eben wirklich die Schnittstelle,
beziehungsweise wenn man das liest, ist man also mal irgendwie von Neumann-Flaschenhals,
also Wortelneck, der Teil, wo man sagen kann,
okay, da habe ich jetzt wirklich die Probleme,
die Daten schnell genug aus dem Speicher zur CPU zu kriegen,
beziehungsweise von der CPU wieder in den Speicher zurück.
Geht rein technisch eben auch nur dadurch,
dass man sagt, okay, ich habe,
wenn ich jetzt also hier bei Prozessoren und CPU bin,
habe dann eben Keine direkte Kommunikation von CPU zum Hauptspeicher,
sondern dazwischen sind noch verschiedene Ebenen, sogenannter Cash-Speicher.
Das ist also ein schnellerer Zwischenspeicher. Der ist dann nämlich nicht derer,
sondern S-RAM-Speicher, auf den ich dann eben deutlich schneller schon mal drauf zugreifen kann.
Das ist ja eine Sache und die andere Sache ist,
also gerade im Bereich von Grafikkarten,
wo ich eben auch sehr viele Recheneinheiten habe,
die also schnell auf Speicher drauf zugreifen müssen,
dass man dann eben sagt, okay,
also teilweise haben die dann ihre eigenen kleinen Speicher oder Speicherbereiche,
beziehungsweise das, was dann so als Speicherbus hat,
also ein Speicherwort, ist nicht ein weit oder 64 Bit breit,
sondern ich habe also deutlich größere Wortbreiten und habe dann eben mit einem Speicherzugriff, also gleich deutlich breitere Datenwörter übertragen.
Zurzeit, Ende der Fahnenstange, also bei Grafikkarten, ist also die Sigh,
Ventals Memory, beziehungsweise im Supercomputing-Bereich wird das auch eingesetzt,
nicht, dass man also irgendwie so bei Übertragungsraten von 256 Gibibyte pro Sekunde,
wo man sagen muss, das sind also schon relativ anständige Datenmengen,
die man da also wirklich irgendwo von A nach B transferiert.
Andererseits, wenn man jetzt eben sagt, ich habe eine anspruchsvolle Anwendung,
die das also ausnutzt, wird das dann eben auch schon entsprechend benötigt. Gut,
hier nur noch mal eine Grafik,
die also quasi nur noch mal zeigt, also Synchronesteram,
also wie gesagt, Synchrones, es gibt eben sowas,
wie sie sind in irgendeinem Taktsignal und ich habe dann eben Seitens der CPU,
sowas, wo ich dann sagen würde,
ich würde hier einen Spar, ich habe eine Adresse anlegen,
würde dann eben hier anschließend mit Row Access und Carlom Access den Speicher adressieren,
diese Adresse übernehmen.
Und die Idee ist eben,
dass die CCPU quasi immer mit der Tag-Drückflanke jetzt hier irgendwelche Werte umschaltet,
der Sparicher dann quasi mit der Taktforderflanke irgendwie darauf reagiert und irgendwann,
wenn der Sparicher quasi jetzt hier sieht,
Die Adressen sind alle da und ich habe gegebenenfalls hier noch irgendwelche Wartezyklen abgearbeitet,
wird dann eben ein gültiger Datenwert da sein,
der dann quasi für mich jetzt mit der Taktrückflanke,
den ich dann lesen könnte.
Da konnte man dann eben die nächste Speicheradresse beziehungsweise die nächsten Speicheradressen da rein nachlesen.
Also das ist ein Ausschnitt aus so einer Art und Weise,
wie das das zum Beispiel bei Armprozessoren gelöst wird mit so einem SD-Rahmen.
Wie gesagt, je nachdem, mit welcher Architektur ich dazu gegangen bin,
mit welcher Art von Speicher hat man da eben hier unterschiedliche Protokolle,
wie welche Leitung da einer beschaltet werden müssen.
Also wie gesagt, lasst es lesen, schreiben passiert letztendlich ähnlich.
Gut, auch eine Vollständigkeit halber, so was wie Flash-Speicher,
hat ja auch schon erwähnt, kriegt man im Prinzip also auch vergleichsweise kompakt gebaut.
Dort ist die Idee, dass der also anders,
als jetzt hier beim S-RAM oder anders als beim DRAM vielmehr,
eben auch seine Informationen erhält, wenn die Versorgungsspannung nicht mehr da ist.
Allerdings Ist dann nachher jetzt bei Flash Speicher im Vergleich zu DRAM oder zur Erstrahmen,
dass die Zugriffe dann teilweise doch langsamer sind, also gerade verglichen mit,
verglichen mit Essrahmen ist es also deutlich langsamer und die andere Sache ist,
Schreiben von manchen Informationen,
also gerade bei Nullen geht dann wieder nur über ganze Speicherbereiche.
Das heißt, wenn ich da ein einzelnes Bit ändern muss oder ein einzelnes Spide.
Kann es sein, dass ich also größere Speicherbereiche erst auslese,
dann dort was ändere und dann wieder komplett neu neu schreiben muss, ist dann also ein bisschen aufwendiger. Deswegen ist das,
also sagen wir jetzt, für eingebettete Systeme ganz gut,
also sprich Smartphones dann eben typischerweise,
beziehungsweise eben auch als Festplattenersatz genutzt, aber insgesamt von den Geschwindigkeiten,
also doch eine etwas andere Klasse, als jetzt sie,
also hier diese Speichertypen und Kann man eben sagen, im Prinzip,
es sind gut zwischen einigen zigtausenden oder einigen hundert Millionen Schreibzugriffen möglich und dann ist da quasi dieser Speicher wirklich physikalisch kaputt, weil es da also Alterungseffekte gibt.
Und dann würde er dann nämlich also auch nicht mehr funktionieren. Gut,
jetzt kann man sagen, okay, wenn ich das hochrechne,
so auf eine typische Festplatte und dann sage, okay,
damit wird jetzt eine SSD realisiert, nicht kann man sagen,
naja gut, also innerhalb so einer normalen Betriebsdauer von fünf,
sechs, sieben Jahren wird diese Alterung eintreten, andererseits,
dann kann man auch sagen, okay,
dann ist Der spare ich ja beziehungsweise die Rechnerhardware eben auch so weit veraltet,
dass man so sagen kann, gut,
dann hat man sich vorher sowieso schon wieder was Neues gekauft und dann interessiert das da dann in dem Fall jetzt also nicht.
Gut, ja, hier auch nochmal kurz aufgezeichnet,
also ein typisches Speichersystem, also auch dies hier für einen Arm-Prozessor.
Das, was man dort nämlich also auch immer ganz gerne macht,
also was hier auch nur angedeutet ist,
ist also die Art und Weise,
wie man also quasi sie aus kleineren Speicherbereichen entsprechend größere
immer macht
Und das heißt, ich habe hier so einen Speicher,
der dann natürlich jetzt hier acht Bit umfasst,
wenn ich jetzt einen 32-Bit-System habe,
wird das dann eben so gespeichert, dass man eben sagt,
hier habe ich die unteren sieben, acht Bit,
hier dann die nächsten acht und so weiter.
Das heißt, mit vier von diesen Speicherregeln,
die dann also quasi immer jeweils parallel adressiert werden,
das heißt, sie kriegen alle die gleiche Adresse,
habe ich dann eben insgesamt meinen 32-Bit-Wort.
Und was man hier dann eben auch sieht,
was typischerweise eben auch so realisiert wird, ist, dass man eben sagt,
in den Gesamtspeicherbereich des Prozessors werden dann eben sowohl pret only als auch Retro Reitschweicher eingeblendet.
Nicht, wo man dann eben sagt,
beispielsweise mit dem obersten Adressbitt mache ich eben eine Unterscheidung,
ob ich in dem Speicherbereich bin oder in dem Speicherbereich.
Also diejenigen von Ihnen, dass da sitzt im Reinerstrukturenpraktikum mit dem Deko haben,
werden das ja jetzt auch gerade als Aufgabe entsprechend mit gesehen haben, wie dann sowas ist.
Hier auch nochmal, also auch nur die Schaltnetze,
also hier sieht man aber eben ganz gut letztendlich diese Unterscheidung mit den Abreißen,
wo man sagt,
also hier habe ich eben genau diese Dieses oberste Adressbitch,
was also anders nicht verwendet wird und womit ich dann eben einmal quasi hier das Rom anspreche,
also das Rom mit dem Output Enable oder das RAM anspreche.
Und in dem Fall würde ich das Rahmen ansprechen,
wenn die Adresse gleich eins ist,
wenn die Adresse gleich null ist,
würde ich dann eben hier das Raum ansprechen.
Gut, dann als zweite Struktur,
die ich also jetzt hier noch vorstellen werde,
Bewusst ist immer sowas wie eine elektrische,
beziehungsweise teilweise auch so was wie eine logische Verbindung,
wo ich dann eben mehrere Geräte oder Komponenten sei,
dass das auf eine Platine oder sei das innerhalb des Prozesses irgendwie miteinander verbinde,
wo ist es eigentlich nur nichts anderes als ein Bündel von irgendwelchen Datenleitungen,
die ich eben irgendwie jetzt als eine logische Einheit betrachte,
was man allerdings dann eben häufig hat, ist, dass ich,
gerade wenn ich jetzt also zum Beispiel in dem Bereich so eine Platine gehe,
dann eben sagen kann,
ich habe einen Bus als eine Verbindung,
wo ich also quasi mehrere Sender haben kann und mehrere Empfänger haben kann und dann eben über eine entsprechende Auswahllogik einschalte,
welcher von den jeweiligen Sendern gerade aktiv ist.
Dann ist auch immer noch entscheidend, der Bus jetzt
als so eine Ressource, wie wird das genutzt?
Welche Protokolle gibt es da? Das heißt,
gibt es sowas wie Master und Slaved? Also typischerweise,
die CPU ist der Master, die darf jetzt irgendwie entscheiden, was passiert.
Desley wird nur abgefragt oder gibt es jetzt mehrere Komponenten, die gleichberechtigt werden können. Dazu muss es dann aber eben wieder irgendwelche Produkte Rolle geben,
die jetzt eben sagen,
wenn ich jetzt also nicht so eine typische Masters-Lave-Kombination habe,
wo also beispielsweise jetzt, sagen wir, also einen kleinen Controller,
der jetzt also hier irgendwelche Werte von irgendwelchen Sensoren hat oder haben möchte, kann ich sagen,
gut, die hängen jetzt alle irgendwo an einem Bus,
der Master fragt jetzt der Reihe nach den ersten Sensor ab,
anschließend den zweiten Sensor, anschließend den dritten Sensor,
das wäre sozusagen jetzt eben so eine typische Art und Weise,
wie man das so in so Masters-Lave-Protokoll machen würde,
hat natürlich den Nachteil, dass ich vergleichsweise aufwendig ist,
was zu machen, weil ich war so im Balling-Betrieb quasi immer der Reihe nach alle Geräte,
die da angeschlossen sind, Abfragen müsste.
Nicht, um dann zu wissen, okay,
hast du neue Werte, hast du neue Werte und nicht,
wenn ich das jetzt also beispielsweise mache,
um jetzt also irgendwie so ein paar Temperatursensoren oder Schließkontakte im Fenster oder sowas abzufragen,
in so einem Heimautomatisierungssystem, nicht,
dann ist der Master die ganze Zeit nur damit beschäftigt,
irgendwie vom Temperatursensor abzufragen,
hat sich die Temperatur geändert und er wird dann jedes Mal sagen,
nein, die ist immer noch 21 Grad, Nicht,
also das ist da dann natürlich,
sagen wir jetzt irgendwie nicht so richtig schlau.
Deswegen hat man häufig Systeme,
wo dann also quasi in dem Busprotokoll das so aussieht,
dass es jetzt nicht einen Master gibt, der jetzt immer abfragt,
sondern dass die Slaves, also sprich der Temperatursensor jetzt eben sagt,
okay, wenn sich bei mir was ändert,
schicke ich eine Nachricht an den Master.
So, jetzt habe ich natürlich wieder das Problem,
gibt es sowas wie einen gemeinsamen Takt oder gibt es nicht gemeinsame Takte?
Nicht, weil wenn ich jetzt nicht gemeinsam irgendwie ein Tax-Signal oder irgendwas habe,
kann es sein, der eine Sensor möchte seine Werte loswerden,
fängt also an irgendwie raus zu fusten, hoa.
Bei mir ist es jetzt 22 Grad warm.
Und gleichzeitig sagt also irgendwie der feuchte Sensor im Bad,
da hat jemand geduscht und die Luftfeuchtigkeit hat sich geändert und will auch seine Daten loswerden.
Und beide fangen jetzt gleichzeitig an zu senden, dass man
da eben solche Konkurrenzsituationen dann eben auch passend behandeln kann.
Das läuft dann eben unter dem Stichwort Busabitrierung. Das heißt,
mit welchen Protokollen wird dann eben dafür gesorgt,
dass es dort nicht zu irgendwelchen Datenverfälschungen kommt bzw. alle möglichen sendenden Knoten quasi ihre Daten loswerden können.
Wie gesagt, das ist dann immer davon abhängig,
um welche Busse oder Bussysteme es sich handelt.
Aber da kann man eben auch noch entsprechend unterscheiden. Gut,
bei Bussen, wie gesagt, synchron,
asynchron, wo man dann eben sagt,
es gibt sowas wie ein globales Taktsignal, was durch alles durchgeht,
was aber natürlich also auch nicht für alle Systeme praktikabel ist.
Allein schon deswegen, weil man natürlich also deutlich mehr Leitung
irgendwo von A nach B führen muss,
ist dann eben wirklich letztendlich davon abhängig,
wie man das macht
Typisches System, also wie gesagt, das,
was wir uns ja mal vorstellen, ist CPU,
ich habe, ich habe RAM, ich habe RAM,
irgendwelche einen Ausgabe-Einheiten, vielleicht noch irgendwie was anderes.
Und die CBU adressiert jetzt hier irgendwelche Komponenten,
das war so quasi genau das,
was ich gerade eben hier letztendlich auch hatte mit Adressbus und Daten,
wo es nicht und dann gibt es noch irgendwelche Kontrollleitungen,
wo dann eben die Sachen dann eben
auch entsprechend miteinander verbunden sind
Gut, bei diesen Bussen oder Bussystemen, also wie gesagt,
hier nur so ein paar ganz allgemeine Eigenschaften, beziehungsweise Namen,
die ich hier so hier nun mal oder Begriffe,
die ich hier noch mal kurz einführe, gibt es eben sehr viele sehr unterschiedliche Anforderungen.
Also wenn ich sagen kann, okay,
Bus ist die Verbindung von meiner GPU zum HBM-Speicher,
der also irgendwo auf der Grafikkarte drauf sitzt,
dann möchte ich da so High-Performance haben, das heißt,
da sollen wirklich möglichst schnell möglichst viele Daten zwischen Speicher und Grafikprozessor ausgetauscht werden können.
Auf der anderen Seite, wenn ich sage, Bus ist sowas wie,
also irgendwie Heimautomatisierungssystem und ich möchte irgendwo einen Kontakt haben,
der mir jetzt also irgendwie meldet,
ist ein Fenster geöffnet oder ist es nicht geöffnet,
dann ist das also nichts anderes als eine doofe,
simple Leitung, die irgendwo von A nach B geht,
nicht in diese Information, Kontakt offen, getoren,
Takt geschlossen, möchte ich jetzt nur von irgendwo hinbringen.
So, und das ist natürlich eine Sache,
da soll also quasi dieses Bullsystem möglichst billig sein, okay,
einigermaßen robust gegen Störung, aber eben wirklich mit ganz anderen Anforderungen,
wo ich dann eben sage, einfach Protokoll,
billige Komponenten, mich dann eben diese Sache,
wie sieht das mit der Multimaza-Fähigkeit aus?
Wie sieht das mit der Abitrierung aus?
Bei einigen Sachen baue ich sowas wie Echtzeitfähigkeit, aber auch
nicht bei vielen Anwendungen. Ich fahre so meine Heizungssteuerung,
wird das also relativ egal sein, wenn Temperatursensor,
also irgendwie zwei Millisekunden später meldet,
dass irgendwie Temperatur
irgendwie gestiegen ist
Wenn ich jetzt als Brustsystem nehme, also irgendwie die Steuerung vom ABS im Auto,
dann möchte ich also schon, dass das also relativ zeitnah reagiert.
Und nicht erst also irgendwie einen Schleudern verhindert, wenn ich schon am Baum hänge.
Gut, also wie gesagt, da ist Echtzeitfähigkeit,
dann ja, von einfachen billigen Systemen zwei Radpusse.
Also da gibt es dann sowas wie ISQRC, SPI, Systemanagement, Bass. Das sind also einfache Billy-Geburte,
die man also irgendwie in teilweise Consumer-Komponenten oder eben einfach ein Computersystem mit verwendet über Busse,
wo ich sagen kann, okay,
ich möchte eben mit, auch mit längeren Leitungen arbeiten,
also sprechen jetzt nicht nur irgendwo auf einem Chip oder auf einer Platine irgendwie was zu überbrücken,
sondern also wie im Fall von Ethernet,
also irgendwie so bis zu knapp 100 Meter Leitungslänge kommen,
ohne dass sich da jetzt also irgendwelche Verstärker dann noch zwischenschalten muss.
Bei seriellen Schnittstellen beziehungsweise sowas wie er ist 485
Das ist Industrieautomatisierung. Da möchte ich eben sagen,
okay, von irgendeiner Steuerzentrale möchte ich jetzt also auf dem Werksgelände
auch noch irgendwie zwei Kilometer entfernte Maschine vernünftig ansprechen können.
Das hat man eben entsprechend sehr viele sehr unterschiedliche Anforderungen.
Gut und funktional. Deswegen hier mit Anstrengung kann ich natürlich
also auch sowas wie WLAN oder Bluetooth als Punkt zu Punkt
Verbindung mit hinzunehmen.
Von daher dann auch so ein bisschen Busfunktionalität mit dabei
Gut, wie gesagt, im Mikroprozessor-System habe ich typischerweise natürlich sowas wie Adress,
Bus und Datenbus, wo ich dann eben irgendwelche Adressleitungen habe, um dann eben irgendwie jetzt beidweise zum Beispiel sowas wie in Speicher zu adressieren und dann eben auch irgendwelche Datenleitungen zur Verfügung habe. Nicht,
dann gibt es ja unterschiedliche Steuerleitungen,
also irgendwie sowas wie Taktsignale, Unterscheidungen,
ob ich es lesen oder schreiben möchte und teilweise macht man dann also auch so ein bisschen Tricks,
dass man Adressen und Daten auf den Leitungen Multiplext,
dass ich also sage, wenn ich also irgendwie 16 Bitboots habe,
dass ich dann ja auch über eine zusätzliche Steuerleitung sagen kann,
okay,
jetzt kommen Adressen und dann wird das eben umgeschaltet und dann eben jetzt kommen Daten,
weil wenn ich das sowieso der Reihe nach und übertrage,
wie das also beispielsweise bei einigen Protokollen der Fall ist,
dann morge ich jetzt also nicht die doppelte Anzahl von Leitungen irgendwo vorzusehen und nur über irgendein Kabel oder einen Steckverbinder zu führen,
sondern hat das eben dann nur über ein einfaches Steuersignal.
Gut, Wasser bewusst dann häufig auch noch. Harz sind jetzt also irgendwelche Kompatibilitäten,
also auch Auch da hattest du etwas, wo man sagen kann,
okay, also hier befinden wir uns jetzt, also irgendwie in den 70er Jahren.
Nichtsdestotrotz, auch jetzt bei unseren aktuellen Co-I-9-Prozessoren,
gibt es immer noch eine Abwärtskompatibilität bis zu den ersten 80,
88-Prozessoren, wo man sieht, dass es zum Beispiel bei den Intel-Prozessoren,
also ursprünglich fing die mal mit 20 Bit-Adressen an.
Damit kann ich also ein Maybe White Adressen adressieren,
nicht irgendwann Anfang der 80er Jahre mit dem 286,
hat man gesagt, na gut,
also inzwischen habe ich da schon so viel speichert,
dass ich den wirklich also auf dem Bord irgendwo unterbringen kann.
Also spendieren wir nochmal vier zusätzliche Bit.
Dann kann man also bis 16 mit 24 Bit-Adressen,
ab Mitte der 80er Jahre mit dem 80-386 wurden dann also nochmal wieder zusätzliche 8 Bit spendiert.
Das heißt, da habe ich den 32 Bit-Adressraum,
ich finde das auch das ist eine Schranke,
wo man sagen muss, okay, ist vor sechs,
sieben Jahren letztendlich dann also auch irgendwie Standard geworden, dass man sagt,
okay, 32 ich bitte das auch nicht mehr, aktuell nicht.
Und inzwischen so vier Gigabyte-Speicher ist inzwischen eigentlich auch eher wundere Fahnen oder unteres Ende dessen,
was man sich also irgendwie kaufen sollte,
würde man da dann eben auch entsprechend mit erweitern.
Gut, wie gesagt, heutzutage hat man theoretisch 64-Bit-Architekturen vom Adressorum,
wobei dann auch je nach Prozessorarchitektur zwischen 48 und 64 wird letztendlich genutzt werden können.
Auf der anderen Seite kann man sagen, okay,
das sind dann inzwischen doch irgendwelche Speichergrößen, setzen,
die man sich also auch nicht mehr so einfach oder so schnell kauft, selbst bei 48-Bit-Adrestaurant.
Gut, hier sieht man dann eben auch nochmal so ein Timing jetzt,
also von so einem Synchronbus, hier eben irgendwo auch nochmal dieses Tax-Signal. Ich habe dann eben hier eine zulesende Speicheradresse,
gebe dann eben hier,
in diesem Fall ist jetzt also hier quasi von der CPU aus dann also mit der Rückflanke,
die ich jetzt also hier irgendwo meine entsprechenden Befehle los,
der Speicher wird mir dann mit der nächsten Vorderflanke sagen,
okay, du kriegst deine Daten,
aber ich, das dauert bei mir noch ein bisschen,
wurde dann also quasi von sich aus dann so eine Wade-Leitung anlegen,
irgendwann nach einigen Wade-Zyklen wird der Speicher dann eben dieses Frate quasi zurücknehmen und mit der nächsten und die Daten irgendwo auf den Daten loszulesen und mit der nächsten Rückflanke,
könnte ich die dann dementsprechend lesen.
Gut, da sieht man eben schon, wie jetzt also
wirklich so ein Protokoll, also auf dieser Ebene Impulsdiagramme aussieht.
Gut, inzwischen können wir sagen, wenn ich jetzt nicht selber Hardware zusammenbaue, Muss ich mich mit so was glücklicherweise nicht rumschlagen? Auf der anderen Seite,
wenn man jetzt eben wirklich vor der Herausforderung stehen sollte,
dass man also jetzt irgendwelche eingebetteten Systeme selber entwirft oder dort was macht,
beziehungsweise wenn man das Ganze jetzt eben wirklich entsprechend also auch noch ein bisschen hart,
wenn näher ausreizen will, findet man eben typischerweise dann eben bei den Elementen,
die man irgendwo einsetzt, sei das jetzt CPU sah,
dass dann eben irgendwo im Speicher irgendwie so ähnlich aussehende Timing-Diagramme,
wo dann eben wirklich genau spezifiziert ist, welche Taktraten,
welche Zeitbedingungen hier gelten und man sich da dann eben entsprechend penibel darauf einstellen muss, dass das dann eben auch so eingehalten wird.
Gut, also hier noch mal eine Beschreibung dieser ganzen Parameter.
Wie gesagt, also hier jetzt aber nicht weiter.
Interessant. So asynchron ist eben von der Grundidee her,
dass man sagt, ich habe jetzt nicht ein Taktsignal und alles richtet sich an diesem Takt aus,
sondern es gibt quasi einen Satz von Leitungen,
die jetzt also quasi seitens der CPU zum...
Spare ich ja beispielsweise jetzt über so einen Controlbots gehen,
die jetzt eben sagen, okay, ich lese beim Lesen,
ich habe hier eine Speicheradresse, lege die Leitung so an,
dass ich sage, ich möchte lesen und warte dann eben,
bis der Sparecher jetzt quasi sagt,
ich habe hier gültige Daten und das dauert dann eben eine Zeit lang.
Irgendwann wird der Speicher dann eben quasi jetzt die Daten auf
den Bus legen und dann eben hier diese Leitung,
die dann quasi zur CPU zurückgeht, entsprechend umschalten und anschließend könnte ich dann quasi die Daten lesen.
Und wenn ich das gemacht habe, dann eben hier diese entsprechenden Steuerleitungen wieder zurückschalten.
Wie gesagt, wie das im Einzelnen aussieht,
ist dann eben wirklich davon abhängig, welche Protokolle es dort verwendet werden,
wie das Ganze aussieht.
Gut, Begriff, Burzabitrierung hat er ja schon gesagt.
Da geht es eben darum, dass man sagt,
Bus als eine Ressort, die jetzt eben mehrere Komponenten miteinander verbindet.
Also im Prinzip so war es. Und die ich jetzt
eben nicht nur sage, hier soll alles andere steuern,
sondern die könnten von sich aus auch irgendwie drauf zugreifen.
Und man muss jetzt eben sagen, wie kann man das eben letztendlich machen?
Zum einen zentral. Das heißt, es gibt eben eine Einheit,
die ist Busmaster und die sagt jetzt, du darfst, du darfst, du darfst.
Da gibt es dann auch unterschiedliche Strategien. Ich man kann sagen,
die Geräte haben jetzt verschiedene Prioritäten oder man kann sowas wie solche Zeitscheibenverfahren machen,
dass man eben sagt, okay,
also jetzt darf der erste anschließend nach einer bestimmten Zeit,
darf dann der nächste und so weiter.
Nicht das ist das, was hier also unter Den Begriff
Frau- und Robin-Verfahren beschrieben ist oder es gibt dann sowas wie Token,
also sprich irgendwelche Schlüssel, die dann, also von den einzelnen Clients,
also da hat dann immer irgendwie durchgereicht werden und derjenige,
der das Token hat, darf jetzt eben seine Informationen senden.
Also da gibt es eben sehr unterschiedliche Strategien. Gut,
das kann zentral passieren, dezentral wären jetzt eben solche Protokollbasierten Sachen,
sowas, was ich gerade beschrieben habe, unterschiedliche Sensoren.
Es gibt keinen gemeinsamen Takt. Der eine Sensor möchte was sensen,
der andere Sensor möchte was senden und da muss ich dann eben irgendwo ein Protokoll haben,
wo die erst mal mitkriegen,
es gibt sowas wie eine Konfliktsituation und in der Regel kann man dann eben auch sagen,
entweder mit unterschiedlichen Prioritäten oder aufgrund der Protokolle hört dann eben einer aufzusenden,
der andere sendet weiter und der, der aufgehört hat,
versucht es dann eben nach einer zufälligen Wartezeit dann eben entsprechend wieder.
Also das sind dann eben viele unterschiedliche Verfahren, im Prinzip sowas,
also dezentrale AR-Betriebung bzw. solche Protokolle ist auch letztendlich das,
was jetzt nicht physikalisch elektrisch auf einer Busleitung passiert,
aber was im Prinzip im WLAN passiert.
Nicht, wenn man sagt, okay, ich habe hier
irgendwie eine Antenne, die jetzt auf Kanal irgendwas sendet.
Ich habe mehr Geräte, die irgendwie kommunizieren möchten. Nicht,
dass man auch dort dann eben solche Kollisionen feststellt und dann eben sagt,
okay, ich versuche jetzt mal nichts zu senden in der Hoffnung,
der andere kommt durch, gibt irgendwann dann quasi das Medium wieder frei,
beziehungsweise aufgrund des Protokolls bin ich dann irgendwann dran und werde
da dann eben entsprechend meine Daten los
Gut, hier auch eine so eine Grafik aus dem Tannenbaum,
wie gesagt, also USA-Betriebung, wenn man so eine zentrale Komponente hat,
die dann eben der Reihe nach jetzt,
also den Geräten immer sagt,
du darfst jetzt und die gemeinsame Ressource,
beziehungsweise die Anforderung an den Bus kommt dann eben von den einzelnen Geräten,
nämlich das kann man dann jetzt eben auch noch mit unterschiedlichen Ebenen und so weiter machen.
Gut, auch hier zu den Begriffen oder zu dem Wurzeln
nur noch mal so ein paar Begriffe.
Auch hier habe ich einfach mal aus der Wikipedia ausgesucht
Bus Bandbreite, nicht um mal wieder so ein paar Zahlen
in den Raum zu werfen. Also man kann von sehr einfachen,
primitiven Bussystemen erst 2 oder 2, das ist im Prinzip serielle Schnittstelle.
Etwas, was also die meisten Computer inzwischen also nicht mehr haben,
was man also bis vor einigen Jahren zumindest im Desktop-Bereich immer noch hatte.
Etwas, wo man also sehr einfach quasi Daten austauschen kann.
Das war das, womit früher an Großrechner Terminals angeschlossen waren,
über eine serielle Schnittstelle. Wo ich also wirklich von Datenraten gehe,
von einigen Bit pro Sekunde, bis zu maximal 460 Kilobit
pro Sekunde
I've great see, das ist im Prinzip auch ein Low-Cost-Wurst-System,
wo ich also mit drei Leitungen auskomme,
wo ich dann eben auch einfach, also irgendwie Sensoren beziehungsweise Komponenten anschließen kann.
USB-Wurst kennen wir alle. Unser PC-Bereich hat man dann eben bis zu,
gut, PCIA ist also das, was jetzt gerade aktuell ist,
also auf dem Platin letztendlich mit drauf und sowas wie Hypertransport beziehungsweise NV-Ling sind dann Kommunikation zwischen Grafikkarten beziehungsweise zwischen Prozessoren,
wo man dann eben auch ähnlich wie bei den Speicherbahnbreiten eben versucht,
irgendwelche Standards oder Systeme zu etablieren, wo ich eben möglichst tue,
Datenraten übertragen bekomme.
Ich war letztendlich, ist das hier genau das gleiche Problem
wie bei Speicherbandbreite. Nicht, dass ich eben sage,
ich muss Daten von A nach B irgendwie übertragen und wie gesagt,
bei den heutigen Verarbeitungsleistungen und Taktfrequenzen können das eben schon sehr,
sehr viele Daten sein
Und demzufolge versucht man da dann eben möglichst hohe Daten raten zu erreichen.
Gut, hier auch noch als kurze Beschreibung von dem,
was eigentlich so auch aus den, ja,
so mittleren Jahren der Computertechnik als Buss-System noch da ist,
PCI-Bus.
Wie gesagt, inzwischen hat man eigentlich technisch gesehen,
PCIE trotzdem als Schnittstelle,
gibt es sowas wie PCI-Komponenten
immer noch
Noch, wurde Anfang der 90er Jahre von Intel,
Perry Farrell Componed Interconnect eingerichtet, ursprünglich mit 93 Megahertz-Tagen,
32 Fitbus-System, wo dann später dann eben entsprechend auch auf höhere Tag taten bzw. größere Wortbreiten erweitert.
Nicht die CPU ist der Busmaster,
das ist also wirklich so dieses klassische System,
ich habe die CPU, ich habe hier meine Platine,
irgendwelche Einsteckkarten,
die dann also quasi da reingedrückt werden und je nachdem,
also ob ich jetzt eine Grafikkarte oder eine Soundcarte oder
irgendwas anderes reintue
Sollte dann eben das Betriebssystem quasi feststellen, okay,
dafür brauche ich jetzt den und den Treiber und anschließend wird dann eben
quasi in das Betriebssystem der passende Treiber geladen und die Funktionalität durch diese,
das Zusatzteil, wo dann eben entsprechend bereitgestellt.
Gut, inzwischen eigentlich durch PCI ersetzt,
trotzdem von der logischen Funktion gibt es PCI-Bus also immer noch,
das wäre jetzt die Ausgabe von diesem Laptop hier,
LSPCI, nicht wo ich dann also im Prinzip sehe,
also hier habe ich irgendwie sowas wie Meine CPU.
Hier hängt jetzt also dran die Schipsatzgrafik,
die aber eigentlich auch in der CPU mit drin ist.
Und dann geht das Ganze noch über, was weiß ich, wie viele Seiten weiter.
Mechasie hier habe ich jetzt also irgendwie sowas wie irgendeinen Thermistor,
der mir also beispielsweise jetzt also irgendwie sagt,
ich weiß es gar nicht,
also ob das jetzt also auf der CPU oder irgendwo auf Motherboard ist,
irgendwelche Temperaturen und so weiter und so fort.
Und da kriegt man dann eben quasi für seine sämtlichen Komponenten das Ganze aufgelistet.
Wie gesagt, wenn ich das grafisch mache, sieht man also,
ist dann hier so ein bisschen mehr an Informationen,
was man da sieht.
Gut, diese Schnittstelle gibt es also heutzutage immer noch.
Wie gesagt, lass es jetzt hier vom ganz stinknormalen Linux
einmal irgendwie gemacht. Das heißt, da kann ich dann
im Prinzip über diese PCI-Schnittstelle auch noch sämtliche Komponenten ansprechen.
Und bei Windows funktioniert das im Prinzip genauso. Das ist dann das,
was ich eigentlich dahinter verbirgt,
wenn ich jetzt also in der Systemsteuerung quasi unter Systemen dann also diese ganzen einzelnen Komponenten habe,
wo ich jetzt also beispielsweise sehe,
wenn der passende Treiber nicht da ist,
also mit dem gelben Ausrufezeichen,
da fehlt irgendwas.
Auch das geht letztendlich auf diese Schnittstelle
dann mit zurück
Gut, hier so ein paar Leitungen, wie gesagt,
das interessiert jetzt also hier nicht weiter.
Nicht, also hier dann PCR-Transaktionen, auch nicht weiter interessant.
Gut, dann auch als ein Beispiel für eine sehr einfache,
primitive Schnittstelle. Dieses Jahr bleibt euch für die Übungsaufgabe dazu
erspart. Gibt es uns immer auch eine schöne Übungsaufgabe,
wo man das dann als endlichen Automaten beschreibt? Ja,
ich hatte ja gesagt, also ganz früher gab es also diese,
oder beziehungsweise bis vor einigen Jahren auch noch auf den Rechnern,
diese seriellen Schnittstellen.
Ursprünglich wie gesagt, zum Anschluss von Terminals an irgendwelche Großrechner.
Deswegen ist hier das Ganze auch noch mit plus 12 Volt
und minus 12 Volt. Hat aber eben den Vorteil,
dass, wenn ich jetzt also irgendwie so eine Leitung habe
und die mit plus minus 12 Volt beheize,
dann kann die eben auch schon mal mehrere hundert Meter lang sein.
Und ich kann damit noch einigermaßen zuverlässig Daten übertragen,
auch wenn wir in geringen Datenübertragungsrate.
Aber das funktioniert. Und da ist dann eben die Idee,
da gibt es einen Unterschied,
die Protokolle mit unterschiedlichen Geschwindigkeiten,
die man sich davor einstellt
Verbindung wird also quasi hergestellt. Dann habe ich hier den
hohen Pegel. Irgendwann kommt dann also mal ein sogenanntes Startbit.
Das heißt, also der Pegel geht einmal auf null.
Dann habe ich, was man also vorher quasi ausgehandelt haben
muss, beispielsweise sowas wie acht Datenbit. Das heißt,
es wird dann einfach nur in festen Zeitpunkten einmal hier,
einmal hier, einmal hier und so weiter,
eben achtbit einfach abgetastet und dann kommt ein Stoppbit.
Das heißt, hier muss wieder ein Eins kommen.
Und dann habe ich also zwischen diesem Startbit dieser ersten Null
um dem Stoppbit diese abschließenden Eins irgendwie wird übertragen.
Und je nachdem, wie schnell diese Abtastung hier passiert,
habe ich dann eben unterschiedliche Datenübertragungsraten. Gut, und das Ganze,
wie gesagt, hiermit plus minus 12. Volt in der PC-Technik kann ich sagen,
okay, es funktioniert eben auch mit plus 5 Volt und 0 Volt.
Nicht, und damit kann man dann eben über so eine Zwei-Drahtleitung,
weil es gibt ja auch keinen gemeinsamen Takt, also wirklich nur diese Informationen übertragen. Das Einzige,
was vorher klar sein muss zwischen Sender und Empfänger,
ist, mit welcher Datenrate kommen die Bits,
damit also quasi der Empfänger dir rechtzeitig oft abtastet,
um dann eben quasi diese Interpretation, weil der sieht ja nur,
da ist eben der hohe Pegel oder der niedrige Pegel,
um die dann eben richtig interpretieren zu können.
Aber das ist eben so ein Beispiel, wo man wirklich mit minimal wenig Leitung,
also so eine Übertragung letztendlich hinguckt, kriegt. Gut,
und das Ganze, deswegen also diese Idee mit der Übungsaufgabe,
kann man eben zum Beispiel sehr schön beschreiben,
einfach über so einen endlichen Automaten, der dann sagt,
ich bin jetzt also hier in irgendeinem Zustand,
nicht irgendwann sehe ich hier eine Null,
das ist mein Staat,
gehe ich in den nächsten Zustand und dann muss ich acht Bit abtasten und dann muss ich eine Eins sehen,
wenn nicht, ist auch irgendwas schiefgelaufen.
Kann man dann eben sehr schön über so einen endlichen Automaten beschreiben,
beziehungsweise ich brauche dann eben noch einen zweiten Automaten,
der mir dann also quasi die Zeit rast als Zähler irgendwie definiert.
Gut, ja, also das zu dieser Sache, serielle Schnittstelle. Gut,
dann möchte ich jetzt dieses Kapitel hier noch abschließen mit etwas,
was wir dann also insgesamt für die Computertechnik auch noch so ein bisschen brauchen.
Das Thema der Mikro Programmierung. Und zwar hatten wir bisher bei den Schaltwerken gehabt,
dass man sagt, okay,
ich habe ein Mili oder ein Moorautomat und setzt den jetzt um,
indem ich jetzt also quasi diese Funktionen für Delta und Lamm da irgendwie minimiere und habe dann eben für meinen Zustand irgendwo einen Zustandsregister in diesem Rückkopplungspfad,
wo ich dann eben sage, okay,
damit mache ich dann eben die Trennung zwischen Folgezustand aktuellen Zustand.
Im Prozessorbereich hat man das typischerweise so, dass sich diese Automaten als sehr gerne als sogenanntes Mikroprogramm realisiere. Das heißt,
nicht als ein Automaten, den ich jetzt so entwerfe,
wie ich das jetzt gerade skizziert habe,
sondern ich habe im Prinzip ein Mikroprogramm Speicher,
kann RAM sein, kann aber auch ein Rom sein,
also nun nur lesbarer Speicher,
der ist dann eben in mehrere Felder unterteilt,
nämlich einmal irgendwelche Teile für den Folgezustand und eben irgendwelche Steuerleitungen,
die mir dann letztendlich die aus Gaben generieren.
Also wie gesagt, im Praktikum wird das also auch mitbenutzt.
Grundidee, also hier nochmal kurz an diesem hochkomplexen Beispiel, diese Ampelschaltung.
Also ich hatte hier jetzt drei nach die vier Zustände,
die durchlaufen werden, kann man sich dann eben so vorstellen,
ich habe hier mein Mikroprogrammzähler, der ist nichts anderes als die Adresse in diesem Mikroprogrammspeicher und jeder Zustand des Automaten entspricht letztendlich einer Zeile dieses Speichers.
Das heißt, ich adressiere hier eine Zeile,
habe da drin eben unter einer Adresse drin stehen,
den Folgezustand, wo ich dann eben sage, okay,
ich bin jetzt in Zustand rot,
der nächste Zustand soll Zustand 1 sein und Zustand 1 wäre dann eben quasi rot,
gelb, das heißt also genau das,
was ich hier in den Zustandsübergangsdiagrammen habe,
würde man dann eben letztendlich in dieser Kombination Adresse und Folgeadresse
reinkodieren und dann habe ich dann eben hier den Rest dieses Speicherworts,
um jetzt irgendwelche Ausgaben zu realisieren
Ist eben auch sehr einfach, straightforward,
so umsetzbar und dann eben natürlich nicht nur für solche trivialen Beispiele,
sondern wie das dann also beispielsweise im Praktikum ist,
dann eben für etwas komplexere Sachen, wo man dann eben sagt,
okay, um jetzt mit meiner Hardware bestimmte Befehle abzuarbeiten,
ich hatte ja gesagt, von Neumann-Zyklus ist Befehl holen,
Befehl dekodieren, nach dem Dekodieren gucken,
welche Art von Befehl ist das,
wenn das so ein Alu-Befehl ist,
sollen jetzt also irgendwie die Operanten aus den Registern geholt werden in der Alu- verarbeitet werden.
Das Ergebnis soll wieder irgendwo hingeschrieben werden. Das wird dann im Zweifelsfall
über mehrere einzelne Teilschritte gemacht und diese werden dann eben wirklich so als Zeilen,
so das Mikroprogramm ist dann realisiert, wo ich dann eben quasi hier so ein Teil habe für irgendwelche Steuerleitungen.
Und hier so ein Teil,
wo ich dann eben jetzt nicht nur eine Folgeadresse habe,
sondern eben auch mehrere,
die man quasi über Multiplexer umschaltet und dadurch kann ich dann eben erreichen,
dass ich von einem Zustand auf unterschiedliche Folgezustände verzweigen kann oder hier noch irgendein externen Wert quasi hier als Adresse in diesem Mikroprogramm-Speicher laden kann,
was man eben auch braucht,
um jetzt zum Beispiel bei verschiedenen Befehlen in verschiedene Ausführungsphasen zu verzweigen.
Dass also die Art und Weise, wie man Mikroprogrammierung macht,
um jetzt in der Computer-Hardware da jetzt eben dafür zu sorgen,
dass der Reihe nach jetzt diese unterschiedlichen Abfolgen, Befehl holen,
Befehl dekodieren, Befehl abarbeiten, über ein,
zwei, drei, für fünf, sechs,
sieben Schritte,
der Reihe nach ablaufen
Gut, hier wäre dann also nochmal diese Gesamthardware. Und da sieht man also ein Mikroprogramm,
Speicher oder dieser Tal wäre dann eben hier irgendwo Tal,
dieses Steuerwerks. Hier hätte ich dann eben die eigentliche Recheneinheit,
also sprich irgendwelche Register und die Alu als Rechnenden Teil,
dann gibt es dann eben noch irgendwie sowas,
wo ich dann den aktuellen Befehl vorhalte, also dieser Program-Counter oder Programmzähler,
den ich dann eben in der Regel für den nächsten Befehl immer nur inkrementiere,
gegebenenfalls, aber für irgendwelche absoluten oder relativen Sprünge muss ich dann eben auch dafür sorgen,
dass ich dort also andere Werte reinbekomme,
beziehungsweise irgendwelche Sprungadressen berechnen kann.
Gut, wie gesagt, das wird dann also irgendwo Praktikum entsprechend mit verwendet,
ist eben ein klassisches Konzept,
wie man quasi jetzt solche Abläufe und auch etwas kompliziertere Abläufe,
weil dies realisiert ja nichts anderes als einen endlichen Automaten,
der aber dann eben schon ein paar hundert Zustände hat,
wie man das dann eben letztendlich umsetzt.
Gegen Ende der Veranstaltung werde ich da nochmal ein bisschen was sagen zum Pipelining,
weil dafür brauche ich dann ein bisschen anderer Hardware-Struktur als sowas hier.
Das ist dann eigentlich jetzt das,
was in aktuellen Prozessoren dann doch noch deutlich mehr oder typischerweise eingesetzt wird,
wo dann also dieses Konzept dann nämlich noch zusätzlich erweitert wird,
dass ich nicht nur einen Befehl gleichzeitig abarbeite,
sondern gleich mehrere und das dann in so einer Stufenweisenverarbeitung.
Gut, ansonsten, wie gesagt, also geradezu bei kleinen,
einfachen Prozessoren hat man also diese Mikroprogrammierung dann immer ganz gerne.
Also hier im Beispiel auch aus dem Buch von Förber über den Namen Prozessor,
wo ich dann also sagen kann, okay,
Ich habe hier auch als typische Steuerung hier irgendwie so eine Dekodiereinheit,
also im Prinzip PLA ist nichts anderes als eine etwas andere Form von so einem Mikroprogrammraum.
Ich habe dann also hier meine Steuerleitung zu den Einzelnen ausführenden Einheiten,
das heißt eine Steuerung der Ahlungsteuerung der Registerbankensteuerung der Adressberechnung,
habe hier irgendwo meine Instruktionsregister und gehe dann eben teilweise in mehreren Schritten,
also genau eben diesen Abfolgen in diesem Mikroprogramm schritten,
dann dazu über das Ganze entsprechend ausführen zu lassen.
Ja, und wie gesagt, der Trick bei dem Ganzen ist immer,
dass ich die Hardware dann eben letztendlich so beschalte,
beziehungsweise auf der Hardware, also alle Datenpfade, möglich habe,
um jetzt alle Arten von Befehlen dann auch ausführen zu können.
Gut, hier nochmal so ein gesamtes Armsystem, also hier die CPU-Raum,
DMA-Controllers ist ein System, was also quasi Datentransfer zum Speicher,
unabhängig von der CPU macht. Das heißt,
damit kann ich dafür sorgen, dass die CPU weiterrechnet,
wenn ich jetzt von irgendeiner externen Schnittstelle beispielsweise jetzt Ethernet-Schnittstelle oder Tastatur-Controller irgendwelche Daten habe,
die jetzt irgendwo hier im Speicher zwischengespeichert werden,
dass eben dieser Datentransfer jetzt nicht durch die CPU gemacht wird,
sondern über eine eigene Verarbeitungseinheit.
Gut, hier sieht man dann eben auch nochmal für den Armprozessor,
wie dann letztendlich sowas wie die Recheneinheit,
also die Alu dann also genug ein bisschen genauer aussieht.
Also hier habe ich dann auch die Operanten,
habe dann eben hier einmal eine Adiereinheit oder eben irgendwelche logischen Funktionen,
wo mir jetzt ein Zweierkompliment zu rechnen,
kann ich dann eben die Operanten A oder Operanten B über
so eine XO-Steuerung quasi mitweise invertieren.
Und wenn ich dann eben mit einem Zweierkompliment rechne,
würde ich dann eben noch den Carry-In auf eins setzen.
Nicht dadurch kann ich dann eben oder B
hinnegieren bzw. A-B rechnen
Und habe dann eben auch hier irgendwo meine Ausgangseinheiten, beziehungsweise hier dann nochmal irgendwas,
womit ich dann jetzt also irgendwelche Flexs setzen kann. Gut,
hier Multiport-Registerbankzelle, dass das im Prinzip so ähnlich ist,
wie so eine S-Rahmenzelle, nicht, also auch das,
dass man dann eben sagt, in dem Registern,
also sprich diesem Teil hier,
wo ich jetzt also quasi irgendwie meine Operanten abspeicher,
auch die baue ich jetzt nicht aus einzelnen Flipflops zusammen,
sondern versuche das auch möglichst klein und kompakt
zu machen
Mal an. Da hat man eben sowas ähnliches wie solche Zellen dann teilweise mit mehreren Leseeinheiten. Gut,
und wie gesagt, Trick bei dem Ganzen ist jetzt,
dass man sagt, okay, so ein gesamter Prozessor,
sei das jetzt hier sowas wie so ein Arm,
Prozessor oder sowas wie jetzt also hier so ein Dekor,
wird halt eben so aufgebaut,
dass man hier alles an möglichen oder überhaupt irgendwie benötigten,
Datenfaden vorsieht,
die man jetzt für seine für die Ausführung seiner Operation irgendwie braucht,
da brauchen könnte.
Und abhängig von diesem Mikroprogramm dann eben einzelne von denen aktiviert,
um dann die verschiedenen Talschritte der Reihe nach auszuführen.
Wie gesagt, also beim Deko,
wenn sie das dann also im Praktikum machen,
beziehungsweise haben das also entsprechend schon gemacht.
Bei dem Armprozesse hier auch nochmal angedeutet, wie das aussieht.
Also ich habe hier im Prinzip das,
hier soll also
dieses Steuerwerk sein
Instruction, die Code und Control. Hier unter Data N-Register
hätte ich dann also sowas wie meinen Befehlswort.
Und dann habe ich jetzt also hier die eigentlichen Register in dem Register
ist in diesem Fall, also auch der Programmzähler mit drin.
Habe dann hier noch ein Register, wo ich dann also
Speicheradressen anlegen kann und dann hier die eigentliche Alu als Recheneinheit und ein Ausgangsregister,
wo ich also Werteinnenspeicher rausschreiben kann.
So, die sind jetzt alle mehr oder minder abstrus mit irgendwie diesen Leitungen miteinander verbunden. So,
und wenn ich jetzt verschiedene Befehle abarbeite,
ist jetzt immer der Trick, dass man eben sagt,
Und das macht genau dieses Mikroprogramm,
dass ich teile hiervon quasi freischalte und aktiviere und andere Teile in Aktiv lasse.
Und insgesamt in meiner Hardware-Architektur muss ich eben einfach nur alles an möglichen Leitungen,
die ich vielleicht mal brauchen könnte, vorgesehen haben,
um die dann eben passend beschalten zu können.
Also hier finden sich dann eben Beispiele, wenn ich sage,
ich habe einen Befehl, der jetzt als typische Register,
Register Operation,
also quasi zwei Register,
meinetwegen agiert und das Ergebnis wieder in einem Register abspeichert
Was muss passieren? Der Befehl wird irgendwo hier gelesen,
liegt jetzt also hier in einem Befehlsregister,
wird dann also quasi jetzt hier von dem Teil hier interpretiert.
Der sagt jetzt, ich möchte mit zwei Registern also irgendwie rechnen,
also werden die also aus der Registerbank gelesen.
Das eine Register, das andere Register, in der Alu
wird irgendwas mit berechnet und das Ergebnis wird wieder hier rein zurückgeschrieben.
Gleichzeitig soll dann ja anschließend der Nächste Befehl geholt werden,
also muss der Programmzähler inkrementiert werden, beziehungsweise er wird rausgelesen,
inkrementiert und dann eben hier wieder zurückgeschrieben.
Und hier in diesem Adressregisterzwischen gespeichert, damit ich dann beim nächsten Tag,
beziehungsweise wenn das dann weitergeht, den nächsten Befehl verarbeiten kann.
Nicht also das nur als Beispiel,
wie man das dann also bescheiden für solche Sachen,
wenn ich jetzt sowas habe, wie einen sogenannten Emediate-Befehl,
das sind also Befehle, wo in den Befehlen eine Zahl drin steht.
Also ich möchte jetzt nicht rechnen, Register A plus Register
B und das Ganze soll ein Register Ziel gespeichert werden,
sondern ich möchte einfach nur rechnen, Register A, plus 5,
eine Konstante, eine kleine Konstante. Nicht dann kann man sagen,
diese kleine Konstante ist eben in dem Befehl selber hier mit drin und bildet dann was,
was sich hierüber angedeutet ist, dann eben quasi den zweiten Operanten,
der dann eben hier mit diesem Register verrechnet wird.
Und auch hier wird dann natürlich logischerweise mit dem Programmzähler irgendwie gearbeitet. Gut,
und je nachdem, welche Art von Befehlen man da abarbeitet,
also hier geht das jetzt noch weiter mit irgendwelchen Speicherbefehlen,
wo ich das also quasi Sachen in den Hauptspeicher schreibe über diesen Pfad oder eben über irgendwelche Sprungbefehle,
wo ich dann also abhängig von Bedingungen quasi jetzt den nächsten Befehl ausrechnen kann,
also sprich den Programmzähler selber jetzt hier irgendwie neu überrechne,
kann man da jetzt also viele unterschiedliche Varianten sich ausdenken.
Nicht, das ist aber natürlich letztendlich dann wirklich davon abhängig,
wie sieht jetzt genau diese Grund-Hardware-Struktur aus und wie sieht mein Befehlssatz aus,
das heißt, was erlaubt Dieser Befehlssatz jetzt eben wirklich an Befehlen, die abgearbeitet werden können.
Gut, bevor wir jetzt also auf die Befehlsätze eingehen,
was dann also Thema des nächsten Kapitels ist,
kommt jetzt hier nur noch abschließend kurze Betrachtung zu dem Thema,
wie rechnet ein Rechner. Ja, das,
was ich hier schon so ein bisschen gezeigt habe,
ist, ich habe hier irgendwie eine gegebene Hardware-Struktur,
den jeweiligen Befehlssatz dazu und über ein Mikroprogramm oder einen endlichen Automaten,
wie auch immer man sich das jetzt also realisiert hat,
wird dann eben immer dafür gesorgt, dass diese passenden Pfade entsprechend geschaltet werden.
Nicht, das ist eigentlich die Grundidee,
wie man dann also von Neumann-Konzept letztendlich realisiert und wie man damit arbeiten kann,
weil man sich jetzt aktuelle Rechnerarchitekturen ansieht,
gibt es dazu allerdings dann doch einiges an Erweiterungen.
Zum einen, was dann also am Ende der Vorlesung noch kurz angesprochen wird,
ist, dass ich eben parallele Verarbeitung habe.
Stichwort dazu, ist Pipelining. Das Zweite ist,
dass man mehrere Ausführungseinheiten hat, also bei dem,
was wir jetzt also hier im reiner Struktur und Praktikum machen
oder was man also hier also bei dem Arm sieht,
habe ich also hier nur eine einzige Alu als Recheneinheit.
Nicht, also bei aktuellen Prozessoren sieht das eben auch so aus,
dass ich sagen kann, da habe ich also schon mal zwei Fließkomma und vier Entager-Recheneinheiten und zwei Adressberechnungseinheiten pro CPU-Kern.
Jetzt habe ich aber natürlich auch noch Nicht nur das,
sondern ich habe auch noch mehrere CPU-Kerne, also mehr Kernarchitekturen.
Das kommt dann auch noch hinzu. Dadurch kommt es dann dazu,
dass man in der Abarbeitungsreihenfolge seines Programms dann eben auch nicht mehr erst den einen Befehl,
dann den anderen Befehl, dann noch einen Befehl abarbeitet,
sondern wenn ich jetzt mehrere Rechenwerke habe, dass ich sage,
okay, ich nehme so einen ganzen Satz von Befehlen,
gucke gerade,
welche Alu ist frei.
Und wenn ich jetzt nicht irgendwelche Datenabhängigkeiten habe,
kann ich diesen Befehl eben schon auf Dialo schmeißen und dann
damit rechnen
Und führt dann dazu, dass Befehle, die im Programmcode in einer bestimmten Reihenfolge sind,
in anderen Reihenfolgen auf der Hardware abgearbeitet werden.
Das Stichwort dazu wäre dann sogenannte Out-of-Order-Execution. Gut,
da kann man sich dann auch immer noch hinterher dann drüber streiten,
möchte ich das hinterher bei den Ergebnissen wieder zurücksortiert haben.
Auch dafür gibt es dann Hardware,
die das macht oder möchte ich das nicht machen, je nachdem,
wieder Abhängigkeiten sind, kann entweder der ein oder andere Auffallvorteile haben.
Also auch das war gerade so in den 90er Jahren zwischen den Firmen AMD und Intel,
also immer irgendwie eine große oder heiße Diskussion, welches Konzept da eigentlich besser ist.
Nicht, weil der eine Hersteller hat das so realisierte andere so,
nicht und jeder hatte dann immer seine Benchmarks,
die mit der eigenen Architektur deutlich besser liefen,
nicht aber wie jemand benutzt das Programm von dem anderen Herstellern,
dann ging das irgendwie alles gar nicht.
Wie gesagt, das sind immer so Sachen, wo man dann auch noch mag.
Und etwas, was dann eben auch noch mit hinzukommt,
sogenannte Harvard oder Prinz-Narchitektur, das,
was wir bislang nur kennengelernt haben oder was sich jetzt,
also hier auch immer so vorgestellt hatte, war,
ich habe CPU, ich habe einen gemeinsamen Speicher für Instruktion und Daten.
Das war immer eines der Kernthemen, wenn ich jetzt gesagt habe,
von Neumann-Konzept. Wenn man jetzt aktuelle Prozessoren sich ansieht,
beziehungsweise die Hardware ansieht, funktioniert das nicht,
weil ich beim Pipelining gar nicht die Informationen an die CPU-Kerne entsprechend ranbekommen
Sondern da gibt es eben eine Trennung zwischen Instruktionen und Datenspeicher.
Das ist nämlich das, was dann quasi bei dem sogenannten First-Level-Cash E-Cash und D-Cash ist,
die dann nämlich einmal für Instruktionen einmal für Daten verantwortlich sind.
Das heißt, da habe ich dann auch nicht mehr getrennte
Instruktions- und Daten oder eben nicht mehr gemeinsame Instruktions- und Datenspeicher.
Das Ganze nennt sich dann Harvard-Architektur. Gut, wie gesagt,
spare ich ja Hierarchie-Cashes, folgt dann alles später noch ein bisschen.
Gut, dann werde ich jetzt,
also hier zumindest dieses Kapitel Rocco abschließend mit einigen Folien,
wo ich dann eben auch noch mal sage, okay,
also wir rechnen ein Rechner, Choreografie, viele Funktionseinheiten.
Auf Ebene des Prozesses hatte ich das ja so ein bisschen an diesen Folien
eigentlich verdeutlicht, dass das immer so einzelne Teilschritte sind.
Und dieses Konzept oder diese Idee geht letztendlich genauso auch eine Ebene drüber,
wenn ich jetzt eben so ein Gesamt so einen Rechner nehme und gucke, wie funktioniert das da?
Also hier jetzt die Folie oder Grafik, also von Brian
und Rohelleron. Ich habe hier also irgendwo meine CPU,
Habe da die Recheneinheit, da irgendwo meine Register,
Programmzähler, hier irgendwo, was ist hier nicht angezeichnet,
ist dann eben diese ganze Steuerwerksmimik und so weiter.
Nicht die sitzt jetzt irgendwo auf dem Sockel,
auf dem Motherboard oder ist im Falle von Laptops irgendwo aufgelötet.
Und da hält sich dann mit irgendeinem Bussystem und er hält sich dann eben noch mit dem Speicher,
beziehungsweise bei aktuellen Prozessoren sind die Teile, also auch schon alle hier mit drin.
Und es gibt dann eben noch irgendwelche Komponenten oder Teile,
mit denen ich dann eben sowas wie Grafikschnittstellen,
USB-Geräte Schnittstellen für Festplatten entsprechend dann eben mit ansprechen kann.
Gut, wenn ich so ein System habe,
eine Ebene drüber, da läuft,
ist das so ein Betriebssystem und ich tippe jetzt, also okay,
ich habe mein Hello World geschrieben als klassisches erstes Programm,
das also irgendwie einmal kompiliert, das soll jetzt ausgeführt werden.
Nicht was passiert dann, also der Benutzer tippt jetzt also irgendwie ein,
Hello soll ausgeführt werden, das geht jetzt also irgendwie über
meine USB-Tastatur irgendwo über die CPU beziehungsweise das stimmt eben auch nicht ganz.
Also in dem Fall wäre das dann also eigentlich
auch schon über eine entsprechende, hatte ich hiermit drauf,
also DMA-Einheit, dann irgendwo in den Speicher mit rein.
Dort steht das dann also irgendwo als ein Task,
wo dann also das Betriebssystem irgendwann hoffentlich mal sagt,
okay,
jetzt ist das und das fertig
Was der Mädel da als gerade an der Tastatur eingetippt hat,
ausgeführt werden, würde das dann also quasi von irgendeinem Betriebssystem interpreter,
klassischerweise sowas wie einer Shell dann eben sagen, okay,
also Hello wurde doppelt geklickt oder eben irgendwo über die Tastatur eingegeben.
Da soll jetzt was passieren, führt dann eben dazu,
dass quasi dann das ausführbare Programm von der Festplatte irgendwie in den Hauptspeicher geladen wird.
Und irgendwann dann wird das Betriebssystem,
wenn das geladen ist, also dann sagen, okay,
jetzt ist das mal der rechtwillige Job von Meda dran.
Hello World, würde das dann also letztendlich auf der CPU ausführen.
Und ich würde das Ergebnis dann irgendwie zu sehen bekommen.
Gut, ja, vorletzte Folie. Also wie gesagt,
das ist zu der Art und Weise,
wie jetzt eigentlich dann so ein Programm,
also letztendlich also auf der Hardware ausgeführt wird.
Und auch da sieht man eigentlich ähnlich, wie vorher eine Ebene drunter.
Ich habe hier immer unterschiedliche Datenpfade und je nachdem,
was passieren soll,
wird dann eben
ein entsprechender Teil geschaltet
So, dann kommen wir noch zu deinem magischen Mechanismus,
wir schalten den Rechner ein und er bootet. Wo man auch sagt,
das ist ja auch nicht so ganz selbstverständlich, wie das jetzt eigentlich funktioniert,
also sprich, wie startet das System, wie kommt es dazu,
dass ich überhaupt jetzt irgendwie erstmal das Betriebssystem in den Hauptspeicher bekomme.
Also hier auch nur sehr grob angedeutet, nicht also das,
was eigentlich passiert beim Einschalten ist, also dass erstmal physikalische Chipsatz,
also sowas wie Reset-Signale generiert für alle angeschlossenen ICs oder Komponenten,
Wichtig dabei dann insbesondere, dass eben diese zentralen Prozessoregister,
also wie der Programmzähler, quasi zurückgesetzt, beziehungsweise mit irgendeinem Startwert initialisiert werden.
So unter diesem Startwert wird dann also quasi der Prozessor letztendlich starten auf eine Adresse zugreifen.
Früher war das das wirklich noch, also irgendwie so ein kleines,
gebranntes Raumwasser irgendwo auf der Platine saß und von dort aus,
also erst mal den ersten Teil,
IOS letztendlich sich holen, der dafür sorgt,
dass also anschließend die gesamten Komponenten hinterher nach irgendwie minimal soweit angesprochen werden,
dass von einer Festplatte letztendlich so was wie das Betriebssystem in den Hauptspeicher kommt.
Anschließend wird dann eben quasi der Programmzähler auf die Startadresse dann in dem Hauptspeicher von dem Betriebssystem aktualisiert.
Und dann wird das Ganze eben richtig loslaufen. Wenn ich ein Vorab,
was den dann eben noch irgendwie sowas wie Selbsttests,
irgendwelche Löschen von Zwischensprachen und Konfigurationen des Schiffsatzes und so weiter.
Und wie gesagt, wenn das dann Da ist Betriebssystem also
im Speicher oder eher die ersten Teile davon, dann kann das also entsprechend loslaufen.
So hört sich hier alles vergleichsweise einfach an,
ist aber eben auch schon, wenn man wirklich sowas war,
also im Sinne so eines eingebetteten Systems selber umsetzen oder programmieren möchte oder sagt, okay,
ich nehme jetzt also sowas wie so einen minimalen Dekor und baue mir mal sowas zusammen.
Also auch schon alles andere als trivial, sowas, also überhaupt erstmal hinzubekommen. Und wie gesagt,
aktuell wird das dann also natürlich dadurch noch ein bisschen schwieriger,
dass ich jetzt ja nicht eine CPU habe, sondern eben zehn CPUs,
dann wird es eben auch schon irgendwie ein Mechanismus geben,
der sagt, okay, irgendwo hier bei diesem Reset,
CPU Nummer 0 ist diejenige, die quasi anfängt zu buten.
Alle anderen werden eben in dieser Phase hier quasi bei dieser Initialisierung bzw. Konfiguration auch erst mal inaktiv geschaltet,
nicht mit dem ersten, fange ich erst mal an,
so weit Betriebssystem zu laden,
dass ich überhaupt erst mal dafür sorgen kann,
dass ich sowas wie ein Mehrprozessorsystem laufen lassen kann.
Und erst wenn das der Fall ist,
läuft alles andere los und weiter
Gut, ja, das war jetzt,
sage ich nochmal,
zum Abschluss jetzt zu diesem Thema Rechtenarchitektur berechnet, Anrechner,
dann werde ich jetzt in der,
beziehungsweise am Freitag als krönenden Abschluss nochmal ein bisschen was zu dem Befehlssatz sagen,
wie man jetzt also aus Sicht des Befehlssatzes den Speicher anspricht,
welchem Befehlsformat und Adressierungsarten es gibt,
nicht weil das haben wir jetzt eben auch noch dann eigentlich die entscheidenden Schnittstellen nachher,
dann sind es zu dem nächsten Kapitel,
wo wir dann ein bisschen was zur Assemblerprogramm Armierung kennenlernen werden.
Gut, that's not for it gewesen sein und dann
bis Freitag