Gott, versuchen wir das mal so rum. Sorry.
So, ja, jetzt halt das auch schön. Gut,
also da ging es also im Prinzip darum zu sehen,
wie man jetzt eigentlich mit unterschiedlichen Zustandskodierungen dann eben beispielsweise die resultierenden Schaltnetze,
also für Zustandsübergangs beziehungsweise für Ausgabefunktionen dann eben entweder sehr einfach oder eben vielleicht auch ein bisschen komplizierter gestaltet,
jedenfalls also wie sich die Zustandskodierung da auswirkt.
Gut, dann hatte ich ja nur kurz vorgestellt,
dass es im Prinzip ein stinknormaler Zähler formal gesehen auch nichts anderes ist,
als eben auch ein Schaltwerk.
Hatte da also irgendwie so ein paar Beispiele beziehungsweise entsprechende Diagramme da aufliegen,
ist aber natürlich relativ trivial,
da hat man eigentlich immer nur irgendwie so eine Folge hat nicht
und dann kann man das noch mit vorwärts rückwärts und anhalten und was weiß ich auch immer, entsprechend ergänzen.
Gut, als letztes Beispiel,
jetzt eigentlich auch noch eine Vollständigkeit halber,
weil das also in den Hades-Sachen beziehungsweise in diesem Zipp-Archiv
dann also auch noch mit drin ist nochmal so ein zum
Beispiel für ein bisschen eine größere oder eine etwas ernsthaftere Schaltung,
wo man sieht, also was man dann im Prinzip dort alles macht.
In diesem Fall geht das also um ein Projekt,
was ich eigentlich auch mal irgendwie so ein bisschen so
ein Praktikum zum Hardwareentwurf irgendwie mitmache,
wo im Prinzip ein kleiner Wecker aufgebaut wird.
Der Funk gesteuert wird, also nach diesem Funkprotokoll DCF77,
also Langwellensender
So rumgesehen, kann man jetzt sagen, okay,
was soll das Ding machen? Also einmal soll das wie eine
ganz stinknormale Digitaluhr irgendwie vor sich hinlaufen. Dann kann ich sagen,
okay, ich kann jetzt noch irgendwelchem wie Manuel wegzeiten,
eine oder mehrere dann eben noch entsprechend einstellen.
Nicht so rumgesehen läuft das erst, wenn du als Uhr,
dann wird eben quasi der aktuelle Zählerstand einfach nur mit der eingestellten Alarmzeit verglichen.
Nicht für den Alarm selber habe ich irgendwo einen Automaten,
wo ich dann eben abhängig von irgendwie Tasten drücken sagen kann,
ich möchte ihn stellen,
er soll aktiv sein oder soll eben abgeschaltet sein oder ich
bin in irgendwelchen Schlummerfunktionen,
was auch immer man sich da letztendlich
irgendwie ausdenken mag
Vor das Ganze ist dann quasi jetzt noch so ein etwas größerer,
endlicher Automat geflanscht, wo es darum geht,
dieses Funksignal, was man,
sagen wir mal jetzt über einen fertigen Empfänger dann letztendlich digital auslesen kann,
so zu dekodieren, dass man quasi aus einer Folge von Nullen und Einsen,
die dann innerhalb einer Minute Zweitsignal quasi übertragen werden,
dann eben feststellen kann,
welche Uhrzeit,
welches Datum sind da
Nicht. Und letztendlich ist das Ganze, also ein Sammelsurium von relativ vielen unterschiedlichen Automaten,
die sich dann eben alle über irgendwelche Steuerleitungen miteinander unterhalten.
Nicht, also sprich,
wenn der Funkempfänger jetzt also noch kein vernünftiges Signal hat,
sich irgendwie jetzt nicht vernünftig einsynchronisieren kann, was weiß ich auch immer,
dann läuft das eben autonom wie eine ganz normale Weguhr.
Wenn irgendwie jetzt richtig das Zeitsignal empfangen wurde, dann soll das natürlich
die interne Uhr auch passend stellen und so weiter und so fort.
Wenn ich also ein ganzer Satz von Automaten,
die es ja eben irgendwie miteinander unterhalten. Und wie gesagt,
also da gibt es dann eben auch so was komplizierteres,
hadesthal, was das Ganze dann letztendlich einmal kurz zeigt. Gut,
hier werde ich da jetzt also nicht größer drauf eingehen,
also nur zum einen, also das,
was man dort macht oder findet, ist,
für so eine Uhr oder so eine UN-Anzeige,
kann man jetzt ja auch sagen, na gut,
normalerweise würde ich die Zeit, wenn ich jetzt also das Ganze irgendwie programmiertechnisch betrachte, ja irgendwie digital zählen.
Und dann zähle ich,
also was zum Beispiel die ganzen Uhren bzw. entsprechenden Bibliotheken für Zeitanzeige,
also quasi zu den unterschiedlichen Programmiersprachen bei den Rechnern machen,
ist, dass sie eben irgendwie Sekunden, Millisekunden, Mikrosekunden, was auch immer, letztendlich zählen.
Und wenn ich jetzt also irgendwie entsprechend größere Werte habe,
kann man sagen, okay,
dann habe ich eben 32 oder 64 Bit lange Zähler und
muss dann letztendlich irgendein Zählerstand von so und so vielen Milliarden dekodieren,
in eine Zeit, die vergangen ist, seit einem fiktiven Startdatum.
Das ist also die Art und Weise,
wie also letztendlich in den Computern, also die Zeitmodelle dann entsprechend funktionieren,
Da habe ich jetzt natürlich das Problem,
wenn ich sowas jetzt irgendwie eine einfache Anzeige,
also sprechen so eine 7-Segmentanzeige umsetzen möchte,
dass ich das dann meinetwegen von Millisekunden erst nur durch 1000 Teile,
dann muss ich, kann ich das dann entsprechend durch 60 bzw. Modulo 60 rechnen,
nicht, dann kann ich letztendlich meine Sekunden irgendwo ausrechnen,
nicht, dann müsste ich das dann eben entsprechend nochmal wieder teilen, um dann sowas wie Minuten und Stunden zu haben.
Das ist natürlich dann wieder vergleichsweise aufwendig, deswegen wird man da,
beziehungsweise hier in dem Beispiel das Ganze dann so aufgebaut,
dass das Zählen quasi dann direkt in so einer BCD-Arethmetik stattfindet.
Das war das vermutlich also ganz am Anfang auch mal so
ein bisschen, kurz was gesagt hatte.
Sprich, man rechnet eben direkt in Dezimalstellen. Das heißt,
ich habe vier Bit, kann damit die Ziffern von 0 bis 9 darstellen.
Wenn ich dann quasi den Übertrag mache von 9 nach 0,
dann muss ich quasi in der nächsten Stelle einen drauf addieren und rechnet damit.
Das ist dann nämlich auch die Art und Weise,
wie diese Information über Uhrzeiten in diesem Funkprotokoll übertragen wird.
Da wird er nämlich nicht in so und so vielen Sekunden seid Mitternacht gerechnet,
sondern werden wirklich immer einzeln Minuten und Stunden in einer Stellen- und Zehnerstellen quasi übertragen.
So, das heißt, da kann man dann eben erst mal versuchen, sowas wie so eine Art BCD-Zähler aufzubauen. Das ist also letztendlich hier über solche fertigen Bausteine mitgemacht,
was hier im Prinzip dann nämlich jetzt immer nur noch so zu sehen ist,
ist dann eigentlich die Logik, die jetzt dafür sorgt,
dass wenn ich eben zum Beispiel nach 59 den Übertrag auf null mache,
das dafür gesorgt werden muss,
dass dann also quasi die niederwärtigste Stelle zurückgesetzt wird,
und dass dann eben die Zehnerstelle nach der Fünf nicht auf sechs zählt,
sondern dann eben entsprechend nach der 59 zurück schaltet,
nicht und das passiert eben dadurch, dass beispielsweise,
also das sieht man hier ganz gut, nicht BCD,
sechs wäre null, 1, 1, 0,
dass darüber dann quasi einfach direkt das Reset ausgelöst wird und Erzähler statt auf 60 zu gehen,
dann eben sich selber zurücksetzt und dann eben eine Null macht.
Also das ist also nur so ein bisschen dazu,
dass man dann eben solche Sachen, da dann eben auch direkt beispielsweise mit reinbringen kann. Gut, ansonsten, ja, Grundidee hatte ich ja schon kurz gezeigt. Dieses DCF 77 Signal,
wie gesagt, wer sowas mal selber machen möchte oder damit mal so rumbasteln möchte,
also man kann den analogen Teil,
sprich den Funkempfänger, so fertig letztendlich kaufen,
muss ich da jetzt also nicht nur irgendwie mit Funktechnik auseinandersetzen,
kann dann im Prinzip sowas wie so ein digitales Signal,
was dann also beispielsweise so aussieht wie das,
was hier angedeutet ist und das, was dort passiert,
ist, dass zu Beginn jeder Sekunde dieses Signal eben von eins nach null wechselt,
dann entweder 100 oder 200 Millisekunden lang null ist, dann wieder auf eins geht und dann die restlichen 900 oder 800 Millisekunden lang eins ist und dann wieder auf null geht.
Das heißt, immer, wenn ich so eine Rückflanke habe,
weiß ich, die Sekunde beginnt genau und je nachdem,
wie lang diese Lücke hier ist,
wird eben entweder eine Null oder eine 1 übertragen
Und jetzt muss ich natürlich noch wissen, bin ich in der fünften,
in der zehnten oder in der 35. Sekunde.
Dazu passiert dann eben Folgendes, dass innerhalb einer Minute letztendlich
59 Sekunden übertragen werden und nach der 59. Sekunde fehlt quasi diese Pause,
sodass sich da dann eben entsprechend lange eins hier habe.
Und wenn dann das Ganze wieder losgeht, dann ist es eben
die nächste Minute und die Sekunde null, die dann quasi beginnt.
Und darüber kann man dann eben letztendlich sich in dieses Signal hier einsynchronisieren,
eben irgendwann feststellen,
es würde an beispielsweise 30. Stelle eine Eins übertragen und kann sich dann eben letztendlich,
also hier irgendwie aus einer Tabelle dann eben raussuchen,
welches diese Eins, wie die zu interpretieren ist.
Also hier sind zum Beispiel jetzt also die Stunden,
die einer stellen, die Zehner stellen,
nicht der Kalendertag und so weiter.
Nicht so werden dann eben letztendlich in diesen 69 Sekunden 59
Bit übertragen und da steht dann letztendlich das Datum und
die Uhrzeit
genau drin
Also wie gesagt, das ist also dieses Protokoll,
kann man also relativ einfach auch irgendwie mit so einem Mikrocontroller so abfragen, also Adruino oder sowas, würde also wunderbar funktionieren.
Kann sowas natürlich auch direkt in Hardware umsetzen. Gut, das ist also dann hier in Form so eines Gesamtsystems dann also irgendwie so mal angegeben zu machen. Was da dann auch noch mit drin ist,
also das auch noch mal so als Trick für irgendwelche Bastline oder elektrischen Bastline,
Problem, was man also auch relativ häufig hat bei irgendwelchen Schaltungen,
die jetzt also Werte ein- oder ausgeben sollen,
also gerade bei solchen sieben Segmentanzeigen, dass ich sagen kann,
also im Prinzip ist natürlich eine,
so ein einzelnes Segment einer Anzeige, letztendlich nichts anderes,
als irgendwie eine Leuchtdiode, hat also im Prinzip zwei Leitungen,
nämlich also einmal die Kathode auf der anderen Seite,
also irgendwie die Anode,
nicht innerhalb so eines Moduls gibt es dann im Prinzip also eine gemeinsame Leitung für alle Kathoden oder für alle Anoden und dann eben für jede Segmente eine einzelne,
das heißt also hier habe ich dann eben im Prinzip für einen so einen Anzeigeblock letztendlich acht Leitungen,
die da anzuschließen sind.
So, wenn ich jetzt aber natürlich sowas mache,
wie also irgendwie für so ein größeres Werbeburner,
für eine Schriftzeile von 80 solchen Elementen,
dann habe ich natürlich das Problem,
dass ich also dann entsprechend 80 mal acht Leitungen da irgendwie unterzubringen habe.
Und irgendwann, wenn das also nur groß genug wird,
und wenn ich das jetzt meinetwegen über so einen Punkt Matrix-Display mache,
also in der Größe,
wie sie da irgendwie im Hauptbahnhof hängen,
kann man sagen,
kriege ich das also einfach von den Leitungen
irgendwie nicht mehr
sinnvoll hin
Und da hast du da so einen Trick,
das ist dann also hier dann auch unter anderem mit drin,
dass man im Prinzip so in Zeiten,
sogenannten Zeitmultiplex macht mit dieser Ansteuerung von diesen Segmenten,
nämlich dass man anstatt für Enziffern dann siebenmal N-Leitung macht.
Einmal, meinetwegen jetzt hier für 600 Ziffern,
die ich jetzt also von Uhrzeit brauche, einmag quasi mit sechs Leitungen,
sagt, welches Modul hier ausgewählt wird und einmal mit den sieben Leitungen dann quasi hier die eigentliche Anzahl gemacht.
Dadurch brauche ich dann eben insgesamt in dem Fall dann also nur 15 Leitungen an Start,
sechs mal sieben, die dann also letztendlich dann reinkommen. So,
und das, was man dann macht für die Anzeige,
ist, dass man einfach sehr schnell erst die Ziffer hier ausgibt,
dann die Ziffer, dann die Ziffer,
dann Liedziffer und wenn man das also irgendwie mit mehreren 100 Herz macht oder so weiter,
dann sieht man als Mensch da also jetzt irgendwie nicht,
wer, dass die eigentlich der Reihe nachleuchten, sondern dann leuchtet das eigentlich alles wunderbar gleichmäßig.
Und nur, wenn man das jetzt also irgendwie mit einer
Digitalkamera oder so aufnehmen würde, würde man eben sehen,
dass eigentlich immer nur ein einziges von diesen Displays dann entsprechend leuchtet.
Ich sag mal, solche Zeiten oder solche Ideen,
also dieses von diesen Zeiten Multiplex,
das wird eben relativ häufig bei irgendwelchen Anzeigen gemacht,
also zum Beispiel bei diesen Busanzeigen ist,
teilweise dann also auch mit drin und so weiter.
Also das sieht man dann immer,
wenn man das dann also mal mit einem Smartphone aufnimmt und dann feststellt,
dass dann also teilweise dann ein bisschen was anderes angezeigt wird,
als das, was man selber sieht.
Gut, wie gesagt, das ist dann also hier jetzt nun mal
so als zum Beispiel, wie sowas dann aussehen würde, aufgebaut werden würde.
Also etwas Größeres Beispiel zu Schaltwerken. Gut, ja,
damit verlassen wir jetzt so langsam mal die Niederung der
Bulschen Algebra oder der Elektrotechnik und kommen jetzt zu dem,
was da so ein bisschen mehren Rechner ausmacht
Das folgende Kapitel,
da werde ich jetzt also auch noch mal ein paar Sachen noch mal wiederholen,
die also ganz am Anfang dran gewesen sind und es ist auch noch mal ein bisschen was zu eigenen anderen Bausteinen sagen,
hat seit vorgestern also den neuen Titel Rechner Architektur 1 und irgendwann später gibt es dann also noch mal Rechnerarchitektur 2,
wo es dann letztendlich darum geht,
wir sind unsere Computer wirklich aufgebaut, aus welchen Komponenten,
wie spielen diese Komponenten miteinander zusammen und Vorlesungen hat es ja nun Rechnerstrukturen und Betriebssysteme.
Dann eben auch,
wie wirkt das Ganze dann eben eigentlich mit der Programmierung zusammen,
die quasi jetzt als unterste Ebene natürlich dann,
also das Assembler-Programm, was dann also vom Betriebssystem aus ausgeführt wird,
beziehungsweise das,
was also überhaupt erstmal das Betriebssystem darstellt,
wie das dann eben auf irgendwie der Hardware oder auf
diesen Komponenten ausgeführt werden wird
Ja, zur Frage, was ist Rechnerarchitektur? Wenn man
da also in die Literatur guckt, findet man da so unendlich viele Definitionen.
Ich habe jetzt hier mal zwei rausgesucht. Einmal von den Herren Amandal,
Blau und Brooks, wo also hier letztendlich darum geht,
dass die Rechnerarchitektur eben wirklich sich danach richtet, Systemattribute, wie der Programmierer sie letztendlich sieht.
Also sprich da ist, was wir eigentlich jetzt,
wenn wir jetzt das mit einer Programmiersprache arbeiten,
was sehen wir jetzt von dem Rechner, von der Rechnerhardware,
beziehungsweise das, was ich hatte ja auch schon als Begriff gesagt,
also was man dann also Instruction Set Architecture nennt, also sprich den untersten Ebene vom Befehlssatz.
Bei anderen Autoren findet man also, dass man dann sowas hat,
wie The Study of Computer Architectures,
The Study of the Organization and and the connection of components of Computersystems,
Computer Architects, Constructure of Computers, vom Basic Building Blocks, Suchas Memories, Aresmitics Unixed and Bassis.
Und das Ganze geht dann noch ein bisschen länger so weiter,
wo man sagen kann, da ist jetzt der Schwerpunkt eigentlich auf dem,
was wir bislang so ein bisschen betrachtet haben, nämlich irgendwelche Talkomponenten.
Also sprich, das, was wir jetzt als Gatter irgendwo hatten,
womit ich also im Prinzip diese Grundfunktion der Bulschen Algebra realisiere oder das,
was wir als Flipflop, Flankengesteuerte oder Ledges, kennengelernt haben,
wo man sagen kann,
da kann ich eben sowas wie ein Bit oder wenn ich davon entsprechend mehrere parallel habe, dann eben so ein ganzes Wort irgendwo speichern.
So, in dem Zufolge kann man dann eben sagen,
bei der Rechnerarchitektur selber, werden dann eben auch eigentlich zwei Aspekte unterschieden,
nämlich einmal, entsprechend dieser ersten Definition, die ist eigentliche Operationsprinzip,
was dann eben so ein bisschen auf den Befehlssatz eher abzielt,
also sprich,
was ist die Programmierschnittstelle
Wie sieht da das Ganze aus? Wie werden die Befehle abgearbeitet? Wie werden,
wenn ich jetzt einen Befehlssatz habe, welche Datentypen sind das?
Wie wird das also entsprechend interpretiert? Das ist das,
was dann im Prinzip jetzt also gleich in dem nächsten Kapitel,
wo es dann also um Instructional
Set Architecture geht, dann noch entsprechend vor. Und auf
der anderen Seite eben die Hardware Architektur jetzt also wirklich als Aufbau des Rechensystems aus irgendwelchen Blöcken,
wo man dann eben sagt, welche Teile habe ich,
wie sind die miteinander verbunden, war es dann eben auch eher in Richtung so einer technischen Realisierung so ein bisschen abzieht.
Ja, ganz am Anfang hatte ich ja schon mal vorgestellt,
eigentlich das, was wir jetzt hier erstmal irgendwo zumindest,
bis es dann mit Rechnerarchitektur 2 losgeht, kennengelernt haben,
als, sag mal, dieses Grundprinzip,
wie wir uns als Informatik jetzt,
also irgendwie so ein Computer oder die Befehlsaberwartung vorstellen,
nämlich dies klassisch von Neumann-Konzept, wo man sagt,
ich habe also eine abstrakte Maschine,
wo ich also eben einen minimalen Hardware-Aufwand habe,
wo ich dann eben sagen kann, ich habe einen Speicher.
Ich habe eine verarbeitende Einheit für Programme und für Daten in dem Speicher
liegen eben sowohl die Programme als auch die Daten.
Ich kann diesen Speicher quasi jetzt über sowas wie eine Adresse auslesen. Und wenn ich jetzt eben weiß,
an einer bestimmten Adresse oder in einem bestimmten Adressbereich liegen eben Programme,
werden die eben dann so interpretiert,
dass quasi die Bit-Folgen aus Nullen und Einsen,
die von dort gelesen werden, dann eben als Befehle,
so eines Befehlssatzes interpretiert werden, wo man dann eben sagen kann,
okay, das ist ein Befehl, der sagt,
nimm den Inhalt von dem und dem Register,
addiere den konstanten Wert beispielsweise dazu und schreibe das Ergebnis da und dahin.
Nicht in das Ganze teilt sich dann eben in so einen Zyklus aus mehreren Phasen,
wo der Befehl geholt wird, dekodiert und ausgeführt wird.
So, das ist eigentlich erst mal so von der Vorstellung her die Grundidee, wie Rechner funktionieren, wie Befehle eben letztendlich abgearbeitet werden. Damit werden wir jetzt also auch noch entsprechend erst mal weiterarbeiten,
jetzt in Bezug auf den Befehlssatz und eben auch in der Grundidee dann übernächsten Kapitel,
wo nochmal so ein paar Grundlagen zum Assembler, beziehungsweise Assembler-Code,
Assembler-Programmierung mit drin sind, also jetzt weniger in dem Sinne,
dass wir hier jetzt also wirklich selber Assembler-Programmierung machen oder das Lernwerden,
sondern dass man einfach erstmal nur weiß,
wie auf dieser untersten Ebene diese Abarbeitung ist und wie beispielsweise jetzt sowas wie Datenstrukturen,
die ich habe, also sprich,
wenn ich jetzt in der Programmiersprache Ein Entegern-Fließkomma-Wert habe,
wenn ich dann Array habe, wie das Ganze im Speicher abgelegt wird,
weil das ist eben genau diese Schnittstelle zwischen Befehlssatz und Hardware geregelt jetzt irgendwie durch ein Betriebssystem,
die man also irgendwie grob im Hinterkopf haben sollte,
um letztendlich effizient zu programmieren,
weil man da eben doch relativ schnell irgendwelche Sachen haben kann,
die dann oder Effekte haben kann, die dann eben dazu führen,
dass also der Code, also auf einmal nicht mehr sonderlich effizient,
hinsichtliche Geschwindigkeit arbeitet, weil der eben entsprechend,
sagen wir es ein bisschen schlecht strukturiert ist von der Art und Weise,
wie Arrays arbeiten und so weiter.
Gut, nicht deswegen nochmal so ein bisschen Motivation,
warum zumindest ein bisschen Grundverständnis von Assembler-Code, also auch irgendwo wichtig ist,
was dann also im übernächsten Kapitel letztendlich folgen wird.
Gut, also von Norman-Konzept hatte ich ja schon kurz vorgestellt,
man hat eben letztendlich immer diese Grundidee Sequenz elementarer Befehle.
Ich fange eben an, ein Befehl aus dem Speicher zu holen.
Der landet jetzt also irgendwo in einem speziellen Register,
nennt sich dann Befehlsregister. Inzwischen wissen wir auch,
was Register sind, nämlich einfach eine Sammlung von Flip-Flops.
Dort wird er dann quasi dekodiert. Inzwischen wissen wir auch,
wie das geht. Nämlich da habe ich dann eben irgendein Schaltnetz,
was eben feststellt,
wenn an den und den Stellen der und der Bit-Vektor liegt,
kommt am Ausgang der 1 raus und wenn der Ausgang der 1 ist,
dann weiß sie eben,
das ist ein Additionsbefehl und schaltet demzufolge dann eben irgendwie entsprechende Alu irgendwo ahnen beziehungsweise sorge dafür,
dass dann eben dort was passiert.
Gut, das heißt also, da wird der Befehl dann eben quasi geholt,
irgendwo interpretiert. Nicht gegebenenfalls, wer noch irgendwo Operanten geholt,
die jetzt noch irgendwo in irgendwelchen Registern sind,
die ja dann auch irgendwie an die A-Eingänge einer CPU beziehungsweise an
die Eingänge der Alu in der CPU dann eigentlich kommen müssen und anschließend wird dann eben die eigentliche Operation ausgeführt.
Ja, und anschließend, wenn das jetzt nicht gerade ein Sprungbefehl ist,
nicht wird also dann entsprechend der Befehlszähler,
der also quasi in einem Speicher sagt,
von welcher Stelle der Programmabarbeitung ich jetzt gerade bin,
entsprechend inkrementiert und dann eben der nächste Befehl gelesen.
Oder es wird eben festgestellt, Hura, ich bin am
Programmende und das Ganze wird eben beendet. In das,
was dann eben nach dieser Stelle hier passiert,
das ist dann eben wieder das,
wo dann letztendlich der Betriebssystemteil einspringt,
der dann eben sagt, okay,
ich habe jetzt Programm XY abgearbeitet und jetzt kann eben entsprechend
ein anderes Programm rechnen,
sofern dort also noch irgendein rechenwilliges Programm wartet
Gut, ja, dieser Ausführungszyklus, also auch diese Folie,
lag ganz am Anfang schon mal drauf, ist eben immer Instruktion holen,
dekodieren, Operanten holen, ausführen, Ergebnis gegebenenfalls speichern und dann eben zu sehen, wie ist dann die nächste Operation.
Gut, die Hardware zu dem Ganzen ist eben,
also na, Anbaum eben quasi immer unterteilt, dass man sagt,
ich habe den Speicher, ich habe hier in der CPU,
was dann also dieser Teil hier drin ist,
eben einmal irgendwo eine Steuerwerk, also Steuereinheit,
wo dann also quasi drin ist, das Befehlsregister,
wo ich dann also den entsprechenden Buffet hier aus dem Speicher geholt habe.
Und eben der Teil, der dann rechnet,
das war es dann also im Prinzip die Alu-Essen.
Zusätzlich gibt es dann eben noch irgendwelche Ein- und Ausgaben. Gut,
und anders als jetzt hier in dieser Grafik hat man dann
eben in der Regel ein Bussystem, was das Ganze verbindet.
Also jetzt hier nicht irgendwie solche Punkt zu Punktverbindung,
weil technisch gesehen ist es eben so dieses hier befindet sich dann in der CPU,
der Speicher, ist dann eben über dem Bussystem irgendwo auf dem System,
auf der Platine oder auf dem Board irgendwo mit drauf und hängt da mit drin.
Gut, ja, hier die entsprechenden Teile hatte ich
also auch schon kurz erwähnt oder vorgestellt.
Das heißt also, die Begriffe sollten eigentlich auch schon klar sein.
Deswegen werde ich jetzt also darauf verzichten,
da nochmal fünf Minuten lang alle mit zu langweilen.
Es seien sie, haben jetzt also irgendwas,
wo sie sagen, also mit der Abkürzung kann ich jetzt
nichts zwingend anfangen
Gut, scheint soweit klar zu sein. Wie gesagt,
wird, lag ich auch noch an einigen anderen Sachen oder Beispielen nochmal ein bisschen erklären. Ja,
auch dieses hatten wir schon mal aufliegen, das,
was dann die eigentliche Rechnerarchitektur, also jetzt im Sinne Hardwareaufbau ist,
ist ja, dass man sagt, Die Grundidee dabei ist,
ich baue halt eben letztendlich alle Funktionsblöcke irgendwie ein,
verschalte die dann irgendwie miteinander.
Und zwar werden die dann eben so miteinander verschaltet,
dass immer abhängig davon, welcher Teil der Befehlsabarbeitung quasi gerade aktiv ist.
Ich dann eben die entsprechenden Leitungen aktivieren kann, um zu sagen,
zum Beispiel, es sollte ein Befehl geholt werden.
Ja gut, was passiert da? Es gibt eben irgendwie sowas wie diesen PC-Program-Counter,
wo also letztendlich drinsteht, welcher Befehl wird abgearbeitet.
Nicht damit adressiere ich also quasi den Hauptspeicher,
lese hier von einer Adresse eben das Wort und das landet dann eben in diesem Befehlsregister.
Nicht anschließend wird es von dort aus über irgendwelche Logik dekodiert und
mit ihm irgendwie so einen ganzen Satz von Steuerleitung wird dann eben dafür gesorgt,
dass abhängig von dem Befehl gerechnet wird, gespeichert wird,
ein Sprung gemacht wird oder was weiß ich auch immer.
Und diese Leitung sagen dann eben immer den einzelnen Einheiten,
Du sollst jetzt gerade was tun oder du sollst jetzt eben gerade nichts tun.
Und gut, dann gibt es hier darin dann eben noch die entsprechenden Datenfahre,
um zu sagen, wenn ich jetzt nicht gerade springe,
wird der Befehlszähler quasi über ein Inkrement da einfach immer nur erhöht.
Und ich kann dann eben beim nächsten Befehl dann aus dem Hauptspeicher
den entsprechenden nächsten Befehl laden. Vorher wird natürlich noch irgendwie gerechnet,
beispielsweise soll jetzt also von irgendeiner Speicheradresse was gelesen werden,
mit einem Zwischenergebnis irgendwie verknüpft werden,
das Ganze landet dann wieder hier oder ich kann eben dieses Zwischenergebnis wieder in den Hauptspeicher zurückschreiben, was auch immer.
Letztendlich ist das jetzt natürlich dann immer davon abhängig,
wie sieht dieser Hardwareaufbau, wie sieht der Befehlssatz aus,
welche Befehle gibt es da.
Das ist dann eben das, was wir dann in Kapitel 12,
Instruction Set Architecture so ein bisschen kennenlernen werden,
wie sowas im Prinzip dann also noch entsprechend anders gemacht oder anders aufgebaut werden kann.
Also dieses Beispiel ist jetzt also weniger typisch für einen Rechner bzw. gerade von aktuellen Rechner.
Also das wird also jetzt noch Rechnerstruktur und Praktikum wird was ähnliches verwarnt,
wenn man sich aktuelle Rechnerarchitekturen ansieht, dann haben die eben noch ein bisschen andere Eigenschaften.
Das ist dann das, was wir dann in dem Kapitel Rechnerarchitektur zwar dann letztendlich kennenlernen werden. Gut,
was dem Ganzen dann eben auch zugrunde liegt, ist,
wenn ich mir das Ganze jetzt also irgendwie so ansehe,
dieses ganze Abarbeitung,
dass man da in der Regel auch was ganz am Anfang schon erwähnt hatte,
dann eben unterschiedliche Abstraktionsebenen hat.
Das heißt, man kann jetzt immer sagen,
ich habe irgendwo Hier unten letztendlich meine Hardware.
Ich habe den Prozessor, ich habe irgendwie meinen Hauptspeicher.
Ich habe hier irgendwelche Ein- und Ausgabegeräte, die ich also über irgendeinen Mechanismus ansprechen kann.
Und darauf aufbauen, dann also quasi jetzt als Schicht Betriebssystem.
Betriebssystem werden wir also jetzt ganz am Ende der Vorlesung noch relativ kurz kennenlernen.
Da geht es eigentlich auch jetzt weniger darum,
irgendwie ein spezifisches Betriebssystem, sei das jetzt also irgendein Unix-artiges,
sah das irgendein Windows XY genau kennenzulernen, sondern
Und da geht es dann eigentlich auch erstmal nur darum zu sehen,
was sind die Grundaufgaben des Betriebssystems, die letztendlich,
also es war bei den Standardbetriebssystemen dann eben erstmal ähnlich oder vergleichbar sind.
Und wie sorgt das dafür, dass die also gegebenenfalls umgesetzt werden können? Gut,
dann haben wir natürlich also Aufbau und darauf dann eigentlich unsere eigentlichen Anwendungen,
nämlich das, was wir tagtäglich dann eben benutzen,
um im Internet zu surfen,
Texte zu schreiben,
was weiß ich auch irgendwie zu machen,
ein Spiel zu spielen und so weiter
Gut, genauso wie man jetzt also hier im Prinzip unterschiedliche Schichten hat,
hat man dann eben auch noch unterschiedliche Abstraktionen hinsichtlich dessen,
wie Betriebs- oder ein Betriebssystem jetzt also irgendwelche Sachen gehandhabt oder verwaltet werden.
Also da gibt es dann eben zum Beispiel auch Ideen,
dass man sagt, Wenn wir jetzt irgendwas schreiben,
irgendwas bearbeiten, dann habe ich meine Daten typischerweise irgendwo in Dateien,
nicht also Bilddateien, Turndateien, Textdateien, was auch immer.
Die liegen dann also irgendwo auf der Festplatte des Rechners rum.
Und wenn ich dann eben irgendwann in dem Dokument weiterarbeite,
wenn ich das PDF jetzt sage,
wird eben entsprechend die Datei geladen und dann eben von einer
passenden Anwendung irgendwie bearbeitet oder gezeigt oder was auch immer.
Seitens des Betriebssystems Das ist etwas,
was ja in der Programmierung auch immer teilweise schon sehen werden,
ist dann immer die Frage, okay, wie handhabe ich irgendwelche Ein- und Ausgaben?
Und da ist es dann eben häufig so,
dass er so Ein- und Ausgaben sinnigerweise dann eben auch als Dateien gehandhabt werden,
also sprich in den meisten Programmiersprachen habe ich dann eben Standard-In-
und Standard-Out und kann da also quasi wie in der Datei
einfach reinschreiben und anstatt dass das jetzt eben wirklich in der Texte Datei auf der Festplatte landet,
geht das dann eben quasi auf ein Terminal auf den Bildschirm oder wie auch immer.
Ich dann also letztendlich die Ausgabe definiert habe. Das heißt,
da hat man dann eben auch so eine Abstraktionsschicht.
Dann kann man sagen, beim Speicher etwas,
was wir dann also auch noch kennenlernen werden,
habe ich dann also das Konzept des virtuellen Speichers.
Wofür braucht man das? Auch das ist dann wieder so ein zusätzliche Abstraktion,
wo man sagt, na gut,
also für mich als Programmierer kann ich sagen,
ich habe den Rechner,
ich habe dort irgendwo in dem Rechner Für den spare ich
ja so was wie eine Byteweise Adressierung mit 32 Bit oder mit 64 Bit Adresswortlänge.
Nicht dem zuvor könnte ich dann 2 hoch 32 oder inzwischen
ist es mal 64 Bit, also 2.64 Uhr, Byte adressieren.
So viel Speicher haben die Rechner natürlich nicht. Nun ist es ja so,
dass nicht nur mein Programm davon ausgeht,
dass ich jetzt gerade schreibe, ich habe den Adressraum,
sondern jedes andere Programm,
was jetzt gerade in der Ausführung ist oder was jemand anders macht,
hat genauso
diesen Adressraum
Und das ist dann eben eine Sache,
die also beispielsweise das Betriebssystem dann virtuell so rumgesehen macht oder umsetzt,
ist, dass es eben dafür sorgt,
dass quasi von den laufenden Programmen dieser Adressräume brav voneinander getrennt werden,
weil wenn ich das nicht mache,
habe ich nämlich genau den Effekt,
den man nicht haben möchte,
dass also irgendein anderes Programm die Daten von meinem Programm beliebig lesen kann,
was ich dann also bei Passwortmanagern oder Online-Banking also
irgendwie nicht so schön macht
Demzufolge sorgt das Betriebssystem eben dafür, dass es quasi die Speicherbereiche
der einzelnen Programme oder der einzelnen Tasks voneinander trennen kann.
Und dass es eben auch dafür sorgen kann,
dass wenn ich jetzt also beispielsweise mehr Speicher in meinem Programm
benötige oder verwalte als wirklich physikalisch in dem Rechner drin ist,
dass dann dafür gesorgt wird,
dass Teile des Programms letztendlich oder Teile des benötigten Speichers letztendlich
dann eben in Form von Dateien oder eine Ausgabe dann eben auf der Festplatte landen.
Das, was Mandan als Auslagerungsdatei in Windows bzw. als Swap Space in Linux
letztendlich kennt, ist inzwischen nicht mehr so das Problem.
Also Speicherpreise sind jetzt so günstig,
dass man also sagen kann, naja gut,
also irgendwie so Standardausstattungen sind, also schon irgendwie 16 Gigabyten,
die wollen erstmal
gefüllt werden
Zur Anfangszeiten der Computertechnik war es eben so, irgendwie so eine Standard-IBM-PC hatte 660 Kilobyte.
Hauptspeicher. Das ist also doch sehr, sehr wenig,
finde ich, mit dem, was man heutzutage hat.
Und da war es eben schon so, dass man also relativ schnell,
also auch mit ganz einfachen Programmen und Algorithmen,
mehr Speicher in seinem Programm benötigte, als wirklich physikalisch Hauptspeicher da war.
Und daher kommt dann eigentlich auch noch diese ganze Sache mit diesen Auslagerungsdateien, dass eben,
wenn ich jetzt also zum Beispiel ein sehr großes Aree in meinem Programm bin,
nötige Aufsteller aluziiere,
dass dann eben Teile von diesem Array in der Regel die,
die jetzt vielleicht nicht gerade im direkten Zugriff sind.
Nicht, wenn ich das zum Beispiel jetzt sequenziell durchlaufe und
ich dann also irgendwie bei den höheren Adressen bin,
dass also quasi die ganzen unteren Adressen dann einfach aus dem Hauptspeicher auf die Festplatte übertragen werden.
Hier kann ich immer noch im Hauptspeicher weiterrechnen,
nur wenn ich irgendwie mal wieder in Zugriff mache,
werden die dann eben,
werden andere Teile wieder aus dem Hauptspeicher freigeschaufelt und das Ganze dann wieder reingetan.
Das ist eben das, was vom Konzept her dann dieses Virtual Memory ist.
Also das wird uns dann später auch noch in einem Kapitel zu den Betriebssystemen begegnen,
wo das dann also nochmal kurz diese Grundidee vorgestellt wird.
Nicht genauso habe ich dann eben auch diese Abstraktion jetzt zwischen Prozessen,
das was ich jetzt eben gesagt habe, wo man auch sagen muss,
ganz früher war es so die Rechner waren quasi Einzelbenutzerrechner,
also sprichst du die allerersten Computersysteme nicht,
da lief also ein einziges Programm, was der Benutzer jetzt,
also irgendwie mühselig in Lochkarten eingestanzt hatte.
Die wurden irgendwie eingelesen und das lief einfach durch, berechnete irgendwas.
Irgendwann kam hoffentlich mal ein Ergebnis raus und dann wurde der nächste Lochkartenstapel
in das Lesegerät reingetan und lief entsprechend durch. So,
inzwischen ist es eben so, dass man sagen kann,
diesen Batchbetrieb, den man also früher hatte,
das gibt es alles nicht mehr,
sondern auch selbst wenn ich jetzt als Alleiniger benutze,
hier ist an dem Rechner eingeloggt bin,
laufen da also irgendwie mehrere oder bis zu mehreren hundert Prozessen.
Die meisten dann also vom Betriebssystem selber. Nicht,
dann habe ich da beliebig viel natürlich jetzt um
die schicke grafische Oberfläche zu machen und dieses und jenes.
Und dann eben vielleicht noch die eigentliche Anwendung,
mit der ich jetzt gerade arbeite. Und okay,
im Hintergrund macht das Betriebssystem dann vielleicht noch ein Update,
sofern da rechne mit dem Internet verbunden ist und, und, und. Das heißt,
da laufen dann eben auch sehr viele Prozesse und das,
was da dann das Betriebssystem eben macht,
jetzt im Sinne von Abstraktion ist dann eben auch diese Prozesse voneinander zu trennen und eben dafür zu sorgen,
dass Also wenn ich jetzt eben nur eine oder eine begrenzte Anzahl von CPUs habe,
die dann also quasi mehr oder minder fair verteilt werden und jeder Prozess hoffentlich mal zum Rechnen kommt.
Und natürlich der, mit dem ich jetzt gerade arbeite,
der dann also mit der für mich gefühlt höchsten Priorität läuft.
Gut, also wie gesagt, das nochmal zu den Beispielen,
also was dann also so an Abfraktion dann noch mit gemeint ist.
Ja, etwas, was auch ganz am Anfang ja schon
mal so ein bisschen vorgestellt worden ist,
ist dann also in Bezug jetzt auf die Programmiersprachen oder die Programmiersprachenumsetzung
Das dann also quasi bei der Umsetzung von Hochsprachenprogrammen, also beispielsweise jetzt hier,
in diesem Fall das INC-Programm, in das eigentliche ausführbare Programm passiert. Auch das wählen wir dann am Ende des übernächsten Kapitels dann also noch ein bisschen genauer kennenlernen. Was ich also hier dann dahinter verbirgt,
wo man eben sagt, okay,
also ich schreibe jetzt hier so irgendwie ein MC-Programm,
ich habe dann so einen Pre-Prozessor,
damit kann man auch so ein bisschen Textersetzung machen,
bedingte Kompilierung, nicht so,
dann habe ich den eigentlichen Compiler, der zäuft aus Assembler-Programm,
der Assembler, der macht dann eben aus den Anweisungen,
die jetzt also quasi spezifisch für einen bestimmten Prozessor,
also beispielsweise X86, sind dann eben letztendlich sowas wie Binärcode,
also dann wirklich eine vorgefundene 0001, nämlich das,
was dann in den Hauptspeicher geladen wird,
später dann zur Ausführung und das ist das,
was also quasi jetzt als Programm dann Auf der Festplatte rumliegt,
was vorher noch passiert, ist,
dass das quasi über den Linker, wenn ich jetzt gesagt habe,
ich habe noch zum Beispiel für eine Ausgabe,
brauche ich also die als Standard-AO, die Routine Print F,
um ist das irgendwie eine Textausgabe zu machen,
dass die dann eben aus irgendeiner externen Bibliothek kommt und dann eben dort noch mit,
sofern das statisch gelingt ist,
also hier mit reingebaut wird.
Also wie gesagt, da werde ich dann also auch noch mal ein bisschen erklären,
welche Unterschiede es da gibt, wie das dann also prinzip.
Gut, also das ist also dieses Kompilierungssystem,
wo man dann eben auch sagt,
unterschiedliche Abstraktionsebenen von dem Programm, bis zu dem,
was also dann als binär string oder da Tage dann auf der Festplatte als ausführbares Programm liegt.
Und zur Ausführung von dem HelloWorld passiert dann eben noch,
dass dann also letztendlich das Betriebssystem jetzt wiederkommt und sagt,
wenn der Benutzer das jetzt ausführen möchte,
es muss in den Speicher geladen werden.
Dabei passieren dann auch nochmal wieder irgendwelche Adressumsetzungen. Das ist dann eben letztendlich das,
was ich also hier hinter dieser Virtualisierungsschicht dann eben auch noch so ein bisschen mitverbirgt,
weil natürlich ich als Benutzer, schreibe jetzt irgendwie,
ich brauche ein Array, der und der Größe.
Dafür wird irgendwo Platz angelegt. Das erzeugt eine Nase hier
irgendwie der Compiler und er sagt, okay,
also der Benutzer braucht für seine Datenstrukturen die Adressen von 0 bis
5000. Das sagt jetzt bei jedem Programm, was übersetzt wird.
Wenn jetzt aber natürlich mehrere Programme oder mehrere Tasts gleichzeitig laufen,
beziehungsweise quasi gleichzeitig und zumindest gleichzeitig im Hauptspeicher sind,
Funktioniert das natürlich nicht, sondern dann ist eben wieder das Betriebssystem dazwischen gefragt,
was eben dafür sorgt,
dass quasi die Adressen von meinem Programm und die Adressen von irgendeinem anderen Programm dann eben wieder so weit verschoben werden, dass die sich eben nicht gegenseitig überladen.
Das ist dann eben letztendlich das, was dann zwischen dem ausführbaren Programm und dem,
was während der Ausführung passiert, dann eben auch noch mit passieren muss.
Gut, ja, ansonsten, Programme selber,
da habe ich dann eben letztendlich die Ausführung auf der Ebene.
Gut, hier ist das Ganze nochmal,
also jetzt nicht aus der Folie von Tarnenbaum wie vorher,
sondern aus der Folie von Patterson und Tennessee, gemacht,
wo man eben sieht, Hochsprachenprogramm,
Assembler-Programm, dann das eigentliche Maschinenprogramm.
Also hier habe ich sowas wie irgendwelchen See-Code. Hier habe ich dann eben diese Assembler-Anweisung,
ich hatte es ja ganz am Anfang,
also auch schon mal für so ein kleines Beispiel mit dem X-86-Assembler was gezeigt.
Wie gesagt, so ein bisschen wird uns das dann am nächsten,
im übernächsten Kapitel dann noch begegnen und letztendlich die Daten selber
liegen dann eben irgendwie als Folge von null und ah,
sind dann irgendwo in einer Datei vor. Gut,
dann habe ich eben genau die Trennung von hier,
das soll dann also hier durch diese Mauer angedeutet sein,
dann eben zu der eigentlichen Hardware,
die das Ganze dann eben interpretiert, die dann eben sagt,
beispielsweise hier 32 Bit betrachte ich dann eben als ein Assembler-Befehl und der sagt jetzt eben,
es soll beispielsweise eine Alu-Operation stattfinden,
wo dann eben irgendwie das und das passiert, die Umsetzung
Von denen sahen in die Ausführung auf der Hardware, das ist eben das,
was letztendlich dann also hier genau an dieser Schnittstelle von Hardware-Strukturen
endlichen Automaten und so weiter dann eben zu irgendwelchen Folgen von Nullen oder Einsen passiert.
Gut, genauso wie ich also auf der Software-Ebene letztendlich unterschiedliche Abstraktionsebenen habe oder unterscheiden kann,
habe ich sowas bei der Hardware im Prinzip auch hier nun mal relativ kurz skizziert oder angedeutet,
weil also auch da kann man sagen,
es gibt je nach Auto dann also quasi unterschiedliche Beschreibungen,
wie das Ganze dann aussieht.
Da kann man sagen, gut,
also so auf oberster Ebene letztendlich von Neumann-Rechner kann ich sagen,
ich habe die CPU, da wird irgendwas dran gerechnet.
Ich habe hier irgendwie meinen Speicher, den kann ich irgendwie bereitweise oder wortweise wie auch immer adressieren.
Die sind miteinander verbunden eben über Adressbursten,
über den Datenburst und dann gibt es in der Regel noch sowas wie ein Kontrollbus,
also mit irgendwelchen Steuerleitungen und ich habe noch irgendwie die meiner einen Ausgabeeinheiten und dieses Ganze entspricht ja dann wirklich eins zu eins primitiv-golden-Prinzip von Neumann-Rechner.
Nicht und das könnte ich jetzt eben,
wenn ich jetzt sage, okay,
also ich möchte jetzt also wirklich mal so eine CPU in Hardware selber aufbauen,
dann eben entsprechend unterteilen oder partitionieren, indem ich dann sage, na gut,
aus dieser Architekturebene mache ich dann also was wie eine nächst niedrigere Ebene,
Hauptblockebene beispielsweise genannt, wo ich dann sage,
in der CPU habe ich sowas wie Operationswerk,
das heißt der Teil,
wo gerechnet wird und ein Steuerwerk der Teil,
wo die Befehle quasi abgearbeitet werden.
Und hier habe ich dann eben sowas wie den Programmfehler,
das Befehlsregister, wenn der Befehl im Befehlsregister ist,
gehen dann eben irgendwelche Steuerleitungen hier zu dem Teil,
wo sich die Alu befindet. Dort wird irgendwie gerechnet,
beispielsweise aufgrund der Ergebnisse der Berechnung kommen irgendwelche Flex zurück,
also irgendwelche Kontrollsignale, die eben zum Beispiel sagen,
wenn ich sowas wie einen bedingten Sprung mache,
soll gesprungen werden oder nicht.
Nicht im Hof Sprachhandprogramm wäre ja sowas, wenn ich also einfach irgendwie eine Verzweigung habe.
Nicht nur so ein klassisches If Stand Else,
also If X kleiner Null, denn mach irgendwas, Else, mach irgendwas anderes.
In Hardware wird das dann eben wirklich so eins zu eins umgesetzt,
dass quasi X in der Alu untersucht wird.
Ist das eine negative Zahl? Ja, negative Zahl.
Wie war das? Zweier Kompliment, höchstwertigstes Bit gesetzt.
Das ist dann quasi letztendlich mein Fleck oder meine Information,
um dann eben zu sagen, soll gesprungen werden oder nicht.
Und demzufolge muss dann hier für den nächsten Befehl eben
entweder aus dem Hauptspeicher der nächste Befehl genommen werden,
der dann also letztendlich über den Befehlsziel, also diesen Programm-Counter direkt adressiert wird.
Oder es wird eben irgendein Sprungziel dort eingetragen,
das ist dann eben das, was letztendlich der Assembler gemacht hat,
der dann eben quasi gesagt hat,
ich meine ihm jetzt nicht die nächste Anweisung,
sondern ich nehme die Anweisung da unten und die Adresse muss dann eben entsprechend an der Stelle dann eingetragen werden.
Gut, dann kann man da eben entsprechend weitergehen. Registertransferebene,
das ist das, wo wir jetzt also quasi mit Schaltnetzen,
Schaltwerken aufgehört haben. Nicht, dass man sagt, okay,
innen drin in dem Operationswerk habe ich sowas wie eine Alu,
wo ich jetzt also Addition, Subtraktion wird, weißes On,
Bettweises oder schieben, was weiß ich auch immer, was da letztendlich gefragt wird.
Realisiere. Und dann habe ich eben hier irgendwelche speichernden Register oder irgendwelche Einheiten,
die dafür sorgen, dass also quasi jetzt irgendwie die Argumente an die Alu kommen und das Ergebnis irgendwo landet.
So wie das Ding jetzt aussieht, ob das nun so oder so aufgebaut ist, ist dann eben von Architektur abhängig. So,
da drunter, das haben wir schon kennengelernt,
kann ich natürlich sowas wie diese Funktionalität dann in irgendwelche Garter übersetzen,
um zu sagen, okay,
ich habe hier sowas wie ein Ripper Carrie, Carrie,
Look Ahead, Adira oder was auch immer,
was dann dort drauf ist,
kann das in Bucce Argebra umsetzen und dann eben in Form solcher Gatter machen,
in nächst niedrigerer Ebene könnte man jetzt eben sagen,
gut, da bin ich bei der Elektrotechnik,
die wir jetzt also hier nicht weiter behandeln,
wo ich dann sagen kann,
sowas wie so ein Nantgutter in CEMOS-Schaltungstechnik besteht dann eben irgendwie so aus vier Transistoren,
zwei Transistoren von diesem Typ, Pekanaltransistor, zwei Transistoren von diesem Typ,
die sind so und so miteinander beschaltet und Hier habe ich dann auf einmal nicht mehr Nullen und Einsen,
sondern Versorgungsspannung, Nullvolt, 2,5 Volt und hier fließen eben irgendwelche Ströme,
die dann eben dafür sorgen,
dass also diese Transistoren entweder wie ein Schalter geschlossen sind oder entsprechend auf sind und dann ich damit dann also quasi dafür sorge,
dass dieser Ausgang entweder hiermit verbunden ist,
nicht dann wäre der Ausgang quasi eine Eins oder der Ausgang hierüber mit dem hier verbunden ist,
dann wäre der Ausgang eine Null.
Nicht, dass dann die Art und Weise,
wie das Ganze, also bei 10 Ausschaltungstechnik beispielsweise umgesetzt wird.
Gut, und dann kann ich die Abstraktion eben noch weitertreiben,
weil das Ding soll ja auch irgendwann mal technisch gesehen gefertigt werden. Dann kann ich sagen,
okay, in zehnmal Schaltungstechnik bei dem und dem Hersteller kann ich also irgendwie so ein und dem und dem Prozess,
kann ich jetzt eben irgendwie einen P-Kanal-Transistor irgendwie so aufbauen,
dass ich sagen kann, also durch irgendwelche Dotierungen,
durch irgendwelche elektrisch leitenden Verbindungen und so weiter,
ist das Ganze dann letztendlich umzusetzen in irgendwie so eine Struktur aus mehreren Ebenen,
die also in dem Sinne,
also mit einem Planarprozess irgendwo erzeugt werden.
Und das Ganze erzeugt mir dann also etwas,
was ich dann eben wie so ein Transistor verhält.
Da kann ich dann sowohl die eine als auch die andere Sorte umsetzen und ja,
okay, wenn ich das habe,
dann bin ich eben genau an der Stelle, wo ich sagen kann,
okay, damit kann ich jetzt zu meinem Chiphersteller gehen,
der nimmt dann eben diese Information und baut daraus dann eben letztendlich die eigentliche Hardware dann eben wirklich physikalisch so rumgesehen auf.
Das heißt also, auch da hat man dann dementsprechend Abstraktionsebenen.
Das Ganze findet man dann häufig immer in so einer Grafik,
die dann also nach dem einen der Autoren,
die das also quasi eingeführt hat, eben entweder Gais,
Gideagramm oder weil das eben so entsprechend angeordnet ist,
Y-Diagramme heißt, wo man dann sagen kann,
ich habe hier unterschiedliche Abstraktionsebenen von Architektur bis zum Schaltkreis und ich unterscheide da also einmal sowas wie jetzt unterschiedliche Achsen,
nämlich einmal das Verhalten
Also was wir jetzt hier zum Beispiel kennen, Logikebene,
Verhalten sind Bullshit-Leichung, Schaltkreisverhalten, also Schaltkreis wäre jetzt,
also das elektrische Netz, kann man eben beschreiben als Differenziergleichungssysteme.
Und darüber kann ich dann eben mein Verhalten spezifizieren.
Dem entspricht dann immer eine Struktur aus irgendwelchen Krimitivelementen.
Das ist eben genau das, was also quasi hiermit immer angedeutet ist,
also eine Struktur aus Transistoren, eine Struktur aus Gattern,
was auch immer.
Und das hat dann eben technisch oder in der Fertigung
gesehen dann eben immer ein Äquivalent innerhalb der Geometrie
Gut. Jedenfalls, also da aber dann eben auch unterschiedliche Abstraktionsebenen.
Sollte man mal grob gehört haben, wird in der Prüfung
nicht abgefragt. Muss jetzt also irgendwie nicht zwingend
irgendwie auswendig gelernt werden, wie so ein Geistgediagramm aussieht.
Nicht nur, dass man damit grob was anfangen kann. So,
was ja auch schon gesagt hatte,
wenn man sich das jetzt so irgendwie so auf unerster Ebene ansieht,
also ich spreche hier sowas, beziehungsweise muss ich mal gucken,
ob ich das jetzt hier mal irgendwie so auf die Schnelle finde.
Ich habe die Folienz hier nämlich gerade neu irgendwie so
ein bisschen kompiliert
Musik Ja, hier, so war es, genau nicht. Also,
das ist das, was man manchmal dann immer noch
so sieht oder was sie dann also mal hervorragend als Plot
irgendwo so an der Wand ganz gut macht.
Nicht so in zweimal zwei Meter. Das, was dann
also letztendlich diese Gesamtfertigung Vertretungsinformationen für irgendeinen Chip ist. Nicht nur,
dass es Tals und das Hardware-Multipliziererers, wo man sagen kann,
okay, wunderbar, es ist ein buntes Tapetenbild.
Aber das ist also das, was man zum Beispiel jetzt eben wirklich bräuchte,
um das irgendwo technisch umzusetzen. So die Sache ist natürlich,
wenn ich jetzt also irgendwie CPU mit mehreren Milliarden Transistoren habe,
dann entwerfe ich sowas ja, hatte ja auch schon gesagt,
also nicht auf der Ebene.
Das heißt, da will man jetzt nicht,
ich sage jetzt mal, mit einem Zeichenprogramm anfangen,
da also irgendwelche bunten Rechtecke,
also irgendwo auf eine Fläche
zu zimmern
Genau da geht man jetzt eben eigentlich die Idee runter,
dass man da jetzt eben im Prinzip, sorry,
dass man da dann eben im Prinzip sagt,
ich habe, so hier sind wir gewesen,
ich habe jetzt eben irgendwie irgendwelche Programme, irgendwelche Werkzeuge,
die mir quasi jetzt diesen Abstieg in diesen Ebenen quasi automatisch machen und ich habe dann eben sowas wie Hardware-Beschreibungssprachen,
Stichwort ist ja auch schon gefallen, wo man dann eben sagen kann,
also damit beschreibe ich mein System, nämlich was es tun soll,
also ähnlich wie in der Programmiersprache,
in der Hochsprache und ähnlich wie ich da dann eben eine Übersetzung,
also dieses Kompilierungssystem habe,
was mir mein C-Code in der Folge aus Nullen und Einsen übersetzt,
die ich mir auch nicht weiter angucke, habe ich dann eben die Möglichkeit,
also einen Hardwareentwurf so zu machen, dass ich sagen kann,
ich habe Hardware-Beschreibungswachen, habe dann entsprechende Werkzeuge,
die mir das dann eben solche Hardware-Strukturen umsetzen,
die dann also quasi in die Fertigung gehen können
Gut, ja, jetzt verlassen wir aber den Tal dann
wirklich gleich. So, jetzt möchte ich,
bevor wir jetzt zum Befehlssatz oder zu den Sachen kommen,
nochmal ein paar Sachen vorstellen, die wir jetzt also noch nicht kennengelernt haben,
jetzt unter Schaltnetze bzw. Schaltwerke, nämlich Komponenten, wo wird Informationen gespeichert?
Da habe ich im Prinzip zum einen Register,
Register ist eben so rum gesehen erstmal nichts anderes als eine
Anzahl von Flipflops in der Regel, sowas wie Flankengesteuerte.
Oder was man teilweise auch hat, eine etwas andere Hardware-Struktur,
wo man dann eben gleich einen ganzen Satz von Registern hat,
was dann technisch gesehen eigentlich eher so ein Ramm-Speicher entspricht.
Dann habe ich eben unterschiedliche Speichernelemente, werde ich
auch gleich noch mal kurz ein bisschen was zu sagen.
Dann habe ich meine eigentlichen Schaltnetze, also sprich arathmetische Schaltung,
das, was ich für logische Operationen brauche und eben das,
was ich brauche, um letztendlich irgendwie sowas wie Pulsure Ausdrücke,
jetzt im anderen Zusammenhang entsprechend umzubringen und dazu bringen.
Und es gibt da natürlich noch irgendwo diese Verbindungsstrukturen,
die ich jetzt in meinem System habe, die jetzt eben dafür sorgen,
wie unterhält sich die CPU mit dem Speicher, also irgendwelche Busse,
wie ist das Ganze dann gemacht bzw. Multiplexer haben wir schon kennengelernt,
wo ich dann eben sagen kann,
ich habe einen ganzen Satz von Eingängen und kann damit dann eben auswählen,
Das soll jetzt also auf einen Ausgang geschaltet werden.
Gut, wie gesagt, bisher haben wir kennengelernt,
Gatta und Schalennetze, Flipflops, schalt Werke.
Nicht die kann man eben benutzen, um bestimmte Abläufe zu machen.
Wenn ich jetzt quasi so ein Gesamtsystem so einen einfachen von Neumann-Rechner aufbauen möchte,
dann brauche ich dann eben noch ein bisschen was wie Speicher,
ein bisschen was zu bussen und noch eine andere Variante,
um Schaltwerke zu realisieren, sogenannte Mikroprogrammierung.
Das ist das, was jetzt also hier am Ende oder
bis zum Ende dieses Kapitels dann also hier letztendlich noch folgen
Gut, Speicher selber hatte ich ja so ganz am Anfang auch schon mal so ein bisschen was zu gesagt.
Ist letztendlich so, dass man sich eben immer vorstellt,
ich habe einfach ein ganzes Array von irgendwelchen Speicherworten,
die man dann eben über Adressen von null bis irgendwas quasi einzeln adressieren kann. Und Typischerweise,
also von der Idee her,
kann man sich das dann eben immer so vorstellen,
dass man hier vorne quasi jetzt für die Adressen sowas wie so ein Demultiplexer hat,
wo ich dann eben hier meinetwegen jetzt acht Bit, beispielsweise Adressleitungen habe,
damit dann quasi eine von 256 Speicherworten hier dann also quasi mit adressieren kann und dann eben sagen kann,
Dieses Wort soll entweder gelesen werden oder,
wenn ich jetzt also reinschreibe, in dieses Wort soll reingeschrieben werden,
wenn das ein Schreiblesespeicher ist.
Gut, wie wird der Speicher dann letztendlich unterschieden?
Also zum einen natürlich jetzt, also wie groß ist er?
Also sprich, wie sieht das mit der Kapazität aus?
Sind überhaupt Schreibzugriffe möglich? Passiert das jetzt nur auf einzelne Bits oder Bytes?
Oder passiert das eben auf ganze Zeilen oder größere Blöcke?
Nicht dann Speicherinformationen ist das flüchtig oder dauerhaft gespeichert,
nicht bei unseren Standardrechnern können wir sagen,
Hauptspeicher ist flüchtig, das heißt, funktioniert halt,
solange das Gerät mit Strom versorgt wird, beziehungsweise eingestaltet ist.
Wenn ich das jetzt also wirklich richtig ausschalte und nicht nur in
irgendwelche Stand-by-Modi gehe, geht der gesamte Hauptspeicherinhalt verloren. Das,
was man dann eben machen muss, ist das Ganze eben,
wenn ich jetzt also sowas wie so ein Schlafmodus habe,
beispielsweise in der Datei auf der Festplatte oder der SSD
quasi abzuspeichern und dann beim nächsten Neustart dann quasi als Schnellstart dann einfach wieder an die entsprechende Stelle im Hauptspeicher zurückzuladen.
Gut, dann Unterscheidungen, wie sind dann die Zeiten, Lesen, Schreiben?
Wie ist das ein bisschen technologisch aufgebaut? Da gibt es jetzt eben viele unterschiedliche Varianten von Speicherbausteinen, das,
was ich jetzt, also hier noch so kurz vorstellen werde,
nur ganz grob von der Idee her,
dass eben Unterschied zwischen Rahmen, Static, Rahmen und D-RAM,
Dynamic Rahmen, beziehungsweise inzwischen ist das irgendwie SD-RAM,
also das, was das einmal Hauptspeicher ist und das,
was also entweder sowas wie ein Registerfall oder was die Cashes sind,
Level 2 kann man hier eigentlich streichen.
Nicht dann gibt es inzwischen eigentlich nicht mehr. Früher gab es das noch,
nur Lesespeicher, das ist halt, dass man sagt,
wenn ich jetzt also irgendwie ein kleines,
eingebettetes System habe, also irgendein Gerät,
was also wirklich nur die und die Funktion machen soll,
dann nehme ich jetzt kein teuren Speicher,
wo ich dann also auch noch sagen muss,
ich brauche dann auch noch eine Festplatte,
weil wenn das Gerät eingeschaltet wird,
muss ja erst mal das Programm selber in den Hauptspeicher geladen werden,
sondern dann habe ich also nur Lesespeicher.
Da ist das Programm fest mit reinkodiert. Das bleibt dann auch erhalten,
wenn das Gerät komplett ausgeschaltet, also elektrisch getrennt ist.
Das war eben auch etwas,
was dann in den Anfängen der Computertechnik dann eben beispielsweise sowas
für Basisteile vom Betriebssystem noch mit hatte oder eben bei eingebetteten Systemen,
die dann eben genau nur eine einzige Funktion ausgeführt haben
Inzwischen auch nicht mehr so richtig aktuell. Also inzwischen
wird sowas in der Regel als Flash-Speicher gemacht. Sprich,
ein Speicher, den man eben elektrisch wieder neu programmieren kann,
der aber quasi seinen Speicherinhalt erhält, auch wenn die Versorgungsspannung nicht da ist.
Gut, und zwischenfertig gab es dann eben auch nochmal programmierbare oder durch den Benutzer programmierbare Speicher,
auch in unterschiedlichsten Techniken von irgendwelchen Sachen,
wo man dann Sachen, also ursprünglich erstmal nur schreiben konnte.
Kann man sich quasi vorstellen, wie so eine Art,
dass sich also hier so eine Matrix oder Verbindungsstruktur habe,
wo ich also im Prinzip einfach nichts anderes als irgendwie sowas
wie kleine Schmelzsicherungen habe und während da für die Programmierung gehe ich eben mit einer hohen Versorgungsspannung hier drauf.
Das Ding brennt durch. Dann bin ich mit der Programmierung fertig und an den Stellen,
wo es durchgebrannt ist, lese ich halt später im Normalbetrieb an eine Null,
da wo es nicht durchgebrannt ist, lese ich eine Eins.
Das war also das, was diese Programmable Roms gemacht haben. Nicht später ging das dann eben einfach,
ging das dann so, dass man die auch wieder zurücksetzen konnte,
ursprünglich, also mit UV-Licht,
da hatte man also irgendwie so eine komische UV-Lampe,
mit denen waren die Dinger dann,
die hatten dann also quasi in dem Ship dann immer noch oben so ein kleines Glasloch drauf oder eine Glaslupe drauf,
womit man das dann also quasi dann wieder zurücksetzen konnte und dann wieder neu programmieren konnte.
Nicht später kam dann E-E-Proms, die ließen sich eben elektrisch schreiben und auch elektrisch auslesen.
Nicht damit kamen dann, sagen wir so, in den 80er,
90er Jahren die ersten Geräte, wo man dann selber Beispielsweise sowas wie Firmen, wer neu flashen konnte. Inzwischen sind das eben alles andere Techniken,
also das, was eben diese Flash-Speicher sind,
die das Ganze jetzt also noch ein bisschen schneller und komfortabler machen,
wo man dann eben aber auch in der Regel das also so ähnlich wie so ein Read-Only-Speicher,
also es sei denn,
das ist jetzt irgendwie der Hauptspeicher vom Smartphone oder sowas,
aber eigentlich eher wie so ein Read-Only-Speicher verwendet,
nicht wo man sagt, na gut,
beispielsweise die Firmware bzw. das Betriebssystem von irgendeinem Modem zum Beispiel wird in so einem Flash-Speicher abgelegt und wenn ich jetzt bei irgendwelchen namenhafteren Herstellern bin,
dann kriege ich dann vielleicht einmal im Jahr,
wenn die also irgendwelche Sicherheitslücken festgestellt haben, mal ein Update,
kann das System mal neu flashen,
wenn ich ihn danach sollte,
also zumindest diese Sicherheitslücke dann irgendwie geschlossen worden sein und ansonsten ist das aber kein Speicher,
den man jetzt,
also wie sein Hauptspeicher in der Programmierung ständig schreibt,
mit neuen Werten und dann eben ausliest und das also
quasi im Dauerbetrieb dann eben auch gerade das Schreiben macht
Ja, Reed Only Memory hatte ich schon gesagt,
kann man sich eben wirklich immer so vorstellen.
Also hier gibt es dann also auch von Hardes dann die entsprechenden Beispiele hier gemacht,
also so, dass man sagt,
ich habe hier also so eine Eingabe in diesem Fall,
also einfach irgendwie vier Adressbits,
kann damit dann also über so ein 4 zu 16 Deko oder dann quasi eine von 16 Zeilen hier irgendwie ansprechen.
Und dann gibt es dann also quasi diese Struktur,
wo dann eben solche Elemente drin sind,
die dafür sorgen, dass wenn sie quasi verbunden sind,
ich eben entsprechend eine Heinz rauslesen kann,
wenn sie nicht verbunden sind, wird eben quasi eine Null rausgelesen.
Nicht und technisch sind das dann eben Sachen,
die man dann während der Fertigung hier entsprechend mit reinbringt.
Nach dem Guten auch, das lässt sich dann wieder
relativ einfach, ja,
Vorlesung,
So nicht, also könnte ich jetzt, also hier die
entsprechenden Adresse anlegen. Nicht das, was man sieht,
ist, dass es quasi der Adressdekoder dann eben,
also jetzt also aus dieser binären Eins genau die Leitung Eins von 0 bis 15 dann hier aktiviert.
Und hier ist es dann eben so aufgebaut,
dass also hier an dieser Stelle keine Verbindung an dieser Stelle der Verbindung ist, an alle anderen auch nicht.
Und das, was dann eben hier rausgelesen wird, ist eine Null. Hiermit ist im Prinzip dann wieder so ein schadungstechnischer Trick,
das Ganze funktioniert quasi so rum gesehen dann immer wie ein großes Oder-Garda,
nennt sich dann Wired All, sorgt dann eben dafür,
dass sich dann im Prinzip, wenn ich jetzt also hier in Dadurch,
dass ich ja eben nur eine einzige Wortzeile,
also sprich so eine einzige Zeile hier auslese,
kann ich die hier quasi alle parallel auf den Ausgang schalten,
weil immer nur die eine,
die jetzt gerade durch den Adressdekoda aktiviert ist,
dann eben wirklich dafür sorgt,
dass ja ein Ausgäng was ausgegeben wird.
Nicht gut, in diesem Fall ist hier keine Verbindung,
kommt also ein lauter Nullen raus. Nicht,
wenn ich jetzt also hier in den kenne, würden hier lauter Einsen rauskommen,
nicht mit die liefern hier natürlich dann immer nur Nullen,
weil die gar nicht aktiviert sind.
Nicht also dann die Art und Weise,
wie man sowas dann also technisch macht,
weil sonst bräuchte ich natürlich hier noch irgendwie wieder ein Dekoder,
der dann also letztendlich sagt oder ein Multiplexer, der dann eben sagt,
entweder das soll rausgegeben werden oder das soll rausgegeben werden.
Den kann ich mir mit diesem Wired Or technisch gesehen sparen,
dass das einfach dann eine Grund dafür.
Gut, das ist die Art und Weise,
wie man sich jetzt so ein Read-Only-Memory vorstellen kann,
so und bei, sorry.
So und wie gesagt, bei den anderen Varianten mit elektrisch
da noch Programmierer und so weiter
Ja, Rahmenspeicher, also das, was wir eigentlich als Hauptspeicher kennen,
steht dann als Akronym dann immer für random Access Memory,
Rom, wie gesagt, Read Only Memory.
Das ist eben eigentlich der Speicher,
der im Betrieb gelesen und geschrieben werden kann.
Typischerweise natürlich dann der eigentliche Arbeitsspeicher des Rechners für Programme und Daten.
Da habe ich auch keine Arthrons und sonstigen Effekte,
aber ich muss eben Versorgungsspannung anhaben,
um meine Werte zu speichern
Auch der ist in der Regel in so einer zweidimensionalen Matrix irgendwie technisch gesehen angeordnet.
Auch da sieht es so aus, ich habe eben,
was ich hier schon gesagt habe, eigentlich einen ganzen Satz von Adressbits,
da wird dann eben letztendlich ideell quasi der Speicher dekodiert.
Auch da habe ich dann eben über den Dekoda zwar auch
eine Wortleitung und dann eben pro Wort so und so viele Bits,
was man meistens allerdings hat, ist,
dass das dann nicht beim 64-Bit-Rechner Es waren 30 oder 64 Bit breit ist,
sondern eben nur einzelne Bite und dann eben mehrere von diesen Speichern quasi parallel geschaltet hat und dann entsprechend größere Sachen auszulesen.
So, technisch gesehen wird da jetzt eben noch unterschieden bei den Speicherbausteinen.
Ist das ein ESRAM, ein Static Ram oder ist es ein DRAM,
ein Dynamic Ram? Das, was wir als Hauptspeicher kennen,
ist Im Prinzip ein dynamischer Speicher. Kommt gleich noch, wie das aufgebaut ist. Das,
was so ein Static-Ramm ist, ein statischer Speicher,
ist das, was dann eben noch ein bisschen zwar aufwendiger ist,
dafür dann aber eben deutlich schneller zugreifbar ist,
dass wir dann in der Regel sowas wie Cash-Speicher in den Prozessoren sein.
Und von der Idee her kann man sich eben so einen Rahmenspeicher eigentlich vorstellen,
wie so ein Array ausspeichernden Elementen, beispielsweise jetzt hier irgendwelche Ledges. So,
jetzt wird natürlich jetzt niemand sagen, okay, wunderbar,
jetzt habe ich also hier bei mir da einen Rechnerstrukturen gelernt,
wie man also irgendwie so ein Ledge aufbaut,
außer so und so viel Gattern,
die entsprechend zusammenschalten und dann könnte man also sich damit also irgendwie seinen Hauptspeicher aufbauen,
würde technisch natürlich funktionieren, ist aber unendlich groß und teuer und für,
sagen wir mal,
den gleichen Hardware-Aufwand kriegt man natürlich ein Vielfaches an Speicherleistung heutzutage und die will man dann natürlich dann also auch zunehmend haben.
Gut, wie gesagt, also Was hier dann eben jetzt nur ist,
ich habe ja Lese als auch Schreibe, Möglichkeit.
Auch hier ist aber im Prinzip wie beim ROM,
die Idee, dass man sagt, wieder im Raum,
dass man sagt, ich dekodiere quasi jetzt über die Adresse,
in diesem Fall sind das jetzt hier nur zwei Bit,
also irgendwie so eine Wortleitung,
habe dann eben mehrere von den speichernden Elementen Parallel geschadet habe,
dann eben auch wieder so einen Trick mit so einem Wired-Or für den eigentlichen Ausgang.
Und was sie jetzt eben nur noch mit hinzukommt, ist,
dass sich hier natürlich auch irgendwie Wert da reinschreiben muss.
Demzufolge gibt es dann so eine Leitung namens Wright and Able,
mit der ich zum Beispiel sagen kann,
diese Eingänge sollen jetzt also hier irgendwie reingeschrieben werden.
Und auch die gehen parallel,
genau wie die Ausgänge quasi an alle Ledges, aber nur das,
was jetzt also hier über den Adress-Dico da gerade als Leitung angesprochen ist.
Nur da werden sie aktiv Und nur da werde ich dann
eben entsprechend was reinschreiben. In diesem Fall,
also hier diesen Vektor da an, die entsprechende Stelle,
wenn ich das frei enable, dann quasi jetzt wegnehme,
hier eine andere Adresse anlege, bleibt das eben hier entsprechend gespeichert.
Und beim Auslesen habe ich natürlich sowieso nur einfach die Adressierung,
lese diesen Wert hier entsprechend aus. Gut,
das ist jetzt einfach nur das, was ich beim Rahmen mache,
dass ich dann eben technisch gesehen sowohl reinschreiben als auch rauslesen kann.
So und je nachdem, wie dieser Teil hier drin jetzt eben aufgebaut ist,
handelt es sich dann eben entweder um ein S-Rahmen oder um ein D-Rahmen.
Was man beim Hauptspeicher dann auch noch macht, ist,
weil man hat ja nun also doch ein bisschen mehr Speicher,
den man eigentlich adressieren möchte,
dass man Das kann es jetzt also quasi nicht nur in einer Dimension quasi hier in den Zeilen adressiert,
sondern dass man die Adressierung eigentlich in Zahlen und Spalten aufbricht.
Das heißt, man kann sich das ja so vorstellen, dass man sagt,
also von der Gesamtadresse wird ein Teil quasi in ein Zeilendekoda übersetzt.
Das heißt, damit kann ich dann eben hier irgendwie eine einzelne Zeile adressieren.
Ein Teil wird in ein Spaltendekoda, also in ein Multiplexer übersetzt.
Und hier in diesem Aray selber spare ich jetzt quasi nicht mehr
Ganze Wörter, sondern immer nur einzelne Bits. Das heißt,
wenn ich also in acht einen Weit adressieren möchte,
brauche ich dann eben entsprechend acht von diesen Strukturen,
wobei die Adressen natürlich dann bei allen identisch sind.
Und ich lese dann eben hier jetzt eben genau ein Bit,
was ich rüber adressiert habe, nicht aus dem Nächsten an,
also quasi das nächste Bit. Und der Trick,
warum mache ich das jetzt hier mit diesen Zahlen und Spaltendekodern,
dass man im Prinzip damit sagen kann, wenn ich das nicht machen würde,
müsste ich aus meiner Adresse, die ja entsprechend größer jetzt ist,
also beispielsweise 32 oder 64 Bit lang, ein, zwei hoch N-Bit-Dekoda bauen.
So, Dekoda haben wir schon kennengelernt,
ist im Prinzip noch nichts anderes als Pulsche Ausdruck,
Bulscheigebrach, kann ich dann eben entsprechend umrechnen,
kriegt dann also irgendeinen Ausdruck, wo ich dann sagen kann,
das Bit wird durch den und den Ausdruck in diesen Fall letztendlich eine Dekodierung des Binärwerts adressiert.
Wenn ich Das jetzt in Zahlen- und Spaltendekodierung umsetze, kann ich sagen,
beispielsweise die Hälfte geht jetzt also hier in die Zahlen,
die Cola, die andere Hälfte in den Spaltendekoda,
dass sich dann letztendlich diesen Dekoda natürlich jetzt nicht mehr nur halb so groß machen muss,
sondern der muss jetzt nur noch zwei hoch in halbe dekodieren
Nicht, weil, also der eine Teil ist ja Zahlen,
die Quoder da annotal sparen, Dekoder. Das heißt also,
wenn ich beispielsweise jetzt sage, hier habe ich,
nehmen wir mal, handliches Beispiel,
also ich habe jetzt eine 16-Bit-Adresse und hätte jetzt also nur diese Dekodierung,
dann müsste ich also quasi 2 hoch 16,
also sprich 65.500,
36 unterschiedliche Leitungen hier rausdekodieren
Wenn ich das in Zahlen und Spalten, die Quoda unterteile,
dann habe ich hier jetzt natürlich nur an dieser Stelle acht Bits
zu dekodieren und an dieser Stelle acht Bits zu dekodieren.
Das heißt, dann habe ich hier 256 und hier 256 zu unterscheiden.
Und das ist natürlich vom Hardware-Aufwand also deutlich einfacher,
nicht deswegen diese Unterscheidung in Zeilen und Spaltendekodierung beim Rahmen.
Gut, ja, was jetzt Unterschied zwischen Essrahmen,
D-RAM ist
Thema Bussysteme werde ich dann also am Freitag noch entsprechend vorstellen.
Ich denke mal, dass wir dann auch mit diesem Kapitel
dann noch so weit durchkommen, dass dann ab nächster Woche,
erst dann also um den eigentlichen Befehlssatz dann weitergehen wird.
Gut, Jan, damit soll es das für heute
gewesen sein, noch einen schönen Abend und bis Freitag