Ja, gut, heute wollte ich dieses Kapitel Rechner-Abstruktur 1 eigentlich abschließen.
Also sprich nochmal kurz die Verbleibenden Komponenten vorstellen, die man jetzt eigentlich braucht,
um jetzt insgesamt sowas wie ein Rechnersystem aufbauen zu können.
Und dazu hatte ich ja nun Mittwoch schon kurz angefangen,
ein bisschen was zu den Speichern oder Speicherbausteinen gesagt. Nicht,
dass ich hier nochmal die entsprechende Folie, wo die also einmal grob aufgelistet sind,
also das, was Wir jetzt eigentlich nur brauchen oder wissen sollten,
also es gibt halt eben irgendwie Rahmen, Random Access Memory, also sprich der normale Schreib, Lesespeicher.
Davon dann noch, sagen wir mal,
so zwei technische Untervarianten, die dann auch dazu führen,
dass sie im Rechner an unterschiedlichen Stellen eingesetzt werden,
nämlich einmal als das, was wir eigentlich als Hauptspeicher bezeichnen,
also sprich die Speicherregel,
die man sich dann typischerweise in seinem System reinkonfiguriert und auf der anderen Seite dann in Form von Speicher,
der jetzt als schneller Zwischenspeicher dient, sogenannten Cashes,
wofür man das dann genau braucht,
wird dann in einem Teil Rechnerarchitektur 2 da noch ein bisschen genauer vorgestellt.
Dann gibt es daneben eben noch sogenanntes Rom, Read Only Memory,
war früher ursprünglich eben auch wirklich so ein Speichel, denn nur zum Lesen war,
wo dann eben letztendlich ein für ein System oder für ein Gerät,
was eben nur genau ein einziges Programm ausführen sollte,
dieses dann eben dort hinterlegt wurde.
Heute wird das eigentlich technisch eher dadurch realisiert,
dass man, also im Laufe der Zeit, alles,
was dann hier so ab Prom beziehungsweise bis E-Prom ist,
Techniken entwickelt hat, wie man das dann also quasi auch wiederbeschreibbar machen kann.
Heute sind das in der Regel dann technisch gesehen Flash-Speicher,
wo dann aber im Prinzip Informationen drinstehen,
die überwiegend erstmal nur gelesen werden sollen und gelegentlich mal aktualisiert werden.
Ausnahme gibt es natürlich auch immer. Ausnahme von dem Ganzen ist im Prinzip das,
was man als Speicher im Prinzip in Smartphones zum Beispiel drin hat,
beziehungsweise den jetzt quasi als Ersatz von einem Agnetfestplatte in Solid Statist.
Das sind dann also technisch gesehen auch Flash-Barch. Da werde ich
auch gleich noch mal kurz ein bisschen was zu sagen.
Gut, bei dem Sparichern, die Folien hatte ich ja schon entsprechend drauf.
Wie gesagt, Rahmen kann man sich immer vorstellen als den A
ganzen Satz von einzelnen adressierbaren Bits, die man dann also lesen, beziehungsweise schreiben kann.
In der Regel ist das dann auch über so eine zweistufige Dekodierung gemacht,
das dann quasi von der Gesamtadresse dann eben nur ein Teil gemacht wird,
einfach damit Technisch gesehen diese Schaltnetze, gerade hier für den Dekoda,
beziehungsweise für diesen Spaltenmultiplexer dann eben entsprechend deutlich einfacher werden,
als wenn ich das jetzt also quasi über die gesamte Wortbreite mache.
Gut, dann hatte ich ja gesagt,
also gibt es dort im Prinzip zwei unterschiedliche Varianten,
nämlich Esram, statisches Rahmen oder eben dynamisches Rahmen,
Derram, Unterschied ist beim statischen Rahmen,
wie der Name eigentlich schon andeutet, sieht das eben so aus,
dass die Information letztendlich so lange gespeichert wird,
wie Da spare ich aber auch Stein an der Spannungsversorgung hängt und dort im Strom bekommt.
Im Prinzip ist das, sagen wir mal,
erst mal nichts anderes als sowas wie ein Ledge, also ein Pegelgesteuertes,
Sparecherelement, was aber mit ein bisschen Trickserei so gemacht ist,
dass es eben deutlich weniger Fläche, beziehungsweise deutlich weniger Hardwarebauteile benötigt.
Die Grundidee dabei ist im Prinzip das,
was hiermit angedeutet ist, ist es so eine Hadesschaltung,
die es also quasi von auf Transistor-Ebene ist,
will ich jetzt also,
ich hatte es zwar eben schon mal hier kurz das Hades dazu gestartet,
werde ich jetzt aber trotzdem nicht in der Simulation kurz sagen.
Die Idee ist einfach, dass man sagt, na gut,
wie kann ich Informationen jetzt irgendwie dauerhaft speichern? Und da sagt man,
okay,
wenn ich jetzt also hier einen Inverter habe und hier den nächsten Inverter und die sind zurückgekoppelt,
dann ist das ein System,
was,
wenn ich also eben beispielsweise an der Stelle eine Eins habe
und an der Stelle nur 0,
war es also erstmal
irgendwie elektrisch gesehen dauerhaft funktioniert
So in Seemarschaltungstechnik besteht ein Wärter aus dem Pärchen von Transistoren
und diese beiden Rückgekoppeln in Wärter ist im Prinzip das,
was hier so in der Mitte zu sehen ist.
So und das Schreiben passiert jetzt eben dadurch,
dass ich quasi hier außen noch Transistoren als Schalter habe,
wo ich dann sagen kann, die werden quasi entweder beide geschlossen bzw. entsprechend aufgemacht.
So und dann kann ich jetzt eben sagen, wenn ich das hier schließe,
kann ich natürlich zum einen also hier irgendwie die Informationen auslesen.
Zum anderen kann ich aber auch sagen, ich zwinge,
hier an der Stelle eine Eins und an der Stelle
eine Null und habe dann quasi die andere Information passend gespeichert.
So dieses Erzwingen passiert dann eben auch wirklich so, dass man sagt,
das, was hier drin an Bauteilen ist, ist quasi vergleichsweise schwach ausgelegt.
Und wenn ich jetzt also hier denen entgegengesetzten werde,
also angenommen, ich habe hier eine Eins gespeichert,
würde jetzt also hier versuchen, eine Null reinzuschreiben. Wenn ich das,
was also quasi hier in die Richtung reinschreibt,
elektrisch eben stärker auslege, kann ich diesen Wert überschreiben,
So rum elektrisch gesehen kommt es zwar zwischen Transistor hier und einem hier zum Kurzschluss,
aber dadurch, dass das also nur einmal kurzzeitig passiert und das Ganze entsprechend schnell passiert,
geht da also in dem Sinne nichts kaputt.
So, und diese Schalter, das sind dann nämlich letztendlich
diese beiden Transistoren hier draußen. Wie gesagt,
bei dem, was wir jetzt an, informatiktauglicher,
elektrotechnik, also hier brauchen, kann man immer sagen,
so ein Franzislo ist für mich erstmal nur ein Schalter,
den ich auf und zumachen kann.
Alles andere brauchen wir dann hier nicht weiter. Gut,
das ist also die Grundidee,
wie man also im Prinzip jetzt so mit sechs Transistoren,
das ist dann nämlich
genau dieses hier
Einbett speichern kann. Es ist also deutlich aufwendiger,
als wenn ich jetzt sage, ich nehme irgendwie so ein Basis-RS-Flip-Flop.
Irgendwie so aus zwei Nances oder zwei Norths und noch irgendwas,
um da jetzt also quasi Logik für ein Ledger vorzubauen.
Dann kostet mich das also schon deutlich mehr Aufwand. Gut,
das sind Sachen, wo sich eben gerade durch diese Rückkopplung natürlich eine Information,
die Armadrefferin gespeichert ist, dann eben auch stabil erhält.
Das ist dann eben Erstrahmen. Das, was wir als,
wie gesagt, habe, da gibt es dann auch so eine Hardys-Demo,
wo man das dann nochmal entsprechend machen kann,
wo dann also auch noch so ein bisschen zusätzliche Leitungen mit drauf sind,
die man also in der Praxis eigentlich bei diesem Baustein dann noch immer hat,
wo man dann sagt, ich kann,
also generell diesen ganzen Baustein überhaupt erstmal ein- und ausschalten,
nennen sie dann immer Chipselect.
Nicht dann möchte ich natürlich sagen, möchte ich es reinschreiben,
demzufolge right ennable, dann passiert eben Datentransferen über den Eingang
hier an ein entsprechendes Speicherwort und möchte ich daraus lesen,
Output enable,
das ist dann das,
dass dann also quasi über diese Adresse
das Ganze rauskommt
Von der Grundidee her ist aber im Prinzip so ein gesamter
Speicher dann eigentlich erstmal nichts anderes als ein großes Schaltnetz.
Das heißt, ich lege die Adresse an.
Ich sage dann also irgendwie lesen oder schreiben und abhängig von
der Adresse dauert es dann eben eine bestimmte Zeit.
Und dann habe ich also quasi am Datenausgang meine Werte oder habe meine Werte,
die ich also über den Ahlengang hier rein anlege,
dann eben entsprechend reingeschrieben
Gut, hier nur nochmal für war es auf so
ein 64er-EC oder so ein anderes Beispiel.
Gut, im Gegensatz dazu ist jetzt natürlich die Sache,
hierfür brauche ich jetzt sechs Transistoren.
Das, was wir als Hauptspeicher in den Rechnern haben,
ist ja dann eben sogenanntes DRAM, Dynamic Gram.
Da wird ein Bit of I'm einzigen Transistor gespeichert,
beziehungsweise so rumgesehen ist es eigentlich ein Transistor und ein Kondensator dahinter.
Was natürlich so aus dem Bauch heraus erstmal grob heißt,
ich bin um Faktor sechs effizienter
Weil wenn ich jetzt hier also irgendwie sechs Transistoren brauche oder
nur einen, nicht das eben der Grund dafür,
dass Hauptsparche jetzt eigentlich immer der Rahmen ist.
Dort ist die Grundidee, dass man eben sagt,
ich habe also hier quasi ein Past-Transistor, also im Prinzip
sowas als Schalter und dahinter letztendlich eigentlich nur ein Kondensator.
Und eine Information wird eben dadurch gespeichert,
dass sie diesen Kondensator entweder auflade
Also jäh hätte ich dann also quasi Grauenpotenzial oder eben entsprechend Endlade.
Und dann habe ich eine Null und sowohl beim Aufladen als auch beim,
also beim Schreiben als auch beim Lesen geht das Ganze dann eben entsprechend hier rüber.
So wie man sieht, da ist das Ganze natürlich entsprechend sehr effektiv,
besonders insofern als das quasi Fertigungstechnisch dieser Kondensator eigentlich in diese Struktur hiermit integriert wird,
sodass man da dann eben wirklich sehr sehr effizient,
seine Bits irgendwo auf der Fläche unterbringen kann.
Nicht, was uns eben die Speichergrößen von mehreren Gigabyte letztendlich beschert,
die wir uns dann also irgendwo in Form von Speicherregeln irgendwo kaufen und auf dem Motherboard verbauen.
Nachteil von dem Ganzen ist natürlich so ein Kondensator,
ist von der Idee her ja hier zwischen, also irgendwas Isolierendes,
die Elektrikum und ich habe dann eben hier meine Ladung drauf,
also meinetwegen jetzt Elektronen als Ladungsträger gegenüber dem hier.
Und das, was aber daran technisch passiert, ist,
dass diese Isolierung nicht unendlich gut ist,
sondern es gibt eben so Effekte, Selbstentladung,
dass entweder also hierüber Ladungsträger verloren gehen oder eben dieser Pass
dran siehst du auch nicht komplett sperrt und darüber,
was verloren geht.
Letztendlich wird aber irgendwann die Information,
ich habe hier also eine Eins gespeichert,
Ich war, gut, ich kann jetzt nicht mehr sagen,
eins, wunderbar. Da ist natürlich der digital denkende Mensch
immer glücklich mit. Nicht rein praktisch ist das natürlich darauf,
dass sich da irgendeine Spannung letztendlich drauf habe.
Also irgendwie, meinetwegen jetzt beziehungsweise gegenüber dem hier dann,
also minus 0,7 Volt zum Beispiel. Und wenn jetzt Elektronen
sind und die dann aber eben irgendwann weniger werden, demzufolge die Spannung abnimmt.
Und irgendwann kann ich dann also eben nicht mehr sauber unterscheiden,
ist das eine Eins oder ist es eine Null oder wie weit hat was nachgelassen.
Deswegen müssen hier dann eben einmal regelmäßig immer irgendwie sogenannte Refresh-Zieglungen gemacht.
Hier werden, das heißt, die Information wird ausgelesen und wieder neu reingeschrieben.
Zweiter Nachteil ist eben auch, ich habe hier eine Eins,
meinetwegen, oder habe gespeichert, lese das jetzt aus.
Das, was dabei natürlich passiert, ist, dass wenn das
jetzt zum Beispiel dadurch gespeichert ist, dass Elektronen drauf sind.
Nach dem Auslesen sind die weg. Das heißt,
nach dem Lesen muss sich die Information dann auch wieder neu reinspeichern.
Also da sieht man schon,
dass es eben im Vergleich zum SRAM dann eben doch um einiges aufwendiger,
was dann eben wieder erklärt,
So ein DERAM eben deutlich langsamer als ein S-Rahmen.
Dafür dann aber eben für eine hohe Kapazität optimiert ist und mit einem minimalen Platzbedarf arbeitet.
So hier sieht man das Ganze nochmal so direkt in der Übersicht gegeneinander.
Also das ist jetzt, dass ich hier quasi eine S-Rahmenzelle,
die Rahmen wäre dann eben nur so ein Passtransistor und ein Kondensator, wo das Ganze dann gespeichert wird.
Hier ist das auch nochmal an so einem,
aufgesägt Elektronenmikroskopische Aufnahme, wie sowas, also rein technisch ist,
also der Kondensator wird eben entweder in Form von solchen ja,
gestapelten oder finnartigen Strukturen realisiert, dass die eine Variante,
die andere Variante ist im Prinzip das,
was dann hier so eine Trench-Zelle ist,
also so ein grabenförmige Struktur in dem Silizium,
wo dann also letztendlich,
dass die eine und dass die andere Teil so eines Plattenkondensatus letztendlich darstellen.
Und hier oben quasi an der Oberfläche ist dann nämlich also auch
gleich der Transistor in dem Sinne mit dran. So,
und damit kann man dann eben extrem effizient das Ganze wirklich
von der Platzanordnung her irgendwo auf dem Silizium unterbringen und dann eben auch entsprechend günstig fertigen.
Das ist also erstmal so grob das,
was man vom Lehrrahmen bzw. S-Rahmen wissen muss,
geht mir jetzt also weniger irgendwie um genau die Schaltungstechnik,
also die müssen jetzt nicht zwingend erklären,
aber dass man eben so grob weiß,
was sind die Eigenschaften, nicht was ist schneller,
was ist kleiner,
solche Sachen,
das sollte man auch bei aller Abstraktion von jetzt irgendwelchen
technischen Gegebenheiten dann doch immer so ein bisschen wissen
Gut, von den Derams selber gibt es dann nämlich noch
unendlich viele Varianten von, also irgendwelchen älteren Sachen,
so aus den 90er oder Anfang der 2000er Jahre,
bis zu dem, was man heutzutage hat.
In der Regel sind die Speicher dann eben auch noch als
sogenannte S-Dirams realisiert. Das heißt,
die haben da nämlich auch noch irgendwie sowas wie ein Taktsignal
und das Ganze läuft dann eigentlich noch synchron zu irgendwelchen Takten mit ab,
was unter anderem dann daran liegt,
dass eben beispielsweise diese Daten- und Adressleitung dann mehrfach benutzt werden
und dann zeitlich quasi über so eine Einbittleitung dann,
also die einzelnen Bitzener
Adresse übertragen werden
Nicht dann, das,
was wir jetzt in Computern quasi als Hauptspeicher sehen oder haben,
hat man dann eigentlich DDR-Rahmen, DDRSD-Rahmen,
steht dann für Double Data Rate, dass man eben sagen kann,
wie ist dann die Speicherung der Daten im Relation zu dem Taktsignal.
Also bislang hatten wir ja mal irgendwie sowas kennengelernt wie Vorder-
oder Rückflanken gesteuert und bei diesen Double Data Rate-Sachen ist es dann eben so,
dass ich das,
also sowohl Aktionen auf der Vorderflanke als auch auf der Rückflanke machen kann,
was dann eben auch dazu führt,
dass man dadurch dann letztendlich intern eben doppelt so schnell arbeitet und da dann eben auch noch mal ein bisschen was gewinnt.
Und dann gibt es eben die ganzen unterschiedlichen Standards,
die dann von dem ursprünglichen Standard inzwischen bis zu DDR 5 gehen,
wo man dann eben sagen kann,
ich versuche generell natürlich irgendwo zu erreichen,
eine möglichst hohe Datenübertragungsrate zum Speicher.
Das ist also das, was hier immer so als Kerngröße mit drin steht.
Warum? Wir haben heutzutage also irgendwo CPUs,
die mit mehreren Gigahertz Taktfrequenz laufen. Die wollen mit Programmen,
der letztendlich aus dem Hauptspeicher kommt und die wollen mit Daten,
das also auch aus dem Hauptspeicher kommt,
beziehungsweise da ein wieder zurückgeschrieben wird, irgendwie gefüttert werden.
Und das, was da eben letztendlich dann der Flaschenhals ist,
ist, dass eben so rumgesehen die CPUs eigentlich zu schnell
für den Speicher sind und da dann immer das Problem ist,
also wirklich rechtzeitig Programmcode ranzubekommen, beziehungsweise Daten ranzubekommen,
beziehungsweise wenn ich was schreibe, die dann also wegzuschreiben.
Wie gesagt, hast du nur mal vorne weggenommen.
Das ist dann eben der Grund für diese Cash-Speicher, die Speicherhierarchie,
weil, sagen wir mal, der Geschwindigkeitsunterschied zwischen CBU und Hauptspeicher dann eben auch nochmal so ein Faktor 100 ist.
Das heißt also, es dauert dann also,
wenn die CBU jetzt irgendwelche Daten aus dem Hauptspeicher lesen will,
was dann eben als SD-RAM realisiert ist, dauert das dann eben mehrere hundert Takte und da kauft sich jetzt natürlich niemand irgendwie eine Vier Gigahertzschnelle,
CPU, die dann also rein technisch letztendlich nur mit 40 Megahertz läuft,
weil die eben jedes Mal dann also entsprechend lange, also auf den Hauptspeicher warten müsste.
Gut, nicht deswegen, also das ist immer die Schwierigkeit,
also da eine möglichst hohe Datenrate hinzukriegen,
was man dann teilweise auch noch macht, ist,
dass man dann eben bei dem,
was man also letztendlich einen Speicher auf Motherbout verbaut,
eben nicht nur ein Übertragungsweg zur CPU hat,
also ein Übertragungskanal, sondern dann eben noch gleich mehrere,
dadurch kriege ich dann natürlich dann also auch nochmal mehr Daten pro Zeiteinheit übertragen,
wo sowas dann eben auch akut ein Problem ist,
ist auf Grafikkarten, also dort sind die Standards dann eben auch so,
dass man da also mit möglichst hohen Datenraten versuchen will,
dann also irgendwie seine Daten ranzubekommen.
Früher klassisch eigentlich so, dass man sagt, na gut,
um jetzt Bilddaten zu haben, beziehungsweise irgendwelche Sachen,
die dargestellt werden sollen, also beispielsweise jetzt von irgendwelchen Oberflächentexturen,
klassisch natürlich in Spielen irgendwie die Texturen, beziehungsweise das, was da also irgendwie dargestellt werden soll. Inzwischen,
da man ja also auch viel auf Grafikkarten letztendlich rechnen kann,
weil ich dort also massiv parallel Fließkomma-Rechenwerke eigentlich zur Verfügung habe und alles,
was heutzutage im Bereich Machine Learning passiert,
wird in der Regel mit Grafikkarten gemacht, weil dann nützt es mir nichts,
wenn ich jetzt nur so hier einen Sechs-Kern-Rechner habe,
nicht und pro Kern vielleicht zwei Fließkomma-Einheiten,
dann kann ich sagen, in jeder Plätze klein Billig-Grafikkarte,
wo also ein Gamer sagen würde, absolut unbrauchbar,
habe ich also schon mehrere hunderte Fließkomma-Recheneinheiten zur Verfügung und kann damit dann eben entsprechend schnell parallel rechnen.
Gut, also wie gesagt, Grafikkarten, das,
was dann andere Standards sind,
also die teilweise auch entweder in Grafikkarten beziehungsweise dann generell eher sie zu einem Super-Computing-Bereich sind,
sind dann eben so HBM oder HMC,
sind dann auch nur irgendwelche Akronyme,
wie gesagt, also die genauen Bezeichnungen,
was was ist und was wie schnell ist,
müssen sie jetzt also nicht
zwingend wissen,
eine Frage
Da schon ein, zwei, drei, vier, sechs Monate aufspeichert ist.
Dieser Kabinett Vater hat nicht die DDR. Gut,
also die Frage war jetzt, wenn der Flaschenhals bei der CPU
der Hauptspeicher ist und wenn ich jetzt also hier so auf die Tabelle gucke,
kann ich natürlich sagen, also GDR ist also so rum gesehen, also letztendlich schneller.
Deswegen wäre das dann ja eigentlich sinniger. So rum gesehen haben sie natürlich recht. Rein praktisch sieht das aber so aus,
dass man sagen kann, also bei dem,
was man typischerweise jetzt also an Chipsätzen hat,
hat man also auf einen normalen Desktop-Ship-Set,
nage ich schon mindestens zwei Speicherkanäle, wenn nicht,
also im Serverbereich geht das dann also mit vier oder sechs Speicherkanälen,
wenn nicht eben nochmal deutlich mehr,
beziehungsweise teilweise wird dann also auch was anderes eingesetzt.
Nachteil ist dann einfach letztendlich die Art und Weise,
wie das mit den Bauformen gemacht ist. Also das,
was also jetzt so als Speicherriegel gemacht und verbaut ist,
was also diese ganzen DDR bis fünf Standards sind, sind halt eben Teile,
wo ich also relativ auf einer relativ günstigen Platine letztendlich mitarbeiten kann,
da alles drauf baue und die dann also quasi dem Benutzer in die Hand drücken kann,
dass ich das irgendwo selber in so einen Sockel reindrückt.
Das, was Graphics oder GDDR-Speicher ist,
ist direkt auf der Platine verlötet über Bolgrad Array.
Da könnte man dann also selber nie am Hauptspeicher irgendwie noch
was nachrüsten oder was umbauen. Letztendlich das,
was dahinter steckt, jetzt als Speicher-Zelle,
also sprich so ein D-Rahmen,
die Bausteine sind in der Regel
sowieso identisch
Also da ist jetzt nichts, dass da noch was ist,
das geht da dann eigentlich hier jetzt nur,
dass man sagen kann, okay,
das sind jetzt nach außen hin unterschiedliche Protokolle,
unterschiedlich breite Datenleitung und irgendwas, wo man sagen kann,
es soll günstig sein von Benutzerhandhabhaber oder es wird irgendwo fest verbaut und im Supercomputing-Bereich,
wo das dann sowieso das Geld dann also irgendwie dann nicht so die Rolle spielt,
dann nimmt man dann eben noch andere Standards.
Ansonsten mit dem Flaschenhals zum Speicher,
das wird dann in dem Kapitel Rechnerarchitektur 2 eigentlich noch ein bisschen genauer erklärt,
das umgeht man eigentlich mit einem anderen Trick,
dass man dann eben dazwischen zwischen Hauptspeicher und CPU dann eben jetzt noch mehrere Ebenen.
Cash-Speicher hat, sodass also von der CPU-Seite aus gesehen,
ich eigentlich direkt vorausgesetzt, ich habe jetzt nicht in Cashmith,
also mit Vorlageschwindigkeit auf den Speicher darauf zugreifen kann.
Und das Problem jetzt mit Instruktionen und Daten lesen wird dann dadurch entschärft,
dass man getrennte Speicher für Instruktionen für Daten hat,
zumindest das, was dann so als First-Level-Cash bezeichnet ist.
Gut, also dass derem hier nochmal so ein bisschen Grafik,
also wie gesagt, also auch nur nochmal,
müssen jetzt das auch nicht zwingend wissen, wie sowas dann aussieht.
Also zum Beispiel SDRAM, das ist dann eben ja sowas,
wo man also im Prinzip so ein Clock-Signal hat, dann wird letztendlich sowas wie eine Adresse angelegt.
Und anschließend nach irgendwie einer bestimmten Wartezeit können dann eben Daten gelesen werden können. Hier sieht das jetzt noch so,
als ob die Adresse dann eben quasi auch immer jedes Mal entsprechend inkrementiert werden muss,
rein praktisch, das ist eben das,
was ich dann also teilweise dann auch dahinter verbirgt,
sieht das so aus, dass man dann eben auch solche Birst Moody hat,
dass man also nur am Anfang so eine Übertragung quasi einmal die Adresse angibt und dann einfach nur sagen kann,
mit jedem Takt lesen, lesen, lesen,
lesen und dann wird in dem Speicherbaustein selber automatisch die Adresse hochgezählt.
Das heißt, da kriegt man dann eben auch relativ effizient dann
seine Daten entsprechend rüber und muss hier nicht jedes Mal so und so viele Takte warten.
Gut, aber das ist eben auch so eine Sache.
Da gibt es also beliebig viele unterschiedliche Standards.
Also das ist jetzt nur ein Ausschnitt aus einem Beispiel,
also auch noch vergleichsweise alt.
Das ist also aus dem Buch von Förber zur Arm-Architektur von 2000.
Also wie gesagt, inzwischen sieht das so ein bisschen anders aus.
Gut, dann hatte ich ja noch gesagt,
um jetzt Informationen vielleicht also auch noch ein bisschen dauerhafter oder anders zu speichern,
gibt es dann eben auch noch den sogenannten Flash-Speicher.
Auch da muss man sagen, ist ähnlich kompakt wie in der Rahmen.
Das heißt, auch da war ich für die Informationsspeicherung letztendlich nur ein Transist.
Das ist dann aber eine etwas speziellere Art. Und zwar
dazu vielleicht nochmal kurz ein Exkurs in die Nummer zwei Folien zur Schaltungstechnik.
Also Morst Transistor. Kann man sich immer so vorstellen.
Ich hatte gesagt, ist letztendlich ein Schalter.
Also es gibt hier zwei zentrale Anschlüsse, Source on Train.
Die sollen quasi miteinander verbunden werden. Das sieht eigentlich so aus,
dass man sagen kann, ich habe hier in dem Silizium,
also irgendwo so einen Bereich, der also einfach direkt mit dem Source verbunden ist.
Und hier im Bereich, der direkt mit dem Drehen verbunden ist.
Und dazwischen ist etwas, wo jetzt erstmal keine Ladungsträger durchkommen
Dann gibt es aber hier im Prinzip jetzt ein isolierende Schicht und da drauf,
also hier, sagen wir mal, mit Blau als Metall gezeichnet,
was es aber technisch gesehen dann auch nicht ist, einen dritten Anschluss,
das ist dann immer das, was quasi dieses hier oben ist.
Also hier bei Source, hier wird Jane, lass ja das geht,
der quasi wie ein Kondensator zu dem Teil hier unten arbeitet.
Und was man jetzt machen kann, ist,
dass wenn dieses Gate letztendlich aufgeladen wird,
Dann erzeuge ich also hier unterhalb dieser isolierenden Schicht,
das ist also hier so ein bisschen angedeutet,
dann letztendlich eine elektrisch leidende Verbindung von den beiden.
Also das ist die Art und Weise, wie wir jetzt sagen,
also ein Transist eben erstmal nur begreifen müssen,
also einfach nur als ein Schalter, wo ich also nachdem,
je nachdem, was ich also hier drauf tue,
hier über eine leidende Verbindung hinkriege oder nicht.
So, wie gesagt,
das funktioniert Ihr im Prinzip so jetzt als die Schaltungstechnik,
die wir jetzt immer benutzen, Seemausschaltungstechnik, man muss dann sagen,
gibt es davor noch zwei unterschiedliche Arten.
Der eine arbeitet quasi mit positiven, anderen mit negativen Spannungen.
Das ist dann immer dieses Pärchen aus den beiden,
was also bei Seemausschaltungen typischerweise der Fall ist.
Gut, und bei dem, was wir jetzt als,
oh Gott, gucken, wo war ich denn jetzt
hier gerade
So, das war es jetzt also letztendlich,
Flash-Speicher technisch gesehen sind,
ist jetzt einfach nur die Idee, dass man sagt,
ich habe hier in dieser isolierenden Schicht dann eben nochmal etwas,
was ich im Prinzip jetzt auch nochmal wie so ein komplett isolierten Bereich,
den ich aber eben entweder aufladen oder entladen kann.
Und dadurch kann im Prinzip über dieses Gate,
was dann also diesen Teil eben entsprechend dann nochmal entsprechend aufladen kann,
können jetzt hier eben dauerhaft erstmal Elektronen reingebracht werden beispielsweise.
Und ich habe dann eben entsprechend Hugo Wear dann eine leitende
Verbindung zwischen Source und Drehen und hätte dann da eben beispielsweise an eben eine Eins gespeichert.
Oder ich entlade es und das eine Null. Ich habe hier
keine Verbindung, habe dann eine Null gespeichert. So,
und das, was hier drin ist,
das ist aber damit so aufgebaut, beziehungsweise so isoliert,
dass sich dort die Information auch hält und das Ganze dann eben auch die Ladung quasi erhalten bleibt,
wenn die Versorgungsspannung weg ist.
Nicht, weil genau das habe ich nämlich bei normalen Feldeffekttransistoren letztendlich nicht,
nicht, weil dann ist da nämlich quasi das,
was ich hier als Spannung auf dem Gate habe,
dann nämlich auch auch weg.
So, und das, was bei Flash war,
ist ja dann eben passiert, ist,
dass man auslesen vergleichsweise schnell machen kann.
Beim Schreiben ist jetzt natürlich die Sache,
dass ich dann also hier über dieses Control-Gate,
also hier drauf irgendwie Ladung raufbringen muss oder das eben gezielt entladen muss.
Dafür bräuchte man dann intern dann eben etwas höhere Spannung und
da ist es dann eben auch so,
dass die Anzahl der Schreibzugriffe eben nicht unendlich groß ist.
Nicht deswegen gewährleisten die Hersteller von Flash-Speicher dann eben auch immer nur
oder garantieren eben so und so viele Terabyte, die geschrieben werden können.
Und danach ist dann eben die Gewährleistung zu Ende.
Und dann kann man dann also je nach Größe,
zum Beispiel ist da so eine Solid-State ist, dann eben sagen,
okay, wie viel schreibe ich jetzt wirklich an Daten drauf?
Wie häufig passiert das? Da kommt man also auf irgendwie
so Lebensdauern von mehreren Jahren, wo man sagt, okay,
danach wird die Technik sowieso in der Regel veraltet sein oder
man hat sich sein neues Smartphone dann also inzwischen schon wieder ausgeguckt und gekauft.
Und dann stört es nicht, wenn danach eigentlich Technik nicht mehr funktionieren würde.
Also das ist ein bisschen das, was also hinter diesem Flash-Speicher steckt.
Nicht also auch dieses jetzt hier nur als Hintergrundwissen,
dass man so ein bisschen wahr ist, wieso sie die technischen Zusammenhänge bei sowas sind. Also es geht jetzt nicht darum, hier irgendwelche Transisto-Leichungen runterzubeten und das also genau zu beschreiben. Gut,
wie sieht ansonsten so ein Speichersystem aus,
also hier dann nur auch an dem Beispiel so eines kleinen eingebetteten Prozesses und des Armprozessors,
also in diesem Fall 32 Bit-Prozessor,
dass man eben sagt, ich habe jetzt meine CPU,
habe dann eben hier irgendwie jetzt meine Speicherbausteine und das,
was man dann typischerweise dann eben auch macht, ist,
was so ein bisschen was, was hier angedeutet ist,
dass wenn ich zum Beispiel Hier einmal irgendwo in meinen S-Rahmen habe,
dass man dann eben auch noch irgendwelchen Reep-Only-Speicher hat,
sei das jetzt also eben für ein Programm, Betriebssystem,
sei das dann eben in Form von,
also auch hier in unseren Rechnern ist sowas mit drin dann eben letztendlich auf dem Motherboard irgendwo mit integriert,
wo man sagen kann, da sind halt eben die Teile,
die letztendlich das System braucht,
um beispielsweise beim Einschalten überhaupt erstmal bis zum Wuten zu kommen,
weil irgendwo muss, bevor der Rechner ja losläuft,
dann also das Betriebssystem hier in den Speicher geladen werden und zumindest der Mechanismus muss er auch irgendwo hinterlegt werden.
Und zumindest dafür habe ich dann so ein Red Only-Speicher
technisch gesehen wird, das heutzutage natürlich ein Flash-Beicher sein.
So, und nicht das, was man dann eben auch
noch so ein bisschen mitmacht. Ich hatte auch immer gesagt,
also ich habe auf der einen Seite, also irgendwie sind bestimmte Speicherwortlänge,
also hier war beispielsweise dann eben zum Beispiel 32, Beat,
die eigentliche Adressierung bei den meisten Prozessoren, auch bei X86,
also das, was wir hier benutzen, ist dann immer beidweise.
Deswegen ist das hier dann eben von der Idee her zum Beispiel schon so aufgebaut,
dass man sagen kann, ich habe hier so vier Blöcke,
jeder ist dann eben letztendlich dann immer ein Wahrheit.
Und dann kann man nämlich auch sehr einfach einzelne Byte adressieren,
indem ich dann im Prinzip hier von den Adressen zum Beispiel
die unteren beiden Bit nehme und damit dann eben sagen kann,
damit wird dann letztendlich das entsprechende Byte nur dekodiert und mit
den anderen verbleibenden Bits der Adresse habe ich dann eben im Prinzip die einzelnen Speicherzählen in der Adressierung.
Also hier ist noch so ein bisschen so was von so Logik von so einem Adressdekodia gezeigt.
Wie gesagt, muss jetzt nicht zwingend nachsimulierend nachvollzogen werden. Also das,
was dann hier eben eigentlich auch nur sieht, ist,
dass eben beispielsweise hier also aus diesen beiden Adressbits hier einfach binär von null bis vier entsprechend dann raus dekodiert wird,
welches einzelne beiden man anspricht,
was dann eben über solche Wright Enable und Chips-Elect-Leitung dann eben gezielt ausgewählt wird.
Also auch da sieht man nur mal so ein Beispiel,
nicht warum wurden wir hier also irgendwie mit Schaltennetzen gequält,
also da ist ein praktisches Beispiel,
wofür man sowas dann eben unter anderem auch mal mitbraucht
Gut, ja, damit haben wir jetzt also den Teil
Speicher- oder Speicherkomponenten irgendwo so mit abgefrühstückt.
Jetzt geht es natürlich noch so ein bisschen darum,
dass wir sagen, wir müssen jetzt ja auch noch irgendwo
den Speicher und die CBU oder irgendwelche externen Geräte mit irgendwelchen Systemen miteinander verbinden.
Dazu als Stichwort Bussysteme, womit man letztendlich eine elektrische oder
zumindest auch eine logische Verbindung zwischen mir an Geräten irgendwie herstellen kann.
Auch da gibt es, ähnlich wie beim Speicher,
habe ich dann also auch so einige Folien hunderte von unterschiedlichen Standards,
mit unterschiedlichsten Eigenschaften. Auch hier geht es mir eher darum,
dass sie einmal so grob so ein paar Begriffen gehört haben,
das ein bisschen einordnen können. Dass es jetzt aber nicht darum geht,
zwingt also jetzt genau irgendwie den oder den Standard oder das Protokoll zu lernen,
weil da kann man sagen,
nicht dann verbergen sich hinter jedem Nasen irgendwie Datenblätter oder Spezifikation,
wo man dann also irgendwie mit ein paar hundert Seiten sich da also irgendwie einarbeiten müsste.
Also das geht es dann eigentlich erstmal nicht weiter
Gut,
im Zusammenhang mit Bussystemen werden dann eben noch so ein paar Sachen mit angesprochen,
was zum Beispiel darum geht,
wenn jetzt an so einem Bussystem,
was also zum Beispiel jetzt bei den Hauptsystemen ist,
die wir also zum Beispiel auf Motherboard haben,
wo ich jetzt also nicht nur eine Punkt-zu-Punkt-Verbindung zwischen zwei Geräten habe,
sondern wo jetzt vielleicht noch mehrere Systeme dranhängen,
wer darf wann auf diesen Bus zugreifen,
das Ganze sich am Bus abitrierung und dann
so ein bisschen was zu den unterschiedlichen Varianten
Grob gesehen kann man immer sagen,
also es geht eigentlich darum zu sagen,
ich habe so was wie beispielsweise jetzt, also nach dem Verneumann-Konzept,
CPU, ich habe hier meinen Speicher,
der ist vielleicht noch unterteilt in Rahmen und kriegt Only-Speicher.
Nicht so ähnlich, wie wir das gerade eben gesehen haben.
Logisch letztendlich unterteilt, funktional ist, dass hier natürlich dann alles irgendwie ein Block.
Ich habe dann vielleicht noch irgendwelche IO-Geräte oder irgendwas anderes,
was da draufhängt und kann die dann eben über entsprechende Adressen ansprechen.
Ich habe dann hier irgendwie einen Datentransfer und ich habe dann natürlich irgendwelche Steuerleitungen,
die zwischen denen Komponenten hin und her gehen. So,
und bei diesem Bussystem hatte ich eben gesagt,
gibt es ja sehr viele sehr unterschiedliche, das geht eben von Bussen,
wo es darum geht, also in möglichst kurzer Zeit,
möglichst viel Daten von A nach B zu transportieren, also sprich beispielsweise vom Hauptspeicher zur CBU.
Auf der anderen Seite gibt es Bussysteme, wo man sagen kann,
die sollen Oder die dürfen nichts kosten, sollen extrem einfach aufgebaut sein. Am besten dann irgendwie sowas, wo ich wirklich nur so zwei einfache Leitungen habe. Nicht,
wo man sagen kann, okay, das ist etwas,
mit dem ich irgendwelche Sensoren anschließen kann,
mit denen ich irgendwelche einfachen Aktuatoren anschließen kann,
was dann also beispielsweise häufig,
also auch bei irgendwelchen eingebetteten Systemen der Fall ist, also sprich,
wenn ich heutzutage irgendwo im Auto sowas wie einen elektrisch einstellbaren Sitz habe,
dann ist es also nicht mehr ein elektrischer Schalter und dahinter irgendein Gleichstrom-Motor,
sondern das wird in der Regel so gemacht,
dass der Motor eigentlich ständig irgendwie an der Versorgungsspannung hängt und dann eben irgendwie ein einfacher Bus drauf ist und mit dem Schalter schalte ich dann halt eben irgendwie irgendeinen Komponenten,
irgendein Protokoll an,
beziehungsweise im Zweifelsfall wird dann eben noch über die Bordelektronik das Infotainment-System und Sonstiges,
die dann auch noch alle an den Bus hängen,
dann eben auch noch gesagt,
also ich mache mit der Funk-Fernbedienung die Autotür auf und wenn das mein Schlüssel ist,
dann identifiziert er sich auch gleich noch und dann fährt natürlich der Fahrer,
sitzt dann auch gleich in meine Position und nicht also solche Sachen verbergen sich dann eben auch dahinter.
Das heißt, So, und das, was dort eingesetzt wird,
eben auch so ein Bussesystem, laut Hersteller, Aufpreiskatalog,
kostet das dann natürlich ein paar tausend Euro extra in der Herstellung selber,
darf das also nicht mehr als ein paar Cent kosten,
ich demzufolge dann eben auch wirklich einfachstes Protokoll, minimal einfaches System,
da muss ich auch nicht mehrere Gigabyte an Daten von A nach B transportieren,
sondern wirklich nur Gefahr in die Position oder fahre nicht in die Position,
beziehungsweise eben noch den Wert von dem Motor,
was dann der Anschlag ist, nicht,
also irgendwie so acht bei Daten,
aber das war es dann auch.
Nicht dem zuvor habe ich dann eben sehr unterschiedliche Anforderungen. Genauso was man dann eben beim Bussystem auch oft hat,
bei einigen Echtzeitfähigkeit, nicht, also auch da ist es kritisch,
Automotive-Bereich, Steuerung von ABS, von irgendwelchen Bremssystemen, Airbag-Auslösung und so weiter,
nicht da möchte man natürlich irgendein Protokoll beziehungsweise irgendeinen Bus haben,
der also a. bei einem Fehlerfall jetzt irgendwie,
wenn das System ausfällt, nicht falsch reagiert,
der auf der anderen Seite dann aber eben auch erlaubt,
überhaupt erst mal festzustellen,
ist ein Fehler aufgetreten.
Wenn das Ding aber normal funktioniert,
dann soll halt eben zwischen Crash und feststellen des Beschleunigungssensors.
Ich bin gegen den Baum gekommen bis zur Zündung des Airbags,
eben nur ein paar Millisekunden vergehen, wenn überhaupt.
Und da muss ich dann eben
entsprechend Echtzeitfähigkeit haben
Gut, ja, Brustsysteme gibt es eben sehr viele sehr unterschiedliche Sachen. Das,
was wir uns das häufig eben oder in der Regel erstmal begegnet,
ist so beim Mikroprozessorsystem eben sowas wie Adressbus in Datenbus,
das, was da eben ja schon an der einen Grafik aufliegen hatte,
wo man dann eben letztendlich sagt,
ich habe so und so viel Adressleitung, kann damit dann eben,
wenn ich jetzt sowas wie Speicher adressiere, dann eben auch sagen,
ich habe damit dann zwei Hochendbytes als Adressierung oder eben so und so viele Datenleitungen.
Häufig haben die dann eben gerade so bei Kontrollbörsen dann eben auch noch unterschiedliche Studien Steuersignale und so weiter und was man eben auch oft macht,
hatte ich auch schon gesagt, ist, dass man teilweise,
wenn ich jetzt eben einfach um die Worte oder die Leitungsgrößen kleiner zu halten,
dass man da dann eben teilweise noch so was macht,
dass man eben die Leitung sowohl für Adressen,
also für Daten nimmt und dann eben in dem Busprotokoll sagt,
es gibt halt eben irgendeinen Umschaltmechanismus, um zu sagen,
was soll als Adresse oder was soll als Datum interpretiert werden?
Gut, bei sowas wie Bussystem für Speicher was teilweise dann auch immer noch ganz gerne gemacht wird. Also hier das Beispiel Intel X86,
da geht es jetzt also nicht darum, um zu zeigen,
wie, also waren die Rechner früher, sondern auch nur,
also das einer der Gründe, weswegen,
also die Intellarchitektur eigentlich ja so vergleichsweise erfolgreich ist,
hat er ja schon gesagt, ist, dass der Befehlssatz über die Zeit eigentlich immer weiterentwickelt wurde.
Also es kamen immer mehr Befehle hinzu. Das,
was früher aber vom ersten 8086 quasi an Befehlen da war,
ist, also auch in heutigen aktuellen Prozessoren von AMD oder von Intel immer noch genauso vorhanden,
was eben dazu führt, dass man sagen kann,
rein technisch gesehen waren eben auch irgendwelche Programme,
die man damals zumindest für teuer Geldern noch irgendwie gekauft hatte, auch immer lauffähig, auch wenn man die Hardware aufgerüstet hat.
Also das war eigentlich also einer der genialen Schachzüge da,
also irgendwie, dass man das mit dieser Rückwärtskompatibilität dafür gesorgt hat,
dass eben, wenn jetzt was weiß ich,
irgendeine kleine Firma sich, also eine Buchhaltungssoftware gekauft hatte und irgendwann gesagt hat,
also nach drei Jahren wunderbar, Rechner sind abgeschrieben,
wir brauchen neue Hardware, die ist inzwischen sowieso so und so viel mal leistungsfähiger,
nicht, dann konnte man die quasi kaufen und die alten Programme liefen letztendlich immer noch.
Gut, und was jetzt zum Beispiel einfach nur so kurz gezeigt ist,
ist eben die Sache, also früher,
ich bei den Rechnern war ja nur nicht vorstellbar,
dass man also irgendwie sehr, sehr viel Hauptspeicher besitzt,
da war der Adressbus eben 20 Bit breit,
nicht damit lassen sich also ein Wenn ich jetzt gerade sage, Megabyte ist es falsch, also maybe byte letztendlich adressieren.
In späteren Generationen wurden dann eben 24 Bitch spendiert.
Nicht dann kamen also quasi ab 803, 86,
32 Bit, 4 Gigabyte. Inzwischen ist also auch das etwas,
was man sich als normalsterbliche Anwender problemlos eigentlich eher als Einsteigermodell inzwischen schon leisten kann.
Und inzwischen sind die ganzen Architekturen so, dass da eben
Die Adressbusse dann eben noch breiter geworden sind.
In der Regel sind das heute dann eigentlich zwischen,
das ist dann jetzt wieder so ein bisschen systemabhängig,
wie das genutzt wird, aber von der Idee her dann eben bis zu 64 Bit, die man da dann adressieren kann.
So, die Daten selber sind dann eben beispielsweise,
dass es jetzt hier sowas wie so ein Synchronerbus zum Schreiben,
also in diesem Fall jetzt ein DRAM-Protokoll,
wo man dann also im, oder SDRAM-Protokoll,
wo ich dann also hier quasi jetzt Vieh als Taktsignal habe,
nicht wo man dann eben sieht, irgendwo der Sender,
also beispielsweise die CPU sagt dann eben, okay, von der Adresse möchte ich lesen.
Die Adresse wird angelegt, dann gibt es dann also irgendwie so ein Memory-Request und ein entsprechendes Not-Read-Enable. Und wenn das da ist,
dann sagt der Speicherbaustein quasi jetzt,
nicht das passiert bei der fallenden Taktflanke, bei der steigenden,
stark flanke, sagt der Speicherbaustein dann eben entsprechend gut,
ich werde das jetzt auslesen, bin aber erstmal beschäftigt,
dann geht eben irgendwie, gehen mehrere Takte ins Land,
bis dann quasi der Speicher, dieses Wade zurücknimmt,
dann war es die CPU quasi,
wenn das jetzt weggenommen wurde, mit der nächsten eigenen,
also in diesem Fall fallenden Tagflanke,
habe ich dann gültige Daten auf dem Boss.
Echt gut, da sind dann immer so ein Beispiel,
also wie dann solche Protokolle immer irgendwie aussehen, nicht und je nach dem,
ob das nun DDR irgendwas oder GDDR oder HBM-Standard oder was weiß ich was ist,
sind die dann natürlich, also entsprechend unterschiedlich spezifiziert,
einmal für Schreiben, einmal für Lesen, wie gesagt,
das ist noch hier noch sowas vergleichsweise einfach ist.
Also wenn man so in die Datenblätter von irgendwelchen Speicherbausteinen reinguckt,
dann hat man da erst mal fünf Seiten mit solchen Diagrammen,
die dann entsprechend zu lesen und zu interpretieren sind.
Also auch das jetzt nur so als kurzer Hinweis darauf, nicht?
Also ich hatte ja schon gesagt, also Impulsdiagramme findet man
dann eben entsprechend häufig dann, also zu so einer Dokumentation dann auch.
Gut, ansonsten, wie das genau aussieht, braucht es dann hier nicht so weiter zu interessieren. Beim A-Synchronenbus habe ich dann im Prinzip auch über so einen Satz von Steuersignalen,
also dass der Sender, also in diesem Fall der Master,
dann eben sagt, ich möchte lesen,
ich lege dann eben die Speicheradresse und irgendwelche Steuerleitungen an,
sagt dann, okay, hiermit wird der Lesebefehl ausgeführt oder getriggert,
der Speicher, also das Lave würde dann eben sagen,
okay, wenn ich jetzt diese feine Flanke sehe, mache ich irgendwas,
dann dauert das eine bestimmte Zeit und wenn die Daten da sind,
dann würde der Speicherbaustein, die dann eben letztendlich auf den Bus legen,
dann von sich aus dann quasi das mit diesem Signal bestätigen
Und anschließend kann dann die CPU quasi diese Daten lesen und würde anschließend sein eigenes Master-Sync zurücknehmen,
woraufhin dann eben auch der Slave dann, also quasi dieses, gut,
wie gesagt, da gibt es eben viele unterschiedliche Protokolle,
nicht in diesem Fall, also quasi über zwei Leitungen,
über die dann also letztendlich dann gesagt wird,
ich möchte was von dir und irgendwann würde dann,
also quasi in diesem Fall dann der Slave das Ganze dann eben irgendwie bestätigen.
Also das nur als zum Beispiel, wie sowas im Prinzip
dann aussehen könnte
Gut, dann kommen wir noch zu dem Stichwort Busabitrierung. Dahinter,
oder daran runter versteht man dann eben letztendlich die Sache,
wie sieht das jetzt aus, wenn ich so ein Bussystem habe,
an dem mehrere Komponenten hängen.
Dadurch, dass ich über diesen gemeinsamen Bus ja immer nur eine einzige Datentransfer machen kann,
muss natürlich, also das Ganze irgendwo verwaltet werden.
Das kann man also dann auch abhängig von der Art
des Busses, also entweder über eine zentrale Ressource machen.
Das ist also die Art und Weise,
wie das beim Busen beispielsweise jetzt in den Computern verbaut sind,
also PCIE-Standard und so weiter passiert, wo es dann eben Buscontroller gibt,
der dann eben letztendlich eine Verwaltung macht.
Es gibt auch protokollbasierte Verfahren, wo man dort letztendlich mitarbeiten
kann, wo das Ganze dann dezentral passiert.
Also gerade so bei solchen Lohkostbussen kann man dann also gerade
auch mit so ein paar elektrischen schaltungstechnischen Tricks dann sagen,
okay, Einfach jeder Client, würde anfangen zu senden.
Die haben eine unterschiedliche Priorisierung und aufgrund dieser Priorisierung würde,
wenn ihr zweit gleichzeitig senden würdet, irgendwann dann quasi auf der Brust in so einer Kollision kommen.
Ist dann aber eben immer so gelöst,
dass letztendlich der mit der höheren Priorität gewinnt,
der mit der niedrigeren Priorität würde dann feststellen,
ich sende eine Eins, empfange aber oder lese auf dem Bus aber eine Null.
Okay, dann hat mich jemand überstimmt und dann würde er
sich abschalten und das irgendwann nach einer bestimmten Zeit wieder versuchen
Also da gibt es relativ viele Trickreiche Protokolle, wie man sowas beispielsweise machen kann.
Bei solchen zentralen Systemen gibt es dann eben auch natürlich eine sehr große Bandbreite,
wie eine Priorisierung anzulegen ist, wo man eben sagt,
entweder das Gerät hat entsprechende höhere Priorität oder ich mache das mit so einer Art Zeitscheibenverfahren,
was dann natürlich das in Anführungszeichen faire Verfahren ist.
Das ist das, was dann immer hier so als
Round Robin bezeichnet ist. Nicht, wo man sagt,
also die Komponente darf so und so lange,
die Komponente darf so und so lange die Komponente, darf so und so lange.
Nicht sowas hat dann wieder einen Vorteil,
dass sich natürlich Fest sagen kann, wann welche Komponenten,
wie viele Daten senden können. Das ist zum Beispiel jetzt wieder entscheidend,
um sowas wie Echtzeitfähigkeit zu garantieren auf System,
weil ich dann eben genau weiß,
wenn ich so und so viele Daten in der Zeit übertragen muss und das System entsprechend ausgelegt ist,
kann ich das also auch garantieren und bin ich davon abhängig,
dass jetzt nicht vielleicht jemand anders irgendwie mich blockiert und die Daten dann nicht übertragen werden können.
Nicht andere Verfahren, das, was dann auch noch häufig hört, sind sogenannte Token-basierte Verfahren.
Da wird dann eben quasi immer so ein Token weitergegeben,
wo dann also die Komponente, die dann quasi gerade das Token hat,
den Bus exklusiv benutzen darf.
Wenn die mit ihren Sachen fertig ist, gibt sie das
dann quasi jetzt wieder an die nächste Komponente weiter.
Dann darf die damit arbeiten und so weiter.
Aber wie gesagt, da lassen sich also beliebig viele Protokolle erstellen.
Ist dann letztendlich also von der Art ist, wo es ist dann also abhängig.
Hier auch nur grob angedeutet, nicht. Also das,
was man dann häufig hat, ist dann eben diese zentrale Komponente,
so ein Busarbeiter, der dann also entweder auf einen oder auf mehreren Bussen das Ganze verwalten kann. Was man in der Praxis auch häufig macht,
also auf den Komponenten, ist, dass,
also auch wenn einem das natürlich erstmal so ein bisschen widersinnig erscheint,
dass die externen Bauersteine und externe Komponenten teilweise höher priorisiert sind als die CPU,
weil beispielsweise, wenn ich jetzt also irgendwie,
nehmen wir mal an, die Netzwerkschnittstelle,
jetzt also irgendwie aus dem Ethernet die Daten bekommt,
die hatten natürlich nicht unendlich große Puffer,
um Sachen zwischenzuspeichern und damit es dort zum Beispiel jetzt nicht zu irgendwelchen Pufferüberläufen kommt,
so eine Strategie dann wieder sinnvoll, weil man sagen kann,
okay, dann wird halt eben Zweifelsfall die CPU mal kurz ausgebremst.
Aber dafür kann dann eben die Netzwerkschnittstelle ihre Daten in irgendeinem Hauptspeicherbereich erstmal übertragen.
Ist die los? Nicht hinteran kann also die normale Berechnung
oder ist was normal auf der CPU läuft, weiterarbeiten.
Gut, aber das ist, wie gesagt, alles von
der Art und Weise abhängig, welches Busprotokoll ist es.
Wie wird es eingesetzt? Was ist da letztendlich das Ziel von dem Ganzen?
Nicht ansonsten hier, also auch nochmal so eine Liste von einigen Busprotokollen.
Wie gesagt, das geht von sehr einfachen Leitungen,
mit denen also im Prinzip früher im Prinzip sowas wie Terminals an Großrechner angeschlossen wurden.
Erst 2, 3, 2, das ist das,
was sich serielle Schnittstelle nennt.
Hatte man früher auch noch, sagen wir mal so,
als 7-Poligen-Stecker in der Regel irgendwo auf seinem PC,
beziehungsweise auf dem Motherboard dann letztendlich mit drauf.
Inzwischen ist das eigentlich abgelöst durch USB
Hängen dann früher zum Beispiel eben Tastatur und Maus dran an der Serienschnittstelle.
Nicht dann über einfache Protokolle, iQuadrat, C,
USB, wie gesagt, also von auch sehr einfachen Standards
bis zu gut USB 4 ist dieses Jahr gerade spezifiziert worden.
Gibt es noch nicht rein praktisch,
soll aber in den ersten Chips Anfang nächstes Jahres,
also auch irgendwo in der Praxis auf irgendwelchen Geräten auftauchen.
PCI wusste, das ist das,
was letztendlich die Verbindung auf dem Malabod zwischen den Komponenten darstellt,
heutzutage ist, dass dann PCI Express,
wo man dann eben auch sagen kann, ähnlich wie über eine Speicherbandbreiten,
man möchte also irgendwie was haben mit möglichst hohen Datenübertragungsraten.
Gut, so Hypertransport, das ist von AMD im Protokoll,
um Prozessoren zu koppeln, NV-Link von Nvidia, Kopplung von Grafikkarten.
Gut, also wie gesagt, die Begriffe, Datenraten,
wann wie, wo, welche Standards,
müssen sie jetzt also nicht zwingend wissen,
das ist ja sie hier wirklich nur mal so,
um zu zeigen,
was es da theoretisch alles gibt
Ja, hier noch mal ein bisschen was zu dem PCI-Bus,
weil da kann man also auch gerne selber noch mal ein bisschen nachgucken.
Wie gesagt, ursprünglich als Wahl- oder Nachfolger des Isabosses,
also das, was auf den Motherboards ganz früher drauf war,
von Intel, also Anfang der 90er Jahre eingeführt,
33 Megaherz-Takt, ganz früher dann eben auch als 32-Bit-System.
Nicht nachher wurde es dann also auch schneller und breiter,
gemeinsame Adresse und Datenleitung und die Appetrierung
erfolgte dann durch die CPU
Was da dann eben auch schon mit drin ist,
dann also auch etwas,
was wir heutzutage auch täglich machen und benutzen und was also in anderen Protokollen
zum Beispiel in den USB eigentlich auch mit drin ist,
dass sie die Komponenten auch immer selber an den Bus quasi identifizieren.
Das heißt, wenn ich jetzt irgendeine neue Komponente einstecke,
dann wird halt während des Einschaltens letztendlich in diesem Vordergrund vom Betriebssystem dann eben nachgefragt Okay,
in Slot 3, wer bist du?
Dann wird eben entsprechendes Protokolls dann eben irgendwie zurückgegeben.
Ich bin die Grafikkarte XY, ich bin so und so schnell,
habe die und die Leitung oder Spezifikation nicht.
Und dann wird das Betriebssystem eben gucken, habe ich den passenden Treiber dafür.
Das ist also die Art und Weise, wie im Prinzip das, also bei PCI bzw. PCIA läuft. Im Prinzip bei USB,
als wir jetzt in Anführungszeichen Billigvariante mit niedrigen Datenübertragungsraten, die ich jetzt eben brauche,
um Maus oder Tastatur oder eben einfache Geräte anzuschließen,
habe ich auch so einen Mechanismus,
dass da das Gerät sich dann eben auch gegenüber dem USB-Controller quasi zu erkennen gibt, beziehungsweise abgefragt wird und man dadurch dann eben auch entsprechend über einen Bus sehr viele sehr unterschiedliche Geräte mit handhaben kann. So,
PCI-Bus hatte ich jetzt nur deswegen noch,
weil inzwischen haben wir zwar eigentlich PCI eh,
nichtsdestotrotz kann man das Ganze heutzutage jeder auf seinem Rechner sich also auch gerne mal ansehen,
also auf linuxartigen Geräten kann ich also mit so einem LSPCI mir,
also das ist jetzt hier von dem Laptop,
dann zum Beispiel anzeigen lassen,
was da also irgendwie drin hängt und kriegt dann eben Informationen über Die Baustahne, die da,
also in dem Sinne jetzt also die Verbindung zur CPU-Ambos machen,
Grafiksystem und, und, und, nicht und je nachdem,
was da alles dranhängt, kann man sich das anzeigen lassen,
beziehungsweise wenn man will, also auch mit ein bisschen anderen Tools,
also nochmal ein bisschen schicker in grafische Oberfläche,
dass ganze funktioniert im Prinzip auch mit anderen Betriebssystemen,
also bei Windows, ja, im Prinzip,
man konnte sich es raussuchen über einen Gerätemanager,
hat man da also ähnlich oder vergleichbare Information bei Windows 10,
weiß es gar nicht, in wann man da ist,
über den Gerät der Manager,
das nicht sogar vielleicht auch noch ein bisschen genauer bekommt.
Denke ich mal, da wird das dann auch sein.
Gut, wie gesagt, also PCI-Bus, hier diese Leitung,
können wir überspringen, das muss man nicht wissen.
Und auch hier dann, also nur so ein Beispiel,
auch da gibt es dann eben irgendwie so ein Timing,
wo man dann sagen kann, ich habe Lese, ich war Beschreibzyklen,
hier dann eben auch so eine gemeinsame Nutzung von Adressen und Datenleitung,
so und wie das hier innen drin einzeln aussieht,
wann,
welche Leitung,
welchen Wert haben muss
Wie gesagt, das soll jetzt hier nicht weiter interessieren.
Gut, als noch mal eine Schnittstelle,
die ich auch noch mal kurz vorstellen werde,
weil die also für ein paar Sachen vielleicht also auch noch interessant ist oder interessant sein könnte.
Und weil die auch noch vergleichsweise einfach zu verstehen ist,
serielle Schnittstelle ist eben wirklich das,
wo also früher eben zum Beispiel sowas wie Maus oder Tastatur dranhängen.
Das ist einfach nur eine Übertragungsschnittstelle,
mit der man also im Prinzip seriell,
deswegen ist es eine reelle Schnittstelle,
einzelne Byte zwischen zwei Geräten
Also auch eine reine Punkt zu Punktverbindung miteinander verbinden kann.
Ursprünglich war das was, womit also so alte Teletypes oder Fernschreiber quasi ein Großrechner angeschlossen waren.
Später kam dann quasi eine Ausgabe Terminals, die dann da dranhängen.
Die waren aber auch dann quasi alle über so eine Kommunikation.
Ursprünglich in der Spezifikation war das dann auch mit Versorgungsspannung von
plus 12 Volt und bis minus 12 Volt,
wo ich dann also im Prinzip hier irgendwie meine Daten dann seriell übertrage.
Gut, warum jetzt also solche komischen, großen Versorgungsspannungen,
wenn ich den Großrechner in dem einen Raum stehen habe und in dem Gebäude 50 Meter weiter mein Terminal nicht,
dann nützt mir das wenig,
wenn ich da also mit 2,5 Wortversorgungsspannung irgendwo leiten,
weil da einfach so viel Leidung dazwischen ist.
Da würde nichts ankommen. Gut,
wenn ich das jetzt natürlich brauche, um, sagen wir jetzt,
also irgendwie 90er-Jahre-Computertechnik, also damit irgendwo meine Maus anzuschließen,
wo ich dann also vielleicht noch irgendwo einen Meter Kabel maximal dran habe,
dann müssen das natürlich nicht mehr plus minus 12 Volt sein.
Nicht das, was man dann also zu der Zeit
im Prinzip an serela Schnittstelle an den Rechnern hatte,
waren dann eben mit plus 5 Volt und Null Volt.
Und das funktioniert dann also auch immer noch entsprechend ganz gut.
Nicht, was dort dann passiert, ist einfach,
dass die Einleitung immer konstant auf 1 ist.
Nicht, da kommen sogenannte Startbit. Das heißt,
da wird dann eben einmal die Leitung auf Null gezogen.
Und dann kommen von 5 bis 8 Datenbits,
vielleicht noch irgendwie sowas wie eine Parität und dann sogenannte Stoppbit,
wo das Ganze dann eben auch wieder auf 1 geht.
Und die Sache ist, Wie lange dieses hier dauert,
das wurde eben vorher apriori festgelegt. Das heißt,
das ist insofern nahesynchrone übertragen, weil man daher weiß,
es gibt also nicht eine globale Taktleitung,
sondern wirklich nur eine einzige Leitung von Sender zu Empfänger.
Der Sender schickt da jetzt meinetwegen seine 5-Volt drauf.
Der Empfänger liest das Ganze, die wissen jetzt einfach,
der hat einen Tag, der hat einen Takt,
aber die wissen zumindest, dass diese Zeit hier,
also Fine Bit, eine so und so lange dauert.
Das ist dann das, was in einer Bootrate ist,
wo dann eben von 300 bis 115 Kilobit pro Sekunde übertragen werden.
In dem Zufolge kann man sich dann die Zeit hier ausrechnen und
das Ganze machen. Und das Ganze funktioniert dann eben,
dadurch, dass ich dann sage,
ich habe nur eine Masseleitung und eine Sendeleitung,
beziehungsweise wenn das bidirektional ist, dann eben noch eine Rückleitung.
Aber damit kriegt man letztendlich mit drei Leitungen dann also irgendwie
seine Geräte direkt miteinander verbunden.
Ist also ein relativ einfaches, triviales Protokoll,
mit dem man dann also seine Sachen machen kann.
Ein Nachteil ist,
es muss eben Apriori bekannt sein
Wie groß ist die Botrate? Wie viele Datenbits werden übertragen?
Gibt es überhaupt eine Perity? Wie lang ist das?
Stoppit, teilweise gab es das teilweise nicht.
Das sind immer so ein bisschen so die Tricksereien.
Ansonsten ist es aber relativ einfach. Und lässt sich also
auch sehr schön dadurch machen oder modellieren, dass man sagen kann,
hier so die Untersuchung von so einem Bus kann man eben
zum Beispiel sehr gut in einen endlichen Automaten packen,
wo man sagen kann, ich taste den mit einer bestimmten Rate ab.
Ich stelle dann fest auf einmal, ich habe hier eine Null. Und dann weiß ich nur,
okay, wenn ich jetzt die und die Botrate habe,
Nach dieser ersten Null, die ich jetzt hier irgendwie abgetastet habe,
weiß ich, so und so lange,
dann kommen irgendwie meine Datenbits und dann muss ich eben nur eine bestimmte Zeit warten,
kann dann immer hier quasi in der Mitte dieses Intervalls dann die einzelnen Datenbits abtasten.
Ich gucke dann eben noch, passt das mit dem Stoppbild oder passt das mit der Perity?
Und man kriegt dann eben sehr einfach seine Sachen von A nach B übertragen. Gut,
dann als letztes in diesem Kapitel werde ich also auch nochmal,
jetzt habe ich eben schon Automaten erwähnt,
nah noch was anderes kurz vorstellen, was diejenigen,
die jetzt also im RSB-Praktikum sind, also schon kennen, Mikroprogrammierung.
Bislang haben wir es ja immer so,
dass es also darum ging, dass man gesagt hat,
wenn ich jetzt da so einen endlichen Automaten habe,
nicht würde der, also im Prinzip beschrieben, dadurch,
dass man sagt, ich habe diese beiden Funktionen,
Zustandsübergangsfunktionen, Delta, Ausgabefunktion, Lamda,
das kann ich als Medi- oder als Mur-Modell machen.
Ich habe irgendwo mein Zustandsregister und kann dann eben entsprechend so
einen Schaltwerksentwurf machen. Als Alternative dazu zu schalt werden,
kann ich so ein endlichen Automaten auch umsetzen durch einen Rom und eben Register als Zustandsregister.
Und das wird also ganz gerne verwendet für die Ablaufsteuerung in CPUs. Sprich,
ich habe ja gesagt, das,
was man so als Idee erstmal für die Befehlsabarbeitung hat,
von Neumann-Zyklus, Befehl holen, Befehl dekodieren,
Operanten holen und so weiter,
das läuft ja einfach stumpf der Reihe nach immer zyklisch
entsprechend durch
Von diesen Zyklen, kann jetzt gegebenenfalls auch noch mehrere Takte dauern,
wo man jetzt eben sagt, okay, was passiert jetzt beispielsweise?
Ich habe meinen Befehl oder ich habe erstmal meinen Befehlszähler,
den Program Counter, da steht die Adresse drin,
von der ich den nächsten Befehl lese.
Das heißt, das, was dort passiert ist,
der Inhalt des Program Counters muss auf den Adressbus gehen.
Der Speicher wird dann also letztendlich so eingestellt,
dass davon gelesen werden soll, beziehungsweise es ist ein Rom,
möchte ich ja sowieso erst mal nicht reinschreiben oder kann das auch nicht.
Nicht der Befehl wird jetzt daraus gelesen, landet im Adressregister,
nicht? Dann kommt jetzt dieser Teil mit Befehl dekodieren.
Man muss jetzt eben gucken, was ist das für ein Befehl?
Ein Alu-Befehl, wo kommen die Operanten her?
Und dann wird das Ganze so sukzessive entwickelt. Und das
kann man jetzt einfach dadurch kodieren, dass man einfach sagt,
na gut, das sind einfach irgendwie Zustände in so einem Ablauf,
in einem endlichen Automaten.
Und den kann ich jetzt natürlich direkt so implementieren,
wie wir das also im vorigen Kapitel kennengelernt haben.
Ich kann das aber auch machen,
indem ich das eben als Programm in einen Speicher,
sei das jetzt also read only oder sowas wie ein Flash-Speicher, schreibe.
Und damit dann also letztendlich meinen Automaten beschreibe.
Das Ganze nennt sich dann eben Mikroprogramm, beziehungsweise Mikroprogrammierung.
Hier mal an dem hochgradig komplexen Beispiel der Ambel-Saltung. Also,
ich habe hier einen Speicher, in diesem Fall red Only-Speicher,
vier Werte drin. Ich habe hier diese Übergänge, rot,
gelb, grün, gelb, rot und dann wieder das.
Und das, was man im Prinzip dann hier macht,
ist letztendlich, sondern dass sie die Adresse natürlich nur sein,
dass sich also quasi jetzt in jeder Speicherzeile sage,
was ist der nächste Zustand?
Und wie sehen in diesem Zustand die zugehörigen Ausgänge aus?
Das heißt, das, was ich hiermit mache,
ist ein Urautomat, weil abhängig vom Zustand,
Zustand entspricht quasi die Adresse,
sage ich Folgezustand und sage ich Ausgänge
So, und dann habe ich eben hier meinen Register,
also in diesem Fall des Zustandsregister, wo dann einfach nur gesagt wird,
okay, mit dem Takt wird der nächste Folgezustand geladen.
Ich adressiere das Ganze und das Ganze schaltet dementsprechend ein weiter.
Nicht dadurch lassen sich natürlich sehr einfach solche Abläufe in so einen Speicherinhalt umsetzen.
Jetzt habe ich hier natürlich noch keine Verzweigung drin.
Macht den Automat natürlich nicht so richtig spannend. Deswegen,
was möchte man jetzt machen, um jetzt Verzweigung zu machen,
dass man da jetzt eben einfach sagt,
wenn ich von meinem aktuellen Zustand beispielsweise in zwei unterschiedliche Folgezustände A und B gehen möchte,
dass ich dann eben hier entsprechend viele Spalten anlege,
um zu sagen, entweder das soll eintreten oder das soll eintreten.
Und die Abhängigkeit von dem Eingang,
was ich also beim Automaten in dem Fall da dann eben letztendlich mache,
um zu verzweigen, unter der Bedingung soll das passieren.
Unter der Bedingung soll das passieren. Passiert dann dadurch,
dass eben quasi hier über irgendwelche Multiplexer-Logik dann eben die entsprechende
Spalte ausgewählt wird und man darüber dann eben sagen kann,
wenn ich Entweder in die oder in die Variante unterscheide,
dass man das hier rüber schalten kann.
Was hiermit dann noch so ein bisschen angedeutet ist,
weil das Ganze geht ja so ein bisschen auf das zurück,
was also in dem RSB-Praktikum dann also mit eingesetzt wird,
ist, dass man eben sagen kann,
ich möchte nicht nur von einem Zustand zu irgendeinem nächsten Zustand gehen,
auch aufgrund dieser Adressierung, sondern ich möchte beispielsweise die Adresse auch noch von extern haben.
Das ist dann dieses XA. Das braucht man zum Beispiel,
wenn ich das jetzt benutze, um so was wie Mikroproprogrammierung wirklich zu machen,
um damit dann also innerhalb dieser Abläufe dann sowas wie Sprünge zu realisieren,
wo dann eben quasi an der Stelle dann eben wirklich einen externer Einsprung wird,
angegeben wird, wo ich dann sage, okay,
angenommen, das wollen wir jetzt hier meine CPU steuern.
Ich fange an mit Befehl holen,
starte also quasi jetzt hier an dieser Adresse null,
laufe dann jetzt, je nachdem wie viele Takte das braucht,
dann eben entsprechend durch die entsprechenden Zustände.
Anschließend weiß ich, Der Befehl ist ein Befehlsregister,
abhängig von dem Inhalt des Befehlsregisters, wird dann ja unterschieden soll,
ein Lot gemacht werden sollen, Store gemacht,
wo er werden soll, irgendeine Alu-Operation ausgeführt werden sollen,
Sprung gemacht werden, was auch immer.
Demzufolge würde dann abhängig von dem Befehl das Ganze eben an
irgendeine Adresse hier unten oder hier oder hier entsprechend weiterlaufen.
Und an den Teilen dann eben letztendlich die Mikroprogrammbefehle für
die Ausführung des entsprechenden Befehls,
also beispielsweise für die Ausführung des Alu-Befehls
dann stehen
Dieser Teil, wohin ich springe, das kommt dann eben in diesem Fall aus dem Befehlsregister,
wo dann eben quasi drinsteht Alu-Befehl oder das oder das oder das.
Also das ist die Art und Weise,
wie im Prinzip mit so einem Mikroprogramm letztendlich die Ablaufsteuerung formal gesehen ist von so einem Automaten stattfindet,
rein praktisch dann eben genutzt wird, um in einem System letztendlich sowas wie jetzt den Befehlsabarbeitung in Sym von Neuem Anzug loszumachen.
Also wie gesagt, das ist dieses Beispiel jetzt hier einmal komplett, wie das dann also in dem Rechnerstrukturenpraktikum da ist. Gut,
ja, also das nochmal zu dem Thema Mikroprogrammierung,
findet sich im Prinzip auch,
zumindest an Teilen in aktuellen Rechnern, das ist das,
was man dann auch immer so ein bisschen als Firmware zu den CPUs beziehungsweise zu den Geräten mit drin hat,
wo dann also beispielsweise auch beim Buten,
also zum Beispiel jetzt irgendwelche Patches gegen die letzten Sicherheitslücken in Intel-Prozessoren,
dann im Prinzip darüber dann eben auch noch mit nachgeladen wird,
wo dann einfach durch Änderung so einer Ablaufsteuerung,
in diesem Fall ist das dann eben nicht ein Rom,
sondern ein Teil des Rahmens, wo das dann geladen wird,
in Änderung der Ablaufsteuerung,
dann eben solche Sachen wie Meltdown is Black,
so zumindest teilweise vermieden werden können.
Ansonsten sind die Abläufe in aktuellen Prozessoren noch ein bisschen anders.
Stichwort ist da Pipelining. Auch da kann ich jetzt erstmal
nur auf spätere Kapitel verweisen. Gut, dann soll jetzt dieses Kapitel
hier nur noch kurz abgeschlossen werden. Also nochmal so ein Beispiel,
wo jetzt also nochmal kurz an dem Beispiel so ein Armprozess,
das ist eigentlich nochmal gezeigt wird, wie jetzt also diese Ablaufsteuerung, so eine Mikroprogrammierung abläuft.
Ich hatte ja gesagt, also die Grundidee bei Rechnerarchitektur ist ja,
ich baue die Hardware so auf, dass alles an Datenfaden,
also sprich Verbindung zwischen Komponenten möglich ist, was ich jemals brauche.
Und das, was dann in der in dem Mikroprogramm,
beziehungsweise in irgendwelchen Automaten an Intelligenz drinsteckt,
für die Abarbeitung von Befehlen ist halt, dass dann eben,
je nachdem, um welchen Befehl es sich handelt, dann eben die entsprechenden Teile aktualisiert werden.
Hier ist es jetzt also nochmal ein Beispiel,
so eines AM-Prozesses, also wie gesagt, AM-Prozessoren,
32, also früher 32, inzwischen auch 64-Bit-Prozesse,
der also ein eingebetteten System, beziehungsweise in Smartphones,
typischerweise eingesetzt wird, wo man dann auch sagt,
auch da habe ich da im Prinzip dann so ein Befehlsdekoder,
der dann also über so ein Mikroprogramm, Zähler letztendlich arbeitet,
das Gesamtsystem ist dann, dass ich hier so was wie CPU habe,
hier dann eben meinen Speicher, habe dann eben irgendein Businterface zum Speicher,
habe dann noch etwas, was ich dann,
also DMA-Controller,
ist dann Direct Memory Access.
Und über Schnittstellen hängen dann da eben noch entsprechende Peripheriebausteine mit dran.
Sowas wie DMA, das ist etwas, was da also
auch hier bei uns in den Rechnern in der Regel haben.
Das sind Bausteine,
die also im Prinzip jetzt außerhalb der CPU sitzen,
die dafür sorgen,
dass ein Datentransfer vom oder zum Speicher
unabhängig von der eigentlichen CPU stattfinden kann
Also sprich für diesen Fall, den ich jetzt gerade geschildert hatte.
Hier hängt jetzt irgendwie die Netzwerkschnittstelle mit dran.
Die hat jetzt Daten irgendwie bekommen und die sollen jetzt eben
irgendwo schnell hier in den Hauptspeicher geladen werden.
Dann kann man eben sagen, okay, entsprechender Interrap wird ausgelöst,
den eigentlichen Datentransfer übernimmt dann eben so ein DMA-Controller.
Und sofern die CPU jetzt nicht zwingt, das Rahmen braucht,
weil dazwischen gibt es jetzt eigentlich noch Speicherhierarchie und Cashes und
die kann dann eben auch teilweise unabhängig hiervon einfach weiterrechnen.
Kann dann eben dieser Datentransfer stattfinden und man spart dadurch dann
eben auch noch mal ein bisschen Zeit eigentlich.
Also das nur für den Hintergrund, was dieses DMA ist.
Früher wurde sowas dann eben alles durch die CPU gemacht,
hat dann aber natürlich den Nachteil,
dass dann an der Stelle das laufende Programm wirklich komplett unterbrochen werden muss.
Der Code, in diesem Fall dann durch das Betriebssystem,
der quasi den Datentransfer in den Hauptspeicher macht,
muss geladen zur Ausführung gebracht werden.
Der Datentransfer von der Schnittstelle In den Hauptspeicher wird gemacht,
dann wird das Ganze quasi wieder aus dem Speicher entladen.
Das Benutzerprogramm wird hier wieder zur Ausführung gebracht. Das kostet natürlich
sehr viel Zeit. Nicht also das nur als Idee,
wofür man dieses DMA, steht dann eben für Direct Memory Access letztendlich braucht.
Gut, hier auch nochmal für dieses Beispiel,
wie dann also die eigentliche Alu aussieht, Adira,
irgendwelche logischen Funktionen und so weiter, dann eben irgendwie entsprechend zusammengebaut.
Dann gibt es also eine Multiporträgeristerbank,
das ist also letztlich nichts anderes als ein eine Essrahmenzelle und die Gesamtschaltung jetzt also für so ein etwas älteren,
inzwischen halt deutlich älteren Nahmenprozesse, sie dann eben so aus,
dass man sagt, ich habe hier meine Register,
habe hier die Halu,
habe dann eben für die Schnittstelle zum Datenspeicher eingangs einen Ausgangsregister,
habe dann hier Adressregister und habe dann eben hier dann noch sowas wie Dekodierung von dem Ganzen.
Ja und dann sieht das eben so aus, ich habe irgendwie
diese Gesamtstruktur und je nachdem, welcher Befehl gearbeitet wird.
Also das hatte ich ja so auch schon mal in
diesem einen hartes Beispiel so ein bisschen gezeigt.
Wir haben dann eben unterschiedliche Teile hier letztendlich aktiviert und das
passiert eben durch ein Mikroprogramm bzw. durch eine Dekodierung von dem Befehlen in dem Teil Instruction,
Decode und Control, also das, was dann hier rechts von diesem Datenvatern, also letztendlich drin ist.
Gut, ja und damit lassen sich dann eben unterschiedliche Befehle ausführen,
also beispielsweise, wenn ich sage, ich möchte Irgendein Befehl ausführen,
wo beispielsweise jetzt Alu-Befehl stattfindet.
Ja gut, was passiert? Der Programmcounter wird gelesen,
beziehungsweise wurde vorher in das Adressregister geparkt.
Nicht von der Adresse wird vom Hauptspeicher die Instruktion gelesen.
Die landet dann eben hier, wird dekodiert.
Lagzeitig wird dann eben der Programmzähler inkrementiert, was dann eben dazu führt,
dass also mit dem nächsten Befehl dann quasi entsprechend da dann der nächste Befehl hier geladen werden kann.
Ja, beim Dekodieren wird dann eben festgestellt,
okay, es soll ein Alu-Befehl gemacht werden,
also wird hier irgendwie aus zwei Registern gelesen
Irgendeine Allo-Operation gemacht und das Ergebnis hier in einem Register wieder zurückgeschrieben. Nicht,
dass wir dann also eine Registerregisteroperation, nicht,
wenn ich einen Befehl habe, in dem sogenannter Emediate vorkommt,
Emediate, wird uns dann also im nächsten Kapitel noch begegnen,
ist nichts anderes, als dass ich sage,
in dem Befehl steht ein Wert quasi als Konstante,
als Zahl mit drin.
Also sprich, wenn ich also jetzt rechnen möchte,
Register 1 plus 5. Also hier rechne ich Register 1 plus Register,
zwar hier rechne ich Register 2 plus 5,
so diese plus 5,
also diese Konstante steckt dann eben selber schon in dem Befehl drin,
demzufolge wird dann das zweite Argument so einer Alu-Operation dann eben hier aus dem Instruktionswort raus gelesen.
Und ansonsten ist das Ganze genauso. Gut,
hier haben wir dann sowas wie so ein Storbefield-Store,
ist also quasi das Speichern von Daten eben oder von Datenwort aus am Register im Hauptspeicher.
Passiert dann also quasi in zwei Schritten,
im ersten Schritt wird erstmal berechnet, die Adresse,
in die das geschrieben wird, die muss also auch aus irgendeinem Register kommen.
Nicht dann wird hier so eine Adressberechnung gemacht,
da ist dann steht dann also die Adresse, in die geschrieben wird.
Im zweiten Schritt wird dann eben aus dem Register entsprechend rausgelesen
und das Ganze dann eben entsprechend an diese Adresse,
die vorher hier gespeichert worden ist, dann entsprechend weitergeschrieben.
Gut, und so kann man jetzt also für alle möglichen Arten von Befehlen dann eben sagen,
wie wird das Ganze letztendlich immer jeweils beschaltet,
damit diese Befehle ausgeführt werden können.
Und das ist also letztendlich das, was sich hinter
diesem Stichwort Rechner Architektur verwirkt. Welche Blöcke habe ich?
Wie sind die miteinander verbunden? Wie müssen die zeitlich aktiviert werden,
um meine Befehle auszuführen
Ja, das ist eben letztendlich das,
was hier jetzt also so als Choreografie der Funktionseinheiten bezeichnet ist.
Ja, wie gesagt, das,
was Sie jetzt hier so grob vorgestellt hatte, ist,
folgt in der Regel natürlich erst mal zu diesem ganz einfachen von Neumann-Konzept.
Da muss man sagen, inzwischen sieht das also schon ein bisschen anders aus.
Man hat Parallele Abarbeitungen durch Pipelining. Man hat mehrere Ausführungseinheiten.
Das Ganze nennt sich dann zum Beispiel Superskalare-Prozessoren. Sprich,
ich habe in einer CBU nicht nur eine Ado, sondern ich habe mehrere Ados, mit denen ich rechnen kann. Nicht dann stellt sich natürlich wieder die Frage,
wo kriegen die jetzt also ihre Instruktionen her,
weil ich da natürlich dann auch schon nicht mehr von Neumann bin,
weil ich dann jetzt nicht mehr sage,
ich nehme einen Befehl, dekodiere den, mache damit irgendwas,
sondern wenn ich fünf Alus habe und ich fünf Additionen gleichzeitig machen kann,
würde es sich anbieten, also quasi immer so einen ganzen,
ganzes Fenster, so einen ganzen Bereich von Befehlen zu nehmen und dann eben zu gucken,
welche Recheneinheiten sind frei,
habe ich Datenabhängigkeiten zwischen diesen Befehlen oder kann ich sagen,
okay, wenn ich keine Datenabhängigkeiten habe,
hier ist eine Addition,
hier ist eine Subtraktion und dann soll das auf der Alu und das auf der Alu gerechnet werden.
Das ist im Prinzip das, was Superskalara-Prozessor ist,
dann haben wir heutzutage natürlich von diesen Prozessoren auch noch vier
oder sechs oder noch mehr Stück auf einem CPU-Chip mit drauf.
Nicht, dass wir uns das Ganze dann also nochmal wieder,
eine Komplexitätsebene weiter. Gut, und wie gesagt,
die Anbindung der Speicher hat dann eben auch noch so
ein paar Sachen auf ein paar von diesen Sachen werde ich
dann also in dem späteren Kapitel dann nochmal ein bisschen drauf eingehen.
Ansonsten bleiben wir jetzt hier natürlich jetzt bei einem
ganz einfachen Modell. Das ist auch das,
womit wir in der Regel als Programmierer erstmal denkt oder
denken muss
Sprich, ich habe meine CPU, ich habe eine Recheneinheit,
ich habe hier irgendwelche Register, mit denen ich rechnen kann,
habe dann eben irgendwie eine Schnittstelle, wie auch immer die technisch aussieht,
zum Hauptspeicher und habe dann eben noch über irgendwelche Schnittstellen letztendlich dann,
also sowas wie permanenten Speicher, sei das jetzt eine Festplatte oder eine SSD-Grafik,
irgendwelche langsameren Komponenten und so weiter mit angeschlossen.
So, und was passiert jetzt,
wenn das System läuft oder laufen soll, nicht,
also das klassische Hello-World-Beispiel, wunderbar, wir haben es übersetzt,
ja, ich als Benutzer tippe, An der Tastatur ein,
Hello als, zum Beispiel jetzt in den Kommandozahlen Interpreter,
das Programm namens Hello soll es eben irgendwie laufen.
So, das, was dann passiert, ist,
dass eben in dem Fall dann ja, also quasi vom USB-Controller,
irgendwie hier die Daten in der CPU landen.
In diesem Fall rechnet an dieser Stelle quasi ein Prozess,
der mir jetzt also den Kommandointerpreter laufen lässt.
Das heißt, der meine Eingaben hier irgendwie jetzt interpretiert,
sprich welchen Befehl habe ich jetzt gerade eingetippt?
Nicht, der stellt fest, okay,
das Programm Hello soll gestartet werden
Das, was an der Stelle dann eben passiert, ist,
dass dieser Kommando und der Preter das natürlich dann also auch
erst mal irgendwo aus dem Speicher liest oder damit macht,
das anschließend dann eben dafür gesorgt wird,
dass per DMA in dem Fall dann quasi das Programm,
was ja irgendwo auf der Festplatte liegt, in den Hauptspalter geladen wird.
Und dann kann der Kommando Interpreter sagen, boah,
das Ganze kommt zur Ausführung, läuft auf der CPU und
gibt mir dann eben beispielsweise dann diesen wunderbaren String aus.
Also das ist eben immer letztendlich das, was,
wenn ich also hier in Linux setzt also hier noch irgendwie
mit so einer Kommandozeile zugange bin oder eben Windows,
also jetzt im Prinzip so was wie eine Kommandozahleneingabe habe.
Nicht, wenn ich da jetzt eben irgendwie was eintippe,
dann habe ich ein Schreiben ist schwierig.
Dann habe ich da jetzt eben entsprechend das als laufendes Programm.
Das würde jetzt diese Eingabe interpretieren. In dem Fall versuchen im Befehl Hello,
den es hier jetzt natürlich nicht gibt, irgendwo auszuführen.
Und in dem, dann würde eben genau dieser Mechanismus,
was sich da jetzt gerade skizziert hatte, quasi in angestoßen werden. Gut,
so, das ist jetzt die letzte Folie aus den Kapitel,
hier auch nur nochmal kurz angedeutet, was passiert,
weil das ist jetzt auch immer noch so das Hen- und All-Problem,
was passiert beim Einschalten des Rechners. Und hier auch nochmal grob angedeutet,
also das, was dann eigentlich passiert, ist,
dass im Prinzip die Hardware selber jetzt für alle beteiligten Komponenten erstmal sowas wie so ein Reset macht,
für die Stellen, wo es benötigt wird,
zum Beispiel für Die zentralen Register im Prozessor, insbesondere für den Program-Counter,
weil der muss jetzt natürlich also mit irgendeinem Wert entweder null oder einem bestimmten Staatwert initialisiert werden.
Und unter dieser Adresse befindet sich dann quasi der erste Teil des Codes,
der dafür sorgt, dass quasi das Betriebssystem überhaupt erst mal geladen werden kann.
Nicht, das ist dann eben dieser Bootloader,
der wird heutzutage eben in irgendwelchen Flashbausteinen drinstehen.
Früher war das eben das, was dann, klassischen irgendwelchen Raums drin war.
Und dann läuft der ganz normale Befehlszyklus los,
der Prozessor greift also auf diese Startadresse zu.
Nicht dort kommt dann das Programm, was dann dafür sorgt,
dass jetzt der Reihe nach die einzelnen Komponenten hochgefahren werden,
dass dann das Betriebssystem selber erstmal in den Speicher geladen wird,
wenn das alles der Fall ist, dann startet das eigentliche Betriebssystem.
Nicht lädt sich dann also Treiber XY und das hierfür irgendwie runter. Nicht alles,
was man so typischerweise an Durchlaufenden Eingaben während des Buches guten Sart,
wie gesagt, bei Linux-Systemen kann man das ganz gut sehen,
weil Windows ja teilweise im abgesicherten Modus sieht man dann so ein bisschen,
wie dann also da so die einzelnen Komponenten da rein nach initialisiert werden.
Nicht und wenn das dann alles fertig ist,
nicht dann geht das dann irgendwo los, dass dann ebenentsprechend die grafische Oberfläche,
das Login-Fans oder was auch immer letztendlich erscheint.
Gut, ja, damit sind wir jetzt mit dem Teil hier fertig und Befehlssätze,
Befehlsatzarchitektur wird uns dann also die nächste Woche beschäftigen.
Bis dahin ein schönes Wochenende und dann sehen wir es
am Mittwoch wieder