Gut, bevor ich jetzt mit dem nächsten Kapitel anfange,
nur noch mal kurz eine Info in eigener Sache.
Ich hatte ja eingangs gesagt, dass es die Musterlösung dann
als Prüfungsvorbereitung entsprechend auch in Verteilung geben wird.
Einmal quasi am Ende des Semesters und einmal war es
dann nämlich jetzt ist.
Sprich kurz vor Weihnachten
Demzufolge nur als Ankündigung, nächste Woche können Sie dann in den Übungsgruppen
die Musterlösung für die Übungsaufgaben 1 bis 8 sich dann jeweils in fertig gedruckter Form abholen.
Und wie gesagt, das ist dann eben eigentlich auch so das,
was ich dann auch unter anderem immer noch als Prüfungs- bzw. Klausurvorbereitung damit empfehlen kann,
weil dort im Prinzip dann eigentlich analog zu den Übungsaufgaben eben vergleichbare Fragen, Aufgabestellungen behandelt werden.
Und so sehen sie dann also eine Musterlösung eben auch schon mal,
wie man da jetzt prinzipiell vorgeht, welche Arten es da gibt,
wie man das also ganz richtig und hundertprozentig perfekt hätte machen können und so weiter und so fort.
Gut, dann sind wir jetzt eigentlich so mit dem,
hat er ja schon vorgestern gesagt, mit diesem Tal,
der sich jetzt also direkt mit der Hardware beschäftigt, überwiegend fertig,
beziehungsweise heute werde ich noch mal ein bisschen was zu Speicherbaustarren und zu Brustsystemen erzählen.
Ansonsten geht es jetzt also hier Vom Jörgordne der Ebenen,
deswegen erstmal die Frage, dieses Kapitel heißt dann Rechnerarchitektur, was ist Rechnerarchitektur?
Da habe ich da jetzt also aus der etwas älteren Literatur zugegebenermaßen,
aber im Prinzip aus der Literatur,
also hier haben wir zwei Definitionen rausgesucht.
Einmal von den Herren Amdal, Blau und Brooks,
die in Mitte der 60er Jahre bei IBM gearbeitet haben.
Seit Term Architecture is used here to discribe the edgy debutes of a system,
as seen by the programer,
special the the conceptual structure and functional behavior,
as disting from the organization and data flow and control
the logical and physical implementation
Da geht es also hauptsächlich um das System,
wie der Programmierer es sieht. Zweite Definition, Rechnerarchitektur,
bisweile dann also Computer-Cnnecture, Study of Computer Architecture,
das ist Study of the Organization and Interconnection of Componence of Computer Systems.
Computer Architects, Construct, Computers from Basic Building Block,
Suchas Memories, Aerosmetic Dunits and Busses.
From these building Blocks, the computer Architect,
can construct anyone of a number of different life of computers,
ranging from the small as tend head,
pocket curatial later to let largest our fast,
Supercomputer und so weiter und so einfach
Das ist jetzt eine Definition, die eigentlich ja nun irgendwie sehr stark auf Hardware-Komponenten
auf irgendwelche Blöcke abzielen, wie sie miteinander verbunden sind.
Demzufolge kann man eigentlich auch immer unterscheiden bei der Rechnerarchitektur,
eben genau diese beiden Aspekte, dass man eben sagt,
das eine ist wirklich das Operationsprinzip, das funktionale Verhalten der Architektur,
letztendlich also dann irgendwie die Programmierschnittstelle,
die also gegeben ist durch das,
was das im Deutschen dann Befehlsatzarchitektur heißt,
im englischen Instruction Set Architecture
Das heißt, welche Befehle gibt es? Wie sind die definiert?
Welche Datentypen verarbeiten, die, wie ist die Semantik der Befehle?
Das alles, das wir dann im folgenden Kapitel in der nächsten Woche behandelt.
Und als zweites, was man eben auch unter Rechnerarchitektur verstehen kann,
eben des Hardwareseitige, also sprich,
wie ist das System von der Struktur her aufgebaut?
Das heißt, welche Hardwarebetriebsmittel heißt es dann immer so schön,
gibt es da, also sprich,
welche Komponenten gibt es?
Wie sind die miteinander verbunden
Wie sieht die Kommunikation zwischen den Komponenten aus? Das heißt also
was wie Protokolle und sowas geht damit drin. Das heißt,
da ist es dann eben überwiegend die Implementation beziehungsweise eben das technische System dahinter.
Hier nochmal als Wiederholung von Neumann-Konzept hatte ich ja im,
ich glaube, dritten Kapitel schon soweit mit drin,
dass man eben sagt, okay,
also die ist eigentliche von Neumann-Konzept, dass man eben sagt,
es gibt eine abstrakte Maschine mit minimalen Hardwareaufwand,
die eben beliebige Aufgaben abarbeiten kann durch etwas,
was dann Als Programm auf dieser Maschine hinterlegt ist.
Diese Maschine besitzt dann eben einen Speicher,
gemeinsam für Programme und Daten, fortlaufend adressiert.
Aus diesem Speicher können dann eben zum einen das Programm,
aber eben auch die Daten selber rausgeholt werden,
können manipuliert werden und so weiter.
Und das, was eben in dem ursprünglichen Konzept mit drin
ist, dass letztendlich Programme sich nicht von Daten unterscheiden.
Welch inzwischen hat man eigentlich wieder eine sehr starke Trennung
zwischen Programmen und Daten,
also gerade aus Sicherheitsgründen
Ursprünglich war das eben anders. Gut, und die Abarbeitung sieht dann eben so aus,
ein Befehl wird geholt, wird dekodiert, wird irgendwie ausgeführt.
Und damit lassen sie sich dann eben letztendlich alle Arten von Aufgabenstellungen, also sprich alles, was ich algorithmisch irgendwie kodieren kann, bearbeiten. Hier aus dem Buch von Tarnbaum und Austin,
also nochmal die entsprechende Grafik dazu, nicht,
dass man also sagt, ursprünglich eben die eigentliche Recheneinheit,
die CPU, die ist dann eben in der Regel noch unterteilt in Steuerwerk und Rechenwerk,
das Steuerwerk, dient halt dazu,
die Befehle zu interpretieren und irgendwie die zeitliche Abarbeitung der einzelnen Befehle zu gewährleisten und das Rechenwerk ist halt das,
wo dann beispielsweise jetzt als Schalteness dann eben Recheneinheiten,
Alu für bestimmte Aufgaben zur Verfügung stehen,
beziehungsweise wo es dann eben Universalregister gibt,
wo dann eben letztendlich die Daten auch hinterlegt werden können,
wenn sie nicht im Speicher liegen.
Dann gibt es ein- und Ausgabewerk und das Ganze ist dann
eben irgendwie durch ein Bussystem miteinander verbunden.
Hier nur noch mal kurz aufgezählt,
was man dann eben auch noch sagt,
also im Steuerwerk habe ich dann immer noch in der Regel zwei spezielle Register,
nämlich einmal ein Befehlszähler, beziehungsweise aus dem Englischen ein Program-Counter.
Deswegen öffnen immer als PC abgekürzt und eben ein Befehlsregister,
dann auch für die Englischen Bezeichnung
dann als ER Instruction Register
Abgekürzt und im Operationswerk,
was man dann also auch oft als Datenfahrt oder im Englischen an Data Pass bezeichnet,
habe ich eben das eigentliche Rechenwerk, wenn ich das was verändere,
im vorletzten Kapitel bei den Schaltnetzen schon grob kennengelernt haben,
wie das also funktional aufgebaut ist,
was sich dann da eigentlich an Funktion dahinter verbirgt und dann eben verschiedene Register,
mindestens eins braucht man im Prinzip minimal,
um jetzt also irgendwie zu rechnen,
typischerweise haben aber moderne Computer, also Mehr 8 bis 64,
das ist dann letztendlich von der Art der CPU abhängig und von der Art des Befehlssatzes.
Nicht also die alten X86-Architekturen, kann man sagen,
da hat man 8 Register inzwischen eigentlich bei modernen Architekturen gibt es deutlich mehr,
beziehungsweise bei Christbefehlssätzen hat man typischerweise auch deutlich größere Registersätze.
Gut, dann habe ich den Speicher, konzeptuell erstmal nur einen gemeinsamen Speicher für Programme und Daten.
Oft ist er dann auch noch unterteilt in Schreiblesespeicher,
was dann also Ram ist kurz dann eben für random Access Memory und nur Lesespeicher,
Rom, was dann also ab Abkürzung für Read Only Memory genommen wird,
was dann eigentlich immer so ein bisschen verwirrend ist,
weil so ein Read Only Memory ist auch random Access,
bloß ich kann dort eben nichts reinschreiben.
Dort liegen dann eigentlich typischerweise, wenn ich ein kleines eingebettetes System habe,
schon die Programme selber oder das Programm, was abgearbeitet wird,
auf PC-artiger Hardware beziehungsweise sonstiger Computerhardware ist das dann eben was,
wo ich also quasi Bereiche habe,
die jetzt also wie ein Programm sich ändern.
Also typischerweise sowas wie irgendwelche Funktionalität, die man zum Buten braucht.
Inzwischen ist es technisch dann auch immer noch ein bisschen anders gelöst,
weil sowas in der Regel jetzt eigentlich aktuell eher in irgendwelchen Flash-Barchern jetzt erlegt ist.
Aber gut, auf die Unterschiede zwischen unterschiedlichen Speichertechnologien werde ich nachher auch noch kurz eingehen. Gut,
hier auf der Folie nur noch mal kurz dieses Konzept,
der Programmverarbeitung von Neumann, dass ich eben sage,
ich habe ihm das Programm als Sequenz elementare Anweisung,
befehle Maschinenbefehlssatzes, wenn ich wieder sowas aussieht,
was man dort also quasi macht,
wird dann nächste Woche folgen.
Die liegen eben als Bit-Vektoren im Speicher kodiert,
werden dann eben zu Befehlsausführungen in das Instruktionsregister geladen.
Dort durch das Steuerwerk interpretiert, in einem oder in mehreren Schritten
letztendlich irgendwie jetzt ausgeführt. Nicht deswegen dann auch Zeit,
sequenzielle Ausführung und anschließend geht es dann eben entsprechend weiter und
das wird der nächste Befehl geholt.
Das Ganze ist dann also letztendlich hier in dieser Grafik
nochmal so ein bisschen visualisiert
Hier noch mal dieser klassische Ausführungszyklus,
der wird uns relativ am Ende der Vorlesung dann noch mal ein bisschen genauer begegnen,
wo es dann eigentlich um Konzepte wie Pipelining geht,
weil also alles, was eigentlich das Ursprüngliche von Neumann-Konzept ist und das,
was ich jetzt hier auch immer so von der Befehlsabarbeitung vorstelle,
ist halt, dass man eben sagt,
ich habe wirklich strikt zeitsequenziell Befehl holen, Befehl irgendwie dekodieren,
gucken, ob ich vielleicht einen Befehl habe,
der nicht nur aus einem, sondern aus mehreren Datenwörtern besteht,
die dann gegebenenfalls noch holen,
anschließend werden dann eben die Operanten ermittelt und geladen.
Dann wird mit der Alu irgendwas gerechnet und das Ergebnis entweder in
den Speicher oder in irgendwelche Register zurückgespeichert und es wird dann eben geguckt,
welches ist der nächste Befehl in der Folge.
In der Regel ergibt sich das jetzt also quasi im sequenziellen Ablauf,
außer wenn ich Sprünge habe oder wenn ich bedingte Sprünge habe,
ergibt sich dann also quasi aus dem Ergebnis irgendeiner arathmetischen Operation hier,
mit welcher Folgeadresse ich weiterrechne
Und da dann den nächsten Befehl hole. So, das ist im Konzept des von Neumann-Rechners,
beziehungsweise so wie ich das jetzt also hier auch immer erst mal vorstelle,
also wirklich rein sequenziell auszuführen und je nachdem,
was sich dann also wirklich ein Einzelfunktion dahinter verbirgt.
Nicht also gerade sowas wie irgendwie Execute, also angenommen,
ich habe einen Befehl Multiplikation,
die Rechner-Hardware hat also jetzt quasi keinen Hardware-Multiplikationseinheit,
sondern eben eine Alu-Dino entsprechend addieren und schieben kann,
dann wäre eben die Multiplikation letztendlich sowas wie ein kleines Unterprogramm,
was dann entsprechend viele Tagzyklen, sequenziell auch abgearbeitet wird,
was aber seitens des, oder für den Programmierer dann eben als ein einzelner elementarer Befehl dasteht.
Inzwischen ist es eben so, dass eigentlich aktuelle Hardware beziehungsweise seit Hardware,
also sagen wir so seit den 90er Jahren,
eigentlich in etwas anderen Konzept gehorcht, dass man eben sagt,
ich versuche diese einzelnen Stufen zeitlich ineinander zu verschränken und fange eben an, einen Befehl zu holen.
Anschließend wandert dieser Befehl dann einen weiter, wird dekodiert,
währenddessen wird dann schon der nächste Befehl geholt und so weiter und das Ganze ist dann eben das,
was dann als Pipelining eigentlich bei allen aktuellen Rechnern letztendlich passiert.
Wie gesagt, das wird dann relativ spät am Ende der Vorlesung dann auch nochmal in einem einzelnen Kapitel behandelt,
wo es dann eben nur wirklich nochmal so um Konzepte vom Pipelining gibt,
welche Vorteile gibt es, welche Probleme können dabei auftreten,
beziehungsweise dann eben so Erweiterungen von der Rechnerarchitektur dann eben nochmal betrachtet werden.
Da kommt da noch ein bisschen mehr dazu. Gut,
hier auch nur nochmal kurz zur Erinnerung, auch ganz am Anfang in der Vorlesung,
kam ja irgendwie mal sowas mit diesen Abstraktionsebenen, wo man sagt,
ja, ich habe da also unterschiedliche Beschreibungsebenen, Abstraktionsschichten,
also auch dieses hier nur nochmal zur Erinnerung,
wenn man so sieht, also wie sieht das also aus,
Zum einen in der Trennung zwischen Software und Hardware.
Nun habe ich also hier unten letztendlich meine Hardware-Einheiten, Prozessor,
Speicher, ein Ausgabegeräte, darauf aufbauen, die Software.
Und in der Regel sieht das eben immer so aus,
dass wir quasi direkt auf den Hardware dann also erstmal aufbauen,
ein Betriebssystem haben, was die Hardware-Ressourcen verwaltet.
Dafür sorgt das, wenn ich jetzt mehrere Anwendungsprogramme habe,
die rechnen möchten, dass also irgendwie über entsprechende Scheduling-Mechanismen quasi aufgeteilt wird und die die Ressourcen zugeteilt bekommen.
Und das, was wir letztendlich dann sehen,
wenn ich jetzt also jedes System gebootet habe ohneher ist,
also meinetwegen jetzt in den PDF-Vior laufen habe,
sind dann natürlich dann eben die eigentlichen Anwendungsprogramme.
Genauso gibt es dann eben auch hier drin noch weiter unterteilt verschiedene Abstraktionsebenen,
also beispielsweise hinsichtlich dieses Betriebssystems kann ich sagen,
das was das Betriebssystem sieht, ist eben eine Menge von Prozessen,
die er rechnen möchten.
Nicht jeder Prozess hat irgendwie Zugriff auf den Prozessor und irgendwie Zugriff auf den Speicher,
Speicherkonzept, auch das wird uns dann Ganz am Ende der Vorlesung begegnen ist dann in der Regel sowas wie virtueller Speicher.
Das heißt, das einzelne Programm weiß erst mal nicht,
wo ist im Speicher liegt. Und das weiß auch erst
mal nicht. Also jetzt bei der Programmierung bzw. bei der Compile-Zeit,
ob es überhaupt physikalisch im Speicher liegt oder teilweise nicht.
Da gibt es dann eben dieses Konzept des Virtual Memory,
wo dann im Prinzip der verfügbare Speicher bzw. dann eben Dateien dafür sorgen,
dass im Prinzip ein Programmierer immer nur sagt, okay,
ich sehe als Speicher einen linearen Adressraum für mich.
Der ist erst mal Beim 32-Bild-Betriebssystem 2 hoch 32,
bald groß. Und das sagt also jedes Programm,
das ist ja natürlich in der Regel schon mal deutlich mehr
als das, was wir eher so physikalischer Hauptspeicher haben.
Dieses Konzept von Virtual Memory macht dann eben die Zuordnung,
wie das dann eben wirklich ist,
also physikalisch auf eine Speicher aufgeteilt wird,
wenn es dazu Konflikten kommt,
wie was Sachen dann teilweise in Dateien ausgelagert werden und so weiter und so fort.
Gut, hier jetzt auch noch mal kurz vorgestellt,
um das also jetzt auch noch mal so ein bisschen weiter
zu beleuchten
Korbilierungssystem, also sprich die Art und Weise, wie man jetzt also aus dem Quellcode,
den man jetzt als Programmierer irgendwie eingibt, also wirklich ein laufiges Programm bekommt.
Also hier aus dem Brian und Orelleren an dem Beispiel,
Programmiersprache C. Nicht, dass ich sage,
ich habe eben mein ursprüngliches Programm, also das klassische Hello World,
lass das dann eben der Reihe nach jetzt durch mehrere Programme laufen,
bis ich dann also wirklich dann also zu einem aus für Warenprogramm komme,
beziehungsweise zu einem ausführbaren Code, der dann also wirklich auf den Prozessor abgearbeitet wird.
Und in der Regel sieht das dann eben immer so aus,
dass ich also erst mal über einen Pre-Prozesse gehe,
dann kommt der eigentliche Compiler, der da draußen dann,
also den Assembler-Code macht, Assembler-Code ist dann quasi der Code,
der also wirklich dem entspricht,
was also dann im übernächsten Kapitel dann vorgestellt wird,
also im Prinzip ist wirklich Assembler-Code,
also Befehle aus der Instruction-Set Architecture,
siehe nächstes Kapitel,
wo man jetzt eben wirklich sagt,
ich habe jetzt wirklich
elementare Befehle für den Prozessor
Ähm, anschließend gibt es dann eben den eigentlichen Assembler,
der jetzt eben also aus dem Code so was wie eine Binärdatei macht.
Das heißt also, dass dann eben in eine Folge von 001 umsetzt,
die dann also durch die Hardware irgendwie interpretiert wird,
als der und der Befehl. Und wenn ich das Programm ausführe,
beziehungsweise bevor ich das eben auch ausführen komme,
kommt dann eben noch der Linker,
der dann also noch sagt, okay,
wenn ich jetzt zum Beispiel jetzt bei meinem Beispiel Hello World eine Funktion aus Standard IO benutze,
Print, F, dann kommt die eben noch aus einer externen Bibliothek,
die dann eben noch entsprechend dazugeladen wird.
Dann habe ich im Prinzip hier mein ausführbares Wie-näher-Programm. Und wenn ich das letztendlich ausführe,
dann kommt eben noch mal ein zusätzlicher Schritt dazu, der Loader,
der dann eben dafür sorgt, dass das Ganze wirklich in den Speicher kommt.
Und das war es hier drin dann eben beispielsweise jetzt an Adress hinterrinnen steht,
dann eben auch noch mit diesen Speicheradressen wieder abgeglichen wird. Nicht,
weil bis hier habe ich quasi jetzt in meinem Programm erstmal einen Adressraum von 0 bis N,
wenn das Programm im Hauptspeicher aber jetzt irgendwo an anderen Adressen liegt,
was in der Regel der Fall sein wird,
müssen dann natürlich also entsprechende Offsets,
also bei den Adressberechnungen da eben noch mit berücksichtigt werden.
Gut, das, also nochmal hier Kurzvorstellung,
also von diesen Komplierungssystemen, wie gesagt,
das werden sie dann also auch in Übungsaufgaben,
also gerade dann in diesem Bereich des Hembler dann eben auch noch selber teilweise sehen,
ausprobieren, beziehungsweise ich denke, das wird dann also auch in der Softwareentwicklung,
also schon mit drin sein.
Also auch wenn das jetzt vielleicht nicht zwingend zäh ist,
sondern Java, aber diese groben Konzepte, denke ich mal,
sollten dann eigentlich auch schon klar sein.
Gut, hier das Ganze eben auch nochmal als Grafik.
Also hier mein Programm, wo ich jetzt also beispielsweise hier zwei Variablen in einem RAI vertausche.
Nicht nach dem Kompilieren habe ich dann eben mein Assembler-Programm.
Das hier wären jetzt eben wirklich X86 Assembler-Code,
wo jetzt also im Prinzip jetzt irgendwelche bestimmten Befehle,
dann quasi in der Maschinensprache drin stehen.
Nee, das ist kein X686, Sambler Code,
das ist Sansberg. Nicht dann habe ich eben den Assembler,
der macht da draußen eben wirklich nur noch irgendwo so ein Binärmuster.
Und hier ist jetzt quasi dann die Schnittstelle von Software zur Hardware. Das,
was bei der Programmausführung dann letztendlich passiert, ist,
dass, wenn es eben heißt,
holen wir den Befehl von der fünften Programme oder meinetwegen von der dritten Programmadresse,
dass dann eben der Programm Counter sagt, okay,
Dieses Wort hier wird entsprechend ausgelesen,
landet im Instruktionsregister und dort wird dann eben entsprechend das interpretiert,
dass man sagt, okay, wenn dieser Tal hier so und so kodiert ist, ist das eben dieser Befehl, Switch, Register 16 mit Register 2.
Und das wird dann eben letztendlich irgendwie durch die Hardware ausgeführt. Das heißt,
es werden dann, wird dann eben gesagt, okay,
in diesem Fall habe ich eben eine Alu-Operation,
es wird dann eben ein Tal dieses Befehlswortes dann als Adresse
für irgendwelche Register genommen und so weiter und so fort
Gut, eigentlich ähnlich oder analog zu dem,
wie man jetzt also diese Abstraktion oder Abstraktionsebenen, ja,
also bei der Befehlsausführung hat, hier nur nochmal kleiner Einschub,
wie das also eigentlich bei der Hardware ist,
also auch da gibt es unterschiedliche Abstraktionsebenen,
auch wenn jeder Autor die anders nennt,
deswegen heben wir die Anmerkung keiner einheitlichen Bezeichnung in der Literatur.
Also da kann ich eben auch sagen, okay,
wenn ich so ein Konzept nehme von Neumann-Rechner ganz einfach,
ich habe mir CPU, ich habe einen Speicher,
ich habe hier irgendwelche einen Ausgabeeinhalten,
die sind eben über Datenbus und der 30. Bus irgendwie miteinander verbunden.
Nicht dieses hier oben entspricht dann quasi der Architekturebene,
wo ich jetzt eben solche Grundeinheiten, Prozessor, Speicher,
Busse und sowas habe. Anschließend kann ich dann eben sagen,
ich gucke mir das eine Ebene tiefer an,
indem ich jetzt die CPU nehme und sage,
die ist funktional noch unterteilt in der nächsten Ebene,
Hauptblock-Ebene oder beispielsweise funktionale Ebene oder Algorithmen-Ebene in Operationswerk und Steuerwerk
Also beispielsweise hier in einem Steuerwerk würde dann eben das Instruktionsregister und der Programmzähler liegen,
hier in einem Operationswerk dann also die Alu und irgendwelche Register.
Und wenn der Befehl hier im Instruktionsregister steht und entsprechend interpretiert wird,
höre ihn hier über entsprechende Kontrollleitung dann,
also eingestellt an der Alu, nimm den Wert aus dem
und dem Register und agiere den Wert aus irgendeinem anderen Register dazu.
Nicht gegebenenfalls gehen dann hier noch irgendwelche Flex zurück,
um ihn dann bei Sprüngen zu sagen,
soll gesprungen werden,
soll nicht
gesprungen werden
Nicht, und dann kann ich das entsprechend weiter unterteilen,
also beispielsweise sagen wir im Operationswerk habe ich also hier irgendwie eine Alu,
hier jetzt irgendwelche Register, Busse, irgendwelche Treibereinheiten,
die ich also hier für die Busse brauche.
Das heißt hier, also auf diese Abstraktionsebene,
die dann im Hardwareentwurf Registertransferebene heißt,
sind wir dann eigentlich so in dem Bereich von Schaltbildern,
wie ich sie ja nun schon letzte Woche dann eben auch
entsprechend in Hades vorgestellt hatte,
beziehungsweise in irgendwelchen Beispielen drin hatte
Ja, und das Ganze kann man dann dementsprechend weitertreiben,
dass ich dann sage, na gut,
in der Alu brauche ich jetzt irgendwelche Schaltnetze für die meinetwegen jetzt ein Adira,
kann den dann eben entsprechend so oder so realisieren.
Das heißt, da ist man bei etwas,
was sich dann Logik-Ebene nennt,
wo ich im Prinzip jetzt also zum Beispiel Schaltfunktion als Bullshit-Leichung beschreiben kann,
beziehungsweise das Ganze dann über so eine Struktur als Garternetzliste Aufzeichnung,
wo ich dann eben beispielsweise hier also irgendwie so
einen ganzen Satz von irgendwelchen Gattern habe und die dann entsprechend
miteinander verbinde
Auch das lässt sich dann wieder weiter unterteilen,
dann kann ich sagen, okay, es ist ein einzelnes Nendgatter,
wird elektrisch realisiert durch zwei P-Kanal und zwei Endkanaltransistoren,
die jetzt eben so miteinander verschaltet sind,
dass ich sagen kann, okay, ich habe hier Versorgungsspannung,
grauend, hier irgendwie zwei Eingänge,
hier einen Ausgang und wenn ich das also letztendlich durchrechne,
habe ich dann also hier in einem elektrischen Netz,
also jetzt natürlich nicht mehr Nullen und Einsen, sondern Ströme und Spannung,
aber ich kann das jetzt eben interpretieren und sagen,
wenn ich hier im Ausgang nur eben eine Spannung in der Nähe von Null wollt habe,
interpretiere ich das als Null,
wenn ich eine Spannung in der Nähe der Versorgungsspannung habe,
interpretiere ich das eben entsprechend als eins.
Und damit hat man dann eben quasi daraus dann diese Bullshit-Funktion gemacht. Gut,
und wenn man dann wirklich in die Fertigung runtergeht,
kann man das also auch noch weiter unterzahlen,
dann bin ich eben wirklich also in der Physik oder bessere geometrische Ebene im Hard,
dass ich dann eben sage, gut, also hier beispielsweise beim N-Wan Simon Simons Prozess wäre dann eben ein P-Kanaltransist, also irgendwie so aufgebaut, ein Endkanaltransist eben so.
Und wenn ich das jetzt entsprechend miteinander verbinde, würde das Ganze dann eben wirklich elektrisch als Transistore funktionieren. Gut,
das Ganze findet man dann häufig immer in dem,
was sich dann in der Literatur dann immer als Y oder ein Geiski-Diagramm findet,
nach einem der beiden Autoren,
wo ich dann also quasi hier so ein angedeutetes Y,
also hier mit drei Achsen habe,
in konzentrischen Ringen sind dort dann also quasi die unterschiedlichen Abstraktionsebenen von Architektur,
algorithmisch funktionaler Ebene, Logik-Ebene,
bis zur Schadkreisebene dann eben dargestellt und auf,
oder in jeder Ebene habe ich eben einmal,
also irgendwie an Beschreibung eines Verhaltens,
wo ich dann eben sagen kann, beispielsweise auf der Logik-Ebene,
das Verhalten ist eben beschrieben durch Bullshit-Gleichung und ich kann das aber eben auch darstellen als Struktur,
das heißt also irgendwie so eine Netzliste aus einzelnen Gattern oder irgendwelchen Flip-Flops,
beziehungsweise den Registern,
die wir ja im Prinzip letzte Woche kennengelernt haben.
Gut, dann gibt es noch, dass es jetzt eher so ein bisschen historisch zu sehen,
dann eben dazu noch als dritte Repräsentation in Geometrie, wo es eben darum geht,
wie das Ganze jetzt eben wirklich physikalisch oder flächig auf dem Schipp angeordnet wird.
Gut, hier, das Ganze nochmal,
was ich gerade eben schon skizziert hatte, nochmal kurz wiederholt,
also im Prinzip diese drei Aspekte und das,
was dann eben eigentlich jetzt Die Kunst ist,
wenn ich jetzt eben wirklich sage,
ich möchte also irgendwelche Hardware oder irgendein Hardware-System, Prozessor,
eine Recheneinheit für irgendwas entwerfen, ist,
dass ich dann eben sage, in diesem Diagramm letztendlich realisieren,
muss ich, finde ich das fertigen lassen will,
so war es.
Sowas möchte man heutzutage natürlich nicht mehr entwerfen. Das ist zwar immer sehr dekorativ,
wenn man also irgendwie so einen Plot von so einem Ship hat und das also so ein fürchterlich buntes Bild ist,
aber das ist natürlich nichts, wo man jetzt also sagen kann,
also damit kriege ich also acht Milliarden Transistoren irgendwo untergebracht,
weil wenn ich die wirklich von Hand einzeln begrüße,
dann wird das also irgendwie im Lebtag nicht fertig.
Deswegen ist da dann eben letztendlich die Idee, dass man sagt,
ich versuche nicht hier unten oder letztendlich muss hier unten landen,
aber ich versuche möglichst weit oben und mit irgendwelchen Verhaltensbeschreibungen quasi zu starten.
Das ist das, wo man dann sagen kann,
okay, inzwischen ist man von Hardwareentwurf mit sowas machen,
was also sagen wir mal so in den 60er und späten
70er Jahren noch gang und gäbe war über Logik-Ebene eigentlich auf deutlich höhere Ebenen gekommen und dann macht man das eben auch nicht grafisch als Strukturbeschreibung.
Das, was hier quasi immer angedeutet ist,
sondern macht das dann eben beispielsweise jetzt über Hardware-Beschreibungssprachen,
wo ich dann im Prinzip das Verhalten ähnlich wie in einer
Programmiersprache beschreibe und dann eben Werkzeuge habe,
die mir das automatisch in entsprechender Hardware beziehungsweise daneben auch wirklich solche Transistor-Nets-Listen,
die gefertigt werden können,
dann eben umsetzen
Das ist dann das, was dann eben hier als Electronic Design Automation-Entwurfsprogramme sind,
die dann eben im Prinzip daraus wirklich aus irgendwelchen höheren Verhaltensbeschreibungen,
also so eine vollständige Geometrie für die Fertigung generieren können.
Gut, also das nochmal als kleinen Einschub zum Abstraktion
jetzt, also irgendwo hardwareseitig. Wie gesagt,
wir befinden uns jetzt natürlich nicht irgendwo bei irgendwelchen elektrotechnischen Gleichungen oder Transistoren,
sondern es sind jetzt also hier nur nochmal kurz jetzt wieder beim Von-Neumann-Konzepten bei den gesamten Systemen.
Da kann ich jetzt eben sagen, gut,
das war es, ich da letztendlich ja habe,
sind Register, einzelne, also alles sprich, eine Speicherung,
Verein Bit als Flip-Plop haben wir schon kennengelernt.
Nicht, dann brauche ich aber eben Register quasi jetzt als einfach mehrere Flip-Flops zusammengenommen,
die dann eben quasi nicht nur ein Bit,
sondern ein, 32 Bit oder ein 64-Bit-Wort speichern können.
Dann habe ich eben das, was normal Halbleiter, Speicher,
Hauptspeicher sind. Das heißt also irgendwelche Rahmen- oder Raumspeichereinheiten.
Dann habe ich in meinem System dann eben quasi jetzt
meine funktionalen Schaltnetze, sprich Alus oder irgendwelche anderen Recheneinheiten.
Und ich habe ihm irgendwelche Verbindungsstrukturen eben in der Regel
Busse oder eben irgendwelche multiplexeartigen Strukturen,
mit denen ich dann eben sagen kann,
wie jetzt bestimmte Werte aus einem Register zu einer Alu
kommen und dann eben entsprechend im nächsten Schritt dann also
irgendwie weiter verarbeitet werden können
Gut, das, was wir bislang kennengelernt haben bei Schaltnetzen,
beziehungsweise Schaltwerken, sind natürlich jetzt hier also einzelne Gatter,
Flipflops, Schaltwerke,
mit denen ich also quasi überendlich Automaten das Ganze dann im Ablauf auch irgendwie steuern kann,
was uns jetzt noch fehlt, um jetzt letztendlich,
also nach oben hin bis zur Hauptblock-Ebene zu kommen,
sind dann eben jetzt noch Speicher,
Busse und was sie dann auch noch kurz vorstellen werde,
ist also Mikroprogrammierung, eine Methode,
die also ähnlich wie ein ähnlicher Automat, quasi sequenzielle Abläufe steuern kann.
Gut, beim Speicher kann man sagen,
in der Regel sieht das so aus,
dass ein Speicher organisiert ist, als ein Feld,
wo ich jetzt eine Anzahl, wo ich, so,
eine Anzahl von Adressen habe,
jeweils dabei ein ganzes Speicherwort adressieren kann.
Das ist dann eben mit breit
Typischerweise habe ich dann eben, wenn ich jetzt in Adress bin,
zur Verfügung habe, wird das einfach binär auskodiert.
Das heißt, ich habe mit N-Adress-Bits dann zwei hochennen Adressen
zur Verfügung und kann damit dann zwei hochennen mal M-Bit in meinem Speicher ablegen.
Beim Speicher wird dann eben noch unterschieden hinsichtlich der Kapazität.
Dann hat er ja schon gesagt,
kann ich ihm auch schreiben oder nicht
Bei den Schreibzugriffen gibt es dann eben noch Unterscheidungen.
Habe ich jetzt nur einzelne Bits, Bite oder größere Blöcke,
die jetzt also irgendwie bearbeitet werden können.
Und es gibt dann eben noch Unterscheidungen hinsichtlich der Technologie.
Zusammengefasst ist das dann eigentlich so grob erst mal in dieser Tabelle,
wo ich dann sage, ich habe erst mal die typischen S-Rahmenspeicher,
lesen und schreiben.
Das Ganze passiert im Prinzip
dann elektrisch
In der Regel sind die baldweise adressierbar, ist aber eben ein flüchtiger Speicher.
Das heißt, nach abschaltender Versorgungsspannung ist der Speicherinhalt weg. Beim D-RAM-Speicher,
das ist das, was also in der Regel,
oder SD-RAM-Speicher, was eben in der Regel Hauptspeicher ist,
die gleichen Eigenschaften, ist nur technologisch anders aufgebaut,
werde ich also auch gleich nochmal nur ganz grob skizziert vorstellen.
Dann gibt es die nur lesbaren Speicher,
Rom oder P-ROM, Programmable Rom,
die man im Prinzip jetzt einmal mit irgendwelchen Werten entweder bei
der Fertigung oder später quasi über so einen elektrischen Programmiervorgang mit Inhalt versieht.
Und anschließend kann man dort aber diesen Inhalt nie wieder ändern, löschen oder irgendwas machen.
Also das ist eben eigentlich etwas, wo man sagt,
wenn ich mein Programm fest habe und das nie geändert werden soll,
kann man das machen.
Wie gesagt, also bei einigen Geräten,
also gerade in eingebettetes System,
kommt sowas also auch immer noch vor inzwischen
eigentlich bei irgendwelchen Computersystemen in der Regel
gar nicht mehr
Da gibt es dann noch elektrisch programmierbare, beziehungsweise elektrisch Programmier- und Löschbare. Nicht,
aber auch das sind eigentlich, sagen wir mal, Technologien,
wo man sagen kann, die sind heute in der Regel dann auch durch Flash-Speicher mitersetzt worden,
wo ich dann eben sagen kann, also da kann ich lesen und schreiben.
Das Ganze passiert elektrisch, einziger Unterschied dann eben zu anderen Sachen ist,
die sind in der Regel dann nicht baldweise adressierbar,
sondern da liest man ihnen deutlich größere Datenblöcke bzw. schreibt dann welche Und gut,
inzwischen sind es eben gute Speicherkarten in mobil Geräten, wird es eingesetzt.
Und inzwischen eigentlich auch in Form von Solid States dann eben als Ersatz für magnetische Festplanten. Gut,
das Grundprinzip von den, ich sag mal in Anführungszeichen,
alten Speichertechniken, also sprich Horm, beziehungsweise aber eigentlich auch von den Rahmens,
ist dann eben immer, dass ich sage,
ich habe letztendlich, also hier irgendwie so eine speichernde Matrix,
wo dann quasi jetzt hier mein einzuspeichern, das Wort drinstehen.
Ich habe einen Adressdekoda, beispielsweise jetzt hier natürlich,
also einem kleinen Beispiel, wo ich dann sage,
ich habe also hier vier Adressleitungen,
damit können dann dementsprechend jetzt 16 Zeilen ausgewählt werden und in
jeder Zeile habe ich jetzt eben hier beispielsweise acht Bit drin und beim Read-Only-Memory ist das Ganze dann eben letztendlich einfach fest verdrahtet.
Das heißt also, ich habe eben hier entweder Also,
was dann quasi in der Fertigung technologisch so ausgeführt wird.
Ich habe dann eben hierüber entweder eine leitende Verbindung von dieser dekodierten Adressleitung,
was dann hier immer als Worldline bezeichnet wird, zu so einer Ausgabeleitung.
Oder ich habe eben keine leitende Verbindung, was dann also
hier dadurch dargestellt ist, dass dort nichts dran ist.
So, und zusätzlich kommt dann also der Effekt,
dass man, was dann also hier durch die Technologie bedingt ist,
quasi jetzt über Sämtliche Leitung, sowas hat wie ein Wired All.
Das heißt also, dieses Ganze verhält sich wie ein einziges
Odergatter mit 16 Eingängen. Das heißt,
wenn einer von denen hier jetzt eben entsprechend eins sagt,
ist das Ergebnis eins, ansonsten ist das Ergebnis eben entsprechend null.
Nicht, das heißt also hiermit werden dann Die Ergebnisse jeweils zusammengefasst,
dadurch, dass ich hier bei der Dekodierung nur eine einzige Zeile adressiere,
wird dann eigentlich auch nur die wirksam.
Und bei allen anderen, dadurch, dass die jetzt nicht adressiert werden,
liefern die quasi jetzt an den Eingängen dieses oder gab das immer eine Null.
Und nur die eine Zeile, die ich ausgewählt habe,
wenn ich da eben so eine Verbindung habe,
würde dann eben eine Eins liefern und dann auch hier am entsprechenden Ausgang eine Eins.
Nicht das Ganze,
also hier nochmal kurz in Hades gezeigt
Zurzeit habe ich jetzt hier Adresse Null ausgewählt, die jetzt hier also entsprechend dekodiert wird. Und dadurch,
dass also hier eine Verbindung ist an allen anderen Stellen nicht,
ist hier quasi jetzt 1, 0, 0,
0, 0, 0, 0 drin stehen,
was dann eben hier auch unten ausgelesen wird. Wenn ich jetzt,
dass ich hier bei der Adresse also einen weiter schalte,
Adresse 1 hätte, hätte ich hier an der zweiten Stelle einen Laden,
eine Verbindung, das heißt hier eine Nuldane 1. Genau das passiert dann eben auch,
dass dann einfach jetzt hier entsprechend Denn der Anzahl dieser Verbindung,
die jetzt hier aktiv sind, dann eben die passenden Bits gesetzt werden.
Das ist also da eigentlich die Funktionsweise und das,
was jetzt eben ein Read-only-Memory, also sprich sowas hier,
von irgendwelchen Rahmen-Speichern unterscheidet, ist,
hier sind halt diese Verbindungen quasi jetzt fest reinprogrammiert oder fest vorgegeben,
während bei Rahmenspeichern sie das dann natürlich anders aus,
sondern da kann ich eben sowohl reinschreiben als auch aus lesen,
je nach Art des Rahmens,
dann also auch nochmal unterschiedlich gemacht,
aber im Prinzip dieses Grundprinzip mit dieser Zeilenweisendekodierung und mit dem Zusammenfassen,
also über die Adresse und dem Zusammenfassen der Spalten über so
ein Wired Or,
ist also auch bei Rahmenbausteinen dann eigentlich
ähnlich vorhanden
Gut, Ram, Random Access Memory, also ein Speicher,
der gelesen und geschrieben werden kann in der Regel der Arbeitsspeicher,
auch der als Matrix-Struktur aufgebaut mit entsprechend Wortleitung und einer Anzahl von Witz pro Wort.
Und dann gibt es eben noch die Unterscheidung zwischen irgendwelchen S-Rahmen,
was dann immer für Staatesrahmen steht und Dynamic-Rahmen,
derrahmen bzw. den diversen Abarten davon,
die also eigentlich heute jetzt eher aktuell sind,
die aber im Prinzip eigentlich auch so die leichte Technologie verwenden,
bloß ein anderes Zeit- und Avasierungsverhalten haben.
So, beim spatischen Rahmen habe ich dann eben bei der Speicherung
etwas oder irgendwelche Grundstrukturen, wo ich dann sagen muss,
um ein Bett zu speichern,
brauche ich dort also letztendlich mindestens sechs Transvestoren.
Dafür bleibt der gespeicherte Wert erhalten. Deswegen statisch beim
Dynamic Rahmen oder derer speichere ich das Ganze quasi wie auf
dem Kondensator als eine Kapazität
Wo ich dann mit deutlich weniger Aufwand hinsichtlich der Bauteile in der Fertigung arbeite,
demzufolge ist das Ganze dann auch deutlich kleiner,
hat aber eben den Nachteil, diese Kapazität ist nicht unendlich gut isoliert,
sondern die entlädt sich selber.
Das heißt, von Zeit zu Zeit ist dann sowas wie
so ein Refrain-Stellinformation notwendig und außerdem gibt es da dann eben auch Effekte,
den Effekt, dass wenn ich das Ganze ausgelesen habe,
dass da die Information nämlich auch erstmal wieder weg ist und
dann muss sie dann also auch letztendlich danach wieder neu reingeschrieben werden
Was dann dazu führt,
dass ein dynamisches Rahmen in der Geschwindigkeit eben deutlich langsamer ist,
wenn ich jetzt lese oder schreibe als ein statisches Rahmen.
Gut, hier Grundidee, auch das hier als ein Blockchart-Bild
in Hades. Wie gesagt, auch da sieht man
ganz gut
diese Unterteilung
Ja, weil das einfache,
also diese Unterteilung mit Adressdekoda und dann eben so einer Zahlen- und Spaltenweisenanordnung,
hin und habe ich eben hier jetzt also quasi so eine,
hier in diesem Fall ist eine Zwei-Bitter-Adresse,
kann damit also jetzt hier eine von diesen vier Zahlen adressieren,
dann eben hier eine Enable-Leitung, die jetzt also sagt,
das Ganze soll überhaupt erstmal ausgelesen werden und die Ausgänge werden hier also auf diese Leuchttion geschaltet und dann eben eine Leitung,
mit der ich unterscheide,
soll geschrieben werden oder soll eben nur gelesen werden.
Und hier oben hätte ich dann eben vier Eingänge,
die jetzt eben sagen, Wasser reingeschrieben werden soll.
Zurzeit ist das Ganze noch nicht weiter initialisiert. Hier sind alles
irgendwelche ungültigen Werte drin. Wenn ich jetzt hier die Ride-Leitung quasi aktiviere,
werden jetzt also hier quasi dieses Eingangswort 1, 0,
0,1 quasi jetzt hier in diese Zahlenweisen, Schreibleitung reingebracht.
Und wenn man jetzt eben hier entsprechend noch den,
die Dekodierung und die Ausgänge freischaltet, dann sieht man,
dass ich also zum einen,
dass jetzt ist es auch hier in den Ausgängen habe,
dass dann aber auch hier an der,
hier war es als Adresse 1 angegeben,
dass dann eben hier null Worldline 1 in dieser Zeile des Rahmens dann eben dieser Wert gespeichert ist.
Und wenn ich jetzt also hier das Schreiben abschalte bzw. hier
das Ganze abschalte, bleibt das dann eben entsprechend erhalten.
Und ich könnte jetzt also beispielsweise jetzt hier an Die Adresse 2,
also ich sitze irgendein anderes Bitmoster, reinschreiben,
was hiermit ist und dann also beispielsweise jetzt mit einem Fall,
wo ich jetzt also hier nur lese,
also hier mache ich mal in den Eingängen nur null Vektoren,
nicht ruhig jetzt, dass ich hier nur lese,
und jetzt hier von der Adresse 1 aus lese,
sieht man das dann dementsprechend hier wieder,
diese Zahlen selektiert wird und der Inhalt hier entsprechend ausgegeben wird.
Nicht, dass also dieses Grundprinzip Wie jetzt so ein Rahmenspeicher funktioniert und die Unterscheidung,
also ob das ein Esram oder DRAM ist,
ist dann eben noch die Art und Weise,
wie dann eben hier innen drin dieses Speichern letztendlich realisiert worden ist.
Das, was man dann meistens auch noch hat oder findet,
bei, also gerade bei Digrammspeichern ist dass man dieses Ray von Speicherzellen dann eben auch noch unterteilt,
hinsichtlich der Adressierung, sodass ich eigentlich nur ein einziges Bit rauslese.
Und zwar wird dann eben die Adresse unterteilt in Row Access,
wo ich dann also quasi eine Zeile auswähle und Carlum Access,
wo ich dann also aus diesem gesamten Wort dann eben nur ein einziges Bit rauslese,
was dazu führt, dass man quasi jetzt hier einfach insgesamt größere Adressen hat.
Das heißt, wenn ich jetzt entsprechend größeren Adressraum habe,
Brauche ich jetzt hier keinen Dekoda, der jetzt also aus einer,
meinetwegen 16-Bit-Adresse zwei hoch 16 Seilen rausdekodiert,
sondern das wird dann eben nochmal unterteilt dann in zwei hoch acht hier und zwar hoch acht hier. Das heißt,
also ich habe dann eben im Prinzip dann entsprechend kleinere Dekodierer,
womit ich dann eben nur ein einziges Bit adressiere und das,
was man dann eben typischerweise hat,
wenn man jetzt also hier zum Beispiel für seinen PC,
also irgendwo so ein Speicherriegel kauft, wo ich dann sage,
okay, also insgesamt Speicherwort ist dann wieder 8-Bit, ist,
dass man dann eben quasi auf dem Speicherriegel dann entsprechend 8 Speicherchips hat,
wobei jeder von denen dann eben entsprechend mit 0-Bit 1 bis 2 dann eben nach diesem Schema letztendlich speichert, beziehungsweise ausgelesen werden kann.
Gut, ich hatte ja schon gesagt, Unterschied,
Esram, deram, wie gesagt, Esram als statisches Rahmen,
da bleibt er inhaltlich dabei,
solange die Betriebsspannung an ist
Verglichen mit Ledges oder Flip-Flops. Ist das dann so eine etwas trickreiche Schaltung aus sechs Transistoren,
die dann eben doch noch deutlich kleiner ist als das,
was wir jetzt also zum Speichern eines einzelnen Bits quasi im letzten Kapitel kennengelernt haben.
Was man also dann auch gerade in der Cimos-Technologie entsprechend kompakt bauen kann. Und die Grundidee beim Speichern ist halt, dass man sagt, ich habe im Prinzip Sowas wie ein Inverter. Zwei Inverter,
die also quasi jetzt so zurückgekoppelt sind,
muss jetzt nur noch irgendwie einen Mechanismus haben, der jetzt also sagt,
wie ich hier also irgendwelche Werte jetzt reingesetzt bekomme,
aber letztendlich kann ich dann eben sagen,
wenn hier null ist und hier eins,
dann ist das eben entsprechend stabil als ein Wert,
wenn ich sage, das ist hier mein Ausgang, hätte ich,
da ist ja so eine Eins drin gespeichert und wenn ich das Ganze jetzt quasi umgeschaltet bekomme,
was man dann dadurch macht, dass also quasi jetzt irgendwelche elektrischen Schaltungen,
die dafür sorgen, dass hier bestimmte Werte anliegen,
eben sagen wir mal stärker sind als das,
was hier diese Inverter sagen würden, kann ich dann eben sagen,
ich mache hier eine Eins und hier eine Null,
auch das ist stabil und die Ladung bleibt erhalten und hätte dann,
hätte ich dann dementsprechend den anderen Wert dort gespeichert.
Also die Art und Weise, wie im Prinzip so ein Essam realisiert wird,
das wäre das Ganze dann eben letztendlich ein Hades,
also dies hier innen drin sind diese beiden Rückgekoppelten in Wörter
und das sind dann im Prinzip Schreibleitungen, die man braucht,
um dort also quasi jetzt Fixewerte darauf zu legen.
Gut, auch das könnte man jetzt also hier durchsimulieren,
werde ich jetzt aber aus Sidekron
mal überspringen
Gut, den gesamten Speicher, das ist jetzt eigentlich das,
was wir jetzt immer nur konzeptuell sehen,
weil wir wollen uns ja jetzt nicht hier mit einzelnen Transistoren irgendwie rumschlagen,
wenn ich der gesamte Speicher ist, dann eben letztendlich sowas,
wie das also dann hier in so einer Harris-Demo jetzt wirklich von entsprechend größeren Speicher dann ablaufen würde.
Das ist vor uns dann eben wirklich nur ein Ball,
Baustein, wo ich eben sage,
ich habe hier also irgendeinen Eingangsbus, wo ich Werte reinschreiben kann.
Ich habe eine Adresse, wo ich sage,
von dieser Adresse möchte ich lesen oder eben diesen Wert hier reinspeichern.
Ich habe dann eben eine Leitung, Wright Enable,
die eben sagt, soll geschrieben werden. Also beispielsweise,
wenn ich das jetzt hier mit innovatierter Logik habe,
wenn die Stright Enable gleich null ist,
dann wird eben hier am Ahlengang bei null geschrieben,
wenn das gleich eins ist, wird eben nur gelesen.
Dann gibt es zusätzlich noch typischerweise, also bei Speicherbausteinen dann eben ein Chipselect,
um diesen ganzen Baustein überhaupt erst mal ein- und auszuschalten.
Und es gibt dann eben noch so ein Output Enable,
womit ich dann eben sagen kann,
dass der Ausgang dann hier auch wirklich aktiv und freigeschaltet wird.
Und ansonsten ist der Speicher für uns dann eben einfach jetzt eben
nur so ein Array von Speicherworten, wo ich dann eben sagen kann,
ich kann dort dann eben ein bestimmtes Wort adressieren und dort irgendwie was reinschreiben.
Nicht, das wird dann eben ja auch beispielsweise beim Rechnerstrukturenpraktikum
dann also später auch noch mitverwendet. Gut,
hier auch noch kurz zusammengefasst, also Beispiel jetzt für so ein S-Rahmen,
hier auch nur in Hadeson, eine Schaltung,
die das dann also hat, als eine Schaltung mit 16 Keybit,
Kapazität, organisiert als 2K-Worte mit dir 8Bit.
Wenn ich dem zuvor war, habe ich dann elf Adresseingänge,
acht Anschlüsse für einen gemeinsamen Datenein- und Ausgang und dann eben diese Steuersignale.
Auch das könnte man dann also hier mit Hades entsprechend ausprobieren.
Gut, derram, was ist da jetzt eigentlich nur der Unterschied?
Die Speicherung erfolgt, wie ich ja schon gesagt hatte
im Prinzip, also auf kleinen Kondensatoren. Das heißt,
pro Bit habe ich eigentlich nur sowas wie einen einzigen Transistor,
wo ich dann eben sagen kann,
lesen oder schreiben und eben diesen Kondensator
Nachteil ist eben, nach jedem Lesen ist der Kondensator entladen.
Ich muss dann also, wenn ich irgendwas rausgelesen habe,
dann wird auch wieder neu reinschreiben.
Und man braucht da dann eben auch noch ein bisschen mehr elektrischen Aufwand,
um dann also hinterher dann diese ganzen Leitungen,
also da quasi das Äquivalent vor diesem Wired-Ordern entsprechend auszuwehren.
Und das hatte ich ja schon gesagt, durch Selbstentladung,
um dem vorzubeugen, brauchen die Speicherbausteine dann eben sowas wie so ein neues Fresh.
Und beim Auslesen, also aufgrund dieser Leseverstärker,
heißt das Ganze dann eben auch deutlich langsamer als ein S-Rahmen
Ist dafür dann aber eben auch sehr viel kompakter.
Da war ich dann also quasi pro Speicherbit, nicht mehr sechs Transistoren,
sondern eigentlich nur noch an einzigen Transistoren entwerfen muss.
Und man kriegt das dann eben entsprechend platzmäßig optimiert.
Hier sind die beiden Techniken auch nochmal so grob gegenübergestellt.
Also hier nochmal mit etwas anderen Schaltungen,
also hier quasi die Stehrahmen, hier diese rückkoppelnden Wörter.
Und beim S-Rahmen habe ich eben hier nur ein Transistor und
eben diesen Kondensator, auf dem das gespeichert wird.
Gut, und je nach Technologie Kann man auch mal sagen,
das Ganze skaliert dann also auch immer relativ gut nicht.
Und also auch das ist dann so eine Frage,
wo man jetzt wieder zu dieser Fragestellung kommt, nicht,
wie geht das mit Murslordern eben noch weiter und wann ist irgendwann Ende? Also ich habe also jetzt im Sommer,
als ich das hier vorbereitet hatte, also nochmal versucht irgendwie zu finden,
wie das jetzt eigentlich genau mit den Ladungen jetzt hier auf dem Kondensator aussieht,
beziehungsweise wenn ich hier irgendwelche Transistoren habe,
was also hier an Gate-Kapazität noch wirksam wird,
die Hersteller halten sich da immer relativ bedeckt, nicht,
aber inzwischen kann man sagen, na gut,
also dass man im Bereich von einigen hunderttausend Elektronen,
die dann noch gespeichert werden, wenn das Ganze jetzt eben irgendwie exponentiell,
also sprich beispielsweise Alle 18 Monate durch zwei geteilt wird.
Nicht irgendwann kommt man dann bei einem Elektron an und spätestens dann
muss man sich eben ein entsprechend anderes Wirkprinzip überlegen oder eingefallen.
Was anderes dann eben gefunden worden sei. Gut,
aber noch, das hatte ich ja auch kurz ausgerechnet,
wie das dann aussieht. Also noch kann man sagen,
okay, geht das also irgendwie noch so 12,
13,
14 Jahre
so weiter
Hier auch nochmal die Art und Weise,
wie das Ganze dann aufgebaut ist, also dieser Kondensator,
wenn ich also hier mal so ein Elektronmikroskop in so einer sogenannten Stackzelle,
also auch das ist also technisch,
also inzwischen auch nicht mehr so ganz aktuell, Gigapethe-Ram,
also da ist man inzwischen auch schon bei größeren Speichergrößen,
aber das kann man sich dann eben vorstellen,
also das sieht man, soll dann hier eigentlich zu sehen sein,
also wie so ein Stapel von Übereinandergeschichteten, Kondensatorplatten,
wo ich dann eben quasi meine Kapazität unterbringe,
dass es eben die sogenannte Stackzelle oder eben Trench wo ich dann also quasi,
das ist jetzt hier das Silizium durchgeschnitten,
wo ich dann also hier quasi so ein Graben habe,
wo ich dann eben sage, das ist die eine Platte,
dieses hier innen drin ist,
dann die andere Platte nicht.
Und das ist dann eben letztendlich dann,
also hier mein Speicherndes Element, was da drin ist.
Gut, bei all diesen Technologien kann man immer sagen,
es geht letztendlich darum zu sagen, okay,
ich kriege die Fläche möglichst klein und ich mache die Kapazität
dann eben auch so weit,
dass ich das also jetzt gerade noch
irgendwie vernünftig auslesen kann
Irgendwie jetzt bei der nächsten Fertigungstechnologie das Ganze dann eben nochmal ein paar Nanometer kleiner wird,
dann kriegt man dann eben entsprechend jetzt wieder die nächste Generation mit der nächstgrößeren Kapazität hin.
Also auch beim DERAM habe ich eben letztendlich immer dieses Layout,
wo ich dann sage, Adressierung, Zeilenweise,
beziehungsweise dann hier über diese Carlem-Adresse-Adressierung dann eben spaltenweise,
wo ich dann eben jetzt wirklich meine einzelnen Spalten adressieren kann.
Und wie gesagt,
das Ganze wirft man eben entsprechend klein ausgelegt und was dann eigentlich auch mal,
sagen wir mal, als technologisch immer ganz reizvoll ist,
also bei solchen Sachen, das sind ja alles,
also wie man das hier dann ja eigentlich auch schon angedeutet sieht, entsprechend reguläre Strukturen.
Wenn ich das jetzt also als Chip entwerfen muss,
muss ich mir also einmal ein entsprechend kompaktes Layout,
also für irgendwie so einen Teil hier in der Mitte ausdenken.
Und wenn ich das fertig habe,
habe ich dann eben einfach nur so eine Art Pattern-Generator,
der mir das dann also quasi entsprechend gespiegelt, gedreht und sonst sich angeordnet,
dann also in 1024 mal 256 in so einem Array anordnet.
Und eben auch für diese Zeilen-Dekoder beziehungsweise Cardam Deko,
da gibt es dann eben auch solche Generatoren,
sodass man dann quasi per Knopfdruck sagen kann,
ich möchte einen Speicher der und der Größe und kriege das dann eben automatisch als fertiges Layout geliefert,
muss aber eben wirklich nur einmal hier ein so ein Teil in der Mitte und eben zum Teil von diesem Dekoda-Logik wirklich designt haben.
Gut, beim DRAM, wenn man in der Literatur guckt,
gibt es dann eben viele unterschiedliche Varianten inzwischen hier eigentlich,
also irgendwie diverse Veraltete. Nicht das, was nun heute hat,
sind dann auch immer S-S-D-RAM, also Synchronus, D-RAM,
das heißt, der Speicher hat dann dort dann auch noch synchron ein Taktsignal zu dem aus, geschrieben oder gelesen wird. Und das,
was man dann eben macht, ist,
dass also früher war es also beim Taktsignal so,
dass also beispielsweise dann bei der Vorderflanke oder bei der Rückflanke geschrieben oder gelesen wurde,
dann kam DDR, SD-RAM, Double Data Rage,
das heißt, da wurde sowohl bei der Vorder,
als auch bei der Rückflanke, gearbeitet und alles,
was man jetzt hat, DDR 2, DDR 3,
DDR 4, ist einfach nichts anderes, dass man sagt,
in jeder Tagperiode kriege ich dann jetzt nicht nur ein Wort gelesen,
sondern eben drei oder vier Worte gelesen,
beziehungsweise geschrieben.
Also das ist eigentlich das, was sich dann dahinter verbirgt.
Ähnliches gilt dann eben auch bei dem, was also im Prinzip
eher auf Grafik speichern, beziehungsweise an den GPUs dranhängt.
Nicht, da heißt es dann, GDDR, irgendwas, Double Data Rate.
Und das Ganze dann eben auch mit relativ sportlichen Übertragungsraten,
wo man dann eben sagt, okay,
also da kommt man dann eben bei DDR 4 mit entsprechend hochgetaktet,
also irgendwo so in einem Bereich von Übertragungsraten mit 25 Gigabyte pro Sekunde,
beziehungsweise bei den GPU-Speichern,
also 5 bis 7 Gigabit pro Leitung und ich habe dann eben entsprechend dann beispielsweise ein bis zu 256 oder noch mehr Datenleitung.
Das heißt also, da kriegt man also schon
relativ viel an Daten
Vom Speicher in die CPU geschoben oder zurück. Gut,
Adressierung, hier auch noch mal kurz angedeutet,
wie sieht das aus, jetzt beim SDRAM,
ich habe ihm außen irgendwo dieses Taktsignal,
habe dann also hier jetzt irgendwie meine Adresse,
sage dann eben, ich möchte Rogue Access, Carlom Access haben,
dadurch wird die Adresse dann übernommen, zwei Takte,
anschließend wird ein Wert ausgegeben und was dann immer auch noch der Trick ist,
das was die Speicher dann nämlich quasi selbstständig machen,
dass wenn ich von aufeinander folgenden Adressen im Speicher,
was lesen will, muss ich nicht jedes Mal sagen,
ich nehme jetzt also die Adresse und ich nehme dann die nächste Adresse,
sondern es gibt dann die Möglichkeiten,
dass die Adressen dann quasi automatisch inkrementiert werden können,
was dann also hier über dieses A plus 4A plus 8 letztendlich dann auch angedeutet ist,
dass man also nur einmal zu Beginn so eines Strope-Zyklus sagen muss,
also von da möchte ich lesen,
anschließend schaltet man das dann in so einen automatischen Modus
und kann dann in Aufeinanderfolgenden Tagen dann wirklich mit jedem Takt
ein nachfolgendes Datenwort lesen
Nicht, das ist aber dann eben letztendlich immer davon abhängig,
wie sieht der Sparcher-Baustein genau aus, wie ist das spezifiziert,
welche Adressierungsmodi, schreibt Modi, Lesemodi, hat der,
nicht umsonst sieht es da dann eben so aus,
dass wenn man jetzt nicht sagt, okay,
ich habe jetzt meinen Standard-PC und ich kaufe mir einen Speicher-Baustein,
entsprechend der und der Spezifikation,
den ich da nur reindrücke und dann läuft das schon alles,
sondern wenn man jetzt wirklich selber so ein Sparcher-IC nimmt und das irgendwo einbauen will,
beispielsweise in einem eingebetteten System oder eben entsprechend so eine Speicherregel entwirft,
kriegt man also nicht umsonst dann,
also irgendwie so ein 60-seitiges Datenblatt,
wo dann also irgendwelche verschiedenen Betriebsmodi und so was dann alles mit drin stehen und das Ganze dann entsprechend genau spezifiziert werden.
Gut, das, was in den, sagen wir mal,
letzten sieben, acht Jahren eigentlich dann so spaltermäßig aufgekommen ist,
ist dann Flash-Speicher, das ist eben ein Speicher,
der anders als Esram oder DRAM seinen Inhalt nicht verliert,
wenn die Versorgungsspannung abgeschaltet wird,
ist eigentlich ähnlich kompakt zu bauen, wie ein D-RAM-Speicher.
Es war jetzt nicht ganz so schnell wie ein Esram,
aber also auch schon vergleichsweise schnell. Und da ist eben der Trick,
dass man da also im Prinzip spezielle Transistoren oder Franziska-Typen hat und einsetzt,
wo man halt sagt, ich habe quasi hier drin,
so eine Art isolierten Teil,
das nennt sich dann Floating Gate in dem Fall,
wo ich entweder Informationen für eine Null bzw. Informationen von eine Eins reinschreiben kann.
Und auch wenn jetzt hier innen drin jetzt also keine Versorgungsspannung mehr anliegt, bleibt diese Information,
also quasi hier gespeichert und nach dem nächsten wieder einschalten, kann ich damit weiterarbeiten.
Und das funktioniert also inzwischen doch auch relativ Gut und zuverlässig,
also auch die Technik hatte sich, sagen wir mal so,
in den letzten 15 Jahren dann auch erst so langsam entwickelt,
bis das also technologisch soweit ging. Inzwischen ist es aber,
sagen wir mal, also gerade jetzt im Bereich von Festplatten,
ja nun also auch schon irgendwo ein Ersatz,
wo man sagen kann, okay,
das nehme ich dann eigentlich auch ganz gerne als Ersatz für eine magnetische Festplatte,
so eine Solid State Disk,
also hier zum Beispiel auch ganz gerne verwendet in Notebooks
Weil die zum einen, zumindest beim Auslesen,
sehr schnell sind, deutlich schneller eben als Festplatten,
es war jetzt nicht so schnell wie ein S-Rahmen und Vertlichen zum D-Rahmen,
glaube ich, also auch nicht ganz so schnell,
aber wie gesagt, da vertlichen mit einer magnetischen Festplatte dann
eben entsprechend schnell und inzwischen also auch preislich einigermaßen erschwinglich.
Nachteil ist dann immer nur,
dass die
Dass die eben jetzt von der Technik nicht beliebig oft geschrieben werden können,
weil also irgendwann also letztendlich das, was sie als Isolierung wirkt, also dann also auch an Wirkung verliert.
Und ich dann eben auch nicht, wie jetzt hier angedeutet,
so einen einzelnen Transist oder so ein einzelnes Bit um adressieren kann,
sondern man dort dann also wirklich größere Speicherblöcke dann auch immer jeweils schreiben muss,
was dann heißt,
dass wenn sich also jetzt in einem gespeicherten Wort nur ein einziges Bit ändert,
trotzdem der gesamte große Speicherblock ausgelesen,
das eine Bit geändert und neu wieder zurückgeschrieben werden muss.
Nicht deswegen ist es da mit dem Schreibzugriff dann immer so ein bisschen schwierig.
Zumindest jetzt, wenn ich da mal so was lösche.
Wenn ich dann hier als Anmerkung dann eben auch Prozelle,
sind nur einige, ja gut,
inzwischen ist man also deutlich über den 100.000 Schreibzugriffen möglich,
aber eben lebensdauer, weil sowas ist dann eben begrenzt.
Gut, das also auch nochmal so als kleiner Ausflug in die aktuelle Technik.
Ja, typisches Speichersystem im PC ist dann eigentlich von der
Grundidee erstmal sowas, also hier eben auch in dem Beispiel
so eines kleinen eingebettet
Prozess ist, also so eines Armprozesses, wie wir den eben typischerweise inzwischen Kleingeräten,
beziehungsweise entsprechend aufgebohrten Versionen dann, also in irgendwelchen Smartphones drin haben,
wo ich dann eben sage, ich habe meinen Prozessor,
ich habe jetzt hier also irgendwelche Adressdecoder, habe dann Fürthteile,
die jetzt quasi einfach nur als Read-Only-Memory quasi als Standardprogramm nur gelesen werden müssen,
dass also hier in so einem Raum speicher und sonst eben mein S-Rahmenspeicher dann eben als eigentlichen Hauptspeicher.
Und hier kann man das dann eben sehr einfach machen, indem ich dann einfach sage, der Adressraum wird letztendlich geteilt. Das heißt,
die werden gemeinsam genutzt, wenn ich jetzt einen 32-Bit-Prozessor habe,
Wordbreite, 32-Bit, jeder von diesen Speicherbausteinen,
liefert mir dann hier quasi 8-Bit,
demzufolge habe ich dann also jetzt immer hier 4 Stück,
wo ich dann eben sage, Bit 0 bis 7,
8 bis 15,
16 bis 23 und 24 bis 32 und Hab dann eben noch hinsichtliche Adressen an eben die Unterteilung,
eben in diesen S-Rahmen und in den ROM-Bereich,
zumindest also bei kleinen eingebildeten Systemen,
macht man das dann eben mit dem ROM,
wo jetzt also wirklich nichts geändert oder umprogrammiert werden muss.
Also ein klassisches Beispiel für so ein ganz,
ganz einfaches Teil wird im Zweifelsfall, also hier die Maus sein,
nicht die inzwischen ja nun auch schon irgendeinen kleinen Armprozessor enthält,
der dann also quasi jetzt den optischen Sensor abtastet und macht.
Gut, und Da kann ich also jetzt nicht zwingend ein Firmware-Update machen,
sondern da ist wirklich das Programm,
was also letztendlich den Sensor auswertet und eben sagt,
ich habe mich um so und so viel Pixel nach links oder nach oben bewegt, fest vorgegeben.
Und das ist dann eben in so einem Read-Only-Speicher dann beispielsweise hinterlegt.
Ja, hier nur noch mal so ein Teil,
wie das dann also mit der Adressdekodierung aussieht,
dass man eben sagt, ich habe hier gemeinsame Adressen.
Und was sich dann eben hier unterscheide, ist,
dass ich also hier das Ganze ausgelegt habe mit 32 Bit Wortbreite.
Es werden jetzt aber immer Das, was ich an Daten adressiere,
quasi beidweise angesprochen. Demzufolge, nehmen wir den hier,
demzufolge kriege ich jetzt mit den unteren Zwei-Adress-Bits eigentlich nur eine Auswahl,
welchen von den vier speichern ich jetzt auswähle.
Das ist eben das, weswegen also hier unten jeweils quasi zwei Adress-Bits fehlen.
Ich wo dann also quasi das in die Dekodierung mit eingeht,
wo ich dann eben die einzelnen Chips quasi einzeln mit ansprechen kann,
dass es eben hier dann einfach so ein Dekodia,
wo also über die zwei wird dann eben mit 0, 1 zwar null,
1, 2 und 3 dann eben entsprechend das Zugehörige oder der Zugehörige Speicherbaustein mit angesprochen wird.
Und in dem Fall hier ist es jetzt eben so,
dass quasi dieser Adressbereich genau in einen gleichgroßen Teil für Rahmen und Rom unterteilt wird.
In dem Fall wird jetzt also hier einfach das höchstwertigste Bit genommen und damit gesagt,
okay, wenn das gleich Null ist, spreche ich das Rom an,
wenn das gleich eins ist, spreche ich das Rahmen an.
Also so kann man dann sehr einfach quasi einen gemeinsamen Speicherbereich
dann eben oder Adressbereich dann eben auch vor unterschiedliche Speichertypen mit nutzen und realisieren. Gut,
das war im sehr groben Überblick eigentlich nur mal das,
was sie jetzt also zu den Speichern, beziehungsweise Speichersystemen vorstellen wollte,
dann haben wir jetzt also in unseren Prozesse, wir haben unser Speichersystem,
irgendwelche ein Ausgabesystem, jetzt brauchen wir noch irgendwas um das Ganze miteinander zu verbinden.
Das sind dann eben in der Regel Bussysteme,
mit denen ich dann eben eine elektrische, beziehungsweise logische Verbindung zwischen diesen Komponenten aufbaue.
Typischerweise habe ich da dann eben mehrere unterschiedliche Busse,
was eigentlich erstmal nur heißt,
ich nehme jetzt also irgendwelche einzelnen Leitungen oder irgendwelche Signale fasse,
die dann eben zusammen und interpretiere das dann eben meinetwegen jetzt als ein Bus, also sprich ein 32 Fixport beispielsweise.
Was man dann auch noch hat,
Elektrisch war es dann eigentlich von der Art des Busses jetzt wieder abhängt,
wie das, sagen wir jetzt weiter mit der Verbindungsstruktur aussieht,
weil bislang das, was wir in Schaltnetzen,
beziehungsweise auch in Schaltwerken gesehen haben,
waren eigentlich immer nur eins zu eins oder eins zu N-Verbindung,
das heißt also angenommen, ich habe jetzt also hier irgendeinen Gatter,
ich hatte hier so einen Endgatter,
nicht dessen Ausgang geht jetzt beispielsweise an irgendwie ein anderes Gat daran oder meins wegen jetzt also auch irgendwie an mehrere Gatter und hier meinetwegen noch als Dateneingang in den Register mit rein.
Ich habe ja im Prinzip, dass ein Ausgang von einem Gatter immer nur mehrere andere Eingänge irgendwie betreibt. So,
wenn ich jetzt ein System habe, wo ich eben sage,
ich habe, wie das da ja nun auch angedeutet war,
so im Prinzip jetzt sowas wie Meine CPU und ich habe jetzt also hier irgendwo,
also hier vor den Adressdeco da, also jetzt hier irgendwie mein,
meinen Speicher, also hier Adresse, hier jetzt also irgendwelche Daten,
dann hat man das eben häufig, dass ich Hammer,
hey, die Adresse, arme Heady-Daten,
dass ich also quasi über eine Leitung Daten sowohl in diese Richtung,
wenn ich schreibe, als auch in diese Richtung,
wenn ich lese, schicken möchte,
beziehungsweise war es rein praktisch dann auch immer noch passiert,
also weswegen man dann eben das bei Brustsystemen dann also auch noch anders nutzt,
ist, dass ich dann eben sage,
ich habe hier an diesem Datenbus dann eben nicht nur eine Einspeicher oder eine Einheit,
die da dran hängt, sondern ich habe dann eben auch noch mehrere andere,
also beispielsweise, ich habe hier noch irgendwelche einen Ausgabeeinheiten, die letztendlich hier auch noch An dem Datenbus hängen und rein faktisch gesehen dann nämlich auch noch irgendwie hier an dem Adressbus dran hängen.
Das ist ein Konzept, was man also zum Beispiel ganz gerne benutzt,
um quasi mit einem einheitlichen Adressierungsschema jetzt auf beliebige Geräte drauf zugreifen zu können.
Das Ganze nennt sich dann also quasi Memory, Maped IO,
dass man eben sagt, okay, also mit meinem Adressraum,
den ich jetzt quasi vom Prozessor her nehme,
wo ich also jetzt auf eine Adresse schreibe oder von einer Adresse lese,
gar nicht sowohl in den Rom-Speicher als auch in den Rahmenspeicher, als auch auf irgendwelche ein Ausgabegerät.
Also meinetwegen jetzt also den Bildspeicher der Grafikkarte drauf zugreifen und eben sagen,
okay, wenn ich da jetzt was reinschreibe,
dann soll das dann eben beispielsweise dann von der Grafikkarte bzw. vom Grafikprozessor dann eben entsprechend auf dem Bildschirm mit ausgegeben werden.
Das Ganze dann aber eben jetzt nicht, indem ich dann sage,
ich brauche jetzt spezielle Befehle in meinem Prozess oder sagt,
gib mir was auf die Grafikkarte aus,
sondern ich mache das über einen ganz normalen Schreibbefehl, ihn,
der eigentlich identisch ist mit dem Schreiben in den Rahmen.
Nur, dass ich dann eben sage,
jetzt habe ich eben keine Adresse, die hier im Adressraum liegt,
sondern eine Adresse, die jetzt also in irgendeinem anderen Adressraum liegt,
wo ich dann eben beispielsweise in Grafik speichere, eingeblendet habe.
Das Ganze nennt sich dann, also im Englischen dann immer Memory Map der IO.
Und deswegen, also wie gesagt, wird ganz gerne verwendet. Gut,
jedenfalls, das ist aber dann eine Sache,
wo ich jetzt eben nicht mehr eins zu eins oder eins
zu in Verbindung habe,
sondern wo ich quasi jetzt über diesen Bus in mehrere Richtungen
schreiben oder lesen möchte
So, und was jetzt hier natürlich nicht sein darf,
ist, dass der sagt,
ich möchte was schreiben und irgendeine andere Einheit, also beispielsweise,
wenn ich hier über dieses Memory-Map, IO,
jetzt ein Tastaturcontroller abgefragt habe, eine andere Einheit sagt,
ja, also da hat jetzt gerade einer eine Taste gedrückt,
um das der CPU mitzuteilen,
schicke ich das jetzt hier auch als Information auf den Bus.
Der eine sagt, also wenn ich das jetzt also nicht 32 Pizze nur noch einbett breit mache,
der eine sagt, ich möchte hier eine Eins schreiben,
der andere sagt, ich möchte hier eine Null schreiben,
Passiert natürlich etwas, was wir alle als Kurzschluss kennen.
Das heißt also, einer von den beiden Chips ist also ein bisschen solider gebaut,
der wird gewinnen und der andere löst sich in Wärme auf.
Dafür braucht man also entsprechend etwas, was sich dann Treestate nennt,
wo ich im Prinzip nochmal wieder ein technisches Bauelement habe,
was dafür sorgt, dass ich quasi elektrische Verbindung,
wenn ich jetzt mehrere Quellen habe,
die jetzt also auf eine Leitung gehen,
die dann eben auch wirklich abtrennen kann, um zu sagen,
damit kann man eben solche Kurzschlüsse dann quasi abschalten.
Gut, dann habe ich bei Bussen dann immer noch die Fragestellung der Busabitrierung.
Also angenommen, ich habe jetzt eben so ein System.
Entschuldigung. Das Mikro nicht rechtzeitig genug abgedeckt. So,
also ich habe jetzt hier irgendwie so ein System und einmal
möchte eine was schreiben, einmal möchte der andere was schreiben.
Welcher darf denn jetzt? Das heißt,
ich muss irgendeine Instanz oder irgendeine Einheit haben
Die mir letztendlich sagt, jetzt darfst du oder jetzt darfst du,
nicht, das ist also quasi das, was dann unter dem Stichwort Busabitrierung läuft.
Das heißt, wer darf wann, wie lange irgendwelche Informationen übertragen,
wie wird das Ganze zeitlich quasi geregelt.
Also auch da gibt es dann sehr viele sehr unterschiedliche Protokolle,
die das letztendlich umsetzen können. Und als weiteren Punkt zu Bussen,
dann eben auch noch Unterscheidung, Synchrone oder asynchrone Bussysteme,
also sprich gibt es sowas wie globale Taktsignale oder habe ich also irgendwelche Mechanismen,
wo aufgrund von irgendwelchen Steuersignalen, Kontrollsignalen quasi jetzt Ereignisse ausgelöst werden?
Bin ich grob beschrieben, also das,
was ich da jetzt, also nicht so schön skizziert habe,
kann man jetzt eben sagen, okay,
beim klassischen PC-Computersystem habe ich eben wirklich, also diese Grundidee,
ich habe, also hier CPU, ich habe hier meinetwegen Rom,
RAM,
irgendwelche einen Ausgabeeinheiten,
eben einen Adressbus
Datenbus und dann eben noch irgendwelche Steuerverbindungen, Steuerbusse, mit denen dann also quasi genau diese Synchronisation mit abgewickelt wird. Gut,
dann bei den Bussen kann man jetzt eben zwischen vielen verschiedenen unterschiedlichen Typen unterscheiden,
je nach Aufgabenstellung, nicht,
das geht eben von irgendwelchen High-Performance-Bussen, wo es darum geht,
also jetzt quasi eine CPU an das Speichersystem anzuschließen oder an irgendwelche eine Ausgabeeinheiten anzuschließen,
bis zu irgendwelchen Low-Level-Bus-System, wo man sagt,
das soll irgendwas sein, was also überhaupt nichts kosten darf,
wo ich wirklich nur eine einzige Leitung zur Verfügung habe.
Und da müssen jetzt also keine dollen Daten raten, übertragen werden,
sondern da hängt es beispielsweise nur ein Temperatursensor dran,
der mir vielleicht irgendwann mal sagt,
also ich habe jetzt also einen Grenzwert überschritten oder das ist noch alles in Ordnung,
das heißt also wirklich nur meinetwegen rein binäres Signal,
was da irgendwie kommt.
Da gibt es eben entsprechend viele unterschiedliche,
was auch noch mit reinkommt,
sind dann eben
solche Sachen
Bei den Bussystemen, ich hatte ja schon gesagt,
Stichwort Abitrierung, wer darf wann senden, wer entscheidet das?
Gibt es einen ausgewählten Knoten, der quasi als Master sagt,
jetzt darfst du, jetzt darfst du oder sind das irgendwelche Protokolle, wo dann die unterschiedlichen Teilnehmer das untereinander aushandeln?
Dann gibt es verschiedene Anforderungen, wenn ich oder spezielle Anforderungen,
wenn ich jetzt sage, das Ganze soll irgendwas Echtzeitfähiges sein,
nicht wenn ich im Prinzip sowas wie Normales, Ethernet nehme,
TCPIP nicht, dann sage ich, okay,
da schicke ich was los und je nach Artist des Protokolls kriege ich entweder noch eine Rückmeldung oder eben auch nicht.
Nicht aber irgendwie Echtzeitfähigkeit ist dort nicht gefragt,
wenn ich jetzt über ein Bussystem das ABS im Auto steuer,
dann möchte ich also schon, dass es innerhalb von irgendwie zwei Millisekunden,
also entsprechend die Steuerung auslöst, wenn der Drehradensensor sagt,
du bist gerade dabei, also irgendwie von der Straße abzufliegen,
Das, gut, da gibt es eben sehr viele,
sehr unterschiedliche Sachen mit entsprechenden unterschiedlichen Anforderungen.
Hier nur einige aufgezählt, eben wirklich solche sehr einfachen,
Ice Squares Sea, System Management Boss,
also sowas, also teilweise mal Rechnern verwendet wird.
Irgendwas, was dann für längere Leitungen geeignet ist,
also quasi eine ganz normale Serielle Schnittstelle, das,
was man früher hatte.
Ja, das ist 2, 3, 2,
was inzwischen eigentlich durch USB ersetzt wird.
Ethernet und zumindest jetzt als logische Verbindung gesehen kann ich
eben sowas wie WLAN dann eben auch noch damit
Einschränkung wieder zu denken. Gut, das mal so kurz gucken,
wie sie das jetzt hier aus, ja, denk mal,
die nächsten zwei, drei Folien kann ich noch machen.
Ja, zum Poster komischerweise, wenn ich jetzt so einen Mikroprozess oder System habe,
kann man sich jetzt eben immer sagen, in der Regel habe ich dort immer Adressbus,
Datenbus und irgendwelche Arten von Kontrollleitung, als Kontrollbusse. Nicht also das,
was dann hier auch in dieser Grafik gerne schon Angedeutet war,
teilweise gibt es, wenn das jetzt also sehr einfache Systeme sein sollen,
dann eben auch noch die Sachen,
dass man eben Adress und Datenbus zusammenfasst und dann über irgendeine zusätzliche Kontrollleitung sagt,
was jetzt gerade übertragen wird,
also ob jetzt Adressen oder Daten, nicht wie gesagt,
das sind dann eben solche Tricks da rein,
wo man dann eben bei Anforderungen oder Anwendungen,
wenn das Ganze jetzt mit möglichst wenig Verdrahtungsaufwand auskommen soll,
dass dann eben zum Beispiel
auch noch mit entsprechend umsetzen kann
Gut, das Timing war dann. Nächstes Mal machen,
hier auch noch mal kurz als Folie vorgestellt, Adressbus,
eigentlich auch eher historisch gesehen,
also wie sieht das beim Intel-Prozessor aus,
nicht also alles da im Prinzip in den 70er Jahren rauskam,
80, 88, der hatte also ein 20-Bit Adressleitung.
Damit konnte man also
ein Megabyte-Adressen unterscheiden mit 20-Bit
Ich, einige Jahre später hat man festgestellt, na gut,
also man kann entsprechend mit den Rechnern jetzt mehr machen,
Technologie ist fortgeschritten,
also mit einem Megabyte ist man also irgendwie relativ schnell am Ende,
hat das dann also quasi dann nochmal um vier Bit aufgebohrt,
hat dann also 16 Megabyte mit einem 24-Bit Adressbus zur Verfügung,
nicht dann ab dem 80-386,
was dann Anfang der 90er Jahre aktuell war,
hatte man dann also das 32-Bit-Adressschema, wo ich dann eben sagen kann,
okay, damit komme ich dann, also bis 4 Gigabyte.
Nicht inzwischen ist das also auch irgendwie alles Schnee von gestern und man sagt,
na gut, also 64-Bit-Adressraum, das brauche ich ja.
Ich war also 4 Gigabyte, ist inzwischen ja nun auch
eigentlich eher das Einstiegsmodell, wenn ich also irgendwo einen Rechner kaufe.
Und man möchte natürlich dann noch ein bisschen größeren Adressraum haben,
beziehungsweise man kann ihn eben einbauen, ist inzwischen also auch entsprechend bezahlbar.
Und gut, jetzt zur Zeit ist es Modell,
dass man da jetzt also irgendwie dann bei 64-Bit-Prozessoren ist,
entsprechend großen Adressraum hatten. Das wird also erstmal noch ein paar,
jetzt wieder ein paar mehr Jahre halten,
bis man da dann wieder Probleme bekommt.
Gut, da ist jetzt erstmal nur so als Einführung oder Motivation zu Bussen.
Nächste Woche werde ich dieses Thema dann also noch relativ kurz zu Ende führen,
weil also was war es dann noch zu Timing kommt oder so,
das ist eigentlich auch eher so ein bisschen allgemeine Aussage.
Und dann nochmal ein bisschen was zu dem Themen wie Rechner arbeiten,
beziehungsweise wie Rechner aufgebaut sind, das Ganze dann nochmal Rechnerarchitektur abschließen.
Gut, damit Schluss für heute und dann bis nächste Woche