hatte ich ja aufgehört,
im Prinzip mit der Vorstellung der unterschiedlichen Speicherbausteine gesagt,
dass es da also je nach technische Realisierungsmöglichkeit und je nach Art und Weise,
wie die jetzt beschrieben werden können,
ob sie überhaupt beschrieben werden können,
eben sehr viele unterschiedliche Typen gibt und, sagen wir mal so,
als vorletzte Folie hatte ich dann ja also im Prinzip beschrieben,
also das eine ist im Prinzip dann sowas wie so ein Read-Only-Memory,
wo dann eben wirklich nur ein fester Speicherinhalt bei der Herstellung quasi im fotolitografischen Prozess direkt reinkodiert wird.
Das lohnt sich dann eben jetzt wirklich nur bei irgendwelchen Geräten oder bei irgendwelchen Sachen,
wo also quasi so was wie ein Programm oder irgendwelche Basisinformationen eben einmalig fest reingeschrieben werden.
Ansonsten hat man eben irgendwelche wiederbeschreibbaren Speicher, also Rammspeicher,
Random Access Memory, die im Prinzip ähnlich aufgebaut sind wie Rom.
Also das heißt, ich habe auch immer so eine Art Matrix-Struktur,
eine Anzahl von Adressbits mit entsprechend vielen Sportleitung und dann eben eine Anzahl von Bits pro Speicherwort. Und,
sagen wir mal, als allererste oder ganz grobe Unterscheidung bei Rahmenspeichern,
also das ist dann auch, sagen wir mal,
auch das, was anspeichern,
was wir jetzt so im Betrieb mit Computern immer noch sehen,
hat man dann eben zum einen S-Rahmen,
steht dann für statisches Rahmen und derer stellvertretend für dynamisches Rahmen.
Was grob die Unterschiede sind, beziehungsweise ein bisschen motivierend,
also auf die technischen Hintergründe werde ich dann in den nächsten Folie noch eingehen.
Beim S-Rahmen, kann man sich das im Prinzip vorstellen,
wie das also jetzt hier in diesem Blogstrahltbild,
also diesem hartes Beispiel, skizziert ist. Das heißt,
Von der Idee her kann man eben auch mal sagen,
ich habe dann sowas wie ein Adressdekoder,
der dann quasi aus den entsprechenden Adressleitungen die einzelnen Speicherwörter dekodiert,
also in diesem Fall jetzt hier natürlich mit zwei Adressleitungen,
kriege ich jetzt also nur vier unterschiedliche Speicherwörter adressiert.
Und in dem Speicher, der jetzt also hier auch nur eine Wortbreite von vier Bit hat,
kann man sich das dann eben letztendlich so vorstellen,
als ob ich dort im Prinzip sowas wie Ledges habe.
Das heißt, pegelgesteuerte Speicherelemente, die eben dadurch aktiviert werden,
dass ihre entsprechenden Adresse dann angelegt wird.
Und man dann eben über einen zusätzlichen Ride-Enable-Eingang sagen kann,
es soll jetzt was reingeschrieben werden. Wenn ich das jetzt,
was ich hier mal mache,
also in diesem Fall jetzt hier mal an die Adresse 1,
das Ride and Able anschalte,
Und dann sieht man das jetzt also hier entsprechend dieses Datenwort 1001,
was quasi jetzt hier in den Eingängen lag, entsprechend Andy Ledges übernommen worden ist.
Und wenn dann also beispielsweise jetzt das Right Enable wieder deaktiviert ist,
kann ich den Speicher dann eben mit seinem Output Enable bzw. entsprechenden Chipselect Signal
dann auslesen und hätte dann also hier diesen Ausgangswert jetzt von dieser Zahle hier am Datenausgang.
Und entsprechend kann man das dann eben für die anderen Speicherzellen machen.
Das ist also relativ, es straight forward und wie gesagt,
also von der Idee her ist die Technologie hier drin dann eigentlich sowas wie ein Ledge.
Das heißt, Pegel gesteuert und das Pegelsignal wird dann eben
aus diesem Adressdekoda erzeugt. Gut,
rein praktisch sieht das jetzt bei etwas größeren Speichern,
also gerade bei deren Speichern,
dann auch noch so aus
Dass eigentlich so die Idee oder dieses Konzept, wie ich das jetzt eben vorgestellt hatte, dann also ein bisschen anders realisiert ist. Und zwar gibt es dann dort eine Unterscheidung,
dass sie jetzt nicht also quasi ein gesamtes Speicherwort adressiere,
sondern dass jeder Speicher oder jeder Speicher Baustein,
also wenn man sich jetzt mal so aus seinem,
meinetwegen heimischen PC mal so einen üblichen Speicherriegel ansieht,
sind dort also mehrere ICs drauf und auf jedem Speicher Baustein oder auf jedem dieser ICs,
wird dann eben eine entsprechend große Anzahl von Gut,
dass es dann ein bisschen von der Gehäuseform und Organisation abhängig,
aber von einem oder von zwei Bit eigentlich nur gespeichert.
Und man hat dann eben entsprechend, also zumindest ganz früher,
bei den älteren Speicherbausteinen sammeln dann also schön,
dass dann also auf diesem, auf diesem kleinen Platinchen,
auf dem sich dann, also die ICs befinden,
dann eben entsprechend viele ICs waren,
um dann also mal wegen jetzt mit der Wortbreite das Ganze zu machen.
In den ICs selber wird dann also quasi jetzt eben nur sowas
wie ein Bit oder eben ein kleinerer Bit-Bereich, letztendlich gespeichert. Und die Adresse war gerade,
wenn man jetzt eben sehr große Speicher hat oder sehr große Speicherbereiche und ich dann also wirklich jetzt mit Adressen von,
beispielsweise dann eben 32 Bit oder noch mehr arbeite,
habe ich natürlich das Problem,
dass ich dann letztendlich 2 hoch 32 Wortleitung daraus dekodieren muss, um jetzt also quasi eine Speicherzeile anzusprechen.
Und da diese Dekoder dann also entsprechend aufwendig werden,
verwendet man eben den Trick,
dass man den Speicher eigentlich unterteilt in Zeilen und Spalten und ich dann also quasi sowas wie so einen einzelnen Speicherblock,
also quasi als Äquivalent zu denen hier sowas wie jetzt nur nicht eine gesamte Zeile,
sondern ein einzelnes Ledge adressieren kann,
indem ich dann also quasi erst eine mit dem Dekoda quasi eine Road Adress generiere.
Dafür steht dann eben dieses RAS,
wo dann im Prinzip jetzt also eine entsprechende Speicherzeile ausgewählt wird und dann mit dem Callen Access,
beziehungsweise der Callen Adresse, wird dann eben eine Spalte ausgewählt,
sodass man dann eben jetzt wirklich einzelne Zellen hat.
Über diesen Trick hat man dann eben eine sehr große Adresse in
logisch gesehen zwei Hälften unterteilt und braucht eben da nur noch Zwei Deko da,
beziehungsweise dann eben hier einen entsprechenden Multiplexer, die dann eben als Wortbreite zwei hochennhalbe mithaben und nicht mehr zwei hochennen, was ja sonst also quasi die Größe dieses Dekodas oder der nächste Kodaschadensetzes wäre. Gut,
nochmal zu den Unterschied zwischen Esram,
also statischem Rahmen und Diaram bzw. dynamischen Rahmen,
bei statischem Rahmen kann man sich das vorstellen, wie das,
was sie jetzt eben als Ledge gezeigt habe,
das heißt also der Inhalt bleibt dauerhaft gespeichert, solange die Betriebsspannung anliegt,
rein technisch gesehen wird der Speicher dann auch nicht als Ledge,
wie ich das also ja nun letzte Woche vorgestellt hatte,
realisiert, wo ich jetzt also quasi zwei nennt oder zwei North,
also über diese Basis-SR-Flip-Flop quasi zurückgeschaltet habe und dann auch mit entsprechenden zusätzlichen Gartern,
also den Enable und den Dateneingang irgendwie miteinander verknüpft habe,
sondern die Speicherung passiert jetzt hier über so einen Trick auf Transistor-Ebene,
dass man im Prinzip sagt, ich benutze quasi zwei in Werder,
die gegeneinander rückgekoppelt sind.
Ich hatte ja schon als Beispiel für diese Laufzeiten,
beziehungsweise für die Delay-Modelle ja im Prinzip,
also diese ungerade Anzahl von Invertern, die quasi jetzt immer dauernd oszillierte,
wenn ich mir das Ganze jetzt vorstelle,
mit einer geraden Anzahl von Inverter,
beziehungsweise an die kleinste gerade Anzahl, dann eben entsprechend zwei nehme,
kann ich sagen, ich kann halt konstant,
wenn ich einen Wert irgendwie in dieses System reingeschrieben habe,
erhält er sich eben selber
Das ist also die Idee, die dahinter steht.
Und elektrisch ist das Ganze jetzt eben so aufgebaut,
dass wenn man den Wert jetzt überschreiben möchte,
man also quasi von außen mit einer,
ich sag mal jetzt, stärkeren Stromstromquelle dafür sorgen kann,
dass sich den Inhalt eben erzwungenermaßen verändern kann beim Schreiben.
Ansonsten, wenn ich das Schreiben eben abschalte und sich da
nichts tut, erhält sich dieses System letztendlich selber.
Das ist also die Idee, die dahinter steht,
lässt sich demzufolge dann eben relativ kompakt mit insgesamt sechs
Transistoren realisieren
Und erlaubt dann eben auch einen sehr schnellen Zugriff auf die Speicherworte,
also sowohl was das Schreiben als auch das Auslesen der Informationen betrifft.
Nachteil bei dem Ganzen,
wenn man das jetzt also vergleicht mit dem Platzbedarf für dynamisches Rahmen,
wo ich dann also nicht sechs Transistoren,
sondern im Prinzip nur noch einen einzigen Transistor brauche,
hat man natürlich einen deutlich höheren Platzbedarf.
Deswegen wird im Prinzip S-Rahmen dann eigentlich auch nur für vergleichsweise kleine Speicherbereiche eingesetzt.
Das heißt, Zum einen im Prozessor für Registerbänke und zum
anderen für das, was, also sagen wir mal,
so prozessornah an in Form von Cash-Speichern realisiert wird.
Das, was aber im Prinzip im Computer
als Hauptspeicher aufgebaut ist, sind eigentlich immer der Rahmenspeicherbausteine.
So das Ganze gibt es dann also hier auch nochmal
als so ein hartes Modell.
Hier ist jetzt das wirklich in Form von einzelnen Transistoren aufgebaut
Was sich dahinter verbirgt, beziehungsweise mit diesen Transistoren oder Transistorschaltungen. Es gibt zwar,
sagen wir jetzt, in Rechnerstrukturen, also jetzt auch noch ein Teil,
wo also nochmal so ein bisschen die technischen Grundlagen erklärt werden und also auch nochmal so ein Bereich,
wo dann also die eigentliche Herstellungstechnik von integrierten Schaltungen kurz beleuchtet ist,
da das jetzt natürlich insgesamt ein Thema ist,
was jetzt also nicht zentral für die Informatik wichtig ist,
habe ich,
dass das jetzt dieses Jahr auch aus Zeitgründen erstmal an das Ende der Vorlesung gelegt
Und das wird dann quasi optional vielleicht noch vorgestellt,
wenn wir entsprechend Zeit haben. Ansonsten kann man darauf verzichten,
beziehungsweise in der Prüfung werden dann die entsprechenden Inhalte auch nicht abgefragt.
Das ist dann eben höchstens, sagen wir jetzt,
für Leute, die jetzt im technischen Bereich eher arbeiten,
beziehungsweise wenn man da jetzt also entsprechend interessiert ist, vielleicht nochmal ganz interessant.
Gut, also hier jetzt mit dieser Schaltung,
man kann sich das so vorstellen, dass man sagt,
also jeder von diesen Blöcken ist im Prinzip jetzt also ein Transistor,
Transistorfunktion, betrachten wir jetzt hier auch als reines Switch-Level-Modell.
Das heißt, ein Transistus ist erstmal nur ein Schalter,
den ich auf- und zumachen kann. Da sage ich jetzt gar nicht,
da hat eigentlich ein analoges Verhalten und den kann ich jetzt für stärker benutzen,
sondern das ist erstmal nur ein Schalter,
den kann ich aufmachen und dann kann ich zumachen.
Das heißt, abhängig davon, was quasi an diesem Steuereingang hier liegt,
ist eben der Schalter hier entsprechend entweder zu oder aufgeschaltet.
So, diese Struktur hier drin mit diesen vier Transistoren,
das sind im Prinzip genau diese zwei Rückgekoppelten in Wärter in dieser Seemausschaltungstechnik,
mit der wir, also sagen wir jetzt seit den,
ja, Ende der 70er Jahre arbeiten, sind,
ist ein Entwerter dann also quasi immer realisiert über zwei Transistoren.
Das heißt, diese beiden Rücke koppeln in Wörter,
stellen jetzt diese vier Transistoren dar und über diese beiden Transistoren kann ich jetzt eben erzwungenermaßen bestimmte Werte reinschreiben,
beziehungsweise kann das benutzen, um Werte auszulesen. So,
und dann hat man hier oben noch entsprechend ein bisschen Ansteuerungslogik,
das heißt also hier in Inverter beziehungsweise dieses hier sind Bauelemente,
die sich dann also auch wie Schalter verhalten, wo ich also quasi jetzt den Wert,
also hier drauflegen kann oder das Ganze komplett abstalten kann.
So, und das führt jetzt eben dazu, dass,
wenn ich das jetzt also hier mal in das kurz vorführe,
Das ich jetzt eben sagen kann,
wenn ich am Dateneingang hier eine Eins habe,
diese Wordline entsprechend aktiviere, diese Schalter sind jetzt quasi hier geschaltet,
dass ich hier was reinschreiben kann und dann also mit der Bitline das einschalte,
kann ich eben diese Information,
nämlich dass also eine Eins drin ist,
also hier reinbringen und nach Abschalten des Enables beziehungsweise nach Abschalten der Wordline bleibt das erhalten.
Und mit Auswahl dieser Wordline kann ich dann den Wert auslesen
und also quasi auf dieser Leitung habe ich dann eben hier
als Information die A1 beziehungsweise hier den negierten Wert.
Um jetzt eine Null reinzuschreiben,
würde ich dann eben hier am Datenargang 0-0 anlegen.
Das Ganze dann jetzt eben hier über wieder das Wright Enable einschalten.
Er zwinge jetzt eben hier den umgekehrten Wert.
Das heißt, hier habe ich eine Null am negierten
Ausgang nach
Und wenn ich jetzt das Enable abschalte, jetzt kann ich hier auch den Eingang torgeln,
bleibt eben dieser Wert hier, konstant gespeichert. Das ist also im Prinzip ganz grob die Grundidee, wie jetzt so eine Esrahmen-Speicherzelle aufgebaut ist. Das,
was man in der Regel dann meistens davon sieht,
ist jetzt natürlich jetzt nicht irgendwie so eine Schaltung aus einzelnen Transistoren,
sondern das, was man dann eigentlich immer davon sieht,
ist, dass man nur sagt,
ich habe also irgendwie so einen IC oder so einen Block,
mit dem ich arbeite, wo ich außen eigentlich nur sage,
ich kann als Über einen Adressbus, eine Speicheradresse auswählen,
über den Datenbus was reinschreiben und habe dann eben noch Kontrollleitungen wie Chipselec,
womit ich jetzt den Baustein überhaupt erst mal ansprechen kann,
dann eben dieses Right Enable,
um zu sagen,
möchte ich schreiben oder möchte ich jetzt nur lesen und mit dem Output Enable kann ich dann eben beim Lesen auch noch entsprechend den Datenausgang einschalten.
Gut, Nicht, das heißt,
da hat man dann eben ein Hares als Modell dann eben wirklich nur so eine Blackbox,
die man eben jetzt über entsprechende Eingänge beschaltet,
wenn ich ihn über so eine Editor-Funktion,
könnte man sich dann eben beispielsweise jetzt hier den Daten oder den Inhalt des Speichers dann hier auch entsprechend ansehen.
Also diejenigen von ihnen,
die jetzt schon das Rechnerstruktur und Praktikum gemacht haben, denen wird sowas,
dann denke ich mir auch schon mal mit über den Weg gelaufen sein,
wo man da jetzt also in entsprechende Speicherbereiche da was schreibt bzw. da was rein programmiert,
mich dann aber eben wirklich jetzt auf dieser Ebene,
dass man jetzt wirklich nur Adressbus und Datenbus mit irgendwelchen Binär werden belegt.
Gut, als anderes Beispiel hier unten, also nur die entsprechenden Verweise,
also dann jetzt eben mal von wirklich richtigen existierenden Speicher,
also so einen kleinen Speicher-IC, auch noch vergleichsweise klein mit 16 Kilowittkapazität,
der dann eben aufgebaut ist mit einer Wortbreite von 8 Bit und mit 11 Adresseingängen demzufolge 2000,
beziehungsweise da müssten eigentlich ein KI stehen,
also 2024 Worte adressieren kann.
Ich zusätzlich gibt es dann eben die 8-Bit Datenbus,
die dann bidirektional sowohl zum Schreiben,
also zum Lesen genommen werden und eben entsprechende Steuersignale,
mit denen man das Ganze ansprechen kann.
Gut, beim dynamischen Rahmen sieht das jetzt ein bisschen anders aus,
da wird die zu speichernde Information im Prinzip auf kleine Konsensatoren gespeichert.
Ein Kondensator ist also im Prinzip ein elektrisches Bauelement, wo ich Ladung aufbringen kann.
Und wenn man das jetzt also hier auch erstmal nur rein digital betrachtet,
kann ich jetzt eben erstmal unterscheiden,
habe ich dort über eine Außenanliegende Spannung irgendwann mal Ladung aufgebracht.
Das heißt, wenn der Kondensator aufgeladen ist,
interpretiere ich das als logischen Inhalt 1. Wenn der Kondensator nicht aufgeladen ist,
interpretiere ich das als logischen Inhalt null. Das ist also da die Grundidee,
Nachteil beim dynamischen Rahmen ist jetzt eben, dass,
wenn ich den Inhalt dieses Kondensators auslese, das heißt,
wenn ich da also jetzt letztendlich, sagen wir mal,
mein Mehrsinstrument dranhalte, gucke, ist da eine Ladung drauf,
durch diesen Vorgang wird der Kondensator dann eben auch schon entladen.
Das heißt, bei ihm lese Zugriff auf den Speicher,
lehrt sich dann eben der Speicher in den Halt.
Das heißt, das, was dann eben noch passieren muss,
ist, dass nach ihm lesen,
also die Information quasi erneut wieder entsprechend reingeschrieben wird,
demzufolge dauert das natürlich
deutlich länger
War ich dann eben dafür sagen, sorgen muss, dass ich also jetzt eben nicht nur auslese,
sondern gleichzeitig dann eben auch die entsprechenden Werte wieder reinschreibe. Zum anderen ist es auch so,
dass also bei der Herstellung der integrierten Schaltung, sagen wir mal,
die Kondensatoren jetzt nicht so gut gegenüber alle Umwelteinflüsse oder alles isoliert sind,
dass sich die Ladung dort also unendlich lange hält,
sondern die entladen sich halt selber,
was dann eben dazu führt,
dass von Zeit zu Zeit auch immer dafür gesorgt werden muss,
dass die dort vielleicht gespeicherte Ladung,
wenn da also quasi die Speicherzelle eine Eins enthält,
dann eben auch wieder erneut auf ein richtiges elektrisches Signal gebracht werden muss.
Das heißt, das Ganze nennt sich dann eben Refresh.
Das heißt, man liest eben letztendlich den Inhalt aus und
schreibt ihn dann wieder einmal komplett neu rein. Das passiert,
sagen wir mal so bei typischen Speicherbausteinern auch immer im Millisekundenbereich,
ist für uns jetzt natürlich immer vergleichsweise schnell vom Computer
unendlich langsam
Aber nichtsdestotrotz ist es eben entsprechend notwendig und es kann dann eben sein,
dass von Zeit zu Zeit ich selber jetzt auch quasi von
meinem Programm oder von meiner Hardware gar nicht an den Speicher rankomme,
weil der jetzt also gerade dabei ist, dann eben so ein Refrash zu machen.
Die Speicher selber sind insgesamt dann auch deutlich langsamer als S-RAM,
also mindestens eine Größenordnung, haben aber eben den Vorteil,
weil ich da jetzt also nicht so viele Transistoren brauche,
dass sie Also auch sehr viel kleiner aufgebaut werden könnten und
man dann eben im Prinzip ein dynamisches Rahmen dann eben offen entsprechend hohe Speicherkapazität optimieren kann,
weil ich das im Entsprechendler einbauen kann.
Hier also nochmal so ein Vergleich von dem Ganzen,
also nein, auf der linken Seite im Prinzip,
dass statische Rahmen, also hier diese beiden,
rückgekoppelten Inverter, also hier die Transistoren,
wo ich da was reinschreiben kann.
Das heißt eben sechs Transistoren probiert,
statisch kein Refrash vergleichsweise schnell,
aber eben mit
erheblich mehr Flächenbedarf
Hier wäre das Ganze jetzt von der Grundidee her,
wie das als dynamische Form aussieht,
wo ich also wirklich nur einen Transistor habe,
der mir hier als Speicher dient und eben hier auf der
einen Seite des Transistus quasi jetzt dieser gefühlte Kondensator dranhängt.
Rein praktisch sind das jetzt also auch keine Extrabauelemente,
sondern das ist eigentlich in diesem Fall dann der Source-Eingang des Transistors selber.
Nicht, aber ich brauche dann eben für die Speicherung von
einem Beet jetzt noch einen einzigen Transistor
Nicht also hier nochmal die entsprechende Kapazität,
zumindest jetzt so bei aktuellem Prozess oder aktuellen Herstellungsprozessen,
um mal zu veranschaulichen, wie wenig sich jetzt also hier nur noch tut,
um jetzt also die Informationen zu speichern.
Also das ist eine Größenordnung von zehn Femto-Verrat.
Und das, was dann also dort drauf gespeichert wird,
entspricht ungefähr noch 200.000 Elektronen. Und jetzt kann man sich vorstellen,
wenn die Schaltung entsprechend Moore's Lore immer kleiner skalieren,
werden also hier natürlich auch irgendwie die Kapazitäten immer kleiner.
Und irgendwann kann man sich dann eben auch mal vorstellen,
sind, also die hier drauf gespeicherten Ladungen,
also wirklich in dem Bereich, wo man sagt,
also wenn ich jetzt irgendwo so in den einstelligen Elektronenbereich komme,
spätestens dann ist also Schluss mit Mors Law.
Guten Nachteil beim dynamischen Rahmen dann eben entsprechend langsam,
dafür aber dann eben als Vorteil,
dass der Speicher dann eben entsprechend eine minimale Fläche besetzt.
Hier nochmal als Beispiel so was wie so ein Speicher,
dann wirklich physikalisch aufgebaut ist. Also hier einmal so eine
elektronenmikroskopische Aufnahme von so einer Speicherzelle von einem Ein-Gigabit-Spar, DRAM,
einer Firma Siemens, inzwischen auch nicht mehr so ganz aktuell.
Das, was man hier also letztendlich sieht,
quasi immer dieses Sandwiches, die hier aufgesägt sind,
das ist dann im Prinzip diese Kapazität von dem Kondensator und
das Wasser ist dann hier der Rest von dem Transess-US,
befindet sich dann letztendlich jeder Drohnen da beziehungsweise an der Einstellung
an daneben
Andere Bauformen sind dann also, das nennt sich dann hier Stacked,
weil das quasi jetzt eben wie so ein Stapel aufeinander aufgebaut ist.
Andere Bauformen sind dann sogenannte Trench-Speicherkondensatoren, Trench, Englisch,
Graben, steht dann eben für einen tiefen Graben,
wo ich dann eben sage, also das,
was also hier mit dieser grünen Struktur zu sehen ist,
also hier jetzt in so einem aufgesägten Chip,
ist dann eben hier dann auch diese Kapazität,
die dann eben dafür sorgt, dass also quasi hier der Transisto,
der jetzt also hier an der Stelle daneben sitzt,
da jetzt eben die Ladung aufbringt.
Wie gesagt,
man versucht jetzt immer entsprechend dem Miniaturisierungsgrad das Ganze dann natürlich möglichst klein zu machen,
beziehungsweise so,
dass die Kapazität jetzt eben immer gerade noch groß genug ist,
dass man das dann eben auch wirklich sicher auslesen kann und eben entscheiden kann,
ist dort überhaupt was drauf gespeichert oder wenn ich das auslese,
messe ich da jetzt nur sowas
wie so ein Grundrauschen
Gut, das ist aber dann natürlich, sagen wir jetzt,
piese Elektrotechnik bzw. Verfahrenstechnik, mit der wir uns jetzt also nicht weiter rumschlagen.
Deswegen kann man das jetzt eigentlich erstmal nur so als Information zur
technischen Realisierung sehen. Hier ist auch nochmal grob angedeutet,
im Prinzip jetzt für so einen DRAM-Layerout,
also wie man das jetzt eben auch vergleichsweise klein hinkriegt,
wo ich dann eben jetzt hier immer angedeutet habe, die einzelnen Worldlines,
wo ich jetzt also die Speicherworte mit adressieren kann, eben hier die Bitlines.
Und dadurch, dass ich jetzt hier immer nur einen Transistor und diese Kapazität brauche,
kann man das dann eben wirklich jetzt von einer flächigen Anordnung nicht nur hier in diesem Schaltdiagramm,
sondern auch nachher in der Schaltung selber dann quasi immer so kachelförmig nebeneinander anordnen und kommt dadurch dann also zu vergleichsweise kompakten Layouts.
Wenn ich also ein bisschen angedeutet, sieht man das ja, also hier schon nicht. Also jeder, dieser Gnobel ist dann also letztendlich ein einzelnes Bild. Gut,
bei dem DRAM-Speicher gibt es dann also noch verschiedenste Varianten,
diverse Zwischen Formen, die es dann also mal so irgendwie in den 90er Jahren,
Anfang der 2000er Jahre mal gab, also irgendwie Fastpage,
Mode, Extended Data Out und was weiß ich,
wie sie alle hießen, inzwischen heutzutage haben wir eigentlich nur noch Synchronous,
D-RAM-Speicher abgekürzt, demzufolge S-D-RAM,
wo der Speicher dann eben auch noch sowas wie ein Taktsignal erhält,
beziehungsweise das Ganze ist also jetzt auch schon deutlich weiter fortgeschritten zu DDR,
Double Data Rate SD-Rahmen, wenn man das jetzt also mal komplett ausweitet,
wo dann eben Daten mit steigender,
unfallender Tagflanke übertragen werden.
Das heißt, wir während eines kompletten Taktes dann eben entsprechend
zwei Zugriffe, auch das inzwischen deutlich veraltet.
Inzwischen ist man also bei DDR 2, 3 und 4
, also das heißt Varianten mit entsprechend höheren Taktbraten.
Und je nachdem, wie schnell ich das takte,
umso mehr Daten pro Zeiteinheit kriege ich natürlich reingeschrieben bzw. rausgelesen.
Das heißt, diese Daten pro Zeiteinheit liefern mir dann also eine Übertragungsdate,
nicht sagen wir mal so bei den schnellsten Testversionen jetzt so von DDR fair speichern.
Das war irgendwie so bei 25,6 Gigabyte pro Sekunde.
Noch ein bisschen weiter ausgereizt wird das also bei Speicher auf Grafikkarten,
wo man dann also entsprechend fiel jetzt also zum Beispiel für Texturen an Informationen schnell reinschreiben bzw. rauslesen muss.
Dort wird das Ganze dann jemals GDDR bezeichnet,
ist immer nicht ganz kompatibel eigentlich zu dem,
aber soll man nicht interessieren und sagen wir mal so die schnellsten Grafikspeicher,
die man jetzt mal so auf den Endspielekarten der Einschlägenfirmen.
Dahards kommen also dann außer auf Datenübertragungsraten bis zu 84 Gigabyte,
Blödsinn 4. 48 Gigabyte vor Sekunde. Gut,
auf dem Derram, was man dann häufig auch noch hat,
also hier jetzt eigentlich auch nochmal kurz angedeutet,
sind dann so was wie Aufeinanderfolgende oder Zugriffe auf aufeinanderfolgende Adressen,
das Ganze nennt sich dann auch immer oder findet man in
den Datenblättern dann eigentlich auch immer irgendwie als Birth-Zugriffe
Das heißt, ich habe jetzt hier irgendwo so was wie mein Taktsignal,
lege hier eigentlich eine Adresse an und möchte anschließend jetzt eben
von der nächsten Adresse und von der übernächsten Adresse lesen.
So, jetzt sieht man hier,
ich habe hier 32 Bit-Adressen und die Adressen inkrementieren jetzt hier
einmal mit plus 4 und einmal mit plus 8. Frage,
weiß jemand warum
Genau, also die Antwort war, weil die Speicheradressierung,
das hatte ich ja auch irgendwann zwischendurch schon mal erklärt,
typischerweise,
und in diesem Fall ist eben auch beidweise eigentlich passiert,
jetzt für die Speicheradressen,
dadurch,
dass ich jetzt aber hier also immer ein gesamtes Speicherwort adressiere von 32 Bit,
habe ich dann eben für zwei aufeinanderfolgende Adressen quasi als Offset dann immer vier Byte,
nicht deswegen zählen die Adressen demzufolge dann eben immer mit
diesem Offset drauf
Und was dann hier eben auch angedeutet ist,
dass man dann eben auch häufig Effekte hat,
dass sich dann eben wirklich fürs erste Mal,
also quasi die Adresse komplett übertrage und nachher die Adresse dann eben automatisch weiter raufzielt und ich dann auf so eine gesamte Folge von Adressen dann eben wirklich mit so einem Burst-Zugriff,
wo ich dann also wirklich so einen kompletten Block auslesen kann,
ohne jedes Mal die komplette Adresse zu beschreiben,
entsprechend schneller den Speicher auslesen kann.
Gut, das war es in vielen anderen technischen Systemen,
inzwischen ja auch eingesetzt wird,
beziehungsweise jetzt da eigentlich auch zunehmend als Ersatz oder Ergänzung für Festplattenspeicher,
also für magnetische Speicher genommen wird,
sind dann also Flash-Speicher von der Bauart, sind,
sagen wir mal, Flash-Speicher,
eigentlich ähnlich kompakt wie dere am Speicher.
Das heißt, ich brauche im Prinzip eigentlich
nur sowas wie einen einzelnen Transistor um die Informationen
zu speichern
Anders als Bardera wird die Information aber nicht auf dem Kondensator,
sondern auf einem entsprechend gut isolierten Gates-Speichers gespeichert.
Und die bleibt eben auch erhalten, wenn die Versorgungsspannung abgeschaltet ist.
Dazu gibt es dann eben spezielle Transistoren,
die also jetzt nochmal ganz anders aufgebaut sind als das,
was ich da jetzt also bislang so vorgestellt hatte,
wo ich dann eben sogenanntes Floating-Gate habe.
Das heißt eben dieses, Dieser Schalnetta oder der Schalende des Transists,
das Verantwortliche Teil ist eben entsprechend irgendwo elektrisch isoliert.
Und wenn ich dort eben eine Ladung reingebracht habe,
dann sitzt die dort auch mehr oder minder fest.
Und da habe ich also dann keine Selbstentladungseffekte.
Nicht nur das Auslesen des Speichers hat halt eben den Vorteil,
dass es also vergleichsweise schnell geht, beliebig oft möglich ist.
Deswegen gerade auch hinsichtlich der Geschwindigkeit,
ist das jetzt natürlich also für Solid State Discs,
wie sie also dann eben in Also indem hier nicht,
aber entsprechend netten Notebooks oder in Moobilgeräten benutzt werden.
Also sehr gut einsetzbar. Nachteil bei dem Ganzen ist,
dass also Schreibzugriffe vergleichsweise problematisch sind. Zum einen dadurch,
weil das jetzt also eine elektrisch ganz andere Technik ist,
wo also intern eine etwas höhere Spannung erforderlich ist,
braucht man da jetzt also mehr Elektronik zum anderen, dauert das Schreiben dann auch deutlich länger.
Und die Speicher sind dann eben so organisiert,
dass beim Schreiben ich jetzt also nicht einzelne Speicher zählen adressieren kann,
sondern immer nur ganze Blöcke von Speicherzellen adressieren kann und dass es dann eben sein kann,
dass wenn ich eben in einem Blog ein einzelnes Bit ändern möchte,
ich quasi den gesamten Blog auslese, das eine Bit verändere und dann eben die neue Information auch wieder reinschreibe.
Und was dann eben auch entscheidend ist,
die Anzahl dieser Schreibzugriffe ist eben technisch begrenzt,
weil diese Schaltung beim Schreiben letztendlich altern Nicht,
das heißt, man ist da dann im Bereich,
dass man da so nahe 10.000, einige hunderttausend inzwischen,
also auch schon gut 500.000 Schreibzugriffe nur machen kann.
So, wenn man sich jetzt so ein gesamtes Rechner-System ansieht,
kann man eben sagen,
ich habe jetzt also bei diesem Speichersystem eigentlich immer eine Mischung von verschiedenen Speichertypen,
also hier als Beispiel aus diesem Buch von Förver,
Arm, System on a Chip Architecture,
ist ein Beispiel für ein relativ kleines, eingebettetes System.
Dieses hier ist also jetzt der Prozessor, CPU,
dann eben noch eine Ansteuerungs- und Konkontrolllogik für den Speicher.
Und im Speicher habe ich dann eben einmal einen Speicherbereich aus S-Rahmenbausteinen und Speicherbereich
aus Rombausteinen in dem Rom sind dann eben quasi jetzt feste Teile des Betriebssystems oder von irgendwelchen Algorithmen reingebrannt.
Wenn ich also jetzt mit der Schaltung nicht weiter was machen möchte,
sondern die jetzt also wirklich wie so ein eingebettetes System,
also beispielsweise Mobilgerät im Handy irgendwo eingesetzt wird,
dass man dann eben sagt, also bestimmte Teile sind,
also quasi jetzt per Firmen,
wer oder ihm vielleicht sogar Hardware technisch als Rom so weit rein,
dass man sie es eben nicht verändern kann.
Und dieses S-Rahmen ist dann der Arbeitsspeicher. Und das,
was der Prozessor letztendlich sieht, ist nur ein einzigen Adressbus und ein Datenbus,
rein praktisch wird das dann aber so organisiert, dass man eben sagt,
Der gesamte Adressraum, den ich also jetzt unterscheiden kann,
also sprich in diesem Fall jetzt zwei hoch 32 Adressen.
Und da teile ich eben in einen Bereich,
den ich eben diesem Rahmenspeicher zuordne und in einen Bereich,
den ich dem Raumspeicher zuordne,
nicht im Idealfall teile ich die einfach durch zwei,
indem ich also sage, okay,
das eine Adressbit unterscheidet jetzt eben zwischen den Adressen und den Adressen.
Und hier habe ich dann eben entsprechend wenige Adressen zur Auswahl.
Also hier Also auch nochmal als vergleichsweise sehr einfaches Beispiel,
war so eine 50-Prozent-Teilung, macht meistens bei den Systemen wenig Sinn. Aber hier nochmal,
also so ein Tal von dieser Adressdekodierung, das,
was man hier eigentlich nur sieht, ist,
dass eben diesem Fall hier das Höchstwertigste Bit des Adressbusses genommen wird und dann eben quasi jetzt hier über diese Ungatta,
die also nichts anderes machen als eine Unterscheidung,
ist das Bit null oder ist das Bit 1, eben entweder den Rahmen oder den Raumspeicher und Atalien.
So dieser Tal Joom ist letztendlich nur noch eine Dekodierung,
wo ich jetzt also die einzelnen Speicherworte,
wenn ich den Speicher jetzt wortweise adressieren möchte, unterteile,
das passiert dann eben mit den unteren beiden Bit,
wo ich jetzt ja im Prinzip die Unterscheidung habe,
gehe ich jetzt eben auf ganze Worte,
wo ich dann ja eben dadurch, dass ich plus vier,
plus acht und so weiter rechne,
quasi dann immer nur A2 inkrementieren muss,
nicht und hiermit hätte ich dann eben die Unterscheidung innerhalb dieses 32-Bit-Speicherworts,
um ein einzelnes Byte raus zu adressieren,
beziehungsweise es gibt dann hier noch Steuerleitung zur Maskierung des Ganzen
Gut, was ich jetzt hier beim Speichel ja auch schon mit beschrieben habe,
ist dann eigentlich die Idee von Bussystemen,
nicht also im Bus,
um jetzt also CPU und Speicher und irgendwas miteinander zu verbinden,
kann man jetzt erstmal sehen, als eine elektrische,
beziehungsweise ich habe das jetzt noch so ein bisschen erweitert,
oder man nimmt das häufig auch erweitert,
eben auch eine logische Verbindung mehrerer Geräte untereinander oder eben innerhalb
einer Schaltung oder eines Computersystems mehrerer Funktionsblöcke
Ich in dem Bus habe ich dann eben typisch oder das,
was man als Bus bezeichnet,
ist eigentlich erst mal so ein ganzes Bündel aus irgendwelchen Datensignalen und Steuersignalen,
die ich jetzt eben irgendwie zusammenfasse und sage,
das ist jetzt, dass ich immer ein Bussystem,
das, was dann Busse typischerweise auch noch auszeichnet, ist,
dass sie häufig jetzt nicht nur Punkt zu Punktverbindungen sind,
wo ich sage, also hier der eine Teil schreibt die Information,
irgendwo hin, der andere Teil, liest die und verarbeitet die,
sondern dass ich jetzt eben eine Leitung oder ein Leitungssystem haben,
wo jetzt mehrere Teile schreiben können und eben auch mehrere Teile letztendlich oder mehrere Einheiten lesen können.
Das führt dann dazu,
dass ich eben nicht nur mehrere Quellen und mehrere senken,
also sprich lesende Zugriffe habe, das führt dann eben auch dazu,
dass man diese Bussysteme elektrisch dann auch noch so ein bisschen anders aufbauen muss,
weil ich da natürlich also sagen, oder dafür sorgen muss,
wenn ich jetzt also mehrere potenzielle schreibenden Quellen hätte,
dass die sich jetzt nicht gegenseitig kurz schließen.
Weil wenn ich jetzt sage, ich habe jetzt mehrere,
die auf den Bus schreiben und der eine sagt,
ich möchte eine Eins draufschreiben und der andere sagt,
ich möchte eine Null draufschreiben und quasi beide aktiv sind,
führt das also elektrisch gesehen zu nichts anderem als einen Kurzschluss in der Schaltung.
Die wird kurzfristig mal sehr warm und eine von den
beiden Quellen wird irgendwo intern,
also irgendwas abrauchen
Das heißt, da hat man dann eben auch noch spezielle Schal-Elemente,
sogenannte Pre-Sday-Treiber, die dafür sorgen,
dass quasi jetzt die Ausgänge der einzelnen Teile dann
eben auch elektrisch quasi komplett vom Bus abgeklemmt werden können,
die dann dafür sorgen, wie das geht.
Anderes Problem bei mehreren Quellen,
die jetzt vielleicht irgendwelche Informationen auf den Bus geben wollen,
ist jetzt die Frage, Wie sieht das jetzt zeitlich korreliert aus?
Das heißt, wer darf wann irgendwie seine Informationen rauspusten?
Gibt es da jetzt einen, der immer nachfragt?
Oder gibt es dann einen Mechanismus, wo jetzt also gesagt wird,
ich darf dann und irgendwann gebe ich die Kontrolle ab und dann darf der Nächste.
Und da gibt es eben auch mehrere unterschiedliche Strategien.
Das Ganze nennt sich dann Bus-Arbitrierung, wo man dann eben
entweder sowas wie typischerweise Masterslave-Konzepte hat. Das heißt also,
einer, also zum Beispiel jetzt hier im PC,
die CBU, Bestimmt, du darfst, du darfst,
du darfst und nicht und irgendwann schreibe ich selber auch mal draus drauf.
Bei vielen anderen Buchsystemen gibt es aber eben auch sowas wie Protokolle,
wo eigentlich alle Knoten gleichberechtigt sind und die dann also innerhalb
durch diese Protokolle untereinander aushandeln, wer dort was schreibt.
Andere Sache bei Bussen ist dann noch die Unterscheidung zwischen Synchron und Asynchron,
Bussystem, das heißt,
gibt es sowas wie ein Taktsignal, was irgendjemand erzeugt,
oder gibt es also auf den Bussen irgendwelche Steuersignale,
wo dann
die entsprechenden Wechselereignisse auslösen
Gut, typischerweise, und das ist ja das,
was ich eben auch schon an diesem Armbeispiel vorgestellt habe,
sieht ein Bus eben so aus, dass ich damit irgendwelche Basiskomponenten,
also CPU-Speicher, also in diesem Fall Prozessorraum, Rahmen,
irgendwelche ein Ausgabeeinheiten, ich also sprich genau das,
was man also jetzt hier so bei diesem von Neumann-Konzept immer hat,
miteinander verbinde.
Und da würde man dann eben immer noch unterscheiden,
jetzt also von einer logischen Interpretation dessen, was über die Bursse geht, nicht.
Also ob das jetzt also irgendwelche Adressen sind,
ob das Daten sind oder irgendwelche Kontrollentformen oder Steuerinformationen,
die jetzt über entsprechende Busse zu den einzelnen Bausteinen so eine Ausgabeeinheiten oder zu irgendwelchen einen Ausgabecontrollern weitergeleitet werden.
Gut, bei den Bussen, je nachdem, wo sie eingesetzt werden,
kann man sich da also jetzt sehr viele sehr unterschiedliche Typen denken.
Das geht also von irgendwelchen, sagen wir jetzt,
High-Performance-Anbindungen, wo ich eben jetzt wirklich sage,
ich habe auf meinem Motherboard in meinem PC mehrere CPUs,
die sich direkt untereinander unterhalten wollen mit maximaler Geschwindigkeit,
bis zu irgendwelchen Anwendungen, wo man eben sagt,
das Ganze darf überhaupt nichts kosten,
also beispielsweise so was wie Heimautomatisierung, also der intelligente Lichtschalter,
nicht wo also jetzt wirklich jeder Lichtschalter und jede Glühbirne eine eigene IP-Adresse hat und ich darüber jetzt,
ja, dafür braucht man IPV 6 für genau sowas.
Und ich darüber dann im Prinzip jetzt über die Leitung
dann eben auch als Bussystem entsprechend meine Informationen übertragen kann.
Nicht, du sollst einschalten, du sollst ausschalten,
du sollst dimmen, um jetzt bei diesem Beispiel zu bleiben.
Nicht, dann gibt es eben hinsichtliche Protokolle jetzt, unterschiedliche Unterscheidungen.
Ich gebe dir jetzt wirklich einen ausgewählten Master. Gibt es sowas wie Multimaster,
das heißt also Bussysteme, wo mehrere Master sein können,
wie sie das hinsichtlich der Echtzeitfähigkeit aus,
nicht also bei vielen Bussen oder Bussystemen spielt das keine Rolle.
Wenn ich das Bussystem nutze,
um irgendwie Videodaten und Audiodaten zu streamen und zu übertragen,
also Beispiel HDMI, um jetzt also zum Beispiel irgendwo auf dem Fernseher jetzt,
also hier eine Ausgabe zu generieren,
dann möchte ich da natürlich schon eine gewisse Echtzeitfähigkeit haben,
hinsichtlich der Datenrate.
Und dem zuvor gibt es da dann eben sehr viele
unterschiedliche Kriterien, nach denen man diese Bussysteme unterscheiden kann
Anzahl der Leitung, nicht Minimalbeispiele sind dann sowas,
also wie wirklich so zwei Drahtbusse, also I-Quadrat-Cebos, also das sind also Sachen,
mit denen man also beispielsweise irgendwelche Servo-Motoren in Auto sitzen,
ansteuern kann, wo das auch alles nichts kosten darf,
oder eben irgendwie so einfache System-Management-Busse,
also die dann teilweise in PCs noch mit drin sind, sehr viele unterschiedliche Sachen.
Leitungslänge ist dann eben auch immer noch eine Unterscheidungskriterium,
wie lang dürfen irgendwelche Leitungen sein, nicht wenn ich sage,
ich muss jetzt also Prozessoren auf dem Motherboard miteinander verbinden,
nicht, dann bräuchte jetzt also keine 200 Meter Leitungslänge,
nicht, aber andererseits bei irgendwelchen anderen Sachen,
also sprich sehr reelle Schnittstelle oder Isanet-Kabel,
dann möchte ich da so schon ein bisschen Leitung dazwischen haben können.
Gut, und der Vollständigkeit halber,
wobei sich hier ist natürlich nur um eine logische Verbindung handelt,
habe ich jetzt also im Prinzip dann noch sowas wie Funkmedien mit aufgenommen,
weil logisch gesehen kann man das dann also zumindest in Bezug auf solche Fragestellen,
irgendwie Echtzeitfähigkeit, Masterfähigkeit, Protokolle und so weiter,
dann eben auch noch unter Bussysteme eigentlich mit hinzunehmen.
Gut, wenn ich jetzt eben so ein typisches Mikroprozessor-System habe,
das Wasser,
also jetzt quasi vor zwei Folien hier zu sehen ist,
habe ich eben eigentlich immer diese Unterteilung zwischen Adressbus,
wo also ein Prozessor jetzt also irgendein Speicher adressieren möchte mit
irgendwie einer Anzahl von Adressleitung,
demzufolge dann
eben zwei hoch enbites adressieren kann
Eine Anzahl von Datenleitung und dann eben vielleicht noch irgendwelche Steuerleitungen,
die es dann eben typischerweise gibt,
also das heißt externe Taktsignale,
Kontrollleitung an die Speicherbausteine nicht,
das heißt möchte ich schreiben oder möchte ich nur lesen und irgendwelche anderen Kontrollleitungen,
die jetzt also zum Beispiel jetzt langsameren Geräten signalisieren,
beziehungsweise von denen dann zurückgegeben werden,
ich bin noch nicht so weit und
die Daten kommen dann und dann
erst an
Nicht, was man häufig dann auch macht,
um jetzt Leitungen zu sparen, ist das dann also gemeinsam genutzte Leitung,
sowohl für Adressen als auch für Daten genommen werden und es dann eben Steuersignale gibt,
die zwischen unterschiedlichen Betriebsmodi jetzt auf diesem Bus unterscheiden. Gut, bei vielen Bussen,
beziehungsweise Systeme sieht man dann ja eben auch so eine Art Evolution,
ich also hier nochmal,
also die Folie oder das Beispiel aus dem Buch von Tarnbaum,
wo dann also im Prinzip jetzt für den Adressbus,
der NTLX 86-Prozessoren gezeigt ist, nicht wie die also von sag ich mal,
Anfang der 70er Jahre, einem ein Mibibyte-Adressraum,
den man im Prinzip mit 20 Adressbits unterscheiden konnte,
über 24 Bit 32 Bit, inzwischen 64 Bit-Adressraum, angewachsen ist.
Und das, was man dann immer versucht zu machen,
beziehungsweise was die Hersteller in dieser Fires,
also Intel, man ja gemacht hat, ist,
dass man da quasi immer so eine Art Abwärtskompatibilität versucht einzubauen,
quasi dann immer die zusätzlichen Adressleitungen logisch gesehen,
dann eben auch letztendlich weggelassen werden können,
um also beispielsweise jetzt auch in Bezug auf schon bestehende Softwareprogramme die Lauffähigkeit immer noch erhalten zu können.
So, ich hatte bei den Bussen ja eben schon gesagt,
also es gibt immer die Unterscheidung zwischen Synchronen und Asynchronverhalten.
Synchron kann man sich jetzt ja immer vorstellen,
dass es eben so ein Tagssignal wie dieses Vieh hier gibt,
zu dem dann Kron jetzt eben irgendwelche Steuerleitungen schalten müssen beziehungsweise
irgendwelche Adressen und Daten auf dem Bus anliegen.
Nicht, wenn man sich dann also mal jetzt zu
irgendwelchen Speicherbausteinen beziehungsweise zu irgendwelchen Systemen dann,
also mal so die Datenblätter ansieht,
dann sieht man da dann eben typischerweise dann so eine ganze Anzahl von solchen Impulsdiagrammen.
In der Regel sind die dann also deutlich komplizierter
als sowas hier
Aber hiermit ist eben eigentlich immer erst mal nur angedeutet,
dass man jetzt eben wirklich sieht, zu irgendwelchen Taktforderflanken beziehungsweise Tag-Drückflanken,
nicht wann darf hier was passieren, nicht und hier hätte ich zum Beispiel,
dass ich also jetzt hier einen Lesezyklus habe,
das heißt also, insgesamt dauert das jetzt hier in diesem Beispiel,
war eben zum Beispiel jetzt drei Takte, das heißt,
es wird also irgendwie die Adresse angelegt,
es wird dann ihm gesagt, ich möchte lesen,
dann gibt es eben noch so eine Wade State,
also dass der Speicher dann eben sagt,
ich bin auch nicht so bereit irgendwann, sagte,
okay, jetzt habe ich die Daten fertig,
die Daten werden dann eben quasi irgendwo auf den Bus gegeben und derjenige,
der das dann lesen möchte, kann die dann eben entsprechend abtasten,
nicht und um diese Rückflanke herum, wo dann eben die Abtastung stattfindet,
sind dann eben beispielsweise die Zeiten eingetragen,
wie ich sie, also schon bei Registern vorgestellt habe,
also sowas wie TDS und TDH was dann eben zum Beispiel so weise sowas wie Data Holt Time und Data Setup Time sind,
wo man dann eben sieht, diese Zeitbedingungen müsste ich jetzt eben entsprechend einhalten,
wenn ich jetzt also mit diesem Speicher-Baustein,
mit denen du dem Timing kommunizieren möchte.
Wie gesagt, das ist dann immer typabhängig,
wie viele Parameter es da gibt, wie dann also die einzelnen Werte genau aussehen,
aber man kann sich dann mit entsprechend viel Aufwand dann eben aus diesen Diagrammen letztendlich komplett rauslesen,
Wie steuere ich jetzt also so einen externen Speicherbaustein an?
Wenn ich jetzt von meinem Prozessor sage, ich möchte jetzt beispielsweise schreiben,
also einen Schreibzyklus oder einen Lesezyklus anwerfen, nicht, das heißt, wann muss ich welches Signal auf welchen Pegel liegen, damit das also diesem Busprotokoll entsprechend stimmt. Gut,
in meinem Synchronenbus gibt es eben quasi dieses Taktsignal,
zu dem das Ganze stattfindet, beim Asynchronenbus,
gibt es dann eben entsprechend jetzt hier nur irgendwelche Kontrollsignale,
die jetzt eben sagen, ich möchte jetzt hier was lesen,
das Ganze wird dann eben dadurch signalisiert,
dass eben hier der zu lesende Einheit,
also jetzt hier der Master sagt,
okay,
ich habe hier die Adresse raufgelegt und hier irgendwelche Steuersignale eingeschaltet und anschließend mit dem Übergang oder mit dieser Rückflanke signalisiere ich,
ich möchte lesen und der Client oder der Slave wartet dann eben irgendwie darauf,
beziehungsweise reagiert dann darauf und legt dann eben die entsprechenden Daten auf den Bus und gebt dann eben quasi als Rückmeldung oder Zurückleitung dann eben hier dieses Slave-Signal auf null.
Nicht woraufhin dann der Master eben reagiert, quasi die Daten
hier auslesen kann und dann eben seine eigenen Signale wieder zurückschaltet und so weiter und so fort.
Nicht das wäre dann eben sowas wie so ein Asynchrones Verfahren,
wo es jetzt also keinen expliziten Takt gibt,
weil sowas ist dann, dass das deutlich flexibler ist,
wenn ich jetzt also sehr viele unterschiedliche Geräte habe,
die dann eben auch unterschiedliche Zugriffszeiten habe.
Und ich also jetzt auch vielleicht gar nicht so was wie
einen einzigen zentralen Tag habe, den es überall gibt.
Also typisch oder oft hat man das ja so,
dass also ein Baustein eines Computersystems,
also eben irgendwo einen eigenen Takt hat,
dann geht eben ein ganzer Satz Leitung zu irgendeiner anderen Einheit.
Und die beiden sollen jetzt miteinander kommunizieren und jeder hat seinen eigenen Tag,
die arbeiten aber erstmal nicht synchron und sind vielleicht also auch
noch unterschiedlich schnell
Empfehlen sich dann eben solche Asynchronprotokolle. Gut,
das Thema der Busabetrierung hatte ich auch schon kurz angesprochen.
Grundidee ist eben, dass ich jetzt sage,
ich habe mehrere Komponenten, die jetzt irgendwie was übertragen möchten.
Es geht aber auf den Bus logischerweise immer nur ein Transfer zurzeit.
Das heißt, diese Daten übertragen muss jetzt irgendwie sehr realisiert werden.
Das kann ich eben entweder machen über eine zentrale Arbitrierung.
Das heißt, es gibt eben eine Einheit,
Die ist dann eben der Arbeiter oder der Busmaster,
die gewährt dann eben entsprechende Zugriffe auf den Bus.
Und je nachdem, wie diese zentrale Einheit das Ganze verwaltet,
gibt es dann eben sehr unterschiedliche Strategien.
Das kann man also prioritätsbasiert machen, dass man eben sagt,
also der hat die Priorität, der hat die Priorität.
Nicht, das kann man nach Zeitscheibenverfahren machen, Round Robin,
im Englischen dann immer, wo man dann immer sagt,
also innerhalb eines bestimmten Zeit-Slots kommt die Einheit dran,
im nächsten Zeit-Slot die nächste Einheit
Oder es gibt eben sogenannte Token, wo dann eben immer nur eine der Slavester,
der dann quasi die Stoken gerade besitzt, entsprechend senden kann.
Dieses hier sind, sagen wir mal, eigentlich Strategien oder Fragestellungen,
die eigentlich genauso auch auftreten in der Programmierung bzw. in der Betriebsmittelverwaltung.
Wenn ich mir jetzt vorstelle, ich habe ein Betriebssystem,
ich höre mehrere rechenwillige Prozesse,
dann hat das Betriebssystem da ja nur unterschiedliche Strategien,
nicht, also wann kommt welcher Taskran,
wie lange darf der rechnen,
nach welchen Strategien geht man da vor
Ähnliche Fragestellungen, nur jetzt eben hier quasi ein paar Ebenen tiefer in Hardware gegossen,
fallen da dann eben bei der Busabitrierung genauso an.
Gut, dezentrale Abitrierung wäre dann im Prinzip sowas Protokollbasiertes,
dass man da jetzt also unterschiedliche Methoden auswählt,
als ein Beispiel wäre jetzt hier zum Beispiel die Arbitrierung vom Iquadrat Sevus.
Da sieht das so aus, dass also eine Komponente,
die was senden möchte, das ist also beispielsweise ein kleiner Sensor,
also hier In meinem Laptop zum Beispiel ist der Temperatursensor auf dem Motherboard.
Der hängt am I-Quadrace-Bus. Und er möchte jetzt sagen,
mir ist gerade so und so warm. Das, was der macht,
ist, dass er einfach guckt, sendet jemand anders auf dem Bus.
Wenn der jetzt gerade kein anderer drauf sendet,
fängt er erstmal an, irgendwie seine Werte rauszupusten.
Gleichzeitig kann es natürlich der Temperatursensor in der CPU auf die
gleiche Idee kommen und fängt auch an, seine Werte zu senden.
Was dann passiert ist,
also dass in diesem Fall der Bus elektrisch jetzt so aufgebaut ist,
dass also so eine Kollision nicht zum Kurzschluss führt,
sondern dass also einer von den beiden einfach rein logisch gesehen verliert.
In dem Fall sieht das so aus, dass eine Einheit,
die sendet, quasi guckt, wenn ich jetzt was raussende,
das, was ich an Daten jetzt auch selber vom Bus lese,
entspricht das dem, was ich gerade sende.
Und wenn es nicht dem entspricht, dann habe ich eine Kollision,
dann hat leider jemand anders gewonnen. Und dann sage ich,
okay, ich warte und versuche also jetzt meine Informationen,
Motherbout-Temperatur ist 43,2 Grad, eben irgendwann später nochmal zu senden.
Nicht das ist eben die Idee jetzt bei solchen dezentralen Verfahren.
Und wie gesagt, also wenn das jetzt nicht zeitkritisch ist,
kann man damit dann also eigentlich mit so einem Protokoll,
weil sie in Sachen ganz gut arbeiten. Gut,
hier nur noch der Hinweis,
auch jetzt zu Bussen oder zu irgendwelchen Prioritäten,
Wenn ich jetzt also eine Ausgabegeräte habe,
die sind in der Regel höher priorisiert als die CPU,
weil dort natürlich jetzt also irgendwelche Zugriffe möglichst schnell behandelt werden sollen,
während jetzt also sag mal so reine Rechenoperationen für den Benutzer letztendlich warten können.
Gut, hier nur noch mal zwei Grafiken,
auch aus dem Buch von Tannenbaum,
wo jetzt im Prinzip dann Bus-Avatarierung auch so skizziert ist,
dass es eben eine zentrale Einheit gibt,
nicht mehrere Ein-Ausgabe-Einheiten,
die dann quasi sowas wie so ein Request losschicken
Können und die Einheit kann dann eben quasi jetzt in Form so einer Daisy Chain,
also so einer Aufeinanderfolgenden Kette dann eben sagen,
du sollst senden oder der nächste oder der,
beziehungsweise wenn der jetzt hier keine Daten hat,
würde er dann eben quasi diese Sendeinformation entsprechend weitergeben und dadurch können sich dann die Einheiten entsprechend den Bus teilen.
Das Ganze kann man dann wie hier unten angedeutet,
das ist also auch noch mit unterschiedlichen Prioritäten machen,
wo dann also einige Geräte dann eben quasi an so einem an einer höheren Priorität angeschlossen sind,
andere an niedrigeren Prioritäten und so weiter und so fort.
Gut, eine Eigenschaften von solchen Bussystemen,
was ihr auch schon gesagt hattet, also im Prinzip, wo ist Bandbreite,
Stichwort Bandbreite ist ja gerade eben schon bei den Übertragungen in Speicher aufgetreten,
also sprich die Menge an Daten,
die jetzt also pro Zeiteinheit übertragen werden können.
Nicht bei Bussen hat man da natürlich typischerweise noch zusätzlichen Overhead,
der sich also irgendwie durch das Protokoll ergibt.
Das heißt, da müsste man dann eigentlich immer noch unterscheiden zwischen Brutto- und Netto-Datenrate. Wenn man jetzt mal irgendwo nachsieht,
also in der englischen Wikipedia gibt es dann,
also unter List of Device Bandwiss für unterschiedliche Busse,
Übertragungsverfahren, Protokolle, mal sagen wir so ganze Statistiken,
was es alles gibt, wie schnell die senden können,
da sind dann typischerweise immer diese ganze Bruttodatenraten mit drin,
nicht hier auch nur nochmal einige Sachen, also sprich das, was wir also häufig im PC-Bereich dann finden, also aufgezählt.
Ich gehe eben von sehr langsamen Schnittstellen wie der seriellen Schnittstelle,
die inzwischen ja nun auch schon quasi fast ausgestorben ist.
Bis in den Bereich von Kilobit pro Sekunde,
wie gesagt, Iqualacebus, irgendwas,
was man dann eigentlich so in der Regel als Systembus noch auf den Platinen gelegentlich mal wiederfindet.
Nicht bei USB kommt man, also zumindest beim aktuellen USB-3-Standard
dann also schon in Gigabit pro Sekunde
Dann Isar, PCI, PCIE, sind dann eigentlich Bussysteme,
die dann also auf der Hauptplatine, auf dem Motherboard zu finden sind.
Also Isar noch historisch langsam,
das war so im Prinzip der erste IBM-PC,
der sowas als Bus hatte, also mit Übertragungsraten,
die also inzwischen deutlich geringer sind als das,
was man jetzt mit USB hinkriegt.
Mit PCI wollen das dann dementsprechend schneller.
AGP war ja dann auch nochmal zwischenzeitlich so eine Grafik,
so ein Standard,
um Grafikkarten anzubinden
Inzwischen wird das dann ja auch alles über BCAE Extended gemacht,
wobei das rein technisch gesehen jetzt wieder
nicht direkt eine Busverbindung oder nur eine logische Busverbindung ist,
weil es eigentlich eine Punkt zur Punktverbindung darstellt.
Und eben als andere Ende der Fahnenstange,
also irgendwie solche High-End-Performance-Verbindungen wie Halber-Transport,
die also benutzt werden,
um jetzt also beispielsweise auf irgendwelchen Blade- oder Cluster-Systemen
mehrere CPU-Chips miteinander direkt zu verbinden
Gut, hier, nur noch mal aufgeführt als Beispiel der PCI-Bus
steht für Periphera Component Interconnect von Intel Anfang der 90er Jahre entwickelt,
war früher eigentlich ein System mit 33 Megahertz-Takt.
Irgendwann gab es dann also auch noch mal eine schnellere Version,
ursprünglich auch als 32-Bitbus-System gedacht,
mit gemeinsamem Adress- und Datenleitung und eben einem Busmaster,
nämlich der CPU
In diesem PCI-Bus, beziehungsweise in den Nachfolgern,
also das, was jetzt PCIE ist,
hat man dann eben typischerweise sowas wie so eine Autokonfiguration.
Das heißt also, die Geräte haben oder geben sich an
den Bus jetzt über entsprechende Hersteller und Geräte,
IDs zu erkennen, werden demzufolge dann automatisch erkannt.
Und sofern das Ganze dann eben auch richtig funktioniert,
kann das Betriebssystem,
also zumindest das Linux macht das immer relativ nett und elegan,
dann eben auch gleich automatisch alle zugehörigen Treiber zu
den Geräten laden
Und entsprechend dieser Konfigurationsinformation passiert dann eben auch eine Zuweisung jetzt
von Adressbereichen und irgendwelchen Interraps und so weiter und so fort.
Also das mit dieser Autokonfiguration muss ich immer sagen,
das ist also relativ charmant, also wirklich so bei Linux-Systemen.
Ich kann also letztendlich hier von dem Rechner das Festplatten-Image nehmen,
Klonen auf irgendeinem Desktop-Rechner rüberziehen,
der also letztendlich eine ganz andere Hardware,
eine andere Grafik hat und was weiß ich hat,
einen anderen Netzwerkschips,
Netzwerkschippen,
einen ganz anderen Chipsatz
Trotzdem würde das also out of the box laufen,
ohne dass ich da jetzt noch irgendwelche Treiber mit reinbauen muss,
mit reinkompilieren oder irgendwas konfigurieren muss. Weil, wie gesagt,
diese Autokonfiguration macht das im Prinzip möglich und zumindest bei den
meisten Linux-Systemen sind natürlich, deswegen funktioniert das überhaupt erstmal,
also letztendlich alle Treiber mehr oder minder mitgeliefert, dass dann sowas funktioniert.
Also wenn man sich sowas mal ansehen möchte, also wie gesagt,
unter Unixen, beziehungsweise mein Linux ist das dann eben mit dieser Befehl LS PCI.
Mich kriegt man dann eben so eine Mehr- oder minder lange Aufstellung,
wo dann also quasi jetzt über hier irgendwelche komischen Adressen gesagt ist,
welche Geräte es da gibt.
In diesem Befehl kann man jetzt also auch noch mit zusätzlichen Parametern angeben,
wo dann also wirklich genau gesagt wird,
also was weiß ich hier,
die Grafikkarte hat eben die und die Eigenschaften mit den und den Wartezyklen und so weiter und so fort.
Und genau das ist das,
was ihm das Betriebssystem dann eben auch für diese Autokonfiguration
letztendlich auswertet
Gut, für sowas gibt es dann auch nur irgendwelche grafischen Frontends.
Das ist dann also hier nochmal so ein entsprechender Screenshot dazu.
Mich und hier auch nur mal eine kurze Liste jetzt für den,
auch aus dem Buch von Tarnbaum,
was also im Prinzip auf dem alten BCI-Bus,
sagen wir mal, an Leitung letztendlich mindestens vorhanden sein muss.
Und gut, zentral natürlich sowas wie Taktleitung,
dann eben 92,
Bitbreit,
Adresse bzw. Daten
Hat er gesagt, dass es in diesem Fall,
um Leitung zu sparen, über so einen Multiplex-Mechanismus gemacht.
Und dann gibt es dann eben so diverse Kontrollleitungen,
die dann eben entsprechend diesem Protokoll, was dann also für
diesen Bus jetzt irgendwie definiert ist, gesetzt werden müssen. Nicht,
dass dann hier auch nochmal so ein Ausschnitt aus so einem Impulsdiagramm,
was man hier eigentlich immer nur sieht, ist,
dass man dann eben immer Teile von diesen Sachen dann eben als so eine Art Buszyklus interpretieren kann,
dass ich eben sage, ich habe hier einmal eine lesende Datenübertragung,
hier eine schreibende Datenübertragung irgendwo dazwischen, da tut sich nichts.
Das ist dann eben ein Idol-Zyklus, nicht nur je nachdem,
wie der Bus dann genau aussieht,
was man dort macht, was das Protokoll spezifiziert,
gibt es dann eben entsprechende Unterscheidungen.
Ein, noch sehr einfaches Beispiel für Busse bzw. Bus-Systeme
wäre dann eigentlich die inzwischen fast ausgestorbene,
serielle Schnittstelle
Hat den Vorteil, beziehungsweise habe ich jetzt hier deswegen nochmal mit drauf,
weil die also, sagen wir mal, so einfach ist,
dass man sie also noch vergleichsweise einfach selber nachvollziehen kann vom Protokoll,
beziehungsweise dazu dann also auch zum Beispiel einen endlichen Automaten für die Steuerung entsprechend dieses Protokolls entwerfen könnte.
Nicht bei, also irgendwie sowas wie PCI oder PCI-E-Bus,
was man heutzutage hat, ist sowas, also sagen wir mal so, ganz trivial eben nicht mehr möglich. Gut,
die serienische Schnittstelle war eigentlich, ich sag mal,
so eine Computerschnittstelle, um die man genutzt hat,
um jetzt also früher langsame Periphere Geräte, also irgendwelche Terminals,
irgendwelche Fernschreiber, also sprich einfache Druckersysteme an Großrechner anzubinden,
beziehungsweise sind dann eben noch in die PC-Welt bis zum Aufkommen
beziehungsweise sagen wir mal bis zum Funktionieren von USB dann eigentlich auch immer noch mit weitergewandert,
nicht einige Rechner haben auch noch serielische Schnittstelle,
wenn ich jetzt hier mal gucke,
die hier allerdings auch schon nicht mehr
Und wie gesagt, ist heute eigentlich weitgehend von USB verdrängt worden.
Man kann aber damit, sagen wir mal,
sehr einfach Daten entsprechend übertragen auf seinem Bussystem.
Während das Ganze passiert dann eben dadurch, dass ich sage,
ich habe hier auch noch mal vergleichsweise hohen differenziellen Spannungspegel.
Also sprich, ich habe hier irgendwie zwischen plus zwölf und minus zwölf und meine Spannung.
Beispielsweise und schalte dann eben hier einmal um dieses Umschalten, nennt sich dann eben Startbit.
Das heißt, der Wechsel von dieser diesem Hohen,
zu dem niedrigen Pegel signalisiert jetzt eben, okay, jetzt Start, jetzt geht's los. Nicht dann kommen,
je nach Art von des Protokolls, dann eben bis zu acht Datenbits,
die dann eben entweder hoher oder niedriger Pegel sein können,
dann optional auch noch irgendwie sowas wie ein Perity, um jetzt eben,
weil mit einer Serienschnittstelle hat man eben typischerweise über sehr lange Leitungen,
dann eben irgendwelche sehr einfachen Geräte,
aber eben um da jetzt eben quasi zu prüfen,
ob die Leitung dann auch richtig funktioniert,
beziehungsweise da keine Fehler aufgetreten sind,
dann eben nochmal die Spirity.
Und dann als Stoppbit würde der Pegel dann wieder auf eins gehen. Das heißt,
wenn ich also so einen Signalverlauf habe wie jetzt hier und
dann eine Einheit quasi mit diesem Zeitraster hier abtasten würde,
würde man dann eben hier die entsprechende Folge von dem Bus auslesen.
Nicht, was man dann bei diesem Bus dann eben auch hart ist,
dass man typischerweise sagt, beide Systeme müssen zwar jetzt wissen,
mit welcher Übertragungsrate irgendwie was übertragen werden kann,
was dann also auch noch ein entsprechend großer Bereich sein kann.
Letztendlich müssen die Systeme aber keine gemeinsame Clock oder keine gemeinsamen Uhren haben,
sondern die können sich,
wenn sie die Übertragungsrate kennen,
dann quasi synchronisieren und müssen dann eben nur hinreichend genau innerhalb so eines Intervalls feststellen,
habe ich den einen Pegel oder habe ich den anderen Pegel.
Nicht dafür braucht man dann eben minimal eigentlich nur drei Leitungen,
nämlich also sowas wie ein grauen Signal
Transmith und Receive, womit ich dann eben eine bidirektionale Übertragung
jetzt zwischen zwei Systemen hinbekomme. Oft hat man dann auch zusätzliche Leitungen,
wo damit lassen sich dann eben noch weitere Funktionen machen. Gut,
auf den letzten paar Folien werde ich jetzt also noch mal kurz vorstellen,
wie man jetzt also aus allem, was man jetzt vorher schon gehabt haben,
Schaltnetze, Schaltwerke, CPU, sonstiges Speicher, Busse,
also jetzt wirklich ein komplettes Rechensystem aufbauen kann.
Also auch da beziehe ich mich, weil das eben wirklich
vergleichsweise einfach und kompakt ist. Also wenn man sich sowas jetzt,
also hier für irgendeinen kleinen PC ansehen würde,
wäre das Ganze also deutlich unübersichtlicher.
Deswegen beziehe ich mich da dann eben auch wieder jetzt auf
das Beispiel des Armprozesses oder so eines kleinen Armsystems.
Also der Arm ist im Prinzip jetzt so eine,
noch vergleichsweise einfach aufgebaute CPU.
Nicht, dann habe ich hier ein zentrales Bussystem
Hier ist irgendwelche Speicherbausteine, die dann eben an diesem Bussystem hängen.
Meistens haben die Systeme dann eben einen sogenannten DMA-Controller, Direct Memory Access.
Der macht im Prinzip folgendes, dass wenn externe Daten,
also beispielsweise jetzt durch irgendwelche einen Ausgabeschips, also solche externen Interfaces,
kommen oder beispielsweise jetzt durch externe Speichermedien, also DVD-Festplatte war es auch.
Wo, was weiß ich auch immer, gelesen werden,
dann werden diese Daten ja nachher, damit sie also von Prozesse verarbeitet werden,
in den Rahmenspeicher übertragen. Jetzt kann man natürlich sagen,
okay, dieses Übertragen der Daten macht die CPU selber,
kostet dann aber natürlich, also war der für jeden Datentransfer quasi die Berechnung in der CPU angehalten werden muss.
Es sind neue Daten da, die CPU holt die Daten, schiebt die jetzt in den Rahmenspeicher, kostet einfach relativ viel Zeit. Deswegen wurde,
also wenn in der Computertechnik dann schon relativ früh der sogenannte Direct-Memory-Access eingerichtet,
wo es dann eben entsprechende Hardware gab,
das heißt also kleine endliche Automaten, die dafür sorgen,
dass die CBU hier einfach weiterrechnet und der Datentransfer von dieser Einheit quasi gesteuert wird,
die dafür sorgt, dass jetzt also meinetwegen die Daten von der Festplatte im Rahmen landen,
wo dann also die CPU,
wenn sie dann irgendwann mal später darauf zugreifen möchte,
dann eben entsprechend drauf zugreifen kann.
Gut, das, was so ein System dann eben typischerweise noch hat,
sind dann also irgendwelche umsätzlichen Schnittstellen an externe Busse oder an andere Bussysteme,
also sogenannte Bridges,
wo ich dann eben jetzt von einem vergleichsweise schnellen,
zentralen Bus auf irgendwelche langsameren Bussysteme übergehe,
an denen dann also beispielsweise eine serielle Schnittstelle,
das ist dieses,
was dann hier als Yu-Art bezeichnet ist,
oder irgendwelche anderen
eine Ausgabeeinheiten dranhängen
Gut, sowas wie die Alu als, sagen wir mal,
eine zentrale Einheit kann man sich jetzt eigentlich immer so vorstellen.
Im Prinzip dieses hier zentrale Recheneinheit. Adira hatte ich ja schon mal vorgestellt,
das war also beim Arm im Prinzip,
dass mit diesem Carrie Select Adira, der da also gruppenweise aufgebaut ist,
nicht ansonsten die zentrale Alu hat dann eben hier irgendwie Speicher für Operanten,
A und B, in diesem Falledges,
mit X Orgates kann man jetzt quasi die Operanten jeweils ins einer Kompliment umsetzen.
Dann gibt es eben hier parallel entweder eine Schalteinheit,
in der die logischen Funktionen realisiert werden oder eben ein Adianetz und je nachdem,
ob es sich jetzt eben um Addition, Subtraktion oder um irgendeine logische Operation handelt,
wird dann eben das Ergebnis ausgewählt und liefert mir dann mal ein Resal zurück.
So, was hier rechts dann immer noch rausgeht, diese Leitung hier sind dann Informationen über das Ergebnis In der Schadung,
beziehungsweise aus dem reichen Weg, sogenannte Flex mit diesem Flex wird signalisiert,
ist ein Result, ein Ergebnis,
egal ob es jetzt also irgendwo aus der Alu oder aus der logischen Funktion kommt,
gleich null, ist mein Ergebnis negativ,
kann ich beim Zweierkompliment ganz einfach dadurch feststellen,
dass ich sage, wie sieht das höchstwertigste Bit aus,
wenn das eins ist,
ist das Ergebnis negativ,
wenn das null ist,
ist es
entweder null oder positiv
In meinem Adira habe ich dann noch sowas wie ein Carry Out und ich habe vielleicht auch noch irgendwie sowas wie die Informationen darüber,
ob ich einen Überlauf erhalten habe,
den ich also beispielsweise an softwaretechnisch, den ich dann,
also beispielsweise an softwaretechnisch abfangen möchte,
um jetzt eben zu sehen, okay,
ich habe mich da jetzt verrechnet bzw. verlasse da einen Wertebereich,
um das also dann in irgendeiner Acception abzufangen.
Demzufolge liefert dann eben so eine Alu-Einheit dann immer noch diverse Flex,
die dann eben benutzt werden können, um eben entweder solche Ausnahmebehandlungen zu generieren.
Oder um, wie jetzt also hier mit diesen beiden Flexs,
so was wie bedingte Sprünge zu realisieren,
wo ich dann ja eben auch sage,
wie kriege ich einen bedingten Sprung hin?
Ich mache einfach irgendwie eine, zum Beispiel,
ich möchte jetzt also an einer Adresse springen,
wenn der Inhalt eines Registers einen bestimmten Wert tat
Mache ich eben jetzt einfach dadurch, dass ich eben sage,
ich rechne den Inhalt dieses Registers minus diesem Wert.
Und wenn das Ergebnis null ist, dann sind sie gleich.
Wenn das Ergebnis nicht null ist, sind sie nicht leicht.
Das heißt, mit diesem Zero-Flag kann ich eben entscheiden,
soll gesprungen werden oder soll nicht gesprungen werden.
Nicht nur diese Flex aus der Alu gehen dann eben jetzt wieder in das Steuerwerk,
das heißt in den Kontrolautomaten der Schaltung,
die dann eben sagt, beispielsweise jetzt mal einen bedingten Sprung,
was ist jetzt die nächste Speicheradresse, wo ich jetzt mein nächstes,
meinen nächsten Befehl rauslese.
Gut, dann hat so ein kleiner Prozessor dann typischerweise noch sowas wie eine Registerbank,
wird dann eben auch ähnlich wie so ein Esramen im Prinzip relativ kompakt gemacht.
Einziger Unterschied ist,
dass man da dann eben noch mehrere parallele Leseports hat,
um jetzt beispielsweise jetzt für die Alu
zwei unterschiedliche Operanten von unterschiedlichen Adressen
auslesen zu können
So, hier nur als Floorplan angedeutet,
wie man das Ganze dann eben quasi physikalisch anordnet,
entsprechend kompakt, nicht uns im gesamten Prozessor,
wäre dann im Prinzip so aufgebaut,
wie man sich das jetzt also hier angedeutet ist.
Das heißt, ich habe hier, hier ist irgendwo meine Registerbank, mein Register.
Zusätzlich gibt es dann ja immer diesen einen speziellen,
oder dieses eine spezielle Register-Program-Counter, wo ich jetzt also im Prinzip zähle,
was wäre jetzt meine Folgeadresse, mit der ich irgendwo weiterrechne?
Der muss in der Regel erstmal inkrementiert werden. Dafür kann ich
also jetzt hier von diesem Adressregister diesen Programm-Countday im entsprechend inkrementieren.
Ich dann habe ich hier die eigentliche Alu.
Zusätzlich gibt es also dann hier bei dieser Einheit dann noch
einen entsprechenden Hardware-Multiplizierer und eben ein Barrowshifter,
das ist die Einheit,
mit der man dann im Prinzip
diese ganzen Schiebeoperationen ausführen kann
Und hier auf der rechten Saat dann eben das eigentliche Steuerwerk,
was jetzt dafür sorgt,
dass wenn ich einen Befehl gelesen habe,
der dann auf dieser Hardware entsprechend abgearbeitet werden kann.
Das Ganze passiert dann eben noch in Form einer sogenannten Pipeline.
Das heißt, es können immer gleichzeitig der nächste Befehl geholt werden.
Währenddessen wird ein Befehl hier schon dekodiert und noch
ein Befehl vorher dann also hier auf dieser Hardware letztendlich
zur Ausführung gebracht
Gut, auf den nächsten Folien sind dann also jetzt noch hervorgehoben,
wie dann die Datenpfade aussehen für bestimmte Operationen, werde ich jetzt aus Zeitgründen allerdings überspringen.
Und dann gibt es noch als kurze Beschreibung,
wie man jetzt also eine Ablaufsteuerung macht mit Mikroprogramm,
wollte ich eigentlich jetzt noch gebracht haben,
aber da ich jetzt also nicht auch nochmal wieder überziehen wollte,
werde ich mir das also jetzt für Januar aufsparen und die letzten vier Folien dieses Kapitels,
also nicht mehr bringen,
von daher kann ich jetzt also allen nur frohes Fest,
guten Rutsch und eine schöne Zeit,
freie Zeit wünschen und dann bis zur zweiten Januarwoche