So, nach den üblichen Wackeleinen mit dem Videoausgang,
haben wir jetzt also endlich auch wieder Bild und Ton.
Ja, bevor ich jetzt mit dem Stoff der Vorlesung weitermache,
nochmal drei Ansagen in eigener Sache.
Zum einen muss ich mich für eine letzten Übungsaufgaben entschuldigen.
Da ist also bei uns was schiefgelaufen. Und da sind
wir dann also zu gehen und dann maßen erst heute Morgen
nach der Besprechung mit den letzten Übungsgruppenleitern auch irgendwie darauf gekommen.
Und zwar die Musterlösung, die sie jetzt ja nun zumindest auch schon haben.
Da gab es ja quasi jetzt hier in einem letzten Bogen,
der quasi jetzt diese Woche korrigiert werden sollte, also unter Aufgabe 8.1, wie viele tribulische Funktionen von viel Variablen gibt es? Für die gilt,
F.V. 0, X-2, X-1, 6.0 gleich F.V. 1,
X-2, 1, 6.0. Und das,
was dann also hier in der Musterlösung drin ist,
ist dann quasi als Ergebnis,
dass man eben die im Prinzip Dass man dort also die quasi zwei hoch zwei hoch en möglichen Lösungen,
die also in Aufgabe A gefragt waren,
dann quasi nimmt und rechnerisch durch zwei teilt, also sprich,
Ergebnis wäre dann zwei hoch zwei hoch en minus eins,
so rum geklammert, das ist das,
was da dort im Prinzip steht.
So, jetzt haben wir uns natürlich erstmal überlegt,
also im Prinzip dann also mit zwei Übungsgruppenleitern und ich.
Also wie kam das überhaupt erst mal begründen? Also dass
man da jetzt also irgendwie zu so einer Lösung oder sowas kommt.
Ich habe dann auch gesagt, naja gut,
also die Aufgabe hat sich, ein Kollege ausgedacht.
Ich habe den also auch nur so überlesen.
Ja, wunderbar, passt. Habe dann also auch hier
bei den Muster-Lösungen das so gelesen. Ja, passt auch
. Leider passt es nicht. Und der Kollege,
der also mathematisch nur auch noch irgendwie deutlich besser drauf ist,
als ich, hat das nur so auch zugegebenermaßen sich selber da also auch quasi an eine Falle gestellt,
weil also dieses Ergebnis also wirklich definitiv falsch ist.
Ich werde nochmal eine entsprechende Korrektur dazu, also auch explizit auf die Webseite stellen,
nur dass sie da Bescheid wissen. Ansonsten war auch noch,
sagen wir mal, die relativ pragmatische Aussage des einen Übungsgruppenleiters,
und das kann ich also hier auch schon mal so weit öffentlich machen,
also sowas wird in der Prüfung nicht gefragt, von daher keine Angst,
wenn sie das jetzt also hier irgendwie versuchen, dann irgendwie herzuleiten oder Sonstiges.
Ich komme gleich auf die Frage zurück,
ich wollte das jetzt noch mal kurz beenden, also das,
was ich dann nämlich auch gesagt habe, naja gut,
also rein pragmatisch gehen wir das doch erstmal so an und sagen, irgendwo in den Eigentor.
So, irgendwo hier in den Unterlagen,
in Kapitel 5 habe ich das ja mal für den Fall,
mit zwei Variablen, wo man dann sagt, okay,
erstmal ohne diese Einschränkung habe ich zwei hoch,
zwei hoch N, also sprich zwei, vier gleich,
16 mögliche Funktionen,
die also hier unten an also entsprechend alle aufgelistet sind und da kann man jetzt natürlich dann quasi A für erstmal gucken,
Welche würden jetzt rausfahren oder welche bleiben eben übrig unter dieser Bedingung?
Das ist auch das,
was also da der Kollege dann also in seiner Übungsgruppe dann
letztendlich einfach nur durchgerechnet hat und wenn man das also hier an diesem Beispiel sich mal überlegt,
kommt man dann also jetzt bei diesem Aufgabenzettel letztendlich auf vier,
die dann von den 16 über euch bleiben und eben nicht acht.
Also sprich durch zwei geteilt, das, was diese falsche Musterlösung suggeriert. Und die richtige Formel ist,
wobei ich da jetzt also auch noch nicht die hundertprozentige Begründung dafür liefern kann,
wäre dann eben, dass man sagt, das,
was da eigentlich rauskommt, ist dann also etwas,
was dem entspricht,
als ob ich einfach eine Variable weniger habe.
Also sprich zwei hoch zwei hoch in minus eins.
Was bei dieser Aufgabenstellung dann also, sprich heißt,
zwei hoch zwei hoch drei oder zwei hoch acht,
also dem zufolge dann 256 Ergebnisse.
Gut, also das nur soweit zur Korrektur oder als Anmerkung
Wenn man sagt, das, das bringt mich niemand mehr.
Ich merke, das hat mich anders einfach ausprobiert.
Das heißt, wenn eine Eisenbohle, das teilt mich nicht.
Ich merke, dass der in meinem Bullenbullen, das ist doch eine Zeit.
Das ist im Prinzip so, dass es nicht die Seite ist,
die man zeigt, diese vateriale wirkt sich nicht besser.
Ja gut, also das ist eigentlich auch das,
wie man das so als Begründung nehmen könnte. Also dass man eben sagt,
okay, wenn ich Wenn die Variable Null ist,
also irgendwie eine Funktion habe und die genau das Gleiche liefert,
wie wenn die Variable 1 ist.
Nicht, dass ich dann eben einfach sagen kann,
ja, dann tue ich ihm also so,
als ob diese Variable überhaupt nicht da ist, weil die immer das Gleiche liefert.
Und dann lande ich dann eben genau bei diesem Ergebnis, wo ich dann eben einfach eine Eingangsvariable weniger habe. Gut,
ja, das als erste Anmerkung für heute,
dann als zweite Anmerkung, da muss ich jetzt auch noch sagen,
also jetzt bei dem kommenden Übungsblatt Nummer 10,
was heute um Mitternacht beziehungsweise, nein, also schon vorher,
also sprich irgendwie heute gegen 14 Uhr,
online gelandet ist, sieht es so aus,
dass also in den späteren Aufgaben teilen, also 10,
3 und 10,
4 im Prinzip Stoff dran ist,
den ich heute noch nicht präsentieren werde.
Also auch da kann ich mich jetzt erstmal nur für entschuldigen.
Normalerweise sollte es ja sein,
also Stoff wird gebracht und Dann kommt erst die Aufgabe dazu.
In dem Fall wird das so aussehen, dass sich das,
also am Freitag vorstelle. Gut, angesichts der Tatsache,
dass dann ja also im Prinzip Weihnachten und Silvester ist,
ist das jetzt nicht ganz so tragisch.
Deswegen, es bleibt dann immer noch genügend Zeit,
auch zwischen den Feiern und Weihnachtsessen, um die Aufgaben dann also,
sagen wir mal, zu lösen.
Und von daher deswegen da die Ausnahme von der Regel.
Weiterhin sieht es so aus auf diesem zehnten Aufgabenblatt
Ist dann schon so ein bisschen als Vorbereitung auf das
übernächste Kapitel 15, wo es also um Assembler-Programmierung geht.
Also hier eine Aufgabe, wo im Prinzip dann also
ein C-Compiler auf dem Rechner installiert werden soll.
Dazu gibt es jetzt mehrere unterschiedliche Möglichkeiten. Also das Einfachste ist natürlich,
man hat ein laufiges Linux-System und kann sich dann also
die GCC-Tools sehen darauf installieren
Das ist jetzt natürlich auch nicht bei jedermann eine Sache.
Dann gibt es also die Möglichkeit zu sagen,
also wir machen das, weil die Sachen gibt es dann
also quasi auch angepasst und runterlagbar, also für Windows-Systeme.
Darüber könnte man das auch machen.
Dann als dritte Alternative hier nur kurz erwähnt,
man kann das auch einfach auf irgendwelchen Rechnern im Informatik-Rechenzentrum machen.
Die sind in der Regel
als Dual-Butrechner ausgestattet
Wobei Ubuntu 12.04 stimmt nicht, sondern die haben inzwischen ein, zumindest bei uns im Bereichen Zentrum, also ein 14.04 drauf. Wobei ich dazu gehen maßnah jetzt auch nicht ausprobiert habe,
inwieweit die da die 32-Bit-Version auch übersetzen können,
weil das ist etwas,
was ich dann nämlich auch für die Aufgabe empfiehlt,
weil also der Assembler für 32-Bit-Systeme und für 64-Bit-Systeme,
da sieht der Code dann hinterher unterschiedlich aus und da wird dann eben empfohlen,
ich deswegen hier also auch als Kommentar in dem Code,
dass man das dann also über entsprechende Kommandozahlen,
Parameter dann umschaltet, was aber eben nur geht,
wenn also auf den Rechnern auch das entsprechende Paket installiert ist.
Deswegen habe ich mir jetzt gedacht,
also als vierte Alternative habe ich eine virtuelle Maschine aufgesetzt,
die im Prinzip hier also aus der Auf der Rechnerstrukturseite,
dort bei den Unterlagen, wenn man da also entsprechend weit runterscrollt,
finden sich da jetzt also nicht nur die Vorlesungsskripte.
Und also auch hier Anmerkung zu diesen Assembler-Sachen in Kapitel 15,
auch mit den entsprechenden Verweisen zum Beispiel,
was sich da jetzt unter Windows installieren kann und so weiter.
Sondern da sind dann also auch Dateien, wo dann also
ein entsprechendes relativ kleingemachtes Linux-System als virtuelle Maschine installiert werden kann.
Und das sollte eigentlich auch so aufgesetzt sein,
dass es also sowohl mit den Virtualisierungs- und mit der Virtualisierungssoftware von VMWare läuft,
als auch mit der Virtualisierungssoftware von Virtual Box.
Beide kann ich sowohl unter Linux als auch Windows im Prinzip laufen lassen,
sodass man sich da dann auch relativ schnell dann,
also sagen wir mal, zu so einem System kommt.
Da sind dann auch alle notwendigen Tools drauf installiert und das soll dann
eigentlich so out of the box Für die ganzen Beispiele,
beziehungsweise für das, was dann also vielleicht noch zur SML-Programmierung kommt, laufen.
Nicht das habe ich dann noch so ein bisschen Anmerkungen und so weiter beschrieben,
also das ist dann etwas, wo man sich dann also vielleicht auch jetzt noch,
wenn man spielfreudig ist, dann also über die Feiertage mit vergnügen kann.
Gut, das war jetzt eigentlich das,
was ich also vorneweg nochmal hatte, dann wollen wir jetzt also hier zum Rechnerarchitektur. Wieder normal zum Vorlesungsstoff. Ich hatte jetzt ja quasi noch als Komponenten vorgestellt letzte Woche,
das, was man eben braucht und dann wirklich so ein komplettes Rechnersystem aufzubauen,
dass man eben sagt, okay,
ich habe jetzt eben neben meinen Elementen in der Hierarchie,
mit denen ich jetzt also entsprechend sowas wie Register,
Alu und so weiter aufbaue,
dann eben noch irgendwelche Speichersysteme, die ich brauche,
hatte ich dann eben schon kurz vorgestellt und dann eben Bussysteme als Entsprechende Verbindung und hatte dann also im Prinzip hier aufgehört mit dieser Folie,
wo es also im Prinzip dann nochmal so um die etwas historisch gesehen Entwicklung beim Adressbus,
bei den Intel-Prozessoren ging,
wo man also quasi früher mal mit 20 Bit angefangen hat,
mit einem relativ kleinen Adressraum und inzwischen also eigentlich bei 64 Bit ist,
wo ich dann eben auch sage,
ich bin dann also jetzt nicht mit 4 Gigabyte Hauptspeicher beschränkt
Ja, hier eigentlich auch nur kurz, um sowas mal zu zeigen oder vorzustellen.
Also bei dem Bussystem wird dann eben immer noch unterschieden.
Also hier zum Beispiel ist bei so einem Speicherbus zwischen synchronen und asynchronen Bussen. Bei synchronen Bussen,
so wie das hier der Fall ist,
habe ich eben sowas wie irgendwie so ein Taktsignalvieh,
wo ich dann eben sage,
mit beispielsweise der steigenden Taktflanke setzt jetzt also ein System,
was jetzt also beispielsweise vom Speicher lesen will,
also irgendwie eine Adresse an mit der fallenden Tag Flanke gibt es dann also quasi ein Memory-Request und sagt,
ob Lesen gelesen oder geschrieben werden soll.
Ich bin mit der nächsten starkenden Tagflanke verarbeitet, der Speicher,
das dann setzt dann, also letztendlich sowas wie so ein Wade-Signal,
was also nicht nur wie hier in diesem Beispiel so was
wie eine Periode dauern kann, sondern eben auch deutlich länger.
Ich hatte ja letztes Mal auch gesagt,
also gerade so bei S-RAM-Speicher ist es eben so, dass da teilweise intern,
also aufgrund dieser Refrash-Mechanismen da eben auch noch zusätzliche Zeitbedingungen mit reinspielen.
Und das ist dann etwas,
wo dann also quasi der Speicher-Baustein auf diese Anfrage,
es soll was gelesen oder geschrieben werden kann,
eben sagen kann, okay, ich habe verstanden,
aber ich bin noch nicht so weit und erst,
wenn der Speicherbaustein quasi jetzt mit einer steigenden Flanke hier wieder DNH setzt,
kann also hier mit der nächsten Rückflanke dann quasi jetzt der Prozessor beispielsweise die Daten lesen.
Wie gesagt, also die Zeiten,
die hier möglich sind oder eben wie die einzelne Abfolge ist,
dass es dann eben wirklich von Speichertechnologie zu Speichertechnologie oder eben auch von dem Bussystem abhängig.
Nicht, also die ist ja so einfach nochmal so ein bisschen veranschaulichen,
wie dann, also gerade sowas wie solche Timing-Diagramme dann letztendlich gelesen oder interpretiert werden können.
Im Gegensatz dazu gibt es dann eben noch sowas wie Asynchrone,
Zugriffe, wo ich jetzt eben keinen Takt habe,
sondern wo ich dann also zum Beispiel als Kommunikationshilfsmittel sowas habe,
wie also irgendwie Master-Synchronize und Slave-Sim-Connize, wo dann eben quasi ausgehandelt wird,
dass, wenn der jetzt eben von 1 auf 0 geht,
hat der Master, der ist also beispielsweise was lesen möchte,
alle notwendigen Informationen vorher bereitgestellt, nämlich Speicheradresse,
soll gelesen oder geschrieben werden.
Und irgendwann nach dieser Rückflanke wird quasi der Slave das jetzt intern verarbeiten,
wenn dann eben die fertigen Werte bei sich bereitstehen hat,
wird er dann eben quasi als Aknowledge dann eben hier seine eigene Leitung auf Null ziehen.
Das ist dann eben die Information für den Master,
dass da so irgendwie gültige Daten sind,
die dann also quasi gelesen werden können
Nicht das nur, als dieses Beispiel, synchron, asynchron,
dann hatte ich letztes Mal ja auch schon ganz kurz angedeutet,
Busabetriebung, das ist dann eben letztendlich die Fragestellung,
wenn ich jetzt nicht nur ein Master oder eine Quelle habe,
die jetzt also irgendwie auf den Bus zugreifen möchte,
wer darf überhaupt.
Und da gibt es dann eben auch viele verschiedene Konzepte von
irgendwelchen zentralen Einheiten, die das dann machen,
wo man sich dann also auch noch verschiedene unterschiedliche Strategien ausdenken kann.
Nicht, wo ich dann eben sage, ich habe,
was weiß
ich,
fünf verschiedene Geräte
Jedes von denen hat dann eben irgendwie eine bestimmte Priorität.
Das Gerät fragt dann quasi, wenn es Zugriff auf den Bus haben möchte,
beim Busmaster nach, gibt dann eben quasi ein entsprechendes Request.
Und der sagt dann, okay,
wenn jetzt ihm gleichzeitig Requests von zwei Geräten ankommen,
das mit der höheren Priorität,
darf eben als erstes oder man macht das mit irgendwelchen Zeitscheiben,
Verfahren oder mit irgendwelchen Tokens, wo dann eben auch der Reihe nach,
also an die Geräte irgendwie was weitergeleitet wird.
Also da lassen sich eben auch
sehr viele sehr unterschiedliche Strategien ausdenken
Genauso gut kann man das auch asynchron, dezentral machen,
wo es dann eben Protokolle gibt, wo dann die möglichen Geräte, die was auf den Bus schreiben wollen, untereinander aushandeln, wie das aussieht. Wo sowas ganz gerne gemacht wird,
ist, also bei irgendwelchen sehr einfachen Lokosbussen,
beispielsweise sowas wie Iquadrat Cebus, also ein Kommunikationsbus,
den man also gerne in Computern oder in irgendwelchen einfachen Geräten anwendet,
nicht also was weiß ich,
wenn ich die Steuerung des Autoradios bei mir am Lenkrad habe und da jetzt also irgendwie so über so ein paar Wippen rauf sagen kann,
lauter, leiser, rauf, runter,
nicht dann wird das in der Regel irgendwie über einen Ü-Quadrace-Bus kommuniziert,
weil das so ein relativ einfache Sachen mit so einem Zwei-Leitungspaar oder zwei Leitungen ist,
über die das Ganze dann läuft,
da muss man dann eben nicht zig Kabel ziehen und da ist eben im Protokoll dann Hals und Mechanismus,
dass also quasi, wenn jetzt mehrere Geräte was senden wollen,
die einfach alle gleichzeitig anfangen zu senden,
dann aber auf dem Bus feststellen, wird jetzt dort das übertragen,
was ich sende oder würde er was anderes übertragen.
Die Burste sind dann eben elektrisch so aufgebaut, dass es da,
also jetzt quasi nicht zu irgendwelchen Kurzschlüssen kommen kann,
sondern dass man dann eben nur feststellen kann, okay,
also das ist das, was ich sende oder das ist was,
was ein anderer sendet.
Und in dem Fall, wenn ein anderer gewonnen hat,
ja gut, dann habe ich Pech gehabt,
dann schalte ich eben meine Sendung wieder ab und warte dann
eben in irgendeine bestimmte Zeit, versuche es dann nochmal.
Das ist also das, was in diesem I-Quadracegus-Protokoll zum Beispiel drin ist.
Nicht, dass es dann eben sowas wie so eine Kollisionserkennung
Was man dann bei dieser Busarbeitrierung dann auch oft hat,
dass also irgendwelche IO-Geräte häufig höher priorisiert sind als die CPU.
Auch das ist eigentlich eine Sache, wo man sagt,
na gut, was soll das eigentlich?
Nicht CPU ist für mich immer das Wichtigste.
Schließlich soll das Ding ja möglichst viel möglichst schnell rechnen.
Häufig sieht es aber eben immer so aus,
dass gerade Datentransfer, also sprich vorn Festplatte zum Hauptspeicher oder
irgendwie sowas,
die CBU ausbremst
Da ist es dann eben auch so,
dass also die Rechnerarchitekturen eigentlich so aufgebaut sind,
dass solche Datentransfers unabhängig von der CPU über eigene Controlle-Einheiten stattfinden können.
Und die CPU, solange sie jetzt noch mit ihren Daten aus internen Cash-Speichern rechnen,
kann er nämlich unabhängig von diesem Datentransfer weiterrechnen kann.
Deswegen diese andere Priorisierung. Gut,
hier nur so Grafik wie im Prinzip dann so eine Busarbeitrierung aussehen könnte,
nicht was man hier auch sieht, ist,
dass es da dann also teilweise noch mehrere Parallellaufende
Busse gibt und so weiter und so fort.
Also das ist letztendlich dann aber nichts
Spezialisten. Gut, hier nur noch mal kurz aufgelistet, so einige unterschiedliche Busprotokolle.
Also das ist hier von so einem entsprechenden Wikipedia-Artikel dann einfach nur kurz mal rausgegriffen,
wo man dann eben auch sehen kann, wie da eigentlich die unterschiedlichen Anforderungen sind,
eben von sehr einfachen Sachen, wie er ist 2,3,2, serielle Schnittstelle.
Das ist das, wie also früher, sagen wir mal,
Geräte an Computer angeschlossen wurden, eben über solche einfachen Nikoracebus,
USB-Busse bis zu ihm irgendwelchen Hochgeschwindigkeitsbussen,
mit denen also quasi Eine oder mehrere CBUs auf dem Rechner miteinander beziehungsweise direkt mit dem Speicher verbunden sind,
wo man dann eben mit entsprechend auch relativ hohen Datenübertragungsraten arbeiten kann.
Gut, hier auch nur noch mal so als Beispiel,
was inzwischen eigentlich auch eher historisch ist,
PCI-Bus, steht dann für Peripheral Component, Interconnect,
ursprünglich mal so ein 33 Megahertz, 32 Bitbus,
was also damals für die Prozessoren dann quasi der Standardbus war,
um jetzt also von der PC PPU aus,
jetzt irgendwelche Erweiterungskarten, also sprich Grafikkarten oder sowas, anzuschließen.
Nicht im Laufe der Zeit gab es dazu dann eben auch Erweiterungen,
also auf größere Wortbreiten, höhere Taktfrequenzen und so weiter und so fort.
Das PCI-Bus gibt es heute im Prinzip immer noch,
also auch wenn das jetzt also in entsprechenden Erweiterungen mit PCIX und technisch gesehen auch nicht mehr dem ursprünglichen PCI,
wo es entspricht, war also PCI X beziehungsweise PCIE sind dann eigentlich wieder Punkt zur Punktverbindung, aber logisch sind das dann immer noch Busse.
Gut, und das kann man sich dann eben,
also das ist jetzt hier so Screenshot von etwas,
was sich ja immer auf dem Laptop gemacht habe,
nicht wo man sich dann eben mit so einem LSPCI,
also List, PCI, dann also auf dem Rechner einfach mal ansehen kann,
welche Geräte da drin hängen und da dann eben drin steht,
wie die jetzt beispielsweise irgendwie in den Speicherbereich eingeblendet werden.
Das hatte ich also ja auch am Freitag schon kurz angesprochen,
das, was man gerne bei dem Rechnersystem dann eben auch macht,
dass man jetzt nicht spezielle ein Ausgabebefehle hat,
wo ich dann sagen muss, also ich habe einen speziellen Prozessorbefehl,
damit spreche ich die Grafikkarte an und ich habe einen speziellen Prozessorbefehl,
damit spreche ich irgendwie das Gerät an,
weil das Ganze lebt ja davon, dass ich also im Prinzip über Einsteckkarten,
also vielleicht noch irgendeine andere Schnittstelle oder irgendwas nachrüsten kann,
sondern das Ganze wird dann eben quasi über so ein Memory-Map-Mechanismus,
über normale Lade- und Speicherbefehle in den Gesamthauptspeicherbereich eingeblendet.
Und das ist eben das, was man dann also hier sieht, Memory Ad.
Nicht, wo dann also beispielsweise jetzt hier also das Grafiksystem
sich gegenüber der CPU dann einfach wie normaler Speicherbereich ausgibt.
Und das ist dann eben für relativ lange Liste dann eben für alle möglichen Geräte.
Also hier einmal so in der grafischen Übersicht,
wo ich dann alles mögliche mir da anzeigen lassen kann
Gut, hier, auch nur von diesem PCI, was Nomazon Timing,
Diagramm, aber werde ich mir jetzt mal schnell überspringen,
weil wie gesagt, das ist nicht interessant,
das wird auch nicht weiter abgefragt, weil das ist etwas,
das guckt man sich aus Datenblättern raus,
wenn man es braucht und ansonsten geht man davon aus,
dass es hoffentlich funktioniert.
Hier auch nochmal zum Beispiel jetzt für so eine relativ einfache Schnittstelle,
hatte ich ja auch schon gesagt, er ist 2,
3, 2, ursprünglich eben wirklich so aus den Anfängen der Computertechnik,
um jetzt also relativ langsam irgendwelche externen Geräte einzubinden,
was dann also auch teilweise über deutlich längere Leitungen noch möglich sein sollte.
Deswegen hat man hier also ursprünglich da so mit Spannungspegeln von plus minus 12 Volt gearbeitet.
Inzwischen gibt es also auch standardmäßig eben mit,
was weiß ich, 0 und 5 Volt, funktioniert eben auch.
Und sagen wir mal so, alte Mäuse,
alte Drucker und sagen wir mal ältere Computer haben dann eben
auch noch eine serielle Schnittstelle, über die man da gehen kann.
Und da gibt es dann eben unterschiedliche Protokolle mit unterschiedlichen Übertragungsgeschwindigkeiten.
In der Regel sieht das aber immer so aus,
dass man sagt, ich habe eben quasi sowas wie so
ein Standard-Play Pegel 1. Nicht irgendwann kommt dann ein Startbett.
Das heißt, da geht dann also diese Spannung auf Null runter. Anschließend,
je nach Art des Protokolls, dann eben ja in der Regel acht Nutzbits,
die dann eben einfach hier der Reihe nach entweder eins oder null sind,
dann auch optional dann noch sowas wie eine Parität und dann eben noch ein Stoppbild.
Das heißt, da geht der Pegel dann definitiv wieder auf eins. Und das ist ein Empfänger,
wenn er jetzt eben weiß, ich arbeite mit irgendeiner bestimmten Übertragungsgeschwindigkeit,
ach, Datenwitz, keine Parität und ein Stoppbit würde er dann eben quasi,
wenn er jetzt also dieses Signal hier empfängt,
quasi diesen String hier raus interpretiert haben oder übertragen haben.
Gut, dann suchen wir jetzt eigentlich zu den Bussen
auch nochmal eine Erweiterung oder Ergänzung zu etwas,
was diejenigen, die jetzt also schon im Praktikum sind,
denke ich mal schon kennengelernt haben, werden.
Zumindest heute Morgen hatte ich das also bei den Übungsaufgaben dann teilweise schon sowas in der Richtung mitgesehen.
Was dann aber eben auch noch als Ergänzung zu dem ist,
was sie dann also im nächsten Kapitel Struction, Set Architecttion dann auch noch vorkommen wird.
Und zwar die sogenannte Mikroprogrammierung. Da geht es im Prinzip darum,
dass man endliche Automaten, also das,
was also im Kapitel 12 vorgekommen ist,
jetzt nicht über Beschreibung mit Übergangstabellen beziehungsweise jetzt mit irgendwelchen Grafen macht und das dann also jetzt also direkt in Form von Logikminimierung implementiert,
sondern dass man den Automaten dadurch macht,
dass man im Prinzip ein Programm C oder ein Register als
Zähler hat und ein Speicher häufig einfach als Rick Only Speicher mit dem man dann eben abhängig von einer Zähleradresse sagen kann, das Wort wird ausgelesen.
Und in dem Wort steht dann quasi jetzt die nächste Adresse,
beziehungsweise stehen dann irgendwelche Steuerleitungen für den Rechner mit drin.
Wie sieht das Ganze aus? Oder wie kann man
sich das vorstellen? Also hier habe ich nochmal,
also die ist inzwischen schon oft genug strapazierte Beispiel von der Ampelschaltung,
wo ich also quasi jetzt hier über diese Zustände der Reihe nachlaufe.
Und das kann ich eben dadurch machen,
dass ich also hier in so einem Rom drinstehen habe,
also hier vorne vier Einträge,
nämlich für die vier Zustände
Dann in dem gespeicherten Wort,
das sind quasi jetzt die drei Bits für die Ausgänge und
hier dann eben nochmal zwei Bits für den Folgezustand,
wo ich dann eben quasi einfach hiermit mit diesem Mikroprogramm zähle eine Adresse anlege,
also beispielsweise null, lese dann eben raus,
der nächste Zustand hat die Adresse 1 und die Ausgänge sollen eben 0,
0 und 1 liefern.
Mit dem nächsten Takt wird dann quasi die 1 hier als Adresse reingeladen.
Ich adressiere in diese Zeile und habe dem zufolge dann an
den Ausgängen 0-1 und 1 und habe dann eben hier schon wieder als Folge,
an zwei drin stehen und so weiter und so fort nicht.
Und so kann man also quasi hiermit dann eben auch so einen Automaten letztendlich direkt implementieren.
Wo man sowas jetzt eben ganz gerne benutzt,
ist dann eben jetzt wirklich in Rechnerarchitekturen,
wenn ich jetzt also zu einem Befehl wo ich jetzt sage,
also beispielsweise addiere mir den Inhalt von dem Register,
mit dem Inhalt von dem Register schreibe, das Ergebnis irgendwo hin.
Das Ganze jetzt in mehrere Schritte aufteilen muss,
um jetzt eben zu sagen,
ich möchte erstmal den Inhalt von dem Register irgendwo hinladen,
möchte mir das noch irgendwo hinladen, mach das,
wo dann also quasi intern jetzt für die Abarbeitung dieses einen Befehls auch noch mehrere Takte vergehen.
Das wird dann eben in der Regel mit solchen Mikroprogrammen gemacht
Und was man da dann eben auch entsprechend mit reinbringen kann,
das ist hier also auch nochmal an diesem Ampelbeispiel mit skizziert ist,
dass sich da dann eben auch sehr schön und sehr einfach
so was wie irgendwelche Verzweigungen oder Sprünge implementieren kann.
Also ich habe hier quasi meinen Zustand, Current,
habe dann hier abhängig von einer Eingangsvariablen zwei verschiedene Folgezustände oder ich habe hier noch irgendwie einen Sprung,
also auf irgendeine externe Adresse und das lässt sich eben auch hier direkt implementieren,
indem ich also quasi jetzt hier zu meiner Zeile,
die ich also mit diesem Select adressiere,
jetzt quasi zwei Felder für diese unterschiedlichen Folgezustände habe,
hier noch irgendwelche Ausgänge.
Und dann eben über Multiplexer auswähle, welche von denen hier genommen
werden sollen oder hier auch noch über einen Multiplexer auswählen kann.
Es soll dann eben irgendwie eine Adresse von außen genommen werden.
Und damit lassen sie sich dann relativ einfach zu Verzwagung
und bedingte Sprünge dann eben auch wirklich so in die Rechnerhardware
direkt hinein implementieren
Wo man sowas zum Beispiel braucht, also jetzt hier auf den folgenden Folien, ist nochmal so ein bisschen was zum Rechnerarchitektur von dem Armprozessor, also ein kleiner Mikrocontroller. Nicht,
dass man eben auch sagt,
also ich habe hier im Prinzip in so einem Speicher meine Befehle drin,
nicht über diese Befehle,
wird dann also hier nochmal dekodiert, die verschiedenen Steuerleitungen,
die dann also wirklich in der Hardware physikalisch dann ankommen und habe dann also hierüber über diesen Cycle Count dann,
also so eine Mikroprogrammierung, wo ich dann eben sage,
wenn ich einen Maschinenbefehl habe,
der jetzt eben in mehreren Teilschritten abgearbeitet wird, wenn ich dann läuft,
dass quasi hier über diese Schleife letztendlich mit ab,
wo dann eben erst mal verschiedene Talschritte gemacht werden,
bis dann der nächste Befehl neu geladen wird und das Ganze dort dann wieder von vorne anfängt.
Gut, hier auch noch mal aus diesem Buch,
das ist also von Förber Arm, System on Chip Architecture,
nicht wieder also ein typisches kleines Minimalsystem aussieht, also sprich,
ich habe hier also CPU irgendwelchen Rahmenspeicher, eine Ausgabe,
Controller und dann eben hier noch über, gegebenenfalls irgendwelche Schnittstellenbausteine dann Ein- und Ausgabeeinheiten mit angeschlossen.
Hier auch nochmal dargestellt,
wie dann also im Prinzip sowas wie so eine Alu aussieht,
nicht, dass also nochmal rückgreifend auf Kapitel 11 im Prinzip,
wo wir also auch schon Alus gesehen hatten, nicht,
also hier auch so klassisch, dass man sagt,
okay, ich habe hier meine Register für die beiden Operanten,
habe dann also hier so eine Recheneinheit,
um jetzt Addition und Subtraktion zu machen,
habe dann hier parallel noch eine zweite Rechnerinheit für logische Funktion über entsprechende Dekodierung des Befehls,
wird dann eben entweder hiermit oder hiermit was gemacht.
Nee, und ich habe dann mit diesem X-Org hat dann eben noch die Möglichkeit,
quasi jetzt für karithmetische Operationen daraus dann quasi so was wie ein Komplimentbildung zu machen,
indem ich dann also quasi das Wettweise invertiere und in Carry-In hier reinschiebe,
nicht, dann kann ich damit also quasi hiermit so eine Art Zweier-Kompliment direkt bilden,
beziehungsweise hiervon dann genauso nicht.
Oder ich kann dann eben auch noch einzelne Witze jetzt
bei irgendwelchen logischen Funktionen kippen
Dann gibt es dann sowas wie so eine Registerbank,
wo ich dann eben viele unterschiedliche Register, also in diesem Fall 32 Stück,
dann eben auch noch ansprechen kann und sagen kann,
von diesen 32 Registern kann ich dann eben beispielsweise zwei auslesen und in eins hineinschreiben.
Nicht insgesamt hat man dann eben letztendlich so eine Struktur,
wo ich dann eben wirklich sagen kann,
ich habe hier als internen Speicher meine Registerbank,
ich habe hier eine Alu, noch eine spezielle Hardware-Multiplikationseinheit,
habe hier mein Adressregister, um jetzt den Speicher anzusprechen,
Inkremente zusätzlich noch zu der Alu um, ist also sowas wie ein Programmzähler,
aufzuzählen und habe dann eben hier jetzt noch für den Datenbus ein- und ausgaberegister.
Und darauf lassen sich dann, wenn das jetzt also quasi geeignet,
zeitlich unterteilt, wo dann eben letztendlich alle Befehle abarbeiten,
nicht also als Beispiel, wenn ich sowas sage,
wie ein Datentransfer von einem Register, ein anderes Register,
wenn ich das jetzt also als Maschinenbefehl hätte,
nicht was muss passieren,
also erst mal kommt das Befehlswort hier in das entsprechende Befehlsregister rein.
Nicht, das heißt, das wäre dann hier mein Befehl,
der wird dann eben entsprechend von dieser Instruction,
die Code-Einheit quasi interpretiert, wurde vorher hier über das Adressregister adressiert.
Anschließen wir dann mit dem Tag quasi hier der Befehlszähler
inkrementiert und hier in das Register zurückgeschrieben und aufgrund dessen,
was ich hier rauslese, sage ich dann eben, ich nehme hier
Zwei Registerwerte, kann damit jetzt also irgendeine Alu-Operation machen und schiebe
das Ergebnis dann eben wieder in ein anderes Register rein.
Wenn ich dann sowas wie irgendwelche Emediate-Werte habe, das heißt,
in dem Befehl steht dann eben ein numerischer Wert,
mit dem gerechnet wird, nicht,
also auch das lässt sich dann eben alles auf diese Blog-Hardware-Struktur irgendwie abbilden,
nicht und je nachdem, welche Datenfahre ich hier schalte,
nicht, also ob das jetzt,
also die sind wie hier oder die sind wie hier,
kann man dann eben die unterschiedlichen Befehle letztendlich abarbeiten
Nicht, dass wir dann sowas wie Speichern von Werten in den Hauptspeicher,
da wird das Ganze jetzt also quasi noch zweigeteilt,
nämlich also zum ersten habe ich jetzt hier das Lesen von dem Speicherbefehlen.
Gleichzeitig wird dann also der Programmzähler wieder inkrementiert, abhängig von dem Speicherbefehl
habe ich in einem Register die Adresse, in die gespeichert werden soll.
Diese Adresse wird dann gegebenenfalls noch mit einem Offset,
der auch hier in diesem Befehl ist, dann also quasi noch verrechnet.
Das heißt, da kann ich dann eben noch wie so
ein Inkrement, Dekrement oder was auch immer noch mitmachen.
Anschließend landet das Ganze hier im Adressregister und im nächsten Schritt
habe ich dann eben die Adresse in die gespeichert werden soll.
Hier adressiere damit also quasi den Hauptspeicher, lese aus dem Register
quasi jetzt den Wert, der dann eben dort reingeschrieben wird.
Das ist dann also quasi jetzt dieser Pfad und gleichzeitig gibt es dann also hier noch die Möglichkeit,
sowas wie so ein Indexregister raufzuzählen und für den nächsten Befehl,
der dann folgen wird, wird der Programmzähler dann wieder in das Adressregister geladen,
weil ich jetzt ja natürlich nicht mehr Speicheradresse zum Lesen hier drin stehen haben möchte,
sondern wieder für den nächsten Befehl den Inhalt von dem Program-Counter.
Also das nur so zur Abarbeitung von Befehlen auf irgendwie so eine Hardware nicht und das,
was dann eben letztendlich der Trick ist, ist,
dass man jetzt eben immer über entsprechende Belegung von irgendwelchen Kontrollleitungen für die Einheiten hier bzw. Steuerleitungen für irgendwie diese Datenpfade,
damit dann eben genau diese hier dunkel gezeichneten Teile dann letztendlich auch geschaltet werden,
dass man darüber dann eben sagen kann,
wie die Befehle dann letztendlich,
also in dieser Hardware oder einer anderen Hardware-Struktur dann wirksam wären.
Und das ist dann eigentlich das, was dann,
also letztendlich diese Schnittstelle ausmacht bei der Befehlsabarbeitung,
wenn ich dann eben sage, ich habe jetzt so von neunmal Konzept,
wo ich dann sage, Befehl holen, Befehl dekodieren,
abarbeiten und so weiter.
Gut, hier Beispiel Funktionsaufruf oder Sprungbefehlen,
also auch da sieht man,
das kriegt man eben entsprechend
auf diese Hardware abgebildet
Gut, dann abschließend, jetzt hier zu dieser Rechnerarchitektur,
wir rechnen an Rechner oder wie läuft das Ganze dann eben wirklich so rein praktisch?
Da kann man eben sagen, gut, also das,
was ich eben hier schon so ein bisschen skizziert habe,
ist, dass man eben bei dieser Abarbeitung von dem Verneumern-Konzept sagt,
ich habe eine gegebene Hardware-Struktur, die ist fest.
Ich habe dann eben über irgendwelche Steuerleitungen, über irgendwelche Möglichkeiten im Mikroprogrammierung,
wo ich dann also mit Multiplexern auswähle, die Daten,
die an die Alu rangehen, von da oder von da kommen.
Die Möglichkeit, das Ganze dann eben entsprechend so zu schalten,
dass sich dann eben entweder den Datenfahrt hier rüber oder darüber quasi habe.
Und was dann eben noch hinzukommt, ist,
dass man dann die Abarbeitung der einzelnen Maschinenbefehle gegebenenfalls dann
eben auch noch in mehrere Teile wieder unterteilen muss.
Nicht, was hier also in diesem Beispiel dann also auch schon ganz kurz rauskam.
Gut, diese ganzen Sachen oder diese ganzen Konzepte werden dann
also beispielsweise dann auch an diesem, Einfachen.
Klein Beispiel dann in einem Rechnerstrukturenpraktikum dann also auch noch ein bisschen weiter vertieft,
wo man dann eben wirklich mal sieht, wie jetzt also so ein ganz einfacher Befehl ist,
als auf so einer gegebenen Hardwarestruktur dann eben letztendlich abgearbeitet werden kann. Nicht,
weil sonst muss man immer sagen, gut, das,
was ich jetzt hier vorstelle und oder jetzt erstmal hier nur vorstelle und das,
was also auch in dem Praktikum ist, ist natürlich,
also die ist ganz einfache, minimale von Neumann-Konzept,
nicht, wenn man sich jetzt aktuelle Rechnerarchitekturen ansieht,
dann habe ich da doch einiges an Abweichung davon, nämlich zum einen,
dass jetzt nicht nur jeder Befehl einzeln der Reihe nach geholt wird,
abgearbeitet wird.
Und dann kommt der nächste Befehl,
sondern man arbeitet mit etwas, was dann Pipelining ist,
wozu ich dann in Kapitel 16 noch kommen werde,
wo dann im Prinzip diese einzelnen Phasen quasi überlappend ausgeführt werden.
Nicht dann haben aktuelle Rechner mehrere Ausführungseinheiten. Also alles,
was ich hier gezeigt habe und auch das,
was also im Praktikum benutzt wird, da gibt es eben eine einzige Alu.
Nicht inzwischen kann man eben sagen, auch auf dem Intel 3,
86 von vor 20 Jahren gab es schon also drei Indiger-Recheneinheiten
und eine Fließkomma-Recheneinheit und also auch da kann ich eigentlich schon
mehrere Befehle quasi innerhalb einer CPU parallel machen.
Das, was wir jetzt ja eben auch noch haben,
ist, dass ich dann natürlich nicht nur eine CPU habe,
sondern dass ich dann also auch noch Architekturen habe,
wo ich dann also auch gleich vier oder acht
oder noch mehr Kerne,
also in einem Ship drin habe
Nicht, dann kommen da noch so Sachen mit rein,
dass also quasi die Abarbeitung heutzutage teilweise auch so ein bisschen anders abläuft als das,
was sich hier jetzt immer so vorgestellt habe.
Und ja, Auswirkungen der Speicherhierarchie, also getrennte Daten,
instruktionsspeichern und sowas werden wir uns also dann auch am Ende der Rechnerstruktur und Vorlesung da noch ein bisschen genauer begegnen, wo ich dann also da dann auch nochmal auf die Themenstellung hier eingehen werde. Gut,
ansonsten kann man sagen, so ein ganz einfaches System,
Nicht, wenn ich jetzt sage so klassischer Rechner,
kann man sich erst mal so vorstellen,
also dass sie aus dem Buch von Bryant und Roheiler Ron,
nicht ich habe hier sowas wie meine CPU,
die hat jetzt also irgendeine Schnittstelle, externes Interface,
als eigentliche Recheneinheiten, Alu,
ein Satz von Registern und dann eben diese ausgewählten Register wie Program Count,
da Instruction Register und vielleicht noch ein paar andere und gut,
je nach Art der CPU,
also ob das jetzt ein X86 ist oder Armprozesse oder was weiß ich wie,
sind ja dann eben hier intern entsprechend anders aufgebaut.
Ich lerne mal typischerweise dann über irgendwelche Busse,
Verbindungen zum Hauptspeicher und über ein Ausgabebusse, also beispielsweise was wie PCI-Bus,
dann Verbindung eben zu irgendwelchen externen Geräten beziehungsweise weiteren Controllern.
Und wenn ich jetzt also im Prinzip ein Programm ausführe,
wie stellt man sich das vor nicht?
Also ich setze mich hier hin, tippe also irgendwie in meiner Kommandozeile Hello,
Und gleichzeitig muss ich erst mal davon ausgehen,
dass es diesen Befehl Hello gibt. Das heißt also,
im Kontext des Betriebssystems habe ich also irgendwie so ein ausführbares Programm namens Hello,
also auf meiner Festplatte gespeichert, würde das dann eben so aussehen,
dass also quasi jetzt diese Information von dem Programm,
was mir jetzt also quasi mein Terminal oder meine Shell aufmacht,
dann also letztendlich verarbeitet wird.
Das heißt also dann irgendwie durch die CPU geht dann,
also hier spare ich ja dann dafür sorgt,
dass das Ganze dann irgendwie ausgeführt werden soll.
Nicht, dann muss es quasi im nächsten Schritt das Betriebssystem dafür sorgen,
dass dieses ausführbare Programm in den Hauptspeicher geladen wird,
bevor es gestartet werden kann. Und anschließend,
wenn das dann eben dort ist,
wird es dann also quasi als Programm gestartet,
läuft auf der CPU und erzeugt dann also beispielsweise dann also
auf dem Display,
also irgendwie die Ausgabe von dem klassischen Hello World
Wenn ich das nur so ganz grob als Idee,
wie jetzt also erstmal so die Schritte zur Programmabarbeitung sind,
am Ende des übernächsten Kapitels,
wo es dann also im Prinzip so um Assembler-Programmierung und diese Sachen geht,
komme ich da dann also auch nochmal so ein bisschen drauf zurück,
weil also zum Beispiel dieser Mechanismus,
was passiert, wenn das Programm ist,
also wirklich einen Speicher geladen und zur Ausführung gebracht werden soll,
da hängt dann eben auch noch einiges mit dran,
weil dann eben zum Beispiel,
also sowas wie irgendwelche Adressen umzurechnen sind,
was da noch passiert
Hier auch nur ganz kurz skizziert. Boot-Prozess, was passiert
eigentlich beim Ein Einschalten des Rechners? Ich weiß auch,
da ist immer nicht so eine ganz triviale Frage,
wobei ich da nordlich, also gerade drüber gestolpert bin,
dass mich dann also ein Kollege mal gefragt hat,
ja, was ist denn jetzt eigentlich,
wenn ich also jetzt so eine aktuelle CP oder einen aktuellen Prozessor habe,
der ist also nicht nur eine, sondern mehrere CPUs hat.
Wie kriegen die denn synchronisiert? Also gibt es da eine,
die dann jetzt Master ist oder fangen die alle gleichzeitig an,
das Betriebssystem zu laden? Das kann ja auch nicht hinhauen.
Also da auch noch so ein bisschen sinniert. Also es gibt dann also wirklich explizit eine, die dann also erstmal startet. Nicht aber ansonsten,
selbst wenn ich jetzt nur eine habe,
auch da sieht das natürlich erstmal so aus,
dass im Prinzip irgendwelche festverdrahteten Hardware-Einheiten,
also in diesem Fall ist also irgendwo der Chipsatz für alle ICs sowas wie Reset-Signale generieren und dafür sorgen,
dass also wirklich alles was an Hardware drauf ist,
was also so rein funktionell,
kann man sich das immer wie so einen endlichen Automaten vorstellen,
die alle erstmal also auf irgendeinen Initialzustand gesetzt werden,
also was weiß ich, alle Register,
wo es benötigt wird, erhalten eben den Wert Null.
Oder sowas wie ein Programm-Counter wird mit irgendeiner Startadresse initialisiert und
unter dieser Startadresse liegt dann also das eigentliche Bootprogramm bzw.
der Bootloader
Nicht. Und dann wird eben ganz normal Befehlszyklus gestartet.
Der Prozessor greift darauf zu, liest dann eben dieses Blutprogramm nicht,
was dann also vom Rom oder eben jetzt irgendwo,
also aus dem Flash-Speicher des Motherboards dann also entsprechend kommt.
Nicht, dann geht eben erst mal sowas wie die Initialisierung los.
In der Regel gibt es dann noch irgendwelche Selbsttestmechanismen,
wo also überhaupt erst mal geguckt wird, ist der Prozessor richtig verbunden.
Funktioniert das alles? Nicht, dann sorgt das Programm dafür,
dass also alles, was dann also irgendwann Zwischenspeichern ist,
also auch zuverlässig gelöscht wird.
Nicht nur wird der Chipssatz konfiguriert, geguckt,
welche Komponenten habe ich also auf dem Rechner drauf, die werden gegebenenfalls initialisiert.
Und anschließend kommt dann eben erst das Laden des Betriebssystems,
was sich dann eben sukzessive dann so hochhangelt. Ja,
also auch das nur so ganz grob skizziert mit den Einzelschritten,
weil das dann eben auch wirklich immer sehr stark hardwareabhängig ist,
was nicht dort also dann im Einzelnen tut
Gut, jetzt mit dem folgenden Kapitel Instruction, Set Architecture. Sag mal,
sind wir eigentlich jetzt so an dieser Stelle,
wo man jetzt sagt,
wir haben uns jetzt also hier mit dem Rechnerarchitekturen schon so langsam nach oben hin vorgearbeitet und sind jetzt also schon noch nicht bei der Softwareentwicklung oder bei der Software angekommen,
aber zumindest also einigermaßen weit auf dem Weg dahin,
nicht weil angefangen hatte ich also jetzt wirklich erstmal mit irgendwelchen Grundlagen Zahlendarstellungen und Sonstiges nicht,
dann gibt es so ein bisschen, wenn man jetzt sagt,
ich möchte wirklich ein Rechnersystem aufbauen und implementieren,
wie sieht das mit Bulciaage, Braun und Logik aus.
Nicht darüber sind wir dann eigentlich zu Automaten gekommen.
Nicht sowas wie hier dann Data Path and Control.
Und wenn man das Ganze dann jetzt eben wirklich so hierarchisch zusammenbaut mit diesen Blöcken,
die wir jetzt also im Prinzip im letzten Kapitel haben,
wo man dann eben sagt, okay,
ich habe hier sowas wie Registerfall,
ich habe eine Alu,
ich habe Programmzähler,
irgendwelche Teile da
Nicht dann habe ich hier eigentlich jetzt,
also irgendwo so meine Hardware drauf und darauf aufbauend gibt es dann eben das,
was dann als Asstruction Set Architecture oder eben Maschinenbefehlssatz eigentlich gilt,
dass man eben sagt, okay,
das sind eben die elementaren Befehle für einen Prozessor oder für eine Prozessorklasse,
die dann eben entsprechend abgearbeitet werden können, die dann mit diesen Befehlen,
die dann eben auf der Hardware wirklich physikalisch abgearbeitet werden können,
kann ich dann eben mein Betrieb Tiebsystem letztendlich implementieren,
beziehungsweise kann man darauf aufbauen, dann eben meine eigentlichen Benutzeranwendungen starten.
Das heißt, das, was dann so als Maschinenbefehlssatz,
oder wenn ich das jetzt hier im Englischen immer als ESA oder Struction Set Architecture bezeichne,
was sich da dahinter verbirgt,
ist dann eben wirklich diese Schnittstelle von irgendwelchen Hardware-Komponenten zu dem,
was dann eigentlich darauf aufbaut,
dann also an Software,
also irgendwo aus dem Assembler
letztendlich herausfordert
Gut, man kann immer sagen, inhaltlich, das ist eigentlich alles,
was das also wirklich jetzt für den Programmierer oder in diesem Fall
jetzt für eine Systemprogrammierer an Attributen eines Rechners wirksam wird.
Nämlich einmal irgendwie sowas wie so eine konzeptionelle Struktur,
also sprich grob so eine Vorstellung,
welche Funktionseinheiten habe ich und wie spielen die miteinander zusammen.
Und war es dann natürlich jetzt im Sinne der Programmierung interessanter ist,
dass ich eben sage, welche Syntax, welche Semantik steht dahinter?
Das heißt, Wie kann ich Speicher ansprechen?
Wie ist er organisiert? Welche Datentypen habe ich zur Verfügung
? Wie sind die einzelnen Datenwerte oder Worte entsprechend kodiert?
Wie wären sie intern im Rechner dargestellt? Weil also irgendwie
gespeichert werden die ja also als 32 oder 64 Bit Folgen von Nullen und Einzelnen.
Aber wie muss ich die jetzt entsprechend interpretieren?
Nicht dann, welche Befehle habe ich zur Verfügung?
Wie sind diese Befehle aufgebaut? Und wenn ich da dann
eben irgendwelche Zugriffe auf Befehle oder auf Daten mache,
was funktioniert da? Was funktioniert oder wie arbeitet das System,
wenn ich sowas wie ein Interrap, also eine Ausnahmebehandlung habe.
Was passiert da dann im Rechner nicht? Und all das zusammengenommen,
entspricht dann eben eigentlich dem, was man dann immer so als Instruktionssatz hat.
Ja, hier auch nur so eine Grafik,
also aus dem Patterson Henderscene, man kann sich das immer vorstellen,
also unten drunter habe ich irgendwie die Hardware,
von der können wir jetzt so langsam abstrahieren.
Ich habe dann als Schnittstelle diesen Instruction Set und darauf
tummelt sich dann eben die Software,
die dann eben wirklich jetzt, also die Funktionalität liefert,
mit der ich in der Regel als Informatiker dann eher
zu tun habe
So, wenn man sich ansieht,
was verbirgt sich dann alles hinter der Instruction Set Architecture.
Einmal Speicher. Wie ist er aufgebaut? Welche Wortbreite?
Wie wird er adressiert? Wie sieht der Rechner intern aus?
Das heißt, wie viele Register habe ich zur Verfügung?
Habe ich überhaupt Register? Ich kann rechnen auch mit dem
Stack aufbauen. Auch dazu folgen dann gleich noch Beispiele.
Mich dann bei den Registern Art, Anzahl,
dann der eigentliche Befehlssatz innerhalb des Befehlssatzes,
welche Operanten gibt es da?
Wie sind die Befehle aufgebaut
Was kann ich mit den Befehlen machen? Kann ich jetzt
mit wem Befehl auf einen Speicher zugreifen oder kann ich jetzt
also eben nur auf Register zugreifen?
Dann eben zu den Daten, wie werden die dargestellt?
Hier dann also auch nur zwei Stichworte,
die dann das auch gleich im Folgenden noch genauer beleuchtet werden.
Nicht dann eben diese Sache Ein- und Ausgabe,
wie ist das gemacht und letztendlich dann so ein bisschen weiter über den Teller ranschauen,
also welche Systemsoftware habe ich zur Verfügung?
Das heißt also, wir sehen dann sowas wie Loader Assembler
Dann eben schon Compiler on Debugger aus. Das ist dann etwas,
also dieser Teil der Sanasa am Beispiel, ja,
32, also x, 86 Koten, 32 Bit-Architektur,
dann also nochmal so ein bisschen an die Assembler-Programmierung ranführen wird.
Gut, das,
was ich jetzt vorstellen würde in der Vorlesung sind halt,
gerade nachher bei der Assembler-Programmierung, also x, 86,
also zum Beispiel für eigentlich eine Cisk-Maschine Cisk steht für Komplex Instruction, Set Computing.
Werde ich auch noch kurz darauf eingehen, was das jetzt ist.
Im Gegensatz zu Risk, Reduced Instruction Set Computing,
wo ich dann also den MIPS-Prozessor noch kurz vorstelle und
im Praktikum wird dann mit auch einem Prinzip einer Client-Sisk-Maschine,
also mit dem Decore gearbeitet.
Das ist dann eben so ein Demo-Rechner, 16-Bit-Wortbreite,
wo man also sieht,
wie das Ganze im Prinzip
rein praktisch aussehen kann
Gut, hier auch nur grob angedeutet. Eigentlich das,
was man so als Vielfalt von Prozessoren hat oder im Prinzip zur Verfügung hat,
was wir in der Regel alles immer gar nicht wahrnehmen,
weil inzwischen kann man ja auch sagen,
es gibt um Größenordnung mehr Rechner oder Rechen der Einheiten jetzt bei irgendwelchen eingebetteten Systemen,
die wir dann eben gar nicht so wahrnehmen,
als das,
was wir jetzt immer als Rechner bezeichnen,
nämlich also sprich irgendwie Desktop,
Lab Propo
Irgendwelche Server, irgendwelche Großrechner, was auch immer. Nicht,
weil, im Prinzip kann man eben sagen,
also von Telefonkarte über irgendwelche Haushaltsgeräte, Mobiltelefon,
Auto bis zu irgendwelchen Medizingeräten oder sowas, alles hat.
Also inzwischen nicht nur eine CPU,
also irgendein Mikro-Controller oder irgendwelche Spezial-Hardware, sondern eben Signalprozessoren,
beliebige Kombinationen davon und inzwischen kann man eben sagen, gut,
da ist ein Auto, Klassischer Mittelklasse-Wagen ist man so bei knapp 100 Controllern,
die da also darin verbaut sind.
Für alle möglichen Systeme, Subsystem und da musst du jetzt noch nicht sagen,
ich habe jetzt also die volle Ausstattung mit WLAN-Ananschluss und sonstigen,
sondern also wirklich ein normales Einfaches, Standard-Auto.
Die ganzen Dinger dann eben auch mit teilweise so unterschiedlichen Prozessoren. Ich war so,
da brauche ich da nicht zwingend irgendwelche High-End-Rechenwerke mit riesen Wortbreiten und 64 Gigabyte Speicheradressierung,
sondern da hat man dann eben wirklich von ganz einfachen vier Bild Prozessoren,
dann bist du eben, ja, typischerweise inzwischen auch schon 1632-Bit-Prozessoren.
Nicht aber meistens weniger Speicherausstattung, dann auch je nach Aufgaben fehlt,
mehr oder minder viel, wobei man das also auch nicht unterschätzen soll.
Also ich habe in einer anderen Vorlesung zu allen gebetteten Systemen also rausgesucht,
so eine Folie von Philips gefunden,
wo die also über die Jahre mal aufgezeichnet haben, was sie also in ihren Fernsehern so an Software inzwischen drin haben. Und inzwischen kann man sagen,
okay, so ein aktueller Fernseher und das muss jetzt noch nicht das neueste 4K-Modell sein,
hat also Größenordnungsmäßig dann also schon 4 Gigabyte Software darin und ein Mehrkernprozessor,
der, was weiß ich, was eben entsprechend alles kann,
weil gut, ich denke,
das können wir ja nun teilweise auch schon außen eigenen Umfeld,
man natürlich jetzt inzwischen auch schon sagt, okay,
das ist eben nicht nur der nackte Fernseher,
sondern man kann nicht eben auch ins Internet,
kann auch irgendwelche Medien streamen,
kann mich da über WLAN eben auch noch irgendwie mit anderen Sachen verbinden und so weiter und so fort.
Und da steckt dann eben schon einiges drin. Wie ich dann hier auch nur angedeutet,
Es gibt dann eben auch noch sehr unterschiedliche Anforderungen nicht,
also wie sieht das aus mit irgendwelchen Sachen, die man als Echtzeitfähigkeit bezeichnet,
nicht also sagen wir mal bei der Telefonkarte völlig schnurzi,
wenn ich jetzt also hier sowas wie einfache,
ein Ausgabegeräte habe, ist das also auch alles nicht kritisch,
nicht wenn ich sowas wie also hier irgendwie die Airbergsteuerung vom Auto nehme,
dann möchte ich eben garantieren, dass also innerhalb von,
was weiß
ich, zwei Millisekunden das Ding eben auch entsprechend auslöst und zündet,
nicht und dann wäre es schlecht, wenn das jetzt nur gerade nicht passiert weiß,
also irgendwie auf der CPU im Betrieb, das Betriebssystem sagt,
ich muss jetzt hier gerade mal so ein bisschen Speicherbereinigung machen oder sowas
. Also deswegen gibt es da eben sehr unterschiedliche Anforderungen,
genauso dann eben auch in der Sicherheitsanforderung,
wo man dann eben auch sagen kann, Nee,
habe ich, muss ich da jetzt also irgendwie,
welche Sicherheit einbauen, was definiere ich als Sicherheit,
nehme ich sowas wie Betriebssicherheit, dass das Ding überhaupt erstmal funktioniert.
Wenn ich bei solchen, sagen wir mal,
lebenswichtigen Sachen, medizintechnik oder eben überlebenswichtige Systeme im Auto,
da findet also wirklich bei jedem Staat,
also ein Selbstteststart und wenn da festgestellt wird,
das Ding funktioniert nicht, dann kriege ich also zumindest,
also zumindest im Auto oder sowas wie eine Warenleuchte,
die dann sagt, also was weiß ich,
das ESP funktioniert jetzt gerade nicht,
mit raus
Ich kann Sicherheit, aber natürlich auch definieren und sagen,
mit Sicherheit meine ich jetzt nicht nur sowas wie die technische Sicherheit,
also das System funktioniert oder funktioniert nicht,
sondern damit definiere ich dann also Anforderungen,
wie schütze ich das System gegen Angriffe von außen?
Also da möchte man ja auch nicht,
dass sich jemand anders jetzt irgendwie sagt, okay,
ich programmiere hier mal so ein bisschen Funkempfang und das,
was ich dann also hier mit meinem Türöffnerfunk Funkschlüsseln mache,
kann jeder andere dann eben auch machen.
Und dann macht er uns, schwuppt das Auto,
dann per Laptop-Fernbedienung auf und kann sich da dann also
irgendwie daran bedienen, das möchte man natürlich auch nicht.
Oder wie sieht das aus mit Sicherheit hinsichtlich der Software,
dass die vernünftig arbeitet, dass die nicht verfälscht wird.
Also da gibt es eben viele sehr unterschiedliche Anforderungen,
die da also letztendlich alle mit reingehen,
was also hier nur so ein paar Sachen sind,
die jetzt also hier unten mit aufgezählt werden.
Gut, das nur noch mal so ein bisschen so aus als Ausblick
eben auf das, was dann eigentlich so klassisch eingebettete Systeme sind.
Wir bleiben jetzt hier also bei der stumpfen, einfachen Computertechnik,
beziehungsweise da eben auch bei den einfachen Grundlagen erstmal,
nicht und als etwas, was es da erstmal immer begegnen wird,
ist dann eben die Frage nach der Organisation des Speichers.
Wie adressiere ich Speicher? Welche Wortbreite, wie ist so organisiert
? Das sind also im Prinzip jetzt hier alles Themen,
die jetzt also gleich auf den folgenden Folien noch angesprochen werden und
Später dann in einem Kapitel zur Speicherhierarchie geht es dann eben noch um so was wie Cashes,
die man heutzutage eigentlich auf aktuellen Rechnersystemen auch unverzichtbar braucht, weil ohne die würde Pipelining nicht funktionieren können.
Auch das werde ich dann nochmal entsprechend motivieren. Nicht an solche Sachen wie virtueller Speicher. Und eben,
wenn ich es eben mehr kann, Prozessoren haben,
wie halte ich den Speicher synchron zwischen diesen Prozessoren,
und auch da gibt es dann eben entsprechende Protokolle,
beziehungsweise Ideen, wie man das machen kann,
wie man da darauf achten kann, dass man sagt, okay,
wenn ein Prozess jetzt also mit irgendeinem Datum rechnet und sich das aus dem Speicher geholt hat,
anderer Prozesse jetzt aber auch damit irgendwie rechnen möchte,
nicht, wie kriege ich das, also entsprechend synchronisiert,
dass ich da jetzt, also mit den Inhalten nicht auseinanderlaufe,
sondern über entsprechende Kohärenzprotokolle dafür sorgen kann,
dass die Daten dann eben auch entsprechend immer gültig multig sind,
beziehungsweise meinetwegen dann der zweite Kern einfach nur weiß, okay, er kann damit jetzt nicht rechnen, sondern muss warten, bis das richtige Ergebnis wieder zurückgeschrieben wurde oder sowas.
Gut. Einfachste Fragestellung jetzt erstmal überhaupt beim Speicher.
Wie ist da aufgebaut? Das heißt, welche Datentypen habe ich
zur Verfügung? Und typischerweise sieht das eben so aus,
dass man im Speicher jetzt nicht anfängt,
irgendwie einzelne Bits zu adressieren, sondern zumindest erstmal beidweise zu arbeiten.
Das heißt also dann mit acht Bit zu arbeiten und das,
was dann eben an ich sag mal, normalen Datentypen hart,
weil man mit acht Bit natürlich dann,
also wenn man nicht so sonderlich weit kommt, sprich von 0 bis 255,
hat man dann eben entsprechend größere Wortbreiten, die dann eben logischerweise immer ein Vielfaches davon sind.
Dann, wie wird dieser Speicher adressiert, wie ist er organisiert?
Das heißt, wie sind dann die einzelnen Speicherzellen unterteilt,
wie kann ich dann eben an so eine Minimaleinheit von acht Bit rankommen,
wenn ich das adressieren möchte,
beispielsweise um Wenn ich jetzt also sowas wie eine Zeichendarstellung habe,
ein einzelnes Zeichen zu lesen.
Nicht und da ist es dann eben schon so,
dass man sagt, in der Regel arbeiten die Speicher eben immer beidweise.
Damit kann ich dann eben wirklich sowas wie gut Aski-Zeichen,
wenn jetzt nur 7-Bit, aber das eine ist dann eben geschenkt.
Wie kann ich dann eben letztendlich sowas wie so einzelne Zeichen
aus dem Speicher auslesen? Andererseits die Hardware selber,
wenn ich einen Speicher habe und jetzt ein einzelnes Speicherwort auslese,
das Speicherwort selber wird Logischerweise nicht nur acht Bit umfassen,
sondern also mit entsprechend größerer Wortbreite arbeiten.
Nicht, das heißt, sowohl der Prozessor, als er der Speicher sind,
in der Regel 32 oder 64 Bit Wortbreite, als das, womit sie arbeiten.
Wie kriegt man das dann eben entsprechend hin? Gut,
hier noch mal angedeutet, also überhaupt erst mal so. Organisationsform,
dass sie also aus dem Buch von Tarnbaum und Austin,
also in 96-Bit-Speicher, kann ich mir eben vorstellen, als zwölf mal acht Bit,
dann adressiere ich wirklich jetzt hier mit jeder Adresse ein einzelnes Bite.
Und das ist auch die Art und Weise,
wie man sich das eigentlich im Weiteren oder typischerweise bei Rechnersystem,
PC-Systemen eben auch immer vorstellt. Nicht hier dann andere Ideen,
acht mal zwölf Bit oder jetzt mit größeren Wortbreiten,
sechs mal 16 Bit und letztendlich alle diese möglichen Anordnungen haben jeweils letztendlich 96 Bit als Speicherinhalt.
Gut, hier auch noch mal kurz in die Historie gegangen.
Ich sag mal, ganz früher war es eben wirklich so,
dass man sowas wie einzelne Bits pro Speicherzelle angesprochen hat.
IBM-PC und das ist auch das,
was heutzutage noch alle Prozessoren zumindest konzeptuell machen,
ist man immer mit eine wirklich breit weisen Adressierung dabei,
das heißt mit den 8 Bit,
nicht aber früher und auch gerade so in der Zeit der Großrechner hatte man also beliebige andere Wortbreiten,
teilweise auch mit wirklich irgendwie ganz krumm werden,
weil da jetzt noch irgendwelche Prüfsummen und irgendwelche Informationen für Verwaltungssachen da noch mit drin waren.
Nicht deswegen, also hier solche relativ komischen Sachen. Wie gesagt,
heutzutage kann man sagen, Von der Idee her,
8-Bit, ein physikalischer mit etwas größeren Wortbreiten aufgebaut.
Nicht damit kann ich dann eben sehr einfach so was wie
irgendwelche Zahlendarstellungen, UTF 8, die ganzen Froating-Point-Formate realisieren.
Ich und wie gesagt, beim X86-Prozessor und der Pro-Mir-Sprache C
habe ich dann eben typischerweise sowas wie Unterteilung wie Byte Wort,
Double Word,
Quad Word,
also jetzt für die Entager-Datentypen
So, diese Wortbasierte Organisation des Speichers führt dann dazu,
dass ich von der Idee her sage,
mit den Adressen, also hier von 0 bis 16,
adressiere ich einzelne Bytes.
Im Speicher selber habe ich aber immer ganze Speicherworte.
Das heißt, wenn ich also sage,
ich rechne mit 32-Bit-Speicherworten und unterscheiden sich eigentlich die
wirklich physikalisch benutzten Adressen,
dann eben immer um den Offset
Beziehungsweise, wenn ich mit 64-Bit-Worten habe, arbeite,
umfasst, also quasi ein Speicherworte, dann auch immer achtbad.
Das heißt, demzufolge sind dann die Offsets dann noch immer jeweils um acht auseinanderliegend. So,
daneben kommt dann eben noch die Fragestellung, hier sieht man,
das ist das Ganze jetzt ja quasi immer so schön innerhalb dieser Speicherworte adressiert.
Wenn ich jetzt aber sage, ich habe Ein Speicher,
der wortweise mit 64 mit Wortbreite adressiert wird.
Und ich habe in diesem Speicher ein Integer,
der jetzt also beispielsweise nicht mit Longgenauigkeit gespeichert wird,
damit Nutzer von diesem Speicherwort, ja,
also jetzt nicht die 64-Bits, sondern eben nur ein Teil.
Und wenn ich jetzt eben beispielsweise anschließend ein Double Word habe,
also irgendwas, was dann also jetzt wirklich 64 mit benötigt,
geht das dann also jetzt hier über zwei Speicherworte oder lasse ich
diesen Teil frei und fange dann also hier wieder an dieser gültigen Grenze weiter an.
Also auch dazu kommt dann nachher gleich nochmal zum Beispiel Speicherzugriff,
ein kleines Beispiel, wo man sieht,
was sich dahinter verbirgt.
Gut,
die Folie bzw. die Folie und die nächste
Hatte ich ganz am Anfang, fast verjährt, Kapitel 5, Zahlen, schon mal aufgelegt.
Da ging es nämlich also genau um diese Sache,
nicht Datentypen auf Maschinenebene, wo man jetzt eben sagt,
wie sind Prozessor abhängig, beispielsweise jetzt die C-Datentypen jetzt auf Bytes abgebildet,
also Deck Alpha, das war so im Prinzip eigentlich der erste 64-Bit-Prozessor,
der Anfang der 90er Jahre rausgekommen ist.
Demzufolge habe ich dann also hier entsprechend
größere Wortbreite
32 Bild, Architekturen haben dann typischerweise diese Wortbreiten,
X86 als IR32 habe ich dann eben auch hier so klassisch diese Wortbreiten,
was man dann eben hier auch schon sieht,
dass eigentlich teilweise auch wirklich abhängig von dem Maschinen-Typ beziehungsweise dem Prozessor jetzt also irgendwelche Datentypen meiner Programmiersprache,
also nehmen wir hier also zum Beispiel sowas wie ein Pointer,
logischerweise unterschiedlich groß sind.
Also sprich, wenn ich ein 64-Bit-Prozessor habe, der als Adressraum 2 hoch 64 beinhalte,
dann ist eben eine Adresse auch 64 Bit lang.
Demzufolge brauche ich dann eben entsprechend 8 Byte. Wenn ich eine 32-Bit-Architektur habe,
ist ein Pointer dann aber natürlich nur 4 Byte groß. Und hier in dieser Folie,
die ich ja auch schon aufliegen hatte,
ist das Ganze dann eben noch mal ein bisschen weiter auf die Spitze getrieben,
wo man dann eben sieht,
jetzt eigentlich Abhängigkeiten sind eben nicht nur hinsichtlich des Prozessors da,
sondern Abhängigkeiten sind also auch noch hinsichtlich des Betriebssystems und des Verwendeten Compilers da,
sodass es eben sein kann, dass je nach Paillar,
ein Datentyp, unterschiedlich, viele Breits belegt.
Gut, in der Regel bei den Standardsachen, so was wie Integer,
habe ich da jetzt also nicht so die Unterschiede nicht.
Das heißt, es ist irgendwie auf dem 32-Bit-System sind die
halt eben immer entsprechend vier Byte lang nicht,
aber es kann dann eben wirklich bei einigen anderen Sachen da
eben schon entsprechende Unterschiede geben.
Also auch das nur als mögliche Anmerkung.
Eine Frage
Ja, du kommst aus dem Licht, nennen wir es Bettel.
Mit 64 Betteln sind wir nicht auf uns bereit zu sehen.
Also die Frage war jetzt, also kostet es jetzt mehr Rechenzeit?
Also 64 Bett-Systems zu verwenden, zu verwenden, statt eines 32-Bit-Systems.
Muss ich zugeben, weiß jetzt genau nicht,
also aus dem Bauch heraus würde ich jetzt sagen,
Das Ganze ist ja eigentlich von der Prozessorarchitektur abhängig.
Und da die ja dann also schon darauf ausgelegt ist und entsprechend
beispielsweise die Datenpfade in 64-Bit hat und beinhaltet, ist das dann eigentlich kein zusätzlicher Mehraufwand.
Das heißt also, da bin ich also egal,
ob 32 oder 64-Bit dann eigentlich mehr oder minder gleich schnell. Das einzige,
wo sich irgendwas auswirken kann, ist, dass man jetzt eben sagt,
hinsichtlich der Kotgröße habe ich dann also noch Unterschiede,
weil ich eben jetzt zum Beispiel sage,
wenn ich also jetzt irgendwelche Adressen habe beim 32-Bit-System,
sind die dann eben entsprechend vier Byte lang,
beim 64-Bit-System, also doppelt so lang,
dem zuvor kann es dann eben sein,
dass der Code beim 64-Bit-System größer wird.
Aber von der Abarbeitung,
da ich dann ja eigentlich immer den gleichen Wortbreite zum Speicher hin habe,
würde ich da jetzt also nicht sagen,
brauche ich jetzt also auf einmal irgendwie doppelt so viele Tage,
weil ich da also entsprechend mehr Code lesen muss,
sondern also die breiten Datenpfade sind ja da.
Aber da denke ich mal, also da kommen auch wieder viele Abhängigkeiten mit rein,
wo ich auch nur sage, muss man ausprobieren und da gibt es eben einige Effekte,
wo einiges dann schneller läuft, anderes vielleicht wieder langsamer.
Muss ich zugeben, weiß ich jetzt auch nicht. Und die Sache ist,
und das ist eben das Gemeine auch wieder so ein bisschen,
weil das ist also auch etwas,
was Dann jetzt also auch zum Beispiel bei den Assembler-Aufgaben dann noch so ein bisschen mit reinkommen wird,
wo ich dann deswegen auch nur sage mit der virtuellen Maschine 32 Bit,
ist dann für die Übungsgruppen leider ein bisschen einfacher,
wenn ich also Code für 32 Bit übersetze,
sieht er ganz anders aus,
als wenn ich ihn für 64 Bit übersetze.
Ich war also auch 64 Bit-System, dem Prozessor,
also auch noch mehr Register zur Verfügung stehen, anderer Registersatz und so weiter.
Und letztendlich in der Hardware ist es vorhanden,
nicht nur wenn ich dieses Compiler-Fleck für 32 benutze,
liegt die Hälfte der Hardware halt brach.
Da kann man auch sagen, ja, wieso eigentlich nicht?
Also dann, wenn die Hardware das liefert, dann will ich auf 64 Bild haben.
Deswegen stellt sich heutzutage die Frage eigentlich kaum noch.
Aber das sind eben dann wieder andere Sachen. Und gut,
da ich jetzt also auch nicht in diesem Kapitel Assembler Programmierung,
also jetzt sämtliche Beispiele umschreiben wollte,
weil dann also auf einmal irgendwelche Register zum Stackpoint oder zur Behandlung,
also auf einmal alle ganz anders heißen und dann teilweise da
also die Abläufe auch noch andere sind.
Nicht also das, was jetzt hier im Vorhinein
auch immer vorgestellt wird, ist ja wirklich so ein
minimal eingedampfter
Befehlsatz oder Wahlspiele, wo man sagen kann, also das,
was heutzutage eigentlich bei aktuellen Prozessoren, durch die Compiler-Optimierung damit reinkommt.
Nicht, da sieht man eben schon zu,
dass es also möglichst optimal das alles ausnutzt. Und da,
denke ich mal, wird dann eigentlich immer irgendwie mit 64-Bit-Code
gearbeitet und das dann also auch entsprechend passend optimiert.
Also ja. Gut, ja,
so viel zu dem Exkurs Fragestellung 32 mit 64. Also hiermit erstmal nur angedeutet,
es gibt dann eben ab Hinsicht dieser Wortbart dann eben auch noch entsprechende und da Schiede.
So, jetzt muss ich mal kurz gucken, wie wir
jetzt eigentlich leben. Das lohnt sich eigentlich nicht mehr.
Von daher werde ich deswegen die nächsten Sachen biete Order und
noch ein bisschen weiter zur Speicheradressierung dann auf Freitag verschieben,
weil das dann also teilweise auch noch wichtige Sachen oder also auch teilweise relativ wichtige Effekte sind,
den Mann in der Programmierung dann auch gerne mal begegnet oder über die man stolpert.
Deswegen übermorgen dann in Ruhe und für heute
soll es das gewesen sein und dann bis Freitag