So. Ja, ich hatte ja letzte Woche im Prinzip aufgehört mit der Vorstellung,
was jetzt eigentlich nochmal vom Begriff her mit Rechenarchitektur verbunden wird,
weil das ist jetzt also letztendlich das, wo wir jetzt eigentlich weitermachen werden.
Also wir haben jetzt in den vergangenen Kapiteln Schaltnetze, Schaltwerke, speichernde Elemente festgestellt.
Jetzt hier werde ich eben noch ein bisschen einführen,
beziehungsweise ein paar Sachen noch erläutern, die denen eigentlich noch fehlen,
um jetzt eigentlich wirklich zu einem Gesamthardwareaufbau für irgendwie Rechnerarchitektur zu kommen.
Und dann gehen wir eben eigentlich über zu dem Teil Befehlssatz,
Abarbeitung von Befehlssätzen beziehungsweise an eben so ein einige kleine Grundlagen, Assembler-Programmierung,
nicht das ist dann das, was dann im Prinzip nach Weihnachten dann entsprechend noch folgen wird. Gut,
die hatte gesagt, Rechnerarchitektur ist eben da letztendlich,
also genau diese Schnittstelle, dass man eben sagt,
zum einen kann ich eben darunter verstehen, das,
was eigentlich einen Befehlssatz ausmacht,
also welche Befehle gibt es, wie sind die kodiert,
wie wirken die, wie ist da die Semantik,
also das, was man letztendlich sehen würde,
wenn man jetzt wirklich Assembler programmiert, was ihnen,
denke ich mal,
also hier zu Beginn des Studiums vielleicht,
also irgendwie so ansatzweise mal kurz gezeigt wird.
Ansonsten muss man sagen, nicht, also bei dem,
was eigentlich Programmiersprachen bieten, bei dem, was vernünftige Compiler daraus machen,
möchte man sich also dann mit Assembler-Code eigentlich nicht mehr zwingend rumschlagen.
Auf der anderen Seite ist es natürlich schon wichtig,
zu wissen, wie der abgearbeitet wird,
was sich dort tut und welche Auswirkungen das eben haben kann,
weil zum einen Das ist so ein Compilerbau, braucht man das.
Das heißt, wenn man in der Richtung irgendwie was später arbeitet,
zum anderen natürlich, wenn es irgendwo knallt, wenn es irgendwo Probleme gibt, nicht.
Also alles, was also irgendwie Sicherheitstechnik ist,
also irgendwie das Ausnutzen von irgendwelchen Lücken basiert eben häufig,
dann eben auch auf solchen Eigenschaften, die sich dann daraus dann mit ergeben.
Gut, und der zweite Aspekt, Rechnerarchitektur ist dann eben jetzt das,
was also hier noch abschließend so ein bisschen kurz vorgestellt wird,
nämlich welche Hardware-Einheiten gibt es,
wie sind die miteinander verbunden und wie ist dann also mal so grob so ein Überblick von dem,
was eigentlich jetzt also irgendwie so ein Rechner letztendlich ausmacht.
Auch da ist das also vergleichsweise allgemein gehalten,
weil auch da muss man jetzt natürlich sagen,
also wenn man jetzt also irgendwie aktuelle Rechnerarchitekturen sich also wirklich ansieht,
also sprich, wie jetzt also ein PC irgendwie von 2016 aufgebaut ist,
wie irgendwelche Server aufgebaut sind,
wenn man dann in der Bereich High Performance Computing geht,
was dort eigentlich an Architekturen eingesetzt wird, Also darüber kann man dann wirklich schon eine eigene Vorlesung lang und breit halten.
Dafür haben wir leider, auch wenn ich persönlich schon immer sage,
es ist ein super interessantes Thema, dann immer nicht die Zeit nicht.
Deswegen hatte ich nur so ein grober Überblick, wie das Ganze prinzipiell funktioniert. Gut,
jetzt nochmal kurze Wiederholung von dem, was also,
glaube ich, irgendwie im zweiten Kapitel oder so mal mit dran war,
so ein bisschen von Neumann-Konzept, war, wie gesagt,
das ist eigentlich erstmal so das Grundlegende, von dem wir jetzt hier auch immer ausgehen werden.
Eben diese Grundidee, wie letztendlich irgendwelche Hardwarebefehle abarbeitet.
Nicht John For Norma hatte dann im Prinzip also diese Idee
ja so was wie so eine zusammen mit den Herrn Morgley und Eckardt im Prinzip so eine einfache Hardware-Struktur zu entwickeln und eben zu sagen,
okay, also es gibt eben so ein Grundsystem von Prozessor,
von Speicher, von Peripherie-Komponenten,
die also durch irgendwelche Busse miteinander verbunden sind und Das,
was dann die eigentliche Problemstellung ist, das,
was dann also von dem Rechner verarbeitet wird, ist dann eben quasi als Programm, beispielsweise dann eben wie näher im Speicher abgelegt, dann eben entsprechend kodiert.
Gut, ist für uns heutzutage eben selbstverständlich. Vorher war es eben wirklich so,
also bis, sagen wir so, in die 50er Jahre,
dass es eben dieses Grundprinzip letztendlich nicht gab,
beziehungsweise eben auch keine A-Bay dazu, sondern dass, wenn irgendwo Aufgaben berechnet werden sollten.
Also beispielsweise im Bereich der Statik im Bereich des,
was weiß ich, also hier in Hamburg kann man sagen,
im Hafen, also irgendwie sowas wie Tidenhub oder sowas berechnen,
dann waren das, also letztendlich irgendwelche Festverdrahteten, Hardwareaufbauten,
zum großen Teil dann eben auch wirklich noch irgendwie analog arbeitend.
Und eben diese freie Programmierbarkeit,
die wir eigentlich heutzutage eben so als selbstverständlich ansehen,
ist dann eben eigentlich erst mit diesem Idee da,
mit dieser Idee dort reingekommen
Gut, wie gesagt, das ist Programm und die Daten
liegen eben in einem Speicher. Und das,
was dann eben passiert, ist, dass man eben irgendwelche Hardware-Einheiten hat,
die letztendlich aus diesem Speicher sukzessive die Befehle lesen,
anhand dessen, was in dem Befehl steht,
dann quasi eben entscheiden, was getan werden soll.
Also der Befehl wird türködiert,
gegebenenfalls wenn noch irgendwelche Operanten geholt und das Ganze wird dann
eben ausgeführt
Einfachste Grafik dazu ist dann immer so was,
also in diesem Fall jetzt hier aus dem Buch von Tarnbaum und Austin,
wo man dann eben sich quasi vorstellt,
also dieser Tal hier ist letztendlich das,
was wir so als CPU können, Central Processing Unit,
logisch eben nochmal unterteilt in ein Teil hier jetzt,
also Steuereinheit oder Steuerwerk genannt, wo es also darum geht,
also quasi die Befehle zu holen,
zu interpretieren und dann eben irgendwie sukzessive abzuarbeiten und eben ein Teil Rechenwerk,
wo man eben sagen kann, okay,
daran befindet sich dann also als Hauptkomponente eben eine heutzutage eben nicht nur eine,
sondern eben also sechs oder sieben verschiedene Alus, entsprechende Schaltnetze,
die dann eben letztendlich diese Funktionen haben und irgendwelche Register,
wo dann eben Informationen gespeichert werden,
minimal Anforderungen ist dann eben letztendlich sowas wie ein einzelnes Register,
was man da sofort zwischen Ergebnisse über Alu-Berechnung braucht,
bei aktuellen Architekturen ist das natürlich auch schon längst nicht mehr so,
sondern da hat man dann eben
deutlich mehr Register
Zusätzlich gibt es dann eben irgendwelche Möglichkeiten, die eine Ausgabe irgendwo zu machen.
Das ist also das, was wir eigentlich heutzutage so typischerweise als Bildschirm,
das Natur, Maus, was auch immer, letztendlich nehmen.
Gut, und diese Komponenten sind dann eben durch ein Bussystem miteinander verbunden.
Also hier jetzt noch wirklich so einzeln als Leitung gezeichnet,
typischerweise, das aber dann eben entsprechend mediaaktionale Leitung.
Gut, hier das Ganze also auch nochmal entsprechend nur aufgelistet.
Inhaltlich hatte ich das schon gesagt. Was hier vielleicht nochmal erwähnenswert ist,
also es gibt dann beim Speicher häufig noch so eine Unterteilung zwischen dem eigentlichen RAM-Random-Access-Memory,
also Speicher, der gelesen und geschrieben wird und dann eben Reed-Only-Memory,
wobei man auch da sagen muss, heutzutage auch nicht mehr so zwingend verbreitet.
Das war also das, wo man also quasi früher gesagt hat,
Teile, die jetzt Grundfunktionalität sind, Betriebssystem oder eben auch irgendwelche festen Programme,
sind halt eben einmalig irgendwo abgelegt und werden entsprechend so abgearbeitet.
Wo man sowas heutzutage noch findet, ist also bei eingebetteten Systemen Ich,
wenn ich jetzt sage, also ich habe jetzt irgendeine Fahrstuhlsteuerung oder sowas,
wo jetzt also nicht andauernd irgendwie was umprogrammiert oder geändert wird,
kann man eben quasi den Quote, der letztendlich dann,
also für diese Steuerung verantwortlich ist, dann natürlich in Symbrid-Only-Speicher ablegen.
Auch da muss man sagen, ist inzwischen also von der Technik dann eben auch schon so ein bisschen überholt. Also heutzutage kennen sie ja nun auch,
hat man sowas dann, also typischerweise in irgendwelchen wiederprogrammierbaren Speichern,
also in Flash-Speichern, wo man dann eben auch sagen kann,
okay, also es gibt dann noch die Möglichkeit per Firmware-Update mit irgendwie diesen oder jenen Mechanismen da dann eben auch noch irgendwelche Sachen zu machen,
ist aber eben auch letztendlich davon abhängig,
wie aufwendig die Algorithmenprogramme dahinter sind,
nicht wo man dann eben sagt, okay,
wenn ich jetzt also sowas wie ein WLAN-Router betreibe,
wo also wirklich dahinter also schon Betriebssysteme und beliebig viel IO und irgendwelche anderen Sachen sind,
dann möchte man da vielleicht mal was aktualisieren können,
weil beispielsweise irgendwo irgendwelche Sicherheitslücken wieder aufgetaucht sind.
Nicht, wenn man sagt,
das ist also jetzt eben wirklich nur irgendwie die Steuerung von der Waschmaschine,
da wird einem das also in der Regel nicht so häufig interessieren,
beziehungsweise da hat man sowieso gar nicht die Möglichkeit,
da ist also irgendwie direkt dann
irgendwelche Programmierports ranzukommen
Gut, die Programmabarbeitung nach diesem Fraun-Neumann-Konzept,
also auch diese Folie hatte ich ja, glaube ich,
schon aufliegen, ist dann eben letztendlich,
dass man immer sagt, ich habe,
also das Programm als eine Sequenz, elementare Anweisung oder Befehle,
die sind dann eben binär im Speicher abgelegt und das,
was eben passiert, ist,
dass eben bei der Programmabarbeitung letztendlich der erste Befehl beispielsweise neben aus dem Speicher geholt wird,
wird an ihm teilweise interpretiert, dann wird eben schon geguckt,
zum Beispiel, wenn das jetzt ein Befehl ist,
der sich jetzt also über mehrere Speicherworte erstreckt,
muss da jetzt noch was nachgeladen werden,
gegebenenfalls werden da auch noch irgendwelche Umrechnungen, Interpretationen ausgeführt,
Und anschließend wird dann zum Beispiel jetzt,
also wenn es sich darum handelt, das ist ein Befehl,
sollen irgendwo zwei Zahlen von irgendwelchen Speicheradressen gelesen werden,
addiert werden, werden die geladen,
das Ganze entsprechend ausgeführt und anschließen würde man dann eben sagen,
also entweder inkrementiere ich dann eben entsprechend den Befehlszähler,
um mir dann eben den nächsten Befehl aus dem Speicher zu holen oder wenn es sich jetzt eben bei diesen Befehlen um sowas wie Sprungbefehle oder eben vielleicht auch bedingte Sprünge handelt,
wird dann eben entsprechend an dieser Stelle festgelegt,
welches dann jetzt die Folge-Adresse ist.
Wie das dann also teilweise ein bisschen genauer aussieht, wird dann also ganz grob,
also später in dem Kapitel zum Assembler-Programmierung noch kurz festgestellt,
vorgestellt werden. Ansonsten diejenigen von ihnen,
die jetzt also schon Rechnerstruktur und Praktikum sind,
werden sich also mit der Problematik dann also auch schon herumgeschlagen haben,
weil es das dann eben ja auch entsprechende Anweisungen gibt,
beziehungsweise Aufgaben gibt,
wo Mandanten entsprechend erarbeitet
Gut, anschließend, wie gesagt,
wird dann eben entsprechend der nächste Befehl geladen oder es gibt eben irgendeinen,
wie auch immer, gerade einen magischen Mechanismus,
der dann eben feststellt, okay,
Programm ist zum Ende abgearbeitet und es kann eben das nächste Programm geholt werden.
Gut, wie das genau aussieht, muss man dann natürlich auch sagen,
ist dann letztendlich natürlich auch wieder von Betriebssystemen abhängig.
Also auch das ist jetzt wieder eine Thematik,
wo man sagen kann, okay, ist oder wird teilweise
vielleicht eben auch noch in anderen Vorlesungen Lehrveranstaltungen angesprochen.
Also auch das geht dann also eigentlich so ein bisschen jetzt,
also ich aus den Rechnerstrukturen raus
Gut, also hier ist nun mal dieser Ausführungszyklus grob beschrieben,
also eben wirklich für jeden Befehl,
einzeln immer irgendwie unterteilt in diese Schritte, Befehl holen,
Befehl dekodieren, Operanten holen, irgendwas rechnen,
anschließend vielleicht noch sowas wie Speicher,
Zugriffe oder eben die ergebt berechneten Ergebnisse wieder irgendwo hinspeichern und anschließend dann eben gucken,
was wäre dann die nächste Instruktion,
die abgearbeitet werden soll
Wo uns sowas nachher dann noch begegnen wird,
ist dann relativ am Ende der Vorlesung,
wenn es dann also nochmal so ein bisschen um Pipelining-Konzepte geht,
weil, wie gesagt, das,
was ich jetzt hier vorstelle und das,
was sie dann eigentlich auch in den Rechnerstrukturen-Praktikum machen,
ist wirklich so eine ganz einfache von Neumann, Befehlsabarbeitung.
Das heißt, es wird wirklich immer ein Befehl geholt,
komplett bis zum Ende abgearbeitet.
Anschließend wird der nächste Befehl geholt. Das ist in Anführungszeichen
die allereinfachste Variante,
wie man
das machen kann
Aktuelle Architekturen machen das eigentlich anders. Das ist dann eben das,
was sich dann letztendlich als Pipelining darstellt,
wo man dann eben sagt,
diese einzelnen Teilphasen der Befehlsabarbeitung werden eben so hintereinander gesetzt,
dass,
wenn ich jetzt also meinetwegen fünf aufeinander folgende Befehle habe,
der erste geholt wird,
dann im nächsten Tag Schritt der erste quasi hier
eine Stufe weiter wandert und der zweite geholt wird und
das Ganze dann eben wirklich so sukzessive durchläuft
Ganz am Ende hat man damit natürlich genau das Gleiche erreicht.
Die Befehle wurden entsprechend abgearbeitet. Was aber da dann eben letztendlich
der Riesenvorteil ist, ist, dass man eben sagen kann,
ich habe zu jedem Zeitschritt dann eben schon mehrere Befehle in der Abarbeitung.
Und rein technisch gesehen werde ich zwar durch Pipelining nicht schneller,
weil also ein Befehl, also irgendwie jetzt die und die und die Operation irgendwie machen muss.
Aber dadurch, dass ich dann insgesamt,
also mehrere Befehle gleichzeitig in der Bearbeitung habe,
erreicht man eben deutlich höheren Durchsatz und insgesamt die Taktrate kann dann eben entsprechend heraufgefahren werden. Also im Prinzip diese Pipelining-Konzepte,
das war also letztendlich der Mechanismus, der also irgendwann dafür gesorgt hat,
dass man so Mitte der 90er Jahre irgendwann mal so von Taktraten,
die also im Bereich von einigen zig Megaherz oder maximal irgendwie so 100 Megaherz gingen,
also bis auf einmal in den Gigahertz-Bereich bei den Prozessortakten kamen und gut,
heutzutage, gut, Moores-Lore hat dann also natürlich auch noch ein bisschen was bewirkt,
ist das eben auch immer noch so,
dass eigentlich sämtliche Architekturen dann eben auch mit solchen Pipeline in Konzepten arbeiten.
Auch das wird dann, wie gesagt, noch etwas genauer später,
aber dann eben auch leider nur in kurze vorgestellt werden.
Gut, bei der Abarbeitung oder Interpretation von dem,
was dann also Rechnerarchitektur ist, kann man eben sagen.
Also ich habe letztendlich immer irgendwie so eine Unterteilung von
Hardware und Softwareanteilen. Also hier ist also Grafiken,
also auch von Brian und O'Haloran
Wo man sagt, also Hardware-seitig habe ich eben,
wenn ich jetzt bei so einem einfachen von Norman-Prinzip bleibe,
eben Prozessor, Speicher, ein Ausgabegeräte.
Da drauf dann eben typischerweise was wie ein Betriebssystem.
Das heißt also irgendein Mechanismus, der dafür verantwortlich ist,
dass der Reihe nach verschiedene Programme überhaupt erstmal ausgeführt werden können,
dass ich also in der Lage bin,
in irgendeiner Kommandozeile oder mit welchem Mechanismus auch immer eben zu sagen,
okay, das und das Programm soll jetzt gerade ausgeführt werden.
Und der eben auch dafür sorgt,
dass wenn zwischendurch irgendwelche einen Ausgaben passieren,
quasi durch Interrapts dann eben die Programmabarbeitung unterbrochen wird,
um jetzt eben auf diese externen Ereignisse zu reagieren.
Nämlich das, was wir natürlich dann typischerweise sehen,
sind eben wirklich dann also die Anwendungsprogramme,
das ist dann in der Regel natürlich auch das,
was wir
dann also meistens programmieren werden
Das, was das Betriebssystem daran eben auch macht,
ist dann eben auch nochmal so eine Art von unterschiedlichen Abstraktionen oder Abstraktionsebenen.
Also das geht dann auch so ein bisschen auf das,
was so ganz am Anfang der Vorlesung mal war,
nicht wo es also irgendwie so um diese Abstraktion und virtuelle Virtualisierung ging.
Auch da ist es so, dass man sagen kann,
okay, also wenn ich jetzt hier irgendwie was laufen lasse und hier meinetwegen jetzt also irgendwie das Programm,
also irgendwie laufen habe, was jetzt also irgendwie das PDF anzeigt,
ist das letztendlich, also irgendwie sowas wie einer von vielen Prozessen,
nicht der eben letztendlich, also den Prozesse irgendwo belegt.
Und irgendwelchen Speicher, nicht beim Speicher, kann man dann eben sagen,
okay, das ist dann eben auch nochmal irgendwie zusammengefasst,
nämlich zwischen dem, was eigentlich also wirklich physikalisch Hauptspeicher ist.
Und wenn der jetzt also nicht reichen sollte, irgendwie sowas wie Auslagerungsspeicher,
und dann hat man eben noch so Konzepte wie Dateien,
und eben dann darauf aufbauen, dann also eine Oscar oder darunter liegen, eine Ausgabegeräte. Gut,
auch diese Folie gab es schon ganz zu Anfang kurz,
Kompilierungssystem, nicht das ist also das, was wir jetzt eigentlich auch in,
gut, also beim Java natürlich nicht so,
aber wenn man jetzt also mit einem C oder C Plus als Programmiersprache arbeitet,
wo man dann sagt, okay, also das,
was man als Programmierer typischerweise macht, ist,
dass man eben jetzt in irgendeiner Hochsprache eben sein Quellprogramm angibt,
hat dann eben Gegebene Phase noch sowas wie so ein Pre-Prozessor.
Anschließend läuft das dann eben durch den Assembler und generiere dann eben irgendwelchen Assembler-Code.
Dieser Assembler-Code besteht dann eben aus jetzt wirklich den einzelnen Maschinenbefehlen
für irgendeine Architektur. Das heißt, wenn ich jetzt sage,
ich arbeite mit x, 86 Architektur, also egal,
ob jetzt dahinter letztendlich AMD oder Intel-CPU liegt,
also der Befehlsatz ist da eben erstmal das Gleiche.
Das wird dann eben entsprechend in diese Befehle übersetzt und anschließend kann man dann
eben diesen Assembler-Co dann eben wirklich jetzt in Maschinencode noch übersetzen,
was dann eben wirklich nur noch eine Folge von irgendwelchen Nullen und Einsen ist.
Auch das ist dann gegebenenfalls noch nicht vollständig ausführbar,
weil da ich jetzt natürlich gerade für irgendwelche einen Ausgabeoperation oder für irgendwelche anderen Sachen,
also nicht jedes Mal das Rad neu erfinden muss,
hat man also typischerweise mehr oder minder umfangreiche Bibliotheken,
welche Funktionen, die man mitbenutzen kann in seinem Programm.
Nicht das wird dann,
wenn das Programm eben letztendlich dann irgendwo ausgeführt werden soll,
eben entweder statisch dazugelenkt oder eben irgendwie dynamisch mit eingebunden.
Auch darauf werde ich dann später noch kurz eingehen,
welche Mechanismen es da dann im Prinzip gibt.
Und das, was man dann eben letztendlich hat,
also dann, um das dann eben auszuführen,
ist dann eben wirklich sowas wie ein Binärprogramm.
So, dieses landet dann eben irgendwann im Hauptspeicher
und wird dann eben letztendlich dann entsprechend von diesem von Neumann-Zyklus
irgendwo abgearbeitet
Hier, auch nochmal aus dem anderen Buch,
beziehungsweise in einer anderen Quelle, also letztendlich das Gleiche nochmal,
also hier sieht man das nochmal so ein bisschen heimpraktisch,
nicht, also hier jetzt, also irgendwie in irgendeiner Pseudosprache,
Hochsprachenprogramm, Assembler-Code, wo dann also im Prinzip jetzt,
also irgendwelche Register in der CPU dann schon angesprochen werden und hier irgendwelche Speicheradressen und dann eben irgendwelche Lade und Store-Befehle oder was immer sich dann dahinter verbergen mag,
also in die jeweiligen Assembler dann eben entsprechend übersetzt, nicht eben
Und das war es dann eben nachher als Maschinenprogramm rauskommt,
beziehungsweise ein wirklich als Assembler-Code, ist dann,
also als Objektdatei wäre dann eben wirklich nur noch irgendwie, welcher binärer Code, der dann letztendlich irgendwo auf der Hardware abgearbeitet wird. Und das,
was dort dann eben passiert, ist dann eben,
dass man sagen kann, okay,
mit diesen 0 und 1 und wenn ich die eben entsprechend interpretiere,
steuere ich quasi dann als eingangs oder Kontrollsignale eben sowas wie die Auswahl von irgendwelchen Allo-Operationen,
um dann letztendlich das,
was sie jetzt vorletzten Teil da gerade gemacht haben,
nicht wo man dann eben sagen kann, okay,
ich habe da also irgendwelche Steuerleitungen und wenn der Vernull ist und er wert eins und das und das,
dann soll eben beispielsweise addiert werden,
ich finde genau das passiert dann eben,
dass man ihm quasi einfach jetzt hier irgendwelche Bit-Strings oder Tals dringt,
sich also irgendwie rausnimmt und dann eben entsprechend interpretiert.
Nicht, dass da so grob das, was sie dahinter verbirgt.
So ein Konzept von Abstraktion gibt es Nicht nur softwareseitig, sondern eben letztendlich, also auch hardwareseitig. Also hier habe ich also jetzt nochmal so ein paar Folien,
die eigentlich früher von einer anderen Vorlesung stammen,
dann nochmal mit reingestreut,
wo es so ein bisschen so um diese Abstraktion von Hardware letztendlich geht,
weil, also das eigentlich auch so ein bisschen zeigt,
wo wir uns jetzt, also irgendwo gerade hinbewegen, nicht das,
wo wir quasi jetzt bei der von Neumann Architektur sind,
ist dann eben letztendlich sowas wie Architekturebene, also sprich,
ich habe hier eine CPU,
ich habe einen Speicher,
irgendwelche einen Ausgabeeinheiten,
die sind dann eben über die irgendwelche Bussysteme
miteinander verbunden
Für so eine Beschreibung, das heißt so eine Struktur,
kann man eben auch, zum einen natürlich, wie jetzt analog zu so einer Grafik so eine Strukturbeschreibung machen.
Ich kann aber eben auch sagen, also ich beschreibe die Funktionalität oder das Verhalten von dem Ganzen. Und das,
was man jetzt macht, um letztendlich,
also jetzt in umgekehrter Reihenfolge von dem, was fest ist,
in der Vorlesung gemacht haben, ist,
dass man da dann eben letztendlich runtergeht und sagt,
okay, ich habe hier meine CPU,
die kann ich jetzt eben unterteilen nach diesem Fonorman-Konzept beispielsweise dann in Operationswerke und Steuerwerk,
nicht hier sorge ich dafür, dass also die Befehle irgendwo in so einem Befehlsregister geladen und interpretiert
Neben Steuerwerk. In einem Befehlsregister geladen und interpretiert werden.
Es gibt dann eben irgendwelche Kontrollleitungen, die dann eben beispielsweise
der Aluhierteren dann eben sagen, das und das soll gemacht werden.
Und gegebenenfalls geht dann eben noch irgendwelche Statusinformationen oder sowas wie Flags,
zum Beispiel dann eben entsprechend zurück.
Und das Ganze kann man dann eben immer weiter aufdröseln.
Nächster Schritt wäre dann eben das,
was ich typischerweise an Registertransfer-Ebene nenne, wo ich dann eben sage,
ich habe hier jetzt also irgendwelche Register,
das heißt also Flip-Flops mit AVN entsprechend großen Wortbreite von 32 oder 64 Bit.
Hier dann eben mal eine Verbindung dazwischen,
habe dann eben hier entsprechend jetzt also irgendwelche 32 oder 64 Bit-Worte und kann dann eben sagen,
also hier vom Datenbus gehen dann eben beispielsweise also irgendwelche Leitungen so durch die Alu.
Ich habe dann hier eben mal eine Steuerleitung und wie
auch immer das dann also letztendlich dann von der internen Struktur aufgebaut ist.
Das, was dann hier,
also hier fangen jetzt also diese Sachen an,
so ein bisschen Sinn zu machen,
dann eben letztendlich an Informationen irgendwo übertragen wird,
sind dann eben hier sowas wie irgendwelche
Zahnwerte, also eigentlich Binärworte, die dann aber eben entsprechend
beispielsweise als Unscience-Saal interpretiert werden. Und auch da kann man jetzt sagen,
okay, das haben wir jetzt schon kennengelernt,
also Alu kann ich dann eben wieder weiter unterteilen in irgendwelche Schaltnetze,
wo ich jetzt, also meinetwegen aus voller Addion oder wie auch immer jetzt,
also irgendwie mal narrentmetische Funktionen aufgebaut habe.
Nicht letztendlich da dann eben beschrieben in Form von irgendwelchen Bullshit-Gleichungen
oder ich kann das eben dann als irgendeine Struktur dann so eine Gatter-Netzliste oder so ein Scamatic dann eben entsprechend aufzeichnen,
nicht das, was dort dann eine Information von A nach B sich bewegt,
sind dann also letztendlich nur noch so was wie einzelne Bit.
Dann kann man weiter runtergehen und sagen,
okay, Bana, gegebenen Technologie,
also beispielsweise Zemos-Technik wäre dann eben so was wie so ein Nantgutter aufgebaut aus vier Transistoren,
zwei IP-Kanal-Transistoren, das sind die oben, zwei Endkanal-Transistoren,
dann brauche ich noch irgendwie sowas wie Versorgungsspannung, nicht,
das hat uns also ja hier auch irgendwie noch gar nicht weiter interessiert,
aber in dem Fall auf elektrischer Ebene brauche ich das
dann eben natürlich auch schon
Das Ganze ist dann eben letztendlich sowas wie so ein elektrisches Netz,
was dann eben aus Transistoren, Kondensatoren,
Widerständen, was weiß ich, was aufgebaut ist.
Darüber kann man dann für diejenigen,
die das vielleicht noch irgendwie aus der Oberstufe oder irgendwo aus
dem Physik-Nebenfach oder wo auch immer dann kennen,
letztendlich dann so ein System von Differenzialgleichung aufstellen und das Ganze dann eben lösen.
Und dann wäre das dann eben letztendlich die Beschreibung des Verhaltens auf elektrischer Ebene.
Und während ich vorher quasi immer Binärworte oder einzelne Bits betrachtet habe,
habe ich hier zu ihm auf einmal Ströme und Spannung.
Und dann steht dahinter dann ebenentsprechend schon diese Interpretation,
dass ich sage,
also eine Spannung von meinetwegen 2,5 Volt interpretiert oder 2,2 Volt und höher
interpretiere ich als eins und irgendwas zwischen null und 0,3 Volt dann eben als null und alles dazwischen sollte nicht vorkommen. Und dann kann man natürlich dann eben wirklich bis in das Ship Layout runtergehen und eben sagen,
okay, also bei einer gegebenen Zemos-Technologie kann ich eben ein P-Kanal-Transisto so aufbauen,
indem ich also jetzt hier irgendwelche Diffusionen in eine Enwanne mache und das Ganze dann über einen Sinoxid und ein Polysilizium geht,
so und so aufbaue und das,
was man da dann eben sieht, ist das,
was man dann eben teilweise nochmal vielleicht in irgendwelchen Ship-Fotos oder so von den Prozessorherstellern sieht,
nicht, also irgendwelche schönen, bunten, beeindruckenden Bilder,
die dann eben letztendlich den geometrischen Informationen von den Herstellungsdaten entsprechen,
wo man dann eben sagen kann, ich,
also wenn es irgendwo heißt,
ich habe jetzt also meine Schaltung mit Einer 14 Annometer-Technologie,
nicht dann weiß, also vielleicht der Eingeweide noch,
dass also da diese 14 Annometer dann im Prinzip,
also diese Dimension hier irgendwo ist,
wobei das dann auch nicht ganz stimmt,
weil da die Transistoren auch wieder ein bisschen anders aufgebaut sind,
aber okay.
Gut, das Ganze wird dann auch immer irgendwie häufig
zusammengefasst in so einer Grafik dargestellt
Meistens, als das Y-Diagramm bezeichnet,
was sich also hier über diese drei Achsen ergibt,
sonst auch Geiski-Diagramm genannt, nach einem der beiden Autoren,
Geiski und Kuhn,
die das also im Prinzip in den Anfang der 80er Jahre vorgestellt haben.
Und im Prinzip diese unterschiedlichen Abstraktionsebenen von Architektur bis zu Logik
und Schadkreis sind dann eben entsprechend konzentrische Kreise und diese
Achsen sind eben einmal das Verhalten
Und die Struktur aus irgendwelchen Primitivelementen oder als dritte Achse hat man dann eben das,
was dann eigentlich nachher für die Fertigung wieder interessant ist,
dann eben irgendwelche geometrische Informationen für das Layout.
Und was man eben in diesem Diagramm macht oder sieht,
ist dann eigentlich, also die Art und Weise,
wie man eben versucht, irgendwie seine Schaltungen zu entwerfen,
nämlich, dass man also versucht,
auf möglichst hohe Abstraktionsebene,
weil man möchte natürlich jetzt also nicht das machen,
was man also irgendwie noch in den 60er Jahren gemacht hat,
also irgendwelche bunten Rechtecke zeichnen mit irgendwelchen Grafikprogrammen
Nichts, sondern das, was man eben typischerweise macht,
ist,
dass sich also im Prinzip das Verhalten von irgendwelchen Chips beschreibe,
mit Hardware-Beschreibungssprachen,
also sprich dann eben sowas wie Algorithmendesign mache und dann hat man eben irgendwelche automatischen Werkzeuge,
die einem das Ganze dann eben quasi mehrstufig dann in so eine Struktur aus irgendwelchen Primitivelementen umsetzen und sich dann eben hier so über die Hierarchie hier runterhangeln,
bis man dann eben letztendlich dann irgendwo Fertigungsinformationen für einen Prozessor oder irgendeine Schaltung letztendlich hat.
Gut, Ja, das habe ich soweit dann eigentlich,
war das alles schon kurz angesprochen.
Also das nur zu der Idee, wie dann eben so
eine Abstraktion an ihm letztendlich auch bei der Hardware auftaucht.
Gut, also wie gesagt, uns wird das jetzt so sich in die Fahrt interessieren.
Das, was wir jetzt schon kennengelernt haben,
ist eben so ein bisschen Logik, nicht darauf, dann eben aufzubauen, die Abstraktion und dann eben sowas wie Schalnetze, Schaltwerke. Gut,
wenn wir jetzt also ein Gesamtsystem eines einfachen von Neumann-Rechners realisieren möchte,
dann fehlen natürlich noch einige Sachen,
also zum einen fehlt noch irgendwie sowas wie speichernde Komponenten,
Das heißt, Register, irgendwelche Speicherteile,
funktionale Schaltungen haben wir schon entsprechend kennengelernt,
nämlich also unter dem Stichwort Charletnetze dann ja Adira,
Arrithmetische Schaltung und das,
was man dort eigentlich alles hat und was man dann natürlich auch noch braucht,
sind eben irgendwie Verbindungsleitungen, also irgendwelche Bussysteme,
die diese Teile miteinander verbinden,
die dann eben auch entsprechend unterschiedliche Datenpfade von A nach B aufstellen beziehungsweise verzweigen können.
In der Regel kann man das eigentlich immer so verstehen,
dass sich da dann eben sowas wie Multiplexer dahinter verbergen,
wo ich dann eben sagen kann, okay, also der Eingang der Alukan,
entweder von dieser Stelle oder von dieser Stelle oder von dieser Stelle ausgespeist werden.
Das heißt, man hat da dann eben entsprechende Multiplexer-Strukturen und um dann eben zu sagen,
von welchem Register beispielsweise jetzt gelesen werden soll. Gut,
wie gesagt, Tale davon hatten wir schon,
das war es hier eigentlich jetzt eben noch fehlt an Teilkomponenten,
Informationen würde ich hier also jetzt also auch nur relativ kurz vorstellen,
spare ich ja ein bisschen was zu Bussen oder Bussystem und dann am Ende dieses Kapitels dann eben noch ein bisschen was zur Mikroprogrammierung.
Das heißt, zu der Ablaufsteuerung, wie man letztendlich bei dem von Neumann-Zyklus,
wenn ich jetzt eben sage, ich hole mir einen Befehl,
der wird dann eben interpretiert, irgendwie abgearbeitet, wie man das eben technisch macht.
Also auch das wird dann etwas sein, was also da dann noch mal kurz gemacht wird. Gut,
Speicher hat man, typischerweise,
da kann man sich eben Angriff einfach mal grob vorstellen,
als eben einfach ein fehlt, mehrdimensionales Ray,
wo ich dann eben sagen kann,
ich kann das also irgendwie jetzt mit, eine Anzahl von mit adressieren,
in der Regel werden diese Adressen dann vollständig auskodiert,
das heißt, wenn ich in Adressbit habe,
kann ich eben entsprechend zwei hoch in Speicherelemente ansprechen,
nicht und jedes dieser Speicherelemente soll dann eben letztendlich MBit beinhalten.
Nicht, das heißt also demzufolge ergibt sich dann also für
die Kapazität des Speichers dann eben einfach 2 Uhr in meinem Bett.
Gut, welche Arten von Speicher gibt es? Deswegen hier
nochmal nur grob drauf eingegangen, wonach kann man Speicher klassifizieren?
Nicht einmal hinsichtlich der Kapazität, dann handelt es sich eben um Speicher,
den ich eben auch entsprechend schreiben kann oder ist eben wie so ein Read-only-Memory nur lesen möglich.
Beim Schreiben, wie passiert das? Also wir gehen dann
eigentlich auch immer erst mal von dem Idealfall aus.
Ich kann also im Prinzip jetzt beliebig auf einzelne Bits oder auf einzelne Bytes entsprechend schreiben.
Rein technisch gesehen muss man eben auch sagen,
also bei vielen Speichertypen, gerade bei einigen neueren Speichertümern,
zum Beispiel sowas wie Flash-Speicher, funktioniert das so nicht,
sondern da kann man jetzt wieder nur blockweise irgendwie was machen.
Auch das geht dann natürlich relativ weit eigentlich in die Realisierungstechnik mit rein.
Deswegen sei das also hier eigentlich auch nur Interesse, aber erwähnt,
aber genauer wen wir das da jetzt also auch nicht weiter betrachten.
Gut, dann bei der Speicherung, wie ist das?
Wird dauerhaft geschrieben oder verliert der Speicher seine Information? Ich hoffe,
das ist etwas, wovon wir in der Regel abstrahieren.
Also wenn wir jetzt irgendein Programm schreiben, sagen,
also ich habe dann eine Variable von irgendeinem Typ und das
ist jetzt also irgendwie ein entsprechendes Datenwort davon, dann interessiert mich das erstmal nicht.
Also ob das jetzt hier eben Hauptspeicher,
der jetzt also eigentlich ein sogenanntes dynamisches Rahmen ist,
was seine Informationen nach einiger Zeit verliert und dann eben technisch gesehen dann eben auch nochmal wieder neu aktualisiert werden muss,
ist dann eben auch etwas, wo ich sage, okay,
davon kann man abstrahieren, muss ich jetzt nicht wissen,
bloß eben,
wenn man jetzt eben dann so ein bisschen weiter in die Hardware reinguckt,
so hätte man das dann eben auch mal zumindest gehört haben
Gut, hier nur eine sehr, sehr grobe Übersicht über irgendwelche Varianten von Speicherbausteinen.
Wie gesagt, einiges davon würde ich also hier nochmal kurz vorstellen.
Also wie gesagt, also einmal die Unterscheidung jetzt um statischen oder
eben um dynamischen Rahmen steht dann immer für random Access Memory Speicher.
Nicht, das heißt, man kann lesen und schreiben, wirklich einzeln adressieren.
Das Ganze ist letztendlich eine Flüchtige Technologie, also flüchtig in dem Sinne, dass wenn ich das Gerät ausschalte, ist das Speichern halt eben letztendlich erst mal gelöscht. Und je nachdem,
wo da dann eben entsprechend eingesetzt wird, Cashspeicher,
oder im Hauptspeicher, gibt es dann eben unterschiedliche Typen,
dann hier eben auch nur grob nachher noch kurz die Unterscheidung zwischen dem,
was eigentlich so ein klassisches,
dynamisches Rahmen ist und das, was man heutzutage eigentlich,
also nur noch hart sind, getaktete Speicherbausteine,
also Synchronos, die Rams, deswegen ist die Ram,
wo der Speicher dann letztendlich eigentlich auch ein kleiner,
na eigentlich auch schon nicht mehr so ganz kleiner,
endlicher Automat ist,
der also letztendlich getaktet wird und wo dann eben entsprechende Protokolle eigentlich gefahren werden,
um jetzt eben zu sagen,
ich möchte Informationen speichern oder ich möchte Informationen auslesen
Über dir dann eben entsprechend mit dem Prozessor beziehungsweise über das Boss-System
dann mit dem Prozessor oder irgendeinen IO-Controller kommuniziert. Gut,
dann hat man eben unterschiedliche nur Lesespeicher,
also einmal Sachen wie Rom, etwas, was fest programmiert ist,
bei der Herstellung, dann gibt es welche,
die also letztendlich programmiert werden können durch den Benutzer,
teilweise können die dann eben auch wieder gelöscht werden, neu geschrieben werden können.
Also alles, was diese Prom, E-Prom, E-Prom sind,
muss man auch sagen, sind inzwischen eigentlich Techniken,
die inzwischen alle von Flashspeicher abgelöst worden sind,
hinsichtlich der Funktionalität, wo man dann aber eben auch sagt,
also das sind dann eben speicher Sachen,
wo man letztendlich eben solchen Code prinzipiell erstmal nur fürs Lesen handhabt.
Gut, wie sieht es so ein Speicher,
beziehungsweise jetzt in diesem Fall jetzt erstmal so ein Rom-Speicher,
von der Idee her aus, auch dazu hier nur grob die Idee,
wie das dann also einmal hier beispielsweise, also Methades, gemacht wird.
Und zwar muss man sich das jetzt eben immer so vorstellen,
ich habe hier jetzt also quasi meine Adressen in diesem Fall,
sind das jetzt also hier vier Bit,
dem zuvor kann ich also quasi 16 Speicherworte damit ausdekodieren.
In diesem Fall sollen die jetzt also beispielsweise acht Bit beinhalten.
Und hier hat man eben erst mal nichts anderes als ein Adress-Dekoder,
der dann eben quasi das Ganze so umsetzt,
dass eben entsprechend dieser hier eingestellten Adresse eben genau eine von 16 Leitungen
quasi aktiv gesetzt wird auf eins, alle anderen sind null.
Und die Information ist einfach dadurch hinterlegt,
dass man dann quasi jetzt hier von dieser Wortleitung, die dann eben entsprechend ausgewählt wird,
eben hier einfach nur eine elektrische Verbindung hat zu einem Ausgang.
Nicht und je nachdem, ob ich eben hier eine Verbindung eingesetzt habe,
was dann eben einer gespeicherten Einzelnen spricht oder ob ich da keine Verbindung eingesetzt habe,
was dann eben einer Null entspricht, hat man da seine Informationen.
Und wenn ich jetzt also hier eben beispielsweise Adresse Null nehme,
würde ich dann eben hier als Dring 1 000 auslesen.
Nicht wenn ich dann eben hier beispielsweise jetzt die Adresse 9 nehme,
würden dann eben hier 4-1en und hier, nee,
also hier nur Nullen, den wollte ich eigentlich haben,
A, hier 4-1en, hier 4-0,
dann eben rauskommen und man hatte dann dementsprechend diese Informationen dann da drin.
Gut, wie gesagt, diese Verbindung sind eben beim eigentlichen Raumspeicher,
also nur Read-Only-Memory eben wirklich während der Herstellung dieser Schaltung
schon gemacht werden und bei diesem ganzen Programmable-Roms,
kann man sich das eben letztendlich so vorstellen,
dass also hier sowas wie zum Beispiel so eine Fuse-Technologie eingesetzt wird.
Das heißt also, da sind also irgendwie sowas wie Verbindungen vorgesehen,
die dann aber eben durch eine hohe Programmierspannung quasi aufgeschmolzen werden können.
Und dadurch kann man dann eben gezielt während der Programmierphase
dort ein Muster aus Nullen und Einsen reinschreiben.
Und anschließend ist das Ding programmiert, man kann es dann nicht wieder zurücksetzen.
Und bei diesen ganzen E-Prom-Typen kann man dann eben das auch
wieder rückgängig machen und dann eben wieder nochmal neu programmieren.
Das ist also erstmal so grob die Art und Weise,
wie jetzt eben solche Speicher funktionieren. Gut, beim Rahmenspeicher,
also dem Random Access Memory oder eben von der Grundidee eben her,
erstmal dem Allereinfachsten, schreibt Lesespeicher, kann man eben sagen,
okay, das ist eben letztendlich das,
was wir eigentlich jetzt eben immer unter Speicher oder Hauptspeicher verstehen,
nämlich also der eigentliche Arbeitsspeicher des Rechners,
nach dem von Neumann Konzept eben sowohl für Programme als auch für Daten genutzt.
Ich habe beim normalen Speich jetzt eben keine Abnutzungseffekte, kann also beliebig,
oft beliebig viel Werte reinspeichern, verändern, was, was ich auch mache. Aufgebaut ist auch dort das Ganze dann eben über so eine Matrix-artige Struktur,
auch ähnlich wie bei dem, was sie gerade ihm gezeigt habe,
dann eben mit entsprechenden Abreißbits in Worte unterteilbar,
mit einer bestimmten Wortbreite, so und je nachdem,
wie das Ganze jetzt technisch umgesetzt ist, kann man eben sagen,
entweder ist das ein sogenanntes S-Rahmen, scheint statisches Rahmen,
was wie man also hier in dieser Zeile sieht,
sechs Transistorzelle, dann eben schon irgendwie impliziert,
dass es also irgendwie ein bisschen größer,
ein bisschen aufwendiger, verglichen mit dem dynamischen Rahmen,
wo ich dann eben wirklich zur Speicherung eines Bits eben auch nur einen einzigen Transistor brauche.
Dort dann aber eben letztendlich andere Nachteile habe,
weil dort die gespeicherte Information sich eben über die Zeit auch durch Selbstentladungseffekte
quasi verliert und dann eben auch so ein Refresh immer gemacht werden muss,
beziehungsweise wenn die Information ausgelesen wurde,
muss sie auch wieder neu reingespeichert werden,
was sich eben bei diesem S-Rahmenstrukturen
nicht habe
Nichtsdestotrotz, dadurch, dass man natürlich sagt, okay,
ich möchte in meiner Hardware möglichst viel Speicher unterbringen,
sieht das eben typischerweise so aus, dass man sagt,
okay, das, was wir jetzt also als Hauptspeicher kennen,
was man also in seinen PC da irgendwo als Speicherriegel reindrückt,
das ist dann eben entsprechend derer bzw. noch getaktet,
ist also eigentlich erst derer.
Und sowas wie so ein statisches Rahmen wird heutzutage eben eigentlich
nur noch irgendwo ein Registerbänken bzw. im Cash Speicher mitbenutzt,
wo ich dann aber eben jetzt nicht Gigabyte-weise irgendwo Speicher drin habe,
sondern eben wirklich ein bisschen kleinere Speicherbereiche dann nur noch.
Gut, von der Funktion her auch hier das Ganze mal als erstmal relativ einfache und technologieunabhängige Hades-Schaltung.
Zwar sieht das dort typischerweise immer so aus,
Speicher oder bei dem Rahmenspeicher kann ich ja sowohl reinschreiben als auch rauslesen.
Rein technisch oder rein praktisch gesehen sieht das eben so aus,
dass der an einem einzigen Bus ist und dort eigentlich auch beide Funktionalitäten hat.
Das heißt, es können eben Daten von der CPU in den Speicher hineinfließen.
Es können aber eben auch Daten aus dem Speicher gelesen und in die CPU hineingehen. Ganz am Ende,
wenn man dann also wirklich in die Hardware reinkommt,
ist das dann eben unterteilt eigentlich in zwei Busse,
so wie hier, wo ich dann eben sage,
ich habe ihm hier einen Dateneingang und hier einen Datenausgang,
also in diesem sehr aufwendigen Beispiel,
also vier Bitbreit und mit zwei Adressbits, das heißt,
sie werden letztendlich dann also viermal vier Bit gespeichert.
Und je nachdem, wie ich jetzt eben entsprechend die Datenleitung hier auswähle,
dann hat man seine Steuerleitung, Gride Enable, wo ich eben sage,
soll geschrieben werden und man hat dann eben noch Kontrolleitung,
die dann eben quasi den Ausgang wieder auf den Bus schalten.
Nicht und das, was man jetzt also machen kann,
ist, also wenn ich jetzt,
dass ich hier beispielsweise irgendein Datenwort anlege,
dass Ride Enable entsprechend aktiviere und dann eben noch sowas wie so ein Chipselect anwähle,
wird eben letztendlich dafür gesorgt,
dass quasi dieser Dateneingang an die entsprechend hier dekodierte Zeile von,
ich sag's mal, so irgendwie speichernde Elementen,
also hier mal als Ledge bezeichnet, also irgendwie reingebracht wird.
Anschließend würde man das Ganze an ihm hier wieder entsprechend abschalten.
Information ist eben entsprechend gespeichert. Ich kann hier irgendwie ein
anderes Fortnehmen, eine andere Erpresse auswählen. Konnte das dann
eben dort reinspeichern. Und wenn ich jetzt eben nur lesen möchte,
Kann ich das eben dadurch machen,
dass ich dann eben jetzt hier quasi das Wright Enable auslasse und dann
eben nur hier draus entsprechend lese und diese Eingänge dann aber hier an dieser Stelle abgeklemmt sind?
Wenn ich das da so grob gesagt, also erstmal so
die Funktionalität, die sich dort beim Rammspeicher dahinter verbirgt.
Von der Grundidee her ist es eben so,
wie dass er sich in Hades aufgebaut war,
rein technisch wird das eigentlich dann also auch nochmal unterteilt,
indem man also die Adresse aufteilt in zwei Teilen,
nämlich einmal in die Adresse jetzt für eine Zeile in dem Speicher und dann eben noch mal in die Adresse für entsprechende Spalten in diesem Speicher.
Die Idee dahinter ist, dass man, also statt jetzt eines Großen,
zwei Hoch-Enbit-Dekodas, eben zwei kleine, deutlich kleinere Dekoda hat.
Und das, was man dort dann eben in diesem Fall jetzt hier realisiert hätte,
wäre, dass ich dann eben in diesem Fall,
also mit dieser zweistufigen Dekodierung dann eben hier ein einzelnes Bit, Außenspeicher auswähle.
So, und wenn ich jetzt dementsprechend größere Wortbreiten brauche,
werden jetzt eben einfach entsprechend mehrere von diesen Elementen zusammengefasst in einem Ship,
beziehungsweise wenn man jetzt eben so auf den typischen Hauptspeicher geht,
hat man dort dann eben auch noch entsprechend mehrere von den Chips,
sodass dann insgesamt aus dem Ganzen sich dann eben letztendlich,
also eine Wortbreite von 64 Bit oder 128 Bit
sich dann entsprechend ergibt
Gut, zu den Arten von Speichertypen hier,
also auch nur noch mal kurz, unterschieden beziehungsweise vorgestellt.
Also die ist statische Rahmen, sieht eben so aus,
dass die Information, wenn sie eingespeichert wurde,
sich jetzt nicht verliert, sondern es bleibt gespeichert,
zumindest solange das Ganze mit Versorgungsspannung versorgt wird.
Dazu hat man dann typischerweise was,
was dann also hier jetzt immer so als sechs Transisterzelle
realisiert wurde
Von der Funktion her ist das eigentlich sowas wie ein Lädsch.
Jetzt haben wir gerade letzte Woche ja so quasi kennengelernt,
also Ledge kann ich also aufbauen,
irgendwie quasi über so eine Basis RS-Struktur,
also irgendwie zwei Nances oder zwei Norgatter,
also irgendwie mit diesen Rückkopplungen und dann kann ich das Ganze auch noch irgendwie getaktet machen und mit Dateneingang,
dann brauche ich also nochmal irgendwie zwei,
nennt oder zwei Norgatter,
sind dann einfach jetzt
erstmal scheidungstechnisch gesehen
vergleichsweise viele Transistoren
Das heißt, das Ganze kostet Fläche. Das,
was man dort eben typischerweise macht, ist also ein etwas anderer Trick zur Speicherung,
der das Ganze dann eben etwas kleiner macht,
was also dann in Hades letztendlich so aussehen würde.
Und zwar muss man sich das,
beziehungsweise damit er überhaupt ein bisschen klar wird,
wie das Ganze funktioniert, muss man sich das so vorstellen,
dass man sagt, okay, also das,
was die eigentlich sparchende Struktur ist, ist, dass ich sage,
ich habe Ein Inverter und ich habe hier einen zweiten Entwärter.
Und die sind erst mal so irgendwie miteinander rückgekoppelt.
Das heißt, wenn ich hier irgendwie eine Eins habe,
dann habe ich hier eine Null und das Ganze ist stabil,
da schwingt nichts.
Andersrum, wenn ich hier eine Null habe,
hier eine Eins,
auch da ist das Ganze stabil
Diese beiden rückgekoppelten Wärter sind im Prinzip diese Teile hier drin.
Das ist jetzt eigentlich wieder CEMOs Schadungstechnik bzw. Transistotechnik.
Dazu kann ich, also vielleicht,
nur damit das mal so ein bisschen klar wird,
also nochmal in den optionalen Anhang springen,
wo ich dazu dann nämlich nochmal irgendwie so
ein paar Folien habe
So, also hier haben wir den in Wärter.
Kann man sich so vorstellen, also wie gesagt,
das ist ein normaler Entwärter in dem,
was wir also auch so immer als Schaltungstechnik in den Computern heutzutage haben.
Sind zwei Transistoren. Dieser eine Transisteur, Pier-Kanal-Transistor,
kann man sich einfach so vorstellen, wie ein Schalter,
der quasi diesen und diesen Punkt miteinander verbindet,
wenn der Eingang gleich null ist.
Dieser zweite Transistor, Endkanal-Transistor, das ist sein Schalter,
der diese beiden Punkte miteinander verbindet,
wenn der Eingang gleich eins ist
So, was macht diese Schaltung aus diesen beiden Transistoren,
wenn ich jetzt also hier an dem Ahrgang eine Null habe,
leitet dieser Transistor und dieser sperrt, das heißt,
dieser Ausgang ist quasi hierüber mit der Versorgungsspannung verbunden und ich habe am Ausgang eine Eins,
wenn der Eingang gleich Null ist.
Wenn der Eingang gleich Eins ist, sperrt dieser Transistor,
die er hier leitet und der Ausgang ist hier quasi mit
dem Grauen Potenzial verbunden und ich habe im Ausgang eine Null.
Das heißt also, dadurch, dass eben entweder dieser Zweig
hier leitet oder dieser Zweig habe ich ihm letztendlich genau diese invertierende Funktion.
Das ist also erstmal so grob,
die uns sehr stark vereinfacht, die Funktionsweise,
wie eigentlich zehnmal Schadungen funktionieren und eben als Allereinfachste Schaltung eben so in Wörter, also diese beiden Transistoren.
So genau das hatten wir jetzt hier eben in dem entsprechenden Teil Hier gesehen,
das sind also im Prinzip hier genau diese beiden Transistoren,
wo die dann eben immer so rückgekoppelt sind, also genau diese Schaltung.
So, und zusätzlich gibt es jetzt eben hier nochmal nach außen hin zwei Transistoren,
die man sich quasi auch erstmal so vorstellen kann,
auch wie irgendwelche Schalter, die eben entweder auf sind,
also beide auf oder beide zu,
und dann eben hier also auf diese Leitung außen gehen,
die dann eben Bitline
Nicht mitleihen sind, womit man dann eben sagen kann,
über diesen Mechanismus kann ich vorausgesetzt, also diese null oder eins,
die hier von außen kommt, ist, in Anführungszeichen,
stärker als das, was hier innen drin gespeichert ist,
kann ich das eben entsprechend umprogrammieren,
indem ich dann eben sage, okay, also hier eins,
hier null, nehme das weg,
habe das dann hier gespeichert.
Und wenn ich das eben entsprechend neu speichern möchte,
kann ich dann eben das entweder mit entsprechend stärkeren Werten umprogrammieren oder
eben einfach nur diese Schalter schließen und das Ganze nach unten hin auslesen.
Also das ist die Art und Weise,
wie man also mit dieser Sechstransistor-Speicherzähle dann eben letztendlich ein einzelnes Bit speichern kann,
was also ein bisschen einfacher ist,
als das jetzt in Form von irgendwelchen Nant und Norgattern
eben in Form eines Ledges
Wie gesagt, wenn Sie wollen, da dann eben auch die entsprechende,
der entsprechende Verweis, also in der Sades,
kann man dann eben da auch mal alles durchsimulieren, werde ich jetzt aber hier drauf verzichten.
Gut, also wie gesagt, das ist dann eben das,
was letztendlich dann so ein IMBit-Speicher ist. Wie gesagt,
diejenigen, die jetzt also schon in dem Praktikum sind,
werden, also diese Grafik kennen nicht,
da ist dann im Prinzip dann eben wirklich so ein größerer Speicher,
wo man eben sagen kann, Eingangsbus, Ausgangsbus,
Adressbus und ich habe dann eben diese Leitung für Chipselect right
enable and output enable und kann das dann eben entsprechend so beschalten,
dass ich dann eben hier innen drin im Speicher gezielt irgendwo Werte reinspeichern kann oder auslesen kann.
Und gut, in diesem Fall ist es im Simulationsmodell jetzt eben so gemacht,
dass es dann also quasi defaultmäßig dann mit lauter Xen,
also sprich leeren Speicherinhaltern irgendwo vordefiniert ist.
Gut, wie gesagt,
das Ganze hier dann auch nur für Weise dann eben auf irgendwelche anderen Speicherships,
die man dann eben irgendwie dann mal so durchsimulieren kann,
mit Hades, nicht aber das ist dann eben letztendlich die Art und Weise,
wie dann also ein statischer war ich ja funktioniert.
Wie gesagt, also wichtig eigentlich immer nur diese Unterscheidung mit diesem
Ride enable Output Enable. Auch da kann man sagen,
das Ganze lässt sich letztendlich immer so interpretieren.
Bride enable ist negiert. Output enable und Chip Select ist dann eben noch etwas,
was man braucht, um jetzt also gezielt den Speicher anzusprechen.
Das ist dann wieder so ein Trick,
den man beispielsweise nutzt, um zu sagen,
wenn ich jetzt größere Worte oder Wortbreiten habe und Zum Beispiel sage,
ich habe jetzt einen Speicher, der ein einzelnes Weit speichert.
Ich habe jetzt meine Architektur, also in dem Beispiel nachher
wird das also auch noch mit dem Armprozessor zum Beispiel kommen,
wo ich also als Wortbreite 32 Bit annehme, also sprich Fear Bite.
Kann man eben sagen, okay,
ich habe entsprechend einfach vier Speicherbausteine hintereinander und sage,
okay, von meinem gesamten Wort habe ich eben in diesem Speicherbaustein
eben die Bits von 7 bis
15 bis 8 und so weiter und so fort.
Und um jetzt eben wirklich ein einzelnes Bite aus so einem Wort dann anzusprechen,
kann ich dann eben auch noch mal explizit sagen,
okay, mit diesen Chipselect kann ich dann eben auch entweder,
wenn ich das gesamte Wort haben will,
alle vier Speicher einschalten oder eben nur gezielt ein oder wie
auch immer nur zwei auswählen und kann dadurch dann eben
nur entsprechend kleinere Wortbreiten bzw. einzelne Bytes ansprechen
Also das ist das, was ich dann eben hinter diesen Leitungen dann immer noch so ein bisschen verbirgt.
Gut, das war jetzt so ein statisches Rahmen,
das, was wir eigentlich als Hauptspeicher haben, deren dynamisches Rahmen.
Funktioniert jetzt also noch mit einem anderen Prinzip und zwar wird dort die Information dann eben nicht mit diesen rückgekoppelnden Wertern gespeichert,
mit sechs Transistoren,
sondern man kann das Ganze natürlich noch viel kleiner bauen,
indem man dann eben sagt, ich nehme nur einen einzigen Transistor,
mit dem kann ich eben sowas wie einen Kondensator Entweder durchschalten,
dort was, also quasi reinschreiben oder eben diesen Schalter öffnen,
also den Transist entsprechend umschalten und die Information bleibt auf diesem Konversator gespeichert.
Das, was rein praktisch dann einmal aber noch dazu kommt,
ist, dass sich eben in der Technologie dann typischerweise diese Konversatoren selber entladen.
Deswegen brauchen dann eben die Speichern sowas wie sogenannte Refresh-Zyklen,
wo dann eben die Informationen eben von Serge Zeit
entsprechend wieder neu hergestellt werden kann
Hinzu kommt dann eben, dass letztendlich beim Lesen das Ganze
dann auch wieder entladen wird. Das heißt also,
auch das muss passieren. Und um da zu interpretieren,
habe ich dort Ladung gespeichert oder habe ich nicht,
braucht man dann eben auch noch entsprechende Hardware-Einheiten,
die das Ganze dann eben letztendlich machen, um das entsprechend zu vergleichen.
Nachteile beim dynamischen Rahmen, wie gesagt,
also Information muss neu geschrieben werden.
Auch ohne irgendwelche Zugriffe ist eben
so ein regelmäßiger Refresh notwendig
Wir kriegen davon dann auch nichts mit, sondern das passiert automatisch durch den Speichercontroller nicht. Das heißt,
wenn ich jetzt da irgendwo meinen Speicherriegel habe, den einsetze,
sitzt da drauf, also lässt natürlich auch eben,
ich hatte ja schon gesagt, sowas wie so ein kleiner endlicher Automat,
der zum einen dieses Protokoll abarbeitet, jetzt Adresse,
jetzt lesen, jetzt schreiben, jetzt kommen Row Access,
jetzt kommt Callum Access, der aber auch dafür sorgt,
dass eben von sich aus automatischen Refresh passiert.
Nachteil bei dem Ganzen ist dann aber eben auch,
Zum einen Speicherzugriffe sind langsamer, als beim dynamischen Rahmen.
Und was hinzukommt, eben auch gerade während dieses Refrashs,
kann ich dann eben auch nicht beliebig drauf zugreifen.
Das heißt, es dauert dann eben auch nochmal zusätzliche Zeit. Nicht deswegen ist es dann eben nicht so,
dass man sagt, wie das also jetzt hier zum Beispiel,
wenn man in den Hades-Modellen oder in dem S-Rahmen drin ist,
ich lege die Adresse an, ich sage lesen oder schreiben,
zack und das Ergebnis ist da, sondern es dauert eben entsprechend viele Zyklen.
Deswegen findet man eben auch typischerweise in den Datenblättern,
wenn man jetzt also bei irgendwelchen Versendern sich jetzt, also irgendwelchen Speicherriegel kauft,
dann eben irgendwelche Speichertimings, die dann eben letztendlich angeben,
bezogen auf diese Basistaktrate, mit der der Speicher betrieben wird,
wie viele Tagzyklen dann eben die entsprechenden Zugriffe dauern.
Vorteil von dem Ganzen braucht eben minimal Platz, ist eben vergleichsweise günstig,
nicht und das beschert uns also heute irgendwo diese Hauptspeichergrößen,
wo man eben auch sagen kann, naja gut,
also vor gar nicht mal allzu langer Zeit hatte man also Festplatten mit diesen Dimensionen,
also irgendwie mehreren Gigabyte nicht, wo ich heute sage,
na gut, also das ist ja so die Mindestanforderung an Hauptspeicher,
die ich eigentlich haben möchte.
Gut, hier ist das Ganze nochmal so ein bisschen gegenübergestellt,
also wie gesagt,
statisches Rahmen mit diesen röhgekoppelnden Wärtern
Kostet dann aber eben vergleichsweise mehr Fläche bei diesem dynamischen Rahmen,
kann ich eben sagen, die Information wird dann technisch gesehen
eigentlich eben nur, also auf so einem Kondensator gespeichert.
Das heißt, ich kann hier mit diesem Passtransister,
beziehungsweise es kann man sich eben wirklich wie so ein Schalter vorstellen,
eben sagen, okay, wenn der verbunden ist,
kann ich eben hier diesen Kondensator eben entweder entladen oder aufladen,
habe demzufolge dann eben entweder eine Null oder eine Eins drauf gespeichert.
Wenn ich also jetzt quasi hier über die Stata in hier wirklich drauf gehe,
wenn ich den jetzt eben nur auslese,
bleibt diese Struktur hier quasi offen und es geht dann eben hier nur zu diesem Ausgang.
Aber wenn eben ein entsprechend hier eine Eins drauf gespeichert war und ich das auslese,
entlädt sich der Kondensator und ich müsste dann eben hinterher dann
eben auch diese Informationen wieder neu reinschreiben.
Ja, vergleichsweise klein,
wenn man so in die Literatur gibt,
wobei sich da die Hersteller immer so
ein bisschen bedeckt halten
Ganz am Anfang gab es ja also auch mal so ein bisschen zu diesem Thema,
Moore Slaw und wie geht das Ganze weiter?
Also auch mal so eine Übungsaufgabe, wo man dann sagt, okay, wie lange funktioniert das mit diesem Schränken eben noch so? Also das,
was, gut, da standen halt was andere Zahlen,
nicht, aber das, was man also jetzt typischerweise,
also varianenspare ich aber auch Stein findet,
also für man das überhaupt an genauer Informationen rankommt,
sind also irgendwie so im Bereich,
dass also die Kapazität derzeit zum bei ungefähr fünf Femto-Verrat liegt,
also 47.000 Elektronen werden dafür ungefähr benötigt,
wobei sich das allerdings jetzt in der letzten Zeit,
also auch nicht groß verändert hat,
weil man einfach doch noch mal so eine gewisse Menge an Ladung einfach braucht,
um das also auch irgendwie sicher zu speichern und eben von irgendwelchen Rauscheffekten unterscheiden zu können.
Ich habe, wie gesagt, das Ganze ist dann
letztendlich mit minimaler Fläche realisierbar
Das, was ein Speicher ist. Rein technisch kann man
sich das immer vorstellen. Da gibt es dann also zwei unterschiedliche Formen.
Einmal quasi hier als ein, ich sag jetzt mal,
so ein gefalteten Kondensator. Also das geht ja darum,
dass man also hier irgendwo diese Kondensator,
also sprich irgendwie leidende Leidendes Material und irgendwelche isolierende Schicht dazwischen hat.
Also entweder Armadas, also irgendwie so eine mehr underförmig aufgefaltete Struktur umsetzt.
Das wären dann eben solche Steck-Bausteine eben als sogenannte Trench,
was also hier dann eben in so einem Elektronenmikroskopischen Querschnitt im Silizium ist,
wo das Ganze dann eben irgendwo in die Tiefe geht und dann eben hier als Kondensator eigentlich dann,
also hier irgendwo in dieser Struktur letztendlich mit drin ist.
Gut, aber wie gesagt, das ist dann
sehr speziell bezogen auf die Herstellungstechnik und den entsprechenden Prozess.
Gut, also hier nochmal so grob dieses Layout,
also wie gesagt, man kriegt das Ganze dann eben
sehr kompakt
Realisiert,
nicht dann immer hier jeweils diese sparchenden Transistoren und diese Struktur,
Zeilen,
Zugriff und sparten Zugriff,
um dann eben letztendlich hier dann also sowas wie eben irgendwie immer einzelne Bits zu unterscheiden,
wenn man jetzt eben entsprechend größere Wortbreiten hat,
würde man dann eben mehrere von diesen RAI-Strukturen dann eben beispielsweise in ein Chipgehäuse packen,
um dann quasi ein einzelnes beizuspeichern und davon dann
eben nochmal entsprechend vier Stück oder wie viel auch immer,
um dann eben entsprechend größere Wortbreiten
zu realisieren
Gut, wie gesagt, bei diesem dynamischen Speicher gibt es
dann also auch noch viele verschiedene technische Varianten.
Also einiges, was also irgendwie eigentlich dann auch nur noch
irgendwo in irgendwelchen alten Datenblättern zu finden ist.
Wie gesagt, das, was man heutzutage typischerweise hat,
ist dann also auch sogenanntes Synchroness-D-Rahmen. Das heißt,
die Speicher haben dann eben auch noch sowas wie eine Taktleitung,
weil ich hatte ja schon gesagt,
also intern ist das eben letztendlich sowas wie ein kleiner,
getakteter Automat
Dann eben auch schon seit mehreren Jahren, sogenanntes DDR-Double-Data,
wo man dann eben sagt, ich habe während eines Taktsignals eben nicht nur einen einzelnens Bit lesen bzw. übertragen,
sondern man kriegt dann eben schon mehrere Bit übertragen nicht und ursprünglich war das mal DDR,
also Double Data Rate, wo man dann eben sagen konnte, an der Vorderflank und an der Rückflanke.
Auch das stimmt inzwischen alles nicht mehr, sondern man kriegt dann eben in einem Tag dann eben entsprechend dann schon mehr Werte übertragen. Nicht,
das ist dann eben das, was da eben irgendwo,
also DDR 2, DDR 3 und wie auch immer sie heißen mögen,
realisieren, wie gesagt,
heutzutage ist man da eben schon mal entsprechend hohen Übertragungsraten,
nicht wo man dann eben sagen kann,
also man kriegt dann eben in so einen Baustein dann,
also beziehungsweise in ein Modul viel mehr, entsprechend ungefähr so,
ja, beziehungsweise jetzt maximal, also 25,6 Gigabyte pro Sekunde rein,
gleich ist noch ein bisschen weiter spezifiziert, ist dann eigentlich bei Grafikspeicher,
weil man dort eigentlich noch deutlich mehr Informationen neu berechnen,
auslesen, neu reinschreiben,
austauschen muss.
Also deswegen, also dass dann eben so die Begriffe G-DDR irgendwas,
das, was man eben so typischerweise dann eben bei irgendwelchen Grafikkarten mitfindet.
Gut, prinzipiell hier auch nochmal aufgezeichnet, also wie gesagt,
je nach Speichertyp sehen solche Dinger da natürlich also unterschiedlich aus,
werden also auch nicht zwingend abgefragt.
Also hier geht es nun mal so grob um das Verständnis überhaupt,
wie das funktioniert. Also so ein Timing-Diagramm in aller einfachster Form,
wo ich ja so hier im Prinzip, also einfach so einen Lesezugriff mache. Nicht, wo ich, also hier jetzt quasi meine Hauptglock habe, also jetzt hier als Masterclock bezeichnet. Nicht,
man sagt dann eben, ich gebe hier eine Adresse an,
gebe dann quasi diesen Zahlen und Spaltenzugriff an und anschließend wird dann eben nach,
in diesem, also jetzt in der einfachsten Variante nach eben zwei Takten dann eben letztendlich,
also irgendwie das erste Datenwort ausgegeben und das,
was die Speichern typischerweise eben auch machen, ist,
dass man dann eben auch nicht sagt, okay,
ich möchte jetzt von Adresse vier lesen und dann fange ich das Ganze nochmal an und sage,
ich möchte von Adresse 8 lesen und ich möchte von Adresse 12 lesen,
sondern typischerweise haben Diese Speicherbausteine, die man eben benutzt und einsetzt,
dann eben auch Mechanismen, die dann sind automatisches Inkrement machen, also das,
was also jeder noch mit angedeutet ist, dass dann eben wirklich nur einmal am Anfang eine Übertragung, irgendwie sowas für so eine Startadresse vorgeben muss und dann gleich mehrere aufeinanderfolgende Speicherworte ausgelesen bekommt.
Also auch das ist ein Mechanismus, der eben dafür sorgt,
dass man weniger Kontrollinformationen, nämlich in diesem Fall diese Adresse,
erstmal zum Speicher übertragen muss und eben mehr Daten,
mich das, was dann dementsprechend Speicherworte sind, übertragen werden.
Und das, was sich dann dahinter verbirgt, ist,
dass man dann eben sagen kann, bei dem,
wie eigentlich jetzt aktuell die Prozess für Architekturen aufgebaut sind,
wie die arbeiten, wo ich da nämlich etwas habe,
was ich da eigentlich Speicherhierarchie nennt.
Und zwar, auch das wird das relativ am Ende der Vorlesung
dann eben nochmal ein bisschen begegnen, bei dem Einfahren von Neumann-Konzept.
Gehen wir davon aus, es gibt einen Speicher,
da liegen Instruktionen drin, da liegen Daten drin, der Prozessor sagt,
lese davon oder schreibe dahin und die Sachen werden in übertragen.
So, wenn man so arbeiten würde, hätte man also keinen Computer,
der also irgendwie schneller als einige Megahertz getaktet werden kann,
weil dieser Speicherzugriff einfach viel zu lange dauert. Das,
was dort dann eben rein technisch gesehen noch funktioniert,
dahinter steht, ist, dass man eben sagt,
ich habe jetzt eigentlich so eine gesamte Hierarchie Was typischerweise dann eben durch einen sogenannten Cash mit abgearbeitet wird,
wo ich eben sage, wenn ich jetzt ein Programm habe,
dieses Programm abgearbeitet oder ausgeführt wird,
belegt das natürlich nur also einen bestimmten oder sehr kleinen Teil des Speichers.
Nämlich das, was quasi übersetzt wurde,
der eigentliche Programmcode,
der also irgendwo in diesem Teil im Speicher liegt und eben das,
was vielleicht an Daten von diesem Programm Außenspeicher gelesen wird bzw.
dort reingeschrieben wird
Und anstatt jetzt eben wirklich jedes Mal auf den sehr langsamen Hauptspeicher zuzugreifen,
gibt es dann eben immer kleiner werdende Speicher,
die dann eben jetzt nicht mehr mehrere Gigabyte groß sind,
sondern dann eben nur noch irgendwie einige Megabyte oder nachher nur noch irgendwie Kilobyte,
wo ich dann aber eben sagen kann,
na gut,
also der eigentliche Programmcode ist in der Regel auch nicht so riesig groß und die Daten,
die ich also irgendwie schreibe,
beziehungsweise lese,
sind auch nicht surriesig groß,
die passen eben in diese kleineren Bereiche
Entsprechender Automatismen sorgen jetzt eben dafür, dass eben für ein laufendes Programm diese Ausschnitte eben in den kleinen, schnellen Speicher geladen werden. Und genau dafür sind dann eben solche Mechanismen sinnvoll,
wo man eben sagt, okay,
wenn ich jetzt also ein Programm starte und hier einen Zugriff auf den Hauptspeicher mache,
dann lese ich jetzt eben nicht nur ein Wort,
sondern lese jetzt meinetwegen also gleich einen ganzen Bereich,
der landet dann irgendwo Cash-Speicher, Third-Level, Second-Level,
First-Level-Cash, der Reihe nach und in der Hoffnung,
dass wenn ich das Programm dann eben abarbeite,
beispielsweise dann eben der Programmcode vom Compiler beziehungsweise dann vom Betriebssystem eben aufeinanderfolgenden Speicheradressen liegt und ich dann eben komplett nur noch aus diesem Cash arbeiten kann und dann eben wirklich nur ein einziges Mal,
nämlich zum Programmstart,
also wirklich ein Zugriff auf den Hauptspeicher,
technisch gesehen erfolgt ist.
Also dafür sind solche Mechanismen dann eben
ganz sinnvoll
Gut, abschließend auch noch kurz. Wie gesagt, das,
was wir heutzutage nun auch viel haben, benutzen, sogenannte Flash-Speicher.
Auch da kann man sagen, ähnlich kompakt und kostengünstig wie so ein dynamischer Speicher.
Anders als der ist aber dann eben entsprechend nicht flüchtig, das heißt eben auch wenn das Gerät ausgeschaltet wird, bleibt eben die Information erhalten. Anders als beim DRAM ist es jetzt technisch gesehen einfach anders gelöst,
und zwar, also da jetzt,
also im Prinzip eigentlich auch so was,
wo also Ladung irgendwo abgelegt wird, aber dann eben jetzt nichts,
wo sich, also dieser Kondensator selber entlädt,
sondern dann gibt es also dort spezielle Transistoren,
wo man quasi hier etwas hat, was sie dann Floating Get nennt,
wo dann eben diese Information, also null oder eins draufgespeichert wird,
und dieses dann eben soweit gut isoliert ist,
dass sich dort also entsprechend nichts tut,
und man dann eben entsprechend, je nachdem,
welche Information hier drauf ist, dann eben sagen kann,
also dieses diese Struktur als Schalter ist,
dann eben entweder konstant geöffnet oder konstant geschlossen.
Umprogrammieren passiert dann eben dadurch, dass quasi dann über entsprechend höhere Spannungen entsprechende Mechanismen
dann eben quasi diese Ladung hier weggenommen bzw. reingebracht wird.
Durch diese elektrische Schicht hindurch oder isolierende Schicht hindurch.
Das führt dann eben dazu, dass Solche Flash-Barche dann eben letztendlich nicht beliebig oft, umprogrammierbar sind. Aber inzwischen muss man sagen,
also von ursprünglich, also irgendwie einigen zigtausend Mal inzwischen,
also bis zu über irgendwie 100 Millionen Schreibzugriffen,
wo man dann eben auch rein statistisch sagen kann, gut,
inzwischen haben, Flash-Speicher, ja nun doch häufig Festplatten ersetzt,
weil die also sehr schnell gelesen werden können, okay,
Schreiben dauert ein bisschen länger, aber nichtsdestotrotz, immer noch deutlich schneller,
als jetzt also irgendwie so ein mechanisches System, was eine Festplatte ist.
Und eben mit irgendwie so 100 Millionen schreibt,
Zugriff, kann ich dann eben auch sagen,
dass ich da jetzt über die Betriebsdauer meines Computers letztendlich,
also fünf Jahre lang,
also jeden Tag mehrere Gigabyte dann also irgendwie an Daten überschreiben kann und dann irgendwann ganz am Ende,
ich dann also insgesamt bei solchen Zahlen lade,
wo dann eben dann wirklich die statistische Wahrscheinlichkeit entsprechend stark ansteigt,
dass dann eben solche Speicherzellen ausfallen und nicht mehr funktionieren und man dann eben auch sagen müsste,
okay,
dann müsste ich das Ding dann dementsprechend austauschen oder wegwerfen.
Gut, da das aber Prinzip inzwischen so in den Bereich
der Produktlebenszeit geht, kann man damit eigentlich ganz gut leben.
Funktioniert ganz gut. Nicht, also da ist nur noch
mal so grob zu dem, was Flashspeicher ist.
Gut, hier ist dann noch mal kurz aufgezeichnet,
also das, was ich dann hier jetzt eben hatte,
noch mal so in richtig typisches Speichersystem, wie das also beispielsweise beim Armprozessor aussieht.
Also das ist so eine Grafik aus diesem Buch von Förber,
Arm, System Marketacture, wo man sagt,
also hier habe ich die eigentliche CPU, Irgendwelche Kontrollen und Steuereinheit.
In diesem Fall ist das dann eben ein 32-Bit-System.
Und ich habe eben hier einmal ein S-RAM-Speicher und einmal irgendwie nur so ein Read-Only-Speicher. Und dadurch,
dass die dann eben, wie das hier angedeutet ist,
dann nämlich quasi mit den Adressen einfach unterschieden werden,
dass ich sage, okay,
mit der beispielsweise höchstwertigsten Adresse wähle ich eben entweder das Rahmen aus oder das Rom habe ich dann eben quasi zwei jeweils 16 Bitbreite, Adressbereiche für S-Rahmen und für Raumspeicher.
Und über entsprechend weitere Adressdekodierung kann ich dann eben jetzt auch
noch bei den niedrigeren Bits sagen.
Wenn ich hier jetzt also wirklich byedwide weise adressiere,
welches von denen ich dann eben hier auswähle und das passiert dann eben über diese Chipselect-Leitung.
Gut, also wie gesagt, das ist nur so grob
zum Beispiel, wie das im Prinzip aussehen kann
Sagte aber eben ganz gut,
also wofür man dann eben beispielsweise bei solchen Adressdekodierungen eben genau solche Gattafarhow,
wie man sie ja dann teilweise nur irgendwie in den Übungen oder in irgendwelchen Aufgaben gehabt haben,
dann eben unter anderem auch brauchen kann.
Gut, ja, nächstes Kapitel,
wir oder nächster kurzer Abschnitt wäre dann jetzt eben nach den Speicheln nochmal ein bisschen was zu Bussystem,
an Gesichts der Fortgeschrittenen Zeit werde ich also auch heute nicht überziehen,
sondern jetzt Schluss machen, weil das lohnt jetzt also nicht,
das jetzt noch irgendwie anzufangen.
Deswegen, das wird dann entsprechend am Freitag folgen.
Ja,
und damit