So, ich hatte am Mittwoch ja mit dem Teil aufgehört,
wo ich jetzt, also sagen wir jetzt noch die fehlenden
Komponenten angefangen hatte zu erklären, die eigentlich jetzt fehlen,
um jetzt wirklich so eine komplette Rechnerarchitektur-Ardware-seitig aufzubauen.
Zum einen sind das dann eben jetzt irgendwelche verschiedenen Speicher,
also Rahmen,
beziehungsweise Rombausteine
Zum anderen das, womit ich jetzt also noch
kurz abschließen werde, sind das dann eben irgendwelche Verbindungsstrukturen.
Das heißt, typischerweise dann eben Bussysteme. Bus vom Begriff
her ist in dem Sinne jetzt eigentlich die elektrische,
beziehungsweise formal gesehen eigentlich eher eine rein logische Verbindung zwischen mehreren Geräten oder zwischen mehreren Blöcken innerhalb einer Schaltung.
Logisch, wie gesagt,
also da kann man sich dann auch mal drüber streiten,
da habe ich aber in gewisser Weise kann ich eben beispielsweise also auch irgendwelche Funkverbindungen
Zu so was dann auch noch mit hinzuzählen. In der Regel
habe ich in einem Bus dann also jetzt ein ganzes Bündel aus irgendwelchen Leitungen.
Datenleitung, Steuersignalen. Und typischerweise dann eben so,
dass man eben sowohl mehrere Sender hat, also mehrere Quälen,
die also quasi jetzt Informationen auf den Bus geben können und
eben auch auf der anderen Seite dementsprechend mehrere Empfänger.
Damit man da jetzt also nicht elektrisch zu irgendwelchen Kurzschlüssen kommt,
sind die dann eben über bestimmte Treiberschaltungen, also solche Treestate,
Treiber oder irgendwelche anderen Schaltungen miteinander verbunden.
Wobei, okay, das ist dann natürlich jetzt also auch wieder Schaltungstechnik.
Mit den mehreren Quellen, muss man jetzt sagen,
das ist immer so ein bisschen von dem Bussystem oder von der Art des Busses abhängig. In dem Bereich,
wo es also jetzt wirklich um sehr hohe Übertragungsraten geht,
also zum Beispiel jetzt Grafikspeicher zur GPU oder sowas oder das,
was also zum Beispiel jetzt einen aktuellen PC ist,
also sowas wie PCIE-Verbindungen sind,
sind Boostsysteme dann eigentlich typischerweise wieder eins zu eins,
Punktverbindungen, weil man sonst, ich sag mal,
also die hohen Übertragungsraten nicht hinbekommt,
nicht aber eigentlich von der Idee her hat man eben jetzt,
wie wir jetzt immer mehrere Quellen und mehrere senken.
Dann stellt sich natürlich das Problem, wenn ich jetzt also mehrere mögliche Komponenten habe,
die jetzt also irgendwie ihre Daten auf den Bus schreiben wollen, wer darf das?
Das Ganze nennt sich dann immer Busabitrierung, das heißt,
es gibt dann eben in der Regel eine Oder meistens eine zentrale Einheit,
also sowas wie ein Busmaster, der dann eben letztendlich entscheidet,
welcher Teilnehmer oder welcher Client darf senden, Wahn senden,
also das Ganze wurde dann dementsprechend synchronisiert, wie lange und so weiter.
Also wie gesagt, da gibt es sehr viel, je nach Art des Bussystems eben mehrere unterschiedliche Systeme und Protokolle. Dann kann man Bus eben auch noch unterscheiden,
Synchrone und Asynchrone verfahren, sprich gibt es in diesem ganzen Bündel von Leitung,
die er sitzt, den Bus darstellen,
eben noch so was wie ein zentrales Taktsignal,
womit dann also letztendlich synchronisiert wird,
waren datengültig sind oder läuft das Ganze asynchron in Form von irgendwelchen Handshake-Signalen,
wo halt eben der Sender jetzt eben beispielsweise sagt, okay,
ich lege jetzt, dass ich hier meine Werte auf den Bus,
gebe dann eben entsprechend dieses Signal an, dadurch,
dass dieses Signal sich jetzt ändert oder wechselt,
war es dann eben der Empfänger,
okay, dort sind gültige Daten,
nimmt die entgegen
Und wenn die verarbeitet worden sind, gibt er dann eben
ein entsprechendes Acnolege-Signal und dann weiß der Sende, okay,
jetzt kann ich neue Daten auf den Bus legen.
Aber letztendlich ist das alles davon abhängig,
welche Art von Bussystemen man dort, also wirklich hart beziehungsweise welches Protokoll.
Auch da geht es also hier jetzt in der Vorlesung eigentlich
nur darum, also grob diese Grundbegriffe vorzustellen.
Ansonsten wären wir da dann eigentlich nicht spezieller auf einzelne Busprotokolle eingehen,
weil nämlich auch da muss man immer sagen,
also da ändern sich die Standards dann doch immer vergleichsweise schnell
und es lohnt es also nicht
Also auch,
wenn jetzt hier nachher vielleicht noch irgendwie Folien oder Beispiele zum PCI,
wo es folgen nicht, wo man sagen kann,
okay, das war also vor zehn Jahren mal aktuell,
also inzwischen ist es irgendwie auch nicht mehr,
also deswegen soll das dann eigentlich nur so ein bisschen exemplarisch das nochmal kurz beleuchten.
Gut, typischerweise hat man als Brustsystem eigentlich sowas,
wie das also hier angedeutet ist,
nicht jetzt von der Grundidee von Neumann-Rechner,
ich habe meine CPU, ich habe irgendwo meinen Speicher,
hier jetzt also auch noch irgendwie aufgeteilt in Rahmen und Rom,
in der Regel sagt man eben erstmal irgendwie
nur Generellspeicher,
Irgendwie das Touchpad. So, dann eine Ausgabe,
Einheiten und vielleicht noch irgendwelche anderen Komponenten,
die also an dem Bus hängen und je nach Funktionalität
wird dann also zum Beispiel bei solchen von Neumann-Architekturen
dann eben entsprechend unterschieden zwischen Adressbus und Datenbus und häufig
hat man dann eben auch noch irgendwie irgendein ganzes Bündel von Kontrolleitung,
dann immer zu so einem Kontrollbus zusammengefasst.
Bei den Arten der Bussysteme kann man dann eben sagen,
okay, je nach Anforderung hat man sehr viele sehr unterschiedliche Typen.
Das kann also wirklich von höchsten Übertragungsraten, High-Performance-Bohrsysteme gehen. Also sprich,
wenn man also hier irgendwie am Geomatikum und Klimarechenzentrum, also sieht,
wie also jetzt also irgendwelche Großrechner aufgebaut sind, solche Cluster-Komponenten,
wo jetzt also im Prinzip einzelne Prozessoren oder beziehungsweise Prozesserknoten miteinander verbunden sind.
Nicht, da sind dort also spezielle große Systeme und Protokolle im Einsatz.
Das andere Spektrum sind eben möglichst einfache Protokolle mit möglichst billigen Komponenten,
die sehr einfach dann eben auch zu realisieren sind.
Also sprichst du im Bereich Gebäudeautomatisierung, nicht wenn man sagt,
also im Prinzip wieder Lichtschade und jede Glühlampe ist im Prinzip,
also irgendein Teilnehmer in einem Netzwerk und die kommunizieren jetzt eben im Zweifelsfall dann über irgendwelche aufmodulierten Signale,
die dann also im Prinzip ist, also einfach Wechselstromnetz,
also irgendwo auf der Phase noch mit drauf liegen und können sich dann darüber unterhalten.
Da kann man sagen, okay,
dann darf der jetzt natürlich in dem nicht schade jetzt,
also nicht irgendwie der Prozessor für 80 Euro drin sitzen,
sondern das Ding sollte dann also möglichst günstig sein,
da muss ja auch nicht viel können, aber ja,
das ist dann eigentlich dann, wie gesagt, die Sache dann mit den Sachen.
Gut, dann auch abhängig vom Bus, letztendlich,
wie sieht das eben aus mit Busmaster, also typischerweise in klassischen PC-Systemen,
kann man sagen, also die CPU kann Busmaster sein,
ansonsten hat man typischerweise noch sowas wie DMA-Controller mit drauf, also Direct Memory Access.
Da geht es eben darum zu sagen,
dass wenn ich also jetzt zum Beispiel von extern über irgendeine Inter rabt,
Daten habe, die sollen irgendwo abgenommen werden,
die landen typischerweise dann hier im Hauptspeicher, dann war es eben früher so,
dass also wirklich sämtlicher Datentrantransfer quasi nur über die CPU möglich war.
Inzwischen hat man dann eben quasi hiermit dran dann eben noch so eine zusätzliche Komponente,
die genau dieses hier macht und die CPU kann,
sofern sie jetzt also nicht selber hier noch irgendwo auf die
diese Sparicher beziehungsweise irgendwelche externen Komponenten darauf zugreift, dann eben einfach weiterrechnen.
Und dafür sind dann eben beispielsweise solche Multimaster-Fähigkeiten dann ganz sinnvoll.
Dann auch immer ein wichtiges Thema, wie sieht das mit Echtzeitfähigkeit aus? Also auch da kann man jetzt sagen, sehr unterschiedliche Anforderungen. Nicht wenn ich eben irgendwo ein System habe,
was mir jetzt also wirklich zartkritisch irgendwelche Sachen verarbeiten soll,
also nehmen wir beispielsweise jetzt Automotive-Bereich, irgendwie sowas wie ein ABS-System,
wo jetzt also quasi von den Radsensoren, also quasi die Umdrehungsinformation ankommt,
das Ganze geht dann eben irgendwie so typischerweise dann nicht auf den Kannenbus,
aber eben auch auf irgendwelche Busse,
soll dann eben hoffentlich dann eben auch in Echtzeit quasi verarbeitet werden,
sodass eben festgestellt wird, okay, Rad blockiert,
dem zuvor soll dort dort jetzt,
also Bremsdruck zurückgenommen werden oder das Auto fängt an zu schleudern,
ist so dann also quasi mit dem ESP gegengewirkt werden dann ist das etwas,
wo also wirklich innerhalb von Millisekunden, also die passende Reaktion erfolgen muss.
Da ist Echtzeitfähigkeit, also lebensnotwendig. Ich auf der anderen Seite,
wenn ich jetzt sage, okay,
ich habe jetzt also hier irgendeinen Streaming-Client im Wohnzimmer,
der jetzt also irgendwelche Daten aus dem Netz empfängt,
mir das Ganze jetzt also irgendwo auf dem Fernseher oder auf dem Monitor entsprechend ausgibt,
dann will ich jetzt natürlich sagen, okay,
ich will den Film also mit optimaler Qualität und ohne irgendwelche Ruckler sehen,
aber letztendlich ist es also erstmal nicht, überlebensnotwendig,
wenn jetzt also vielleicht mal,
also ein Teilbild also irgendwie ausfällt oder nicht komplett übertragen wird,
weil in der Regel werde ich das sowieso gar nicht bemerken,
sondern es wird dann durch irgendwelche Interpolationen dann wieder passend ausgeglichen nicht.
Also das heißt, da braucht man eben nur keinerlei Echtzeitfähigkeit.
Gut, dann, wie sieht das dann aus mit den Leitungen,
mit der Anzahl der Leitung? Nicht auch da kann man sagen,
also okay, so Allereinfachste Systeme, die Quadratcebus,
SPI, also ein Serial Peripheral Interface, Systemmanagement, Bus,
das sind also irgendwie Auch Bussysteme, die also auf billigste Fertigung, einfache Informationsübertragung dann nur ausgelegt sind.
Wo ich dann auch sagen kann, bleiben wir bei dem Beispiel Automotive nicht. Also ich möchte jetzt also irgendwie die Sitzhöhenfeststellung beeinflussen,
dann geht das also darum, also den Motor zu sagen,
also der sitzt so irgendwie noch ein Stück nach hinten oder raufgefahren werden,
wenn dann also eine Taste betätigt wird, auch da will man jetzt natürlich,
also jetzt nicht irgendwelche Glasfaserstränge oder was weiß ich,
welchen Aufwand im Auto betreiben,
sondern wir sollen also mit maximal zwei Leitungen dann eigentlich sämtliche Übertragungen,
also auch zu einem ganz einfachen Bus überfragen werden.
Also war in dem Fall dann ja also auch keine Mengen
an Informationen anfallen, sondern eben nur entsprechend wenig Sachen.
Gut, dann gibt es auch Anforderungen, Leitungslängen. Also auch da kann man sagen,
gut, also es ist von sehr einfachen kleinen Bussen,
also irgendwas, was jetzt nur innerhalb eines Prozessors stattfindet oder eben auf einer Platine im Rechner oder wo ich jetzt eben wie Isar Nett,
also über irgendwelche Gebäudeverkabelung, dann eben,
also mit maximalen Lagerungslängen pro Strang dann,
also irgendwie so von 120, 150 Metern,
also letztendlich arbeiten muss,
wo man dann eben auch schon entsprechend ganz andere Anforderungen hat.
Gut, und ich sage mal so,
als grobe Erweiterung hat ja auch schon gesagt,
also teilweise kann man dann sowas wie Funkmedien natürlich dann auch immer noch mit hinzunehmen.
Gut, in typischen Mikroprozessorsystemen hat man eben,
also war es wie Adressbussen, Busse,
Datenbusse, ich warte Reispussen, entsprechende Anzahl der Leitungen,
eben einen entsprechend großen Adressraum,
den man ansprechen kann
Nicht dann typischerweise noch so was wie Kontrollbusse,
wo dann eben, wenn das synchrone Bussesysteme sind,
so was wie ein Taktsignal drauf fliegt und dann eben irgendwelche Steuerleitungen,
mit denen ich sage, beispielsweise,
wenn ich jetzt eben an Hauptspeicher gehe,
ich möchte lesen oder ich möchte schreiben, wenn die Systeme miteinander kommunizieren wollen,
wo dann eben quasi über Wade-Signale noch gesagt wird, okay,
also jetzt sind überhaupt erst mal gültige Daten da oder eben noch nicht und so weiter.
Was man teilweise bei den Buslandern eben auch macht,
folgt auch gleich in dem Beispiel, ist Jabos noch kurz,
dass man um jetzt eben Leidung zu sparen,
dann eben noch so ein Multiplexing macht. Das heißt,
es gibt dann eben noch eine zusätzliche Steuerleitung und es wird dann eben umgeschaltet,
ob die Daten oder das Wort,
was also auf dem Bus übertragen wird,
dann eben quasi sowas wie eine Adresse ist oder ob das dann also die eigentlichen Nutzdaten sind.
Gut, als klassisches Beispiel von irgendwelchen einfachen Wohlsystemen,
nehmen wir also hier mal sowas wie Adressbus bei Prozessoren,
also Intel X
Architektur, weil das ist nämlich etwas, was da so bei Bonussystemen dann eigentlich auch häufig immer noch als wichtiges Argument hinzukommt, sowas wie Kompatibilität. Also hier sieht man das ja sehr schön. Sorry,
so die ersten Prozessoren, 70er Jahre, also 80er,
88, nicht die anderen, also irgendwie sowas wie ein 20-Bit,
Adressbus, Hauptspeicher, umfasse dem zufolge zwei hoch 20,
byte, dass man also irgendwie so bei einem Megabyte oder Mibi byte Adressraum,
nicht, das ist das etwas, wo man sagt,
naja gut, das geht heute irgendwo noch im Cash unter,
interessiert also nicht mehr so ganz, nicht, also mit den 2,
86 Prozessoren, wo das Ganze dann eben erweitert,
wo man dann eben gesagt hat,
ich habe diese 20 Bilder und nochmal zusätzlich 4 wird,
dann kommen wir bis 16, wenn ich dann eine ganze Zeit lang bist,
sagen wir so vor fünf Jahren,
war man dann eben noch häufig so in dem Bereich bis 32 Bit unterwegs,
nicht womit, also 4 GB adressieren kann,
inzwischen natürlich ich dann typischerweise auch deutlich mehr, wenn ich einen Prozessoren, so Desktop-Laptop-Bereich nicht, kann man sagen, sind eben 64 mit Architekturen, das heißt, die haben dann eben logisch gesehen 64-Bit-Adressraum.
Gut, bei den Bussen hier eben nochmal nur so grob zur Unterscheidung, wie dann so ein Busprotokoll quasi aussehen kann. Synchronerbus,
wo ich jetzt sage, ich habe eben hier also ein gemeinsames Taktsignalvieh,
abhängig davon wird dann also sowohl von dem Prozessor,
der jetzt quasi Daten lesen oder schreiben möchte,
als auch von dem Speicher,
der dann also auf der anderen Seite dort hängt,
letztendlich dann immer abhängig von den Taktflanken, einmal abhängig schon erfordert,
einmal abhängig von der Rückflanke, dann eben das Talme gemacht,
mit der Prozesse wurde jetzt eben sagen,
wenn ich von einer bestimmten Speicheradresse was lesen möchte,
dass dann eben die entsprechenden Kontrollleitungen, die jetzt sagen,
es soll oder gelesen werden und es soll da eben entsprechend darauf zugegriffen werden,
also dann in diesem Fall abhängig nach der Rückflanke irgendwann aktiv geschaltet werden.
Vorher muss also dann schon die Adresse auf dem Bus gegeben sein.
Und dann dauert es eben ein oder mehrere Tagzyklen,
was dann eben ja auch noch signalisiert werden kann,
bis dann also der Sparcher quasi jetzt seinerseits dann eben die gültigen Daten auf den Datenbus legt und anschließend dann eben hier diese Steuerleitungen zurückgenommen werden kann. Und je nachdem,
wie lange das jetzt dauert,
wird dann eben entsprechend dieses Wade-Signal quasi dann angehalten,
weil das hatte ich also auch schon am Mittwoch kurz gesagt,
dass im Prinzip jetzt Speicherbausteine auch getaktet sind,
auch sowas wie kleine Automaten sind, die kriegen eben irgendwann mit,
okay, er soll gelesen werden,
nicht wenn die jetzt aber selber, also intern,
da ist also gerade in irgendwelchen Refrain-Zyklen sind oder so,
kann es dann eben auch davon abhängig jetzt nicht nur ein,
sondern eben auch mehrere Takte dauern,
bis dann also gültige Werte kommen und das wird dann
quasi entsprechend dynamisch den Prozessor gegenüber dann angezeigt
Gut, hier, wie gesagt, also etwas ältere Werte,
nicht, da sieht man da,
aber das liegt dann also hier noch irgendwie so am einigen Nanosekundenbereich.
Letztendlich kann man aber sagen, gut,
also diese Werte selber hier sind jetzt also nicht weiter interessant,
das Protokoll wird also auch nicht zwingend abgefragt werden.
Ich habe aber nur mal als ein Beispiel,
wie im Prinzip so ein synchrones Busprotokoll aussehen würde.
Asynchron kann man sowas auch machen, dann gibt es eben
letztendlich kein Taktsignal. Es sieht dann eben so aus,
dass also auch seitens des Prozesses oder der Einheit,
die jetzt also Daten lesen möchte,
also quasi die Adresse aktualisiert wird auf den Kontrollleitung,
wird dann eben signalisiert ist, soll sich was tun,
die entsprechende Masterleitung wird dann quasi aktiv gesetzt.
Das heißt also, ab diesem Zeitpunkt sind eben hier alle gültigen Informationen für den Slave,
also in diesem Fall dann für den Speicher vorahnten.
Das kann dann eben auch beliebig lange dauern, bis der
dann quasi seine gültigen Werte hat. Wenn die da sind,
werden die quasi jetzt auf den Datenbus gelegt und der Slave selber
gibt dann eben das entsprechende Signal zurück an die CPU,
war es dann eben signalisiert, die Daten sind da.
Die CPU würde dann die Daten verarbeiten,
wenn die gelesen worden sind, dann eben hier die eigenen Steuersignale deaktivieren.
Nicht woraufhin dann eben der Slave quasi dadurch antwortet,
dass er dann eben sein Signal dann auch zurücknimmt und dann eben auch quasi hier diese Daten vom Bus abschalten kann.
Gut, zu dem Stichwort Busabitrierung. Wie gesagt,
wie sieht das jetzt aus an mehrere Komponenten
Irgendwelche Daten senden möchten. Auch da kann man sagen,
gibt es grundsätzlich jetzt mal unterschiedliche Verfahren.
Zum einen kann ich so was über eine zentrale Einheit steuern,
die dann letztendlich als Bus-Master eben sagt, jetzt darfst du,
jetzt darfst du, jetzt darfst du,
je nach Protokoll kann man sich dort dann eben auch verschiedene Strategien ausdenken.
Also von irgendwelchen Zeitscheiben basierten Verfahren, wo dann eben gesagt wird,
also jetzt darf der Sender so und so lange, jetzt darf der so und so lange,
jetzt darf der so und so lange, das ist dann also das,
was jetzt hier unter dem Stichwort Ra und Robin drinsteht oder eben irgendwie sowas wie Verfahren,
wo quasi immer ein Token zwischen den Einzelnen beteiligten Komponenten ausgetauscht wird und weitergegeben wird nicht.
Und derjenige, der das Token besitzt, darf senden,
wenn er keine zu sendenden Daten hat oder entsprechend zu empfangenden Sachen,
wird das Token dann eben quasi an den Nächsten weitergegeben.
Als einfachere Möglichkeit, das ist dann etwas,
was also gerade bei solchen Lohkostbussen ganz gerne passiert,
gibt es dann sowas wie ein dezentrales Verfahren,
was dann also im Prinzip über irgendwelche Protokolle funktioniert Beispielsweise beim so einem Iquadrat-Cebus sieht das so aus,
dass das Ganze dort elektrisch so verschaltet ist,
dass wenn mehrere am Bus beteiligten Komponenten jetzt ihre Daten loswerden wollen und anfangen zu senden.
Er ist jetzt also nicht zu einem Kurzschluss kommt,
sondern dass es eben nur sein kann,
dass also auf dem Bus auf einmal andere Daten liegen als das,
was jetzt also eine Einheit, die gerade dabei ist,
zu senden, gerade loswerden will.
Und das kann diese Einheit dann nämlich detektieren und feststellen,
oh, da sendet jetzt jemand anders, der hat also
In dem Fall jetzt also elektrisch gesehen eine höhere Priorität.
Und ich komme mit meinen Daten nicht durch. Also nehme
ich das Ganze zurück und versuche es irgendwann später nochmal.
Nicht, das sind also solche Sachen,
wo dann also im Prinzip solche Kollisionen erkannt werden und dann
eben irgendwelche zufälligen Tal mal quasi angestoßen werden und man dann eben versucht,
nochmal zu senden.
Also wie gesagt, bei solchen ganz einfachen Zwei-Draht-Bussen passiert sowas,
also in der Regel relativ häufig,
weil das da also viel zu aufwendig ist,
also sowas wie ein Busarbeiter zu generieren
Im Prinzip ist sowas auch bei irgendwelchen Funknetzwerken, also WLAN mit drauf,
wenn jetzt also wirklich sämtliche Wahlfinetze mit dem Default eingestellten Kanal 1 anfangen wollen, zu senden.
Also alle anderen Nachbarn da auch noch rein strahlen,
dass man dann also letztendlich da dann nämlich auch Kollisionen erkennt und feststellt,
okay, also da stört sich irgendwie was und das,
was eigentlich gesendet wird, entspricht nicht dem,
was ich jetzt also quasi über meinen Empfangsteil auch wieder empfange und gut,
dann versuche ich das eben Einige Millisekunden später nochmal in der Hoffnung,
dass es dann eben nicht mehr zu so einer Kollision kommt.
Ja. Synchrona Boss.
Achso, ja
Ja, also hier, also die Frage war jetzt,
also hier nochmal zu dieser Folie,
also ich bin jetzt also immer nicht genau auf die Busprotokolle eingegangen,
sowohl bei dem asynchronen Bus als auch hier einen vorher bei dem synchronen Bus.
Was man also eigentlich bei beiden Protokollen immer häufig hart oder generell häufig hat oder sieht,
sind, dass also quasi der inaktive Teil durch einen High-Pegel gekennzeichnet wird,
nicht deswegen immer Mary Request Nord,
oder Nord Reed, beziehungsweise Nord Wade.
Und hier habe ich dann eben beispielsweise sowas wie Nord Master sind und Nord Slave sind,
weil letztendlich ist das dann eine Frage der Interpretation, wie man das jetzt macht.
Also man kann natürlich auch sagen, also inaktiv ist low und aktiv ist sy.
Häufig macht man aber das immer mit diesem umgekehrten Polaritäten,
sodass also quasi der inaktive Teil Low ist, um einfach jetzt irgendwie so eine elektrische Sicherheit zu gewährleisten. Also sprich,
wenn irgendeine Komponente ausfällt, wenn irgendwas nicht funktioniert,
wenn die jetzt keine Spannungsversorgung hat,
wird das Ding quasi dann auf Null gehen, was dann dazu führt,
dass in dem Fall sich das ganze System dann zwar blockiert,
das aber erstmal sichergestellt wird, dass ganz am Anfang,
dadurch, dass alle Signale dann eben quasi auf 1 gehen,
auch klar ist,
sowohl Master als auch Slave würden funktionieren.
Also deswegen arbeitet man dann häufig mit solchen umgedrehten Polaritäten.
War das jetzt grob das, worauf sie hinaus wollten?
Also letztendlich, also man kann es genauso gut andersrum interpretieren.
Also wie gesagt, hier ist es eben immer so,
solange der Eins ist, ist er nicht aktiv und gültiger wert,
wird eben hier durch die Null signalisiert.
Und hier wird eben auch als Synchronisationssignal dann eben auch
quasi der Nullteil angenommen
Also im Prinzip, ich hatte sowas ja auch schon mal angedeutet, also bei Flip-Flops,
Reset-Signale sind in der Regel eigentlich auch immer nur aktiv.
Auch da kann man sagen, okay,
das ist einfach, um mir zu gewährleisten,
dass das System beim Einschalten dann immer gleich automatisch ein Reset
bekommt und wenn der Strom ausfällt oder wenn da irgendwas ist,
wird eben auch ein Reset ausgelöst.
Nicht deswegen arbeitet man dann eigentlich immer mit so einer
umgedrehten Logik dort ganz gerne
Ja, Thema Booster-Abitrierung, also hier eben auch noch grob gesagt.
Ich dachte, man kann eben letztendlich sagen, okay,
ich habe jetzt hier mehrere Gerede, die irgendwie auf dem Bus darauf zugreifen wollen.
Und dann gibt es eben irgendwie dann noch so eine,
also der eigentliche Bus ist jetzt hier gar nicht gezeichnet.
Es gibt dann aber im Prinzip also in diesem Kontrollleitung dann eben irgendwie dann so eine Anforderungsleitung,
nicht wo man dann eben dem Busmaster sagen kann,
okay,
ich möchte und der kann dann eben entweder jetzt hier über
so ein Token basiertes Verfahren oder wie auch immer dann
eben dem einzelnen Gerät sagen,
okay,
jetzt darfst du
Entsprechend senden, beziehungsweise damit arbeiten. Gut, ansonsten, welche Brustsysteme gibt es? Also wie gesagt,
sehr viele von Bs, also hier nun mal grob so ein paar außen Wikipedia rausgesucht,
wo man also einfach dann eben auch mal sieht,
wie groß, also letztendlich, also die Bandbreite,
übertragungsmäßig jetzt bei den Bussen ist, nicht also von ganz einfachen,
seriellen Übertragungen, also er ist 2-3-3-2,
ist im Prinzip eine serielle Übertragung über Ähm, ja,
Versorgungsspannung, Grauen, dann eigentlich, ähm,
zwei Daten leiten, beziehungsweise zwei Datenleitungen und Grauen.
Damit hat man letztendlich ganz früher Fernschreiber angesteuert, nicht später als die ersten Computeraufgaben,
wo also ein Großrechner dann also hier noch irgendwie einen halben Saal gefüllt hatte, wurden dann dort,
also letztendlich dann also als Ausgabe Medium fernschreibe, als,
äh, beziehungsweise als Eingabe dann eben auch dann dort die Tastatur genommen, nicht?
Also das ist nun auch so in Zeiten,
als das eben mit Aski-Zeichen, Satz und 7-Bit irgendwo losging,
wo man dann sagen kann, ja gut, also bei den Geschwindigkeiten,
mit denen also ein Mensch schreibt oder jetzt also so eine,
ich sag jetzt mal elektrische Schreibmaschine irgendwelche Zeichen ausgeben kann,
also da kommt man mit einigen Bit pro Sekunde aus,
wo dann natürlich, also später auch für irgendwelche anderen Sachen eine serielle Schnittstelle,
gab es ja dann also auch dann nachher Mäuse,
irgendwelche anderen Sachen oder eben auch teilweise irgendwie Datenübertragung zwischen Rechnern,
konnte man darüber dann eben auch machen,
dann eben ein bisschen im Bereich von irgendwie
Einigen 100 Kilobit pro Sekunde. Wie gesagt,
so eine Low-Cost-Variante von dem, was also heutzutage so ein Standardbus ist,
iQuadrat C. Also da geht man also bis maximal, also irgendwie so ein Megabit pro Sekunde.
USB-Systeme von allerersten Versionen bis zum aktuellen USB 3.1. Ist dann eben eines der üblichen Bussysteme dann auf dem,
was in PCs beziehungsweise entsprechend also auf den Motherboards von also irgendwelchen Personal Computern drauf ist,
ging das also ganz früher mal irgendwie mit sowas wie in Isabus los,
dann kam also PCI für Grafik dann eben AGP-Ports,
inzwischen ist man da so bei PCI E,
wo man dann eben schon bis zu entsprechend hohen Datenratenraten kommt,
die dann also auch immer jetzt jeweils nur für,
hier jetzt also für eine Verbindungsleitung angegeben ist und kann ich dann aber eben auch bis zu 32 bündeln,
also beispielsweise um jetzt entsprechend hohe Datenübertragungsraten zu meiner Grafikkarte hinzubekommen.
Hypertransport ist im Prinzip auch so ein Protokoll aus dem Bereich NV-Link,
deutet schon also auf an Grafikkartenhersteller hin, nicht also auch dort,
also entsprechendes Protokoll, um entsprechend viele Daten untereinander auszutauschen.
Nicht, dass Nazodam beides auch schon Sachen,
die also in dem Bereich des Cluster Computing oder sowas dann
eben auch noch mit eingesetzt werden. Gut, ja,
jetzt hier nur noch mal kurz als Beispiel Einfache Bussysteme,
PCI-Bus, wie gesagt,
Anfang der Anfang der 90er Jahre von Jentel quasi,
also als Starspost-System, also auf den, damals auf den Motherboards eingesetzt.
Ich fing also mit 33 Megaherzstakt an. Nicht später kam dann also
irgendwie dann noch eine schnellere Version mit 66 Megaherz nicht.
Das war dann eben das, wo man gesagt hat,
okay, ich habe jetzt hier mein Motherboard dort an irgendeinem
Bus und kann da dann eben entsprechend meine Grafikkarte,
Soundkarte,
irgendwelche Firewire oder irgendwelche anderen IO-Karten
dort dann eben noch entsprechend
mit reinsetzen
Ursprünglich als Zahlen 30-Bit-System gestartet, wo er dann später auch noch
entsprechend auf 64-Bit erweitert. Und das ist eben so ein System,
wo man gesagt hat, okay, um jetzt Datenleitung zu sparen,
hat man eben so eine gemeinsame Adress-Datenleitungsarchitektur und kann dann eben überall so ein Steuersignal immer umschalten,
handelt es sich jetzt um Adressen oder handelt es sich um Daten.
Und die Appetrierung erfolgt dann typischerweise durch die CPU, die dann, also der Bursmaster war. Nicht,
was diese System dann eben auch schon hart ist und sowas wie Autokonfiguration,
das heißt, also irgendwelche angeschlossenen Geräte wurden automatisch erkannt mit irgendwelchen Identifikation,
das heißt, in dem Protokoll war dann eben festgelegt,
dass also unter bestimmten Adressbereichen eben so was wie so ein Rom angesprochen werden konnte,
wo dann eben drin stand,
der und der Hersteller und es handelt sich um Laske Gerät mit den und den Eigenschaften,
nicht und das konnte dann eben entsprechend ausgelesen werden, verarbeitet werden,
sorgt dann eben zum Beispiel dafür, dass dann also beispielsweise das Betriebssystem dann eben auch wusste, welche Treiber es zu laden hatte.
Gut, also inzwischen haben wir eigentlich nicht mehr PCI,
sondern PCIE, Diese Grundidee von diesem Protokoll ist aber im Prinzip immer noch.
Also wenn ich jetzt also hier, also auf dem Laptop,
also irgendwie sowas wie in der Shells und LSPCI mache,
dann gibt es da also irgendwelche Ausgaben,
wo dann also letztendlich dann sich irgendwie sowas dahinter verbirgt,
nicht wo man dann eben sieht,
also das ist dann also jetzt irgendwo aus dem Schippsatz ein Teil von dem Bussystem,
beziehungsweise das ist in diesem Fall die Brett,
die dann also inzwischen bei den neueren Prozessoren in der CPU selber mit drin sitzt.
Nicht früher war das ein Extraship auf dem Motherboard
mit drauf und dann eben entsprechend Verbindung zu VGA-Controller,
auch der liegt inzwischen, wie man also hier unschwer sehen kann,
als Antil Skylake in der CPU mit drin.
Nicht, dass er in diesem Fall die Grafikeinheit und so weiter und so fort.
Das Ganze kann man dann auch je nach Tool sich dann noch
irgendwie schön grafisch anzeigen lassen und sie da dann also letztendlich alle möglichen Arten von Komponenten,
die letztendlich, also hier in dem Rechner angeschlossen werden können,
nicht so gut, also je nachdem,
also ob das ein Intel Windows oder Linux ist,
wird das dann entsprechend anders grafisch aufbereitet.
Und gut, da sieht man dann eben der Reihe nach,
der ist also hier wirklich alles,
was dann also an CPU beziehungsweise an irgendwelchen externen Komponenten mit vorhanden ist.
Gut, hier auch nur aufbelistet, nochmal irgendwie so exemplarisch einige von diesen Leitungen. Nicht,
wie gesagt, zwar in diesem Fall, also in 32 Bit Fortbreite,
Adressen und Daten, dann gibt es dann eben entsprechende Steuerleitungen,
mit denen dazwischen dann eben umgeschaltet werden kann und dann eben irgendwelche Sachen,
die für Master beziehungsweise von Slave notwendig sind.
Will ich jetzt aber hier im Einzelnen gar nicht erklären,
weil wie gesagt, das ist da jetzt eigentlich nicht spezieller gerade warnt.
Gut, hier sieht man dann eben auch mal,
wie dann eben beispielsweise auf so einem PCI-Russland typischerweise so eine Transaktion stattfindet.
Also so ein Lesezugriff, beispielsweise, dass man dann auch dieses ein Synchronaboss,
es gibt also auch hier wieder so ein Tag-Signal-Fee,
wo man dann eben sagt,
also es wird erst eine Adresse quasi auf den ausgegeben.
Nicht dann wird also quasi über die entsprechenden Steuerleitungen, in diesem Fall ist es,
also diese Weiten eine entsprechende Anzahl von den Byte-and-Able-Leitungen gesagt,
also was gelesen werden soll, Prame-Signal wird gegeben.
Und anschließend, wenn die Adresse gültig war,
wird dann quasi der Bus wieder freigegeben und ein entsprechendes Signal
gegeben und anschließend kann dann eben die andere Einheit dann eben die Daten auf den Bus legen,
die dann eben quasi unter dieser Adresse angefordert worden sind und eben Signal dass dort also wirklich fast gültiges da ist,
was abgeholt werden kann.
Ich war beim Schreiben im Prinzip ähnlich,
nur dass man da dann natürlich dann quasi jetzt die Komponente,
die jetzt senden möchte, dann beides gleichzeitig macht,
nämlich also erst die Adresse, auf die geschrieben werden soll,
dann die Daten quasi im nächsten Tag und dann eben auch durch entsprechende Kombinationen von diesen Kontrollleitungen letztendlich dem Client dann also quasi sagt,
es soll jetzt eben geschrieben werden.
Als ein weiteres Beispiel eines ganz, ganz einfachen Brustsystems,
was also hier noch vorgestellt wird,
zu dem ich vielleicht auch noch eine Übungsaufgabe stellen werde.
Hier nochmal ganz zurück in die Standardzeit der Computertechnik, serielle Schnittstelle.
Er ist 2, 3, 2, also wie gesagt,
hier jetzt beschrieben mit Pegeln plus 12 Volt, minus 12 Volt,
wie gesagt, das kommt noch aus der Zeit,
als man dann eben mit irgendwelchen einfachen Leitungen über große Entfernung auch gehen musste.
Inzwischen, also falls jetzt noch irgendwie einen PC haben sollen,
der also eine serielle Schnittstelle hat,
wird die in der Regel mit 0, Volt und 5 Volt funktionieren.
Nicht, das heißt also,
da muss man jetzt nicht mehr zwingend diese Pegel haben,
aber ursprünglich war das also nochmal mit anderen Pegeln.
Wie gesagt, hier hat man also sehr niedrige Übertragungsraten.
Botroate gibt immer an, wie viele Bits pro Sekunde übertragen werden,
wo dann also letztendlich Leerlaufzeiten und noch irgendwelche zusätzlichen Synchronisationszeiten mit rausfallen.
Ich finde, da gab es dann eben auch entsprechend standardisierte Übertragungsraten.
Und es gab dann also beliebig viele unterschiedliche Varianten,
wo also im Prinzip zwischen Sender und Empfänger beziehungsweise im Beteiligten Komponenten,
jetzt also auf so einer Serienschnittstelle klar sein musste,
um wie viele Datenbits handelt es sich.
Gibt es irgendwie noch sowas wie Paritätsbits,
weil das ist also auch optional immer gewesen.
Wie viele Stoppitz werden benutzt und mit welcher Bootrate arbeite ich?
Und ansonsten ist einfach grob die Idee,
ich habe hier einen hohen Pegel
Irgendwann als Startbett wird eben quasi immer der niedrige Pegel verwendet und anschließend dann
eben jetzt immer mit gleich langen Zeitabständen folgt dann eben die Anzahl der Datenbitz,
also hier in dem Beispiel jetzt also mit acht Datenbitz,
nicht dann kann noch sowas wie eine Parität mitkommen und als Startbit wird dann eben immer eine Eins gesendet.
Wenn irgendwann später dann mal wieder der Pegel runterfällt,
ist das dann eben dann quasi wieder das nächste Startbit. Und hier in dem Beispiel,
wenn ich das jetzt also hier einmal so zartlich in den Verlauf nehme,
Word quasi Startbett, Startbett und dann eben der Reihe nach die Bits,
1, 1, 0, 0, 1, 0,
0, 0 gesendet, ich war es dann also quasi von beginnt mit dem niederwendigsten Bild bis zum höchstwertigsten
, wird dann eben dieses Achtbett wie Nährworte ergibt. Und gut,
da kommt man eben mit maximal oder mit der Minimalanzahl von drei Leitungen aus,
nämlich einem gemeinsamen Grauenpotenzial, ein Signal in die eine Richtung,
Transmith und einem Signal zurück in die andere Richtung Receive.
Damit kann man dann eben wirklich sehr einfach mit drei solchen Leitungen quasi jetzt zwischen zwei Geräten einzelne Bike übertragen. Und die Informationen,
damit das richtig interpretiert wird,
weil also hier gibt es ja nun keine gemeinsame Taktleitung,
ist es eben auch notwendig, dass dann also beide beteiligten Parteien wissen,
also um welche Bootrate und welche Sachen hier es sich handelt,
weil wenn ich als Empfänger quasi jetzt Beispielsweise,
also dieses Signal hier nehme,
jetzt aber von der falschen Bootrate ausgehe und dass also beispielsweise jetzt also doppelt so schnell abtasten würde,
dann hätte ich jetzt also hier nicht eine Null,
sondern schon 2-0 empfangen.
Und ja, vielleicht habe ich dann an dieser Stelle interpretiere ich das ja schon als Staubbetten,
dann ist das hier eigentlich ein gültiges Wort,
was aber eigentlich völliger Unsinn ist. Das war also immer sehr,
sehr, sehr schön, ganz, ganz früher,
muss ich zugeben, habe ich irgendwie auch noch erlebt,
wenn man jetzt also im Prinzip,
also irgendwie so ein Terminal an so einen zentralen Rechner angeschlossen hat,
irgendwie die falsche Bootrate, man hat irgendwas eingetippt.
Es kamen auch irgendwelche Zeichen auf den Bildschirm zurück.
Das war dann aber nicht das, was man getippt hatte,
sondern also nur irgendwelcher kruder Salat aus irgendwelchen Steuerzeichen,
Sonderzeichen und was weiß ich.
Dann konnte man also erstmal so lange rumprobieren, bis man
dann also entsprechend hier diese Einstellung dann wirklich passend hat.
Gut, ja, damit verlassen wir jetzt aber eigentlich diesen Tal zu dem Bussystem.
Wie gesagt, was eigentlich nur hängen bleiben soll von ganz,
ganz einfach bis zu High Performance Computing kann da alles mit dabei sein,
von sehr billig bis zu, was weiß ich,
oder letztendlich von der Anforderung abhängig und eben so ein paar Begriffe wie von den einfachen Bussystemen bzw. überhaupt die Begriffe,
das, was also in dem täglichen Umfeld jetzt,
also im PC noch irgendwie auftaucht,
das sollte man dann nochmal gehört haben.
Gut, abschließend in diesem Kapitel werde ich dann nochmal kurz auf Mikroprogrammierung eingehen.
Da geht es darum, Ich hatte ja eigentlich jetzt in der letzten Woche,
beziehungsweise ganz am Anfang, am Mittwochstermin ja noch so ein bisschen Entwurf endlicher Automaten vorgestellt.
Stichwort Schaltwerke, Miliautomat, Moorautomat. Neben dem direkten Entwurf von irgendwelchen Automaten,
wo ich jetzt eben sage, okay,
ich zeichne jetzt meinen automaten Zustandsübergangsdiagramm und ich überlege mir jetzt daraus,
also die entsprechende Automatentabelle und mache dann also irgendwie die passende Minimierung mit KV-Diagrammen,
um daraus jetzt, also wie jetzt beispielsweise eine Übungsaufgabe gefordert,
da jetzt also irgendwelche Schaltungen umzusetzen,
gibt es noch als zweite Variante die sogenannte Mikroprogrammierung,
wo man im Prinzip die Abfolge der Automatenzustände in ein Speicher legt,
eigentlich von der Idee her ein Rahmen,
typischerweise war das früher immer ein Rom,
also ein Richt-Only-Speicher
Wo man dann eben ein ausgewähltes Register, den Mikroprogrammzähler hat,
nämlich also ein Register, das in diesen Speicher adressiert.
Und womit man dann in diesem, oder im Inhalt dieses Speichers dann eben quasi die Information hat, Folgezustand beziehungsweise irgendeinen Ausgangsvektor. Typischerweise ist sowas dann immer aufgetaucht bei irgendwelchen Mikroprogrammierten Rechnerarchitekturen,
wo man eben sagen kann, ich habe immer diese Abfolge,
Befehl holen, Befehl dekodieren, Befehl abarbeiten, warm Befehl abarbeiten,
wenn ich das jetzt mal nach diesem ganz einfachen von Neumann-Schema mache,
habe ich ja so jetzt wieder mehrere Stufen, wo ich sage,
okay, jetzt sollen also die Operanten erstmal geholt werden in das Register,
dann geht das Ganze durch die Alu,
da muss der Alu gesagt, werden sie so als beispielsweise addieren,
dann soll das Ergebnis wieder in irgendeinem Register landen und so weiter und so fort.
Und das hat man dann eben in so eine Folge von
einzelnen Mikroinstruktionen geparkt. Diejenigen, die jetzt also Rechnerstrukturen,
Praktikum sind, werden sich also damit schon rumgeschlagen haben.
Nicht, weil das also genau so eine Architektur da nämlich ist.
Nicht, wo man dann eben letztendlich genau dort dann eben diese Abfolge in so ein Mikroprogramm bringt.
Um das Ganze erstmal ein bisschen zu veranschaulichen, das,
was ich jetzt eben irgendwie so abstrus durcheinander erzählt habe,
also hier nochmal dieses hochelaborierte Beispiel, eine Ampelschaltung,
wo ich also quasi jetzt hier diese Abfolge habe von vier Zuständen,
rot gelb, grün,
nach Grün kommen dann wieder gelb und rot.
Und irgendwann soll es dann eh wieder entsprechend weitergehen.
Kann man Mikroprogrammiert dann eben so machen, dass man sagt,
ich habe jetzt also hier quasi so ein Mikroprogrammspeicher mit eben entsprechend für diese vier Zustände vier Einträgen.
Sage dann eben jetzt quasi für jeden Zustand oder für jede Adresse,
was ist der Folgezustand und wie sehen die Ausgänge aus?
Und dann kann man eben quasi über so ein zwei mit Mikroprogrammzähler dann eben mit jedem Tag hier quasi immer einen Schritt weitergehen und damit also genau diesen Ablauf entsprechend durchlaufen lassen. Gut,
wenn man das jetzt rein praktisch nimmt,
um jetzt irgendwie so einen kleinen Prozessor zu steuern,
also das ist jetzt hier also auch so ein Ausschnitt,
also aus diesem, dieser Deko-Architektur,
was also in einem Praktikum genutzt wird nicht,
dann sieht das dann eben so aus,
dass ich dort dann eben auch so einen Speicher habe,
der ist da dann natürlich in der Regel ein bisschen größer,
weil ich da dann also vielleicht noch ein paar mehr Zustände brauche und wo man dann eben zum Beispiel dann eben auch noch sowas mit einstellen oder machen kann,
dass ich also jetzt hier nicht nur irgendwelche Ausgangs Werte habe,
die dort in der Regel dann also irgendwelche Belegungen für,
was soll die Alu machen,
welche Register sollen jetzt gerade aktiviert werden, auswählen,
sondern dass man dort dann eben auch zum Beispiel jetzt für irgendwelche Verzweigungen,
bedingte Sprünge dann eben sagen kann,
ich habe jetzt eben nicht nur einen möglichen Folgezustand,
sondern ich habe mehrere und ich habe dann eben hier irgendwelche Multiplexerstrukturen,
mit denen ich dann eben sagen kann,
es soll abhängig von irgendwelchen Eingangsbedingungen eben entweder der oder der Folgezustand eingenommen werden und man kann das dann eben hier entsprechend umschalten und dort in dem Praktikum ist es dann also auch noch so aufgebaut,
dass man dann eben jetzt nicht nur so einfache Verzweigungen hat,
sondern man kann dann eben auch noch einen externen Wert laden,
nicht das bräuchte man jetzt zum Beispiel für sowas wie irgendwelche unbedingten Sprünge,
wo ich dann eben sagen kann,
also ich habe jetzt einen Sprung an die und die Adresse,
nicht dem zuvor soll dann eben beispielsweise hier in dem Mikroprogramm dann eben jetzt wieder an irgendeinen bestimmten Teil hier in der Ablaufsteuerung zurückgesprungen werden oder ich habe eben bei bedingten Sprüngen sowas,
wo ich dann da sicher quasi über so einen,
zwischen zwei unterschiedlichen Varianten dann auswählen kann,
über ein externes Steuersignal und dieses externe Steuersignal wird dann typischerweise sowas sein wie irgendein Fleck,
was aus der Alu kommt, wo ich dann eben sagen kann,
okay, nicht wenn das Ergebnis gleich null ist,
spring dahin,
wenn das Ergebnis ungleich null ist,
springt dahin.
Gut, und je nachdem, was die Architektur machen soll,
muss man das dann natürlich sich entsprechend dann,
also hier hardwaremäßig dann überlegen, wie das aussehen soll,
aber das ist also grob die Art und Weise,
wie man Und dann also eine Mikroprogrammierung macht.
Also hier wäre jetzt nochmal, also da dann also jetzt beispielsweise diese gesamte Architektur,
nicht also wirklich zum Beispiel für so eine kleine Prozessorarchitektur,
wo man dann eben wirklich sieht, ich habe hier jetzt meinen Ram-und-Raum-Speicher über Adresse und Datenbus angeschlossen, über irgendwelche Bright-Enable-Leitungen bzw. Output-Enable-Leitungen dann zu aktivieren.
Habe hier im Steuerwerk dann eben quasi jetzt dieses Mikroprogrammraum mit irgendwelchen Sachen,
wo dann eben im Prinzip befehlen, hier aus dem ROM-Bereich,
dann eben beispielsweise eine Menstruktionsregister landet,
dort dekodiert wird und da dann eben entsprechend jetzt also hier die Einheiten anspricht und für die Alu-Befehle habe ich dann eben hier eine Alu-Register,
wo jetzt also mehrere Werte quasi einzeln ausgewählt werden können,
dann brauche ich hier, um für den Programmzähler sowas,
wo ich dann eben hier noch eine Einheit habe,
wo ich ja hier den eigentlichen Programmzähler habe,
den dann eben hier immer entsprechend inkrementieren kann,
beziehungsweise für bedingte Sprünge kann er dann eben auch hier mit irgendwelchen Werten,
also explizit geladen werden.
Und dann gibt es dann eben hier noch eine
zusätzliche Rechnereinheit oder eine Alu, mit der ich dann,
also quasi sowas wie Adressberechnung, also hierfür machen kann.
So, und letztendlich bei dem,
was dann also eigentlich so eine Prozessorarchitektur immer ist,
wie viele Recheneinheiten ich brauche oder wie ich die aufbaue,
dass es dann eben wirklich davon abhängig,
also wie ich da dann eben auch entsprechend die zeitliche
Abfolge reinsetze
Also sprich, muss parallel Alu befehlen und eine Adressberechnung stattfinden.
Wenn ja, brauche ich hier getrennte Einheiten.
Wenn nicht, könnte ich im Prinzip so was wie so
eine Adressberechnung auch über diese Alu machen.
Nicht gleich, es gilt eben auch für Erhöhung des Programmzählers.
Das ist dann eben letztendlich immer davon abhängig,
wie ich jetzt also meine,
die Abarbeitung meiner Befehle dann auf irgendeine Hardwarestruktur abbilde
Ja. Nochmal, jetzt nur kurz, der Hinweis darauf,
also wie gesagt, im Rechnerstruktur- und Praktikum wird das ja auch noch entsprechend so gemacht.
Ansonsten muss man sagen, also bei aktuellen Hardware-Architekturen wird inzwischen
eigentlich deutlich weniger an Mikroprogrammierung gemacht, was also daran liegt,
dass aktuelle Architekturen eigentlich sowas wie ein Pipelining-Konzept verfolgen.
Das wird uns dann in Kapitel 16,
hier in der Vorlesung dann also auch noch ein bisschen weiter begegnen,
wo beispielsweise dann also so eine Struktur,
wie sie jetzt hier aufgezeichnet ist, nicht funktionieren würde.
Bloß da muss man eben sagen, also Pipelining ist dann
eigentlich auf so einem klassischen Phone-Normen-Konzept aufbauen, dann doch noch etwas komplizierter umzusetzen.
Also deswegen sind wir da jetzt also oder haben wir davon dann jetzt eigentlich immer Abstand genommen,
dass also irgendwie dann schon in dem Praktikum anzubieten,
weil wie gesagt, also diejenigen von ihnen, der ist,
also gerade zu Gange sind, denke ich mir,
werden am Anfang dann also eh schon gesagt haben, na gut,
also es ist dann doch relativ viel Neues, erstmal reinarbeiten, reinlesen, überhaupt den Ablauf verstehen.
Und da ist man mit so einer einfachen mikroprogrammierten Struktur dann immer noch deutlich besser dran,
als wenn ich jetzt also sowas wie ein Pipelining umsetze,
wo ich dann eigentlich nicht nur, also formal gesehen,
nicht nur ein Automaten als Steuerung habe,
sondern also dann mehrere gekoppelte Automaten als Steuerung,
also das ist dann doch jetzt
entsprechend aufwendig
Gut, abschließend, auch nur nochmal um diesen Gedanken mit der Hardware-Architektur und der Abarbeitung jetzt durch die einzelnen Einheiten abzuschließen,
hier nochmal so ein kleines Beispiel von einem inzwischen auch nicht mehr so ganz taufrischen Arm-Prozessor,
aus dem Buch von Förver von 2000, wo man dann auch sieht,
also auch da hat man teilweise eine Mikroprogrammierung, ist zwar eigentlich,
also schon eine Pipelining-Architektur, aber zumindest sowas wie Multiplikation und einige von den Lade- und Speicherbefehlen arbeiten dann da auch über so ein Mikro Mikroprogrammzähler.
Nicht ansonsten so ein Grundsystem kann man sich dann immer so vorstellen,
also ein klassisches SOC-Systemondel-Chip-System, wo ich dann eben sage,
ich habe hier also irgendwo eigentlich mein Hauptbussystem, also sprich das,
was ich eben auf der Grafik drauf hatte, wo ich dann sage,
ich habe hier die eigentliche CPU, ich habe hier irgendwelchen Rahmenspeicher,
vielleicht nur noch für einen Datentransfer, unabhängig von der CPU,
sowas wie ein DMA-Controller und für irgendwelche langsameren Schnittstellen,
YuA, das ist also eine serielle Schnittstelle, irgendwelche Timer,
parallele Schnittstellen, gibt es dann eben noch Schnittstellenchips,
die dann eben an entsprechend wieder andere Bussysteme dann quasi diese Protokolle übersetzen.
Hier aufgezeichnet dann also im Prinzip sowas wie so eine einfache Alu in so einem Prozess,
wo ich dann eben auch sagen kann,
also ähnlich zu dem,
was ich in den Beispielen zu den Schaltnetzen schon drin hatte,
also einmal sowas wie ein Adira oder eben Recheneinheiten für irgendwelche logischen Funktionen,
also Bidvises und Bidvises oder x Uhr
von irgendwelchen Sachen
Und über Multiplexer wird dann eben quasi immer ausgewählt,
um welche Funktion es sich handelt, nicht zusätzlich kann man dann eben noch
so was wie für die jeweiligen Operanten X-Order vorschalten, wofür das?
Das war genau die Sache, statt Addition, entsprech oder statt Subtraktion,
Addition des Zwei-Komplimentes, das Zweier-Kompliment bilden ist Bitweise invertieren,
also sprich X-Or-Rechnen und ein Carry-In zu setzen, also sprich statt Zweier-Kompliment 1 Kompliment
Und nochmal plus eins. Nicht, das kriegt man dann
eben alles hier hier sehr einfach in diese Struktur entsprechend abgebildet.
Gut, dann haben diese Prozessoren dann eben so eine Multiport-Registerbank.
Und ich also auch das ist etwas,
wo man sagen kann, okay, ich habe Register,
um jetzt in der CPU meine Werte zu speichern,
kann ich natürlich aus einzelnen Flip-Flops, also beispielsweise vorderflankengesteuerten Flip-Flops aufbauen.
Wenn ich davon jetzt also 32 Bit nehme, dann habe ich einen 32-Bit-Register.
Wenn ich davon jetzt also irgendwie 16 Stück brauche, nicht,
dann hätte ich demzufolge 32 mal 16 Flip-Flops, ist dann eben auch schon vergleichsweise aufwendig.
Dort wird dann häufig eben auch schon so eine etwas optimiertere Struktur genommen,
wie das, was also im Prinzip wie so ein S-RAM aussieht,
also diese Rückgekoppelten in Wärter und man hat dann eben zusätzlich die Möglichkeit dann eben über zwei Ausgabe,
wo sie dann eben unterschiedliche mit jeweils auszuwählen bzw. unterschiedliche Register,
womit ich dann eben sagen kann,
beispielsweise bei so einem Zwei Adress-Alu-Befehlen.
Ich nehme den Inhalt von dem Register und den Inhalt von
dem Register und ich kann eben gleichzeitig,
indem ich das quasi einmal auf den USA und einmal auf dem Bus B lege,
dann eben unterschiedliche Register auslesen.
Vorteil von dem Ganzen mag ich das Ganze eben vom Layout her,
sehr kompakt hin. Also es ist dann wirklich wie,
also dieses hier soll jetzt eigentlich nur sowas wie so ein Layout veranschaulichen.
Das heißt, man hat dann aber im Prinzip so eine Struktur,
wo man eben wirklich nur sagen kann, ich habe hier irgendwo Versorgungsspannung.
Ich habe hier innen drin, also irgendwie dann so einen Block,
wo dann eigentlich die einzelnen Bits abgespeichert werden.
Nicht und habe dann eben hier quasi zwei Ausgangsbusse,
die dann nämlich quasi auf dieser Seite hin dann einfach an die Alu gehen.
Und hier habe ich dann eben vom Ergebnis her, also irgendwas,
wo ich dann eben Werte wieder reinschreiben kann und man kriegt
das Ganze dann eben sehr schön, sehr klein aufgebaut.
Von der Grobstruktur her kann man sich das dann eben
irgendwie mal so vorstellen und dass man sagt,
also bei so einem ganz einfachen Armsystem, also hier noch Arm der allerersten.
Ich habe hier irgendwie diesen Teil, der jetzt für
die Instruktionsdekodierung zuständig ist und irgendwie diese Ablaufsteuerung macht.
Nicht also das, was eben in dem Beispiel dann diese Mikroprogrammierung war.
Stimmt hier nicht ganz, der Rest also Pipeline nicht,
Pipelining mäßig dann teilweise arbeitet,
aber dann habe ich hier eben diesen zentralen Blog mit diesem,
vergiss wo dann also letztendlich immer gerechnet wird.
Ich habe hier meine Alu, die dann also diese,
sowohl arathmetischen als auch logischen Befehle abarbeiten kann.
Ich habe hier einen Adressbus. Datenbus, der quasi vom Speicher
reingeht und eben Datenbus, der quasi zum Speicher rausgeht.
Hinterher habe dann eben hier noch irgendwelche zusätzlichen Einheiten mit drin.
Und wenn man jetzt sagt, würde so eine Hardware funktionieren.
Da geht es da jetzt eben eigentlich immer darum,
dass man sich also letztendlich einfach jetzt nur für die
verschiedenen Befehle immer überlegen muss
Wie muss ich auf so einer gegebenen Hardware-Struktur jetzt also quasi immer die Datenpfade schalten,
damit ich diesen Befehl abarbeiten kann? Nicht, das ist das,
was also im Prinzip jetzt genau in Rechnerstruktur und Praktikum mit der Mikroprogrammierung so abläuft,
wo man eben sagt, okay,
wenn ich den Befehl abarbeite, im ersten Schritt passiert das,
im zweiten Schritt passiert das, im dritten Schritt passiert das.
Hier jetzt eben wirklich an diesem Beispiel diese Armarchitektur,
wo man eben auch sagt, okay,
wie kriege ich diese Datenpfade eben so geschaltet,
dass bestimmte Befehle abgearbeitet werden können, wenn das alles irgendwie funktioniert.
Wie gesagt, koordiniert, also hier irgendwie durch so einen Block,
der quasi jetzt diese Datenfahrer dann eben irgendwie schaltet,
dann kann man damit dann eben letztendlich diese Befehle eben auch wirklich,
also auf diese Hardware-Struktur realisieren.
Und das, was jetzt hier immer jeweils dunkel hervorgehoben ist,
ist dann eben letztendlich das, was für bestimmte Befehle passieren würde.
Ich also beispielsweise sowas wie ein Registertransfer, was passiert.
Zum einen muss ich erst mal den Buffet lesen,
der kommt irgendwo hier vom Speicher an, landet dann also
quasi hier Register, was dann letztendlich das Instruktionsregister wäre.
Dort wird er dann interpretiert. Es wird eben festgestellt,
es soll ein Registertransfer stattfinden. Das heißt also,
hier aus einem Register wird gelesen. Und das Ganze durch
die Alu einmal durchgeschleust. Dort passiert nichts weiter.
Und das Ergebnis landet dann eben in einem Zielregister.
Und gleichzeitig muss dann eben noch irgendwo der Programmzähler inkrementiert werden,
weil dieser Armarchitektur liegt da also auch in der Registerbank selber mit drin.
Und da gibt es dann eben auch einen entsprechenden Datenfahrt,
wo dann also quasi hier in dem Adressregister,
habe ich ja, um das hier zu lesen,
also jetzt den Wert meines Programmzählers gehabt, der wird inkrementiert.
Er gibt dann hier den neuen Wert für den nächsten Befehl
und wird dann eben auch passend hier in das entsprechende Register dann mit reingeschrieben.
Wenn nicht sowas wie Emediate Operation mache, Emediate heißt ein Teil des Befehlswortes,
ist jetzt eben wirklich eine Zahl, Also die Medienwert,
der dort also irgendwo schon drin steht.
Nicht, dass man dann eben sagt, okay,
ich nehme jetzt eben hier beispielsweise dann eben von diesen Befehlswortern
eben noch die unteren 8-Bit und mache damit dann eine Berechnung
und schreibe das dann eben irgendwie in die Registerbank nicht und hier oben die das Inkrementieren des Programmziel, das funktioniert dann eben letztendlich genauso.
Sowas wie ein Speicherner Zugriff, das heißt,
ich habe den Wert oder möchte den Inhalt eines Registers in den Hauptspeicher zurückschreiben,
würde also auf diese Architektur dann also quasi in zwei Takten passieren.
Nämlich zum einen auch erst mal wieder dieser erste Teil
Befehls- oder der Befehl wird geladen.
Land waren eben hier entsprechend drin. Dann habe ich als Teil
des Befehls quasi als Emediat dann eben einen Teil der Adresse.
Der andere Teil der Adresse kommt aus dem Register.
Das Ganze landet dann eben hier in dem Adressregister
Der Programmzähler, der vorher hier drin stand,
der genommen wurde, um den Befehl zu laden wird.
Also hier inkrementiert und für den nächsten Befehl dann aber erstmal hier zurückgeschrieben.
Und im zweiten Schritt wird dann also von dieser Adresse,
oder soll er auf diese Adresse geschrieben werden,
wird dann also quasi hier der Wert, der geschrieben werden soll,
also hier in das entsprechende Ausgangsregister getan und ihm auf den Speicherbus dann eben dann die entsprechende Adresse gelegt.
Und das kann man jetzt eben auch noch mit irgendwelchen anderen Befehlen genauso durchspielen.
Nicht letztendlich läuft das aber immer alles darauf hinaus,
dass man sich eben wirklich ich jetzt überlegt,
für meinen Befehlssatz kriege ich das irgendwie auf diese Hardware-Struktur abgebildet.
Und je nachdem, wie jetzt hier welche Datenpfade geschaltet werden sind,
müssten, muss man dann eben beispielsweise,
wie dann also in einem Rechnerstrukturenpraktikum dann eben irgendwelche Multiplexer oder
irgendwelche Treesdate-Treiber an irgendwelchem Bussystem dann letztendlich dort vorsehen.
Gut, abschließend zu diesem Kapitel jetzt nur noch so ganz grob,
wie würde jetzt so so ein Rechner prinzipiell funktionieren.
Also wir haben jetzt also grob die Funktionseinheiten. Wir haben gerade eben gesehen,
wie man die jetzt mehr oder minder kompliziert zusammenschalten kann,
wie man jetzt durch Mikroprogrammierung dafür sorgt oder beziehungsweise irgendwelche Steuereinheiten.
Dafür sorgt das quasi jetzt solche Schrittweisen, Abarbeitung,
wie das da eben angedeutet war, möglich sind.
Was folgt oder was passiert jetzt eigentlich noch, wenn man jetzt sagt,
also ich habe jetzt also hier irgendwie so einen Rechner,
nicht dazu komme jetzt, dass ich hier nochmal so ganz ganz grob,
also nur so die Ideen.
Also zum einen, also Choreografie, der Funktionseinheiten,
das hatten wir eben schon so ein bisschen.
Gut, wie kommuniziert man mit Rechnern, was passiert beim Einschalten.
Auch nur informell letztendlich vorgestellt. Nicht ansonsten muss man eben auch sagen,
also alles, was ich jetzt hier vorgestellt habe,
was in dem Rechnerstrukturenpraktikum mit drin ist,
was hier an Folien irgendwie so zur Armprozessoren oder sowas mit drin ist,
muss man sagen, sind natürlich immer nur so die allereinfachsten kleinsten Beispiele,
so einer von Neumann-Architektur und der Befehlsabarbeitung auf diese Architektur, wie man sich das vorstellt.
Letztendlich, wenn ich jetzt also hier, selbst wenn das jetzt also noch gar nicht der hochgeröstete Spiele-PC ist, sondern jetzt also hier nur irgendwie so ein, umstinknormaler Laptop. Letztendlich muss natürlich sagen,
das was, also im Prinzip eigentlich jetzt also auf aktuellen Rechnerarchitekturen stattfindet,
ist schon eine sehr deutliche Erweiterung,
dieses sehr einfachen von Neumann-Konzept ist, wo man dann eben sagt,
okay, ich habe jetzt Nicht mehr, wie jetzt,
also gerade bei diesen mikroprogrammierten Beispielen,
so eine streng sequenzielle Befehlsabarbeitung, sondern ich habe Pipelining,
das heißt, wenn ich jetzt eben sage,
Befehl wird geholt, der Befehl wird dekodiert,
die Operanten werden geholt, es wird in der Alu irgendwas gerechnet,
das passiert jetzt eben nicht sequenziell nacheinander, sondern das,
was passiert, ist,
dass eben der erste Befehl eines Programms wird geholt,
landet immenstruktionsregister,
im nächsten Tag werden von diesem ersten Befehl die Operanten geholt und der zweite wird dann schon geholt und landet im Instruktionsregister im dritten Takt,
wandert das quasi einen weiter.
Das heißt, ich habe die Operanten vom ersten,
damit wird dann in der Alu schon gerechnet,
die Operanten des zweiten Befehls werden quasi jetzt geholt und
der dritte Befehl ist im Instruktionsregister angekommen und so weiter.
Das heißt, man hat dann eben so eine überlattende Abarbeitung von
diesen einzelnen Phasen, so eines von Neumann-Zyklus mit drin.
Das ist also das, was sich dann in der Pipelining verbirgt.
Wie gesagt, wird in Kapitel 16 oder 17,
dann letztendlich noch mal kurz 16 müsste es sein, angesprochen werden.
Gut, dann das, was wir heutzutage ja auch typischerweise haben,
ist, dass man sagt, okay,
also ich habe jetzt nicht nur eine Alu, sondern man hat deutlich mehr.
Ich meine, okay, hier in dem Beispiel,
also war es jetzt hier von dem Deko-Rechner,
also jetzt aus dem Rechnerstruktur- und Praktikum war,
kann man sagen,
na,
nicht also hier habe ich die Alu und da gab es
aber hier noch einen Adierer und hier noch einen Adierer,
auch wenn er teilweise dann immer nur mit Konstanten funktionierte
Bei, naja, sorry,
aktuellen Architekturen sieht das dann aber eigentlich typischerweise so aus,
dass man sagen kann, also jetzt allein um mit Registern,
mit Alus oder normale Aloperationen zu machen,
habe ich eben in meinem Prozessor Kern quasi in einem Prozessor schon vier Einheiten,
die Fixpoint Arithmetik können oder vielleicht noch für irgendwelche Spezialeinheiten,
mit denen ich dann schon Fließkomma-Berechnung machen kann,
unabhängig davon habe ich dann also noch mehrere Einheiten,
mit denen ich dann parallel dazu eben noch solche Adressberechnungen durchführen kann.
Nicht, das heißt, ich habe dann eben nicht nur eine oder zwei,
sondern eben letztendlich dann also irgendwie acht, neun verschiedene Recheneinheiten, die aktiv werden können.
Nicht, das ist das, was sich dann super skalan nennt. Und darüber hinausgehend,
weil damit beschreibe ich jetzt einen Prozessor, das,
was du heutzutage haben, sind zwei Kern,
vier Kern, beziehungsweise eben bis zu 24 Kernen,
die ich also quasi in einer CPU drin habe und gegebenenfalls kann man dann eben auch noch mehrere CPUs,
also in ein Motherboard oder eben im Gesamt jetzt irgendwie so ein Zahnsystem zusammenpacken,
da dann eben auch noch entsprechende Architekturen,
mit denen man dann eben auch nochmal deutlich mehr Recheneinheiten hat.
So, allein schon in Bezug auf Superskalare-Prozessoren,
was sich jetzt natürlich fragen, ja gut,
ich habe jetzt hier vier Recheneinheiten,
mit denen ich gleichzeitig Register addieren kann
Dann macht es aber keinen Sinn mehr zu sagen,
ich arbeite sie jetzt so nach Vor-Neumann-Konzept-Befehl holen und damit irgendwie was machen,
weil mit allem Befehl kann ich nur eine einzige Recheneinheit ansprechen.
Demzufolge führt das dazu,
dass man bei aktuellen Rechnern dann eben auch nicht mehr nur einen einzigen Befehl nimmt,
sondern quasi immer so einen ganzen Satz von Befehlen nimmt,
guckt, sind zwischen diesen Befehlen Datenabhängigkeiten und guckt,
welche Recheneinheiten habe ich frei und anschließend dann eben zugesehen wird,
wenn keine Datenabhängigkeiten da sind und freie Rechnereinheiten zur Verfügung stehen.
Dieser Befehl kann also auf der Alu rechnen,
der Befehl kann auf der Alu rechnen,
der Befehl muss noch warten, weil also der beispielsweise jetzt
eine Fließkommerberechnung machen will und die Einheit ist gerade belegt.
Das heißt, da weicht man dann eben auch sehr stark,
also von diesem ursprünglichen von Neumann-Konzept dann eben schon ab.
Und was daran,
also das ist dann dieses dynamische veränderte Abarbeitungsreihenfolge,
was da dann eben auch mit reinspielt nachher ist,
wenn ich fertig bin mit der Abarbeitung der Befehle
Wie werden die nach außen hin wirksam in der Reihenfolge,
in der sie ursprünglich im Code standen? Kann jetzt dazu führen,
dass ein Befehl, der weit da hinten steht,
weil also dessen Recheneinheit frei war, der schon früher abgearbeitet ist,
dann müsste der aber noch warten,
bevor das Ergebnis quasi nach außen hin wirksam wird, weil vielleicht Befehle,
die vor ihm standen, also noch nicht abgearbeitet sind.
Das ist dann etwas, was dann immer dieses In-Order oder Out of Order Execution ist,
wo man dann eben auch sagen kann,
also je nach unterschiedlicher Strategie wird dann eben auch das Wirksamwerden von Befehlsabwartungen entsprechend in der Reihenfolge der Befehle nur wirksam,
was dann eben in Order ist oder ich kann das also auch beliebig umsortieren,
das wäre dann eben out of order.
Beide Konzepte haben jeweils Vor- und Nachteile und also gerade als das aktuell war,
also irgendwie so Mitte der 2000er-Jahre, bis mal so bis 2010,
haben sich da dann also immer so die Chip-Hersteller dann,
also auch immer noch regelmäßig quasi zumindest werbetechnisch bekriegt das,
also eben jeweils, also entweder das oder das andere Konzept, dann ist es entsprechend jeweils besser waren.
Gut, dann hat man eben auch, ich habe jetzt immer gesagt, ursprüngliches von neuem Konzept, ein gemeinsamer Speicher für Daten und Programme. So,
jetzt habe ich ja auch schon ein paar Mal gesagt oder angedeutet,
also das, was man typischerweise sehr hart ist,
dass man einen langsamen Speicher hat,
einen sehr schnellen Prozessor, das passt nicht zusammen,
dem zuvor gibt es dann eben so was wie immer kleiner und immer schneller werdende Speicher,
das, was nämlich First Level, Second Level,
Third Level Cash ist und Zum Prozessor hingesehen,
wenn ich Pipelining machen möchte,
habe ich dann eben schon eine Trennung von Instruktionen und Daten,
was dann auch wirklich getrennte Speicherbereiche sind,
weil sonst würde Pipelining auch nicht funktionieren.
Also auch darauf werde ich dann also in dem entsprechenden Kapitel
noch kurz eingehen. Das ist dann das,
was unter dem Stichwort Harvard-Architektur dann eigentlich dahintersteht. Gut,
Speicher-Herarchie-Cashes, also auch das wird uns dann noch in,
dann also nochmal ein Kapitel später,
dann nach dem Pipelining
als Kapitel 18 begegnen
Gut, ja, wie sieht jetzt so die Hardware-Architektur so
eines typischen Systems aus? Also dies hier oben soll Registerpfeil
heißen. Da ist man also irgendwie bei dem PDF-Generieren,
also irgendwie irgend so ein Overlab da drauf gefallen,
dass wir das also dann irgendwie nicht angezeigt wird.
Also wie gesagt, also ich habe hier also eigentlich meine
eigentliche CPU mit den Registern, mit Programmzähler, Alu,
wo es Interface, ich gehe dann über irgendwelche Systembusse, dann eben
Auf sowas wie so ein zentrales Buchsystem. Hab dann eben
vielleicht noch eine entsprechende Verbindung zum Hauptspeicher. Und hier an
diesem zentralen Buchsystem hängen dann eben irgendwie sowas wie Grafiksystem,
irgendwelche anderen Schnittstellen oder eben die Festplatten mit dran.
Und ich habe eben so Erweiterungskarten, um da jetzt noch irgendwas reinzutun. Gut,
also dass hier die Grafik aus dem Buch von Brian Donnroe Helleran,
nicht Azoom muss dann sich im Prinzip so ein 286 Computer,
also irgendwie so aus den 80er Jahren vorstellen.
Inzwischen stimmt das eben auch nicht mehr so ganz,
weil Der Hauptspeicher, beziehungsweise der Hauptspeicher-Controller und diese Memory-Busse,
das hängt dann eben hier auch schon alles in der CPU mit drin.
Und teilweise diese Schnittstellen sind eben auch hier reingewandert.
Und hier gibt es dann eben auch mehrere getrennte Bussysteme nicht.
Also dieses hier wäre jetzt typischerweise sowas wie ein Isar oder ein später PCI-Bus,
nicht aber für einen PCI-E-Bus, stimmt das so,
also auch schon alles nicht mehr, sondern das ist dann nochmal zweistufige Übersetzung nicht.
Aber das ist eigentlich so grob erstmal die Idee,
wie so ein System aufgeteilt ist
Ja, und wie würde das jetzt also irgendwie arbeiten,
wenn ich jetzt sage, okay,
ich möchte mein Programm Hello World starten, nicht,
wo ich dann also jetzt irgendwie eine Kommandozeile habe,
nicht, da würde ich dann eben entsprechend eintippen,
okay, Hello soll ausgeführt werden,
das geht dann also in dem Fall jetzt bei USB-Tastatur dann also hier irgendwie über den Boss,
entsprechend an die CPU, dann wurde eben nachgeguckt werden,
gibt es das ausführbare Executable dazu dann eben auch passend in dem Hauptspeicher,
nicht, dass das in dem Fall jetzt,
also das war es in dem Fall jetzt,
also meine Shell oder meinen Kommandozahleninterpreter,
also den ich jetzt also vom Betriebssystem habe,
dann eben letztendlich daraus mache.
Und was da dann eben passiert, ist dann,
dass im Hintergrund dann quasi von der Festplatte beziehungsweise aktuell dann
natürlich logischerweise von der SSB ja sowas wie dieser Code quasi dann hier reingeladen werden würde.
Nicht, was man hier eben auch sieht. Also bei sowas
hier ist die CBU dann eben auch nicht mehr beteiligt. Nicht,
dass es dann eben genauso ein Mechanismus, wo ich jetzt gesagt habe,
Irgendwas von der Platte laden ist im Vergleich zu den mehreren Gigahertz, mit denen der Prozesse arbeitet, unendlich langsam. Und da ich natürlich typischerweise jetzt nicht nur also irgendwie meine,
meine langsame Benutzereingabe habe, sondern die CPU aneinander,
also auch noch irgendwie mit ein paar anderen Aufgaben beschäftigt ist,
also im Zweifelsfall möchte ich erst mal meine Fans,
die Oberfläche vom Betriebssystem irgendwo sehen,
also spreche grafische Oberfläche mit Desktop und hier was und da was und Eigens und Sonstiges,
dass wir ja auch alles irgendwo laufen und braucht Rechenzeit,
nicht das heißt, während Ich also hier irgendwie so eine Aufgabe oder Angabe mache,
sage, Programm starten, Betriebssystem stellt fest,
das Programm ist eben nicht im Hauptspeicher, würde dann quasi mein Prozess,
nämlich in diesem Fall der Kommandointerpreter, quasi hier abgebrochen werden,
irgendwas anderes, also beispielsweise jetzt die grafische Ausgabe von meinem Desktop,
würde Rechenzeit oder beziehungsweise CPU-Ressourcen bekommen und jetzt also irgendwie irgendwas neu zeichnen oder irgendwas machen.
Und im Hintergrund findet dann eben letztendlich dieser Datentransfer von
den Programmen statt
Nicht irgendwann, wenn das dann im Hauptspeicher gelandet ist,
würde dann eben entsprechend jetzt von dem DMA-Controller dann eben wieder
ein Interrapt an das Betriebssystem gehen.
Und dann gegebenenfalls irgendwann mal wieder gesagt werden, okay,
jetzt soll das Programm ausgeführt werden, nicht was dann heißt vom Hauptspeicher,
irgendwelche Sachen landen in den Registern, wir nennen das entsprechend ausgeführt.
Und in dem Fall wurde dann eben noch sowas
wie eine Ausgabe dann eben auf dem Display
letztendlich erfolgen
Gut, also das nur grob, so die Idee,
wie dann eigentlich jetzt noch Betriebssystem und diese ganzen anderen Mechanismen da jetzt eben auch noch mit reinspielen.
Also auch da muss ich jetzt immer nur sagen, okay,
das ist einfach jetzt eben auch irgendwie dann aus Zeitgründen jetzt,
also hier natürlich schon, also auch leider nicht mehr in der Vorlesung mit drin. Gut,
ich weiß eben auch nicht,
inwieweit das jetzt da noch bei Softwareentwicklung dann also noch mit dabei ist,
solche Konzepte, also im Prinzip aber sagen wir mal,
so Grundverständnis, also wie jetzt eigentlich so in dieser Schnittstelle von Hardware,
der da drauf liegenden Schicht, Betriebssystem und dem,
was ich jetzt also quasi jetzt hier eben als Hello World hatte,
nämlich dem eigentlichen Anwendungsprogramm oder Anwenderprogramm, also wie das dann zusammenspielt,
auf irgendwelchen Hardware-Einheiten, das ist dann eben das,
was Yankee noch so ein bisschen veranschaulicht werden sollte.
Gute andere Sache dann eben auch,
wo man sich jetzt immer fragen kann, ja,
was passiert jetzt eigentlich, wenn ich die Kiste irgendwie einschalte,
also auch da kann man immer sagen, gut,
bislang bin ich immer irgendwo von so einem stationären Zustand ausgegangen,
alles läuft.
Ich habe hier also irgendwie sämtliche CPU-Kerne am Laufen und, und, und.
Ich habe ein Betriebssystem gebootet, ich habe eine grafische Oberfläche und so weiter.
Ganz am Anfang hat man eben wirklich überhaupt erstmal diese,
das grundsätzliche Problem, wie kriege ich das Ganze zum Fliegen,
was dann in dem Fall heißt,
dass also im Prinzip beim Einschalten der Spannungsversorgung im Prinzip für die ganzen ICs dann eben sowas wie Reset-Signal generiert wird.
Das heißt, dort alles, was irgendwo an Automaten für die Steuerung oder die Kontrolle verantwortlich ist, wird eben auf definierte Anfangszustände gesetzt. Das,
was so zentrale Prozessorregister sind,
also gerade sowas wie Programmcounter, wird eben passend zurückgesetzt,
in dem Fall dann eben auf sowas wie irgendeine Startadresse und unter dieser Startadresse liegt dann,
in dem Fall dann,
also beispielsweise so was wie jetzt also irgendwie so ein einfaches Raum,
also erstmal ein Mechanismus, der dafür sorgt,
dass das Betriebssystem als erstes geladen wird,
was dann eben Als erster Tal des Programms dann eben in dem Fall dann über so ein Bootloader-Mechanismus dann geladen wird.
Was dann zusätzlich noch mit stattfindet, ist,
dass im Prinzip sowas wie irgendwelche Selbsttests noch mit durchlaufen,
also in der Regel am Markt man noch irgendwelche Speichertests,
die dann stattfinden, Cash-Speicher werden,
initialisialisiert bzw. in dem Fall jetzt zurückgesetzt,
das heißt also alles,
was dort in Information ist,
wird als ungültig markiert
Chipsatz wird, passen konfiguriert. Nicht,
es wird eben festgestellt, welche ein Ausgabekomponenten sind dann letztendlich
da nicht und anschließend erfolgt dann eben das eigentliche Laden des Betriebssystemkerns.
Gut, ja, damit sind wir jetzt eigentlich so mit
diesem Teil der Rechnerarchitektur oder Hardwarearchitektur soweit fertig.
Jetzt werde ich in dem Kapitel in der nächsten Woche
noch so ein bisschen was zum Befehlssatz sagen,
beziehungsweise dann eben zu den dort zugrunde liegenden Eigenschaften.
Letztendlich das, wo wir uns da bewegen. Hier nochmal
jetzt also irgendwie in zwei, drei Folie nur ganz,
ganz kurz, also zur Motivation, also aus dem Buch von Betterson Hellnessy.
Also wir haben jetzt hier in Rechnerstrukturen so ein bisschen kennengelernt,
Digitalschaltung, also sprich irgendwie so Butsche Algebra, Schaltnetze,
Schaltwerke, nicht also welche Hardware-Einheiten gibt es da.
Und gut, so ein bisschen was zum IO-System hatte ich jetzt eben ja schon so kurz gesagt,
nicht ansonsten wären wir jetzt also in diesem Kapitel uns dann
eben noch mal kurz mit diesem der Instruction Set Architecture oder den Befehlssatz kurz beschäftigen.
Und das ist dann eben eigentlich genau die Schnittstelle,
wo man sagt, also aufbauend,
auf irgendwelche Hardwareeinheit habe ich eben für meinen Prozessor einen bestimmten Befehlssatz,
der dann, ähnlich wie ich das also eben gerade an diesen Grafiken dann gezeigt hatte,
irgendwo auf diesen Hardware-Strukturen durch geeignete Datenfahrer abgearbeitet werden kann.
Und damit wird quasi zum einen als Basis natürlich irgendwie sowas wie
das eigentliche Betriebssystem da drauf, also irgendwo zu realisieren sein.
Und auf der anderen Seite das,
was wir dann eigentlich typischerweise in der Softwareentwicklung dann erstmal sehen,
also unsere eigene Anwendung, die dann eben auch darauf aufbaut.
Zusätzlich hat man da natürlich noch irgendwie sowas wie ein Compiler-System,
was man dann eben braucht, um jetzt also von Hochsprache,
sei es für Anwendung, sei es für Betriebssystem,
dann eben wirklich zu diesen eigentlichen Teilen des Befehlssatzes zu kommen.
Gut, und in dem Befehlssatz kann man eben sagen,
das ist eigentlich alles, was Attribute eines Rechners sind,
die den Programmierer interessieren. Also das heißt,
zum einen muss ich irgendwo als Programmierer grob wissen,
wenn ich jetzt also Code für,
also zumindest ist das auf Isar-Ebene für einen Rechner schreibe,
wie sie grob diese Hardware-Struktur aus.
Das heißt, wie viele Register gibt es?
Wie ist die Wortbreite? Welche Recheneinheiten gibt es? Wie
ist der Speicher organisiert? Wie sind die jetzt miteinander verbunden? Das heißt,
also da ist man so ein bisschen so auf dieser Hardware-Basis
und auf der anderen Seite muss sie natürlich also irgendwie sowas Wir wissen,
wie dann eben entsprechend das Verhalten dazu ist.
Das heißt, welche Datentypen, Datenstrukturen gibt es? Wie werden die kodiert im Speicher abgelegt? Dann den eigentlichen Befehl,
das ist die Befehlsformate, das ist also etwas,
was dann, wie gesagt,
nächsten Mittwoch dann also hier noch weiter folgen wird und letztendlich dann eben noch so Sachen,
okay, wie sehen eigentlich jetzt Datenzugriffe auf einen Speicher aus,
wie wird das modelliert und was kann dort dann eben noch entsprechend alles passieren,
also Ausnahmebedingungen,
wenn ich jetzt zum Beispiel sowas wie irgendwelche Cash-Messes habe.
Gut, wie gesagt, Befehlssatz. Hier abschließend nochmal,
also diese Grafik aus Pattern und Hellescene,
kann man sich eben immer so vorstellen, als der Teil,
wo er sagt, okay, da wird Software und Hardware voneinander getrennt.
Also oben tummelt sich die Software und dann hat man also die zugrunde liegenden Hardware,
die dann also letztendlich die Basis davon darstellt. Gut,
jetzt nachfolgend haben wir also jetzt genug von Registern und Flip-Flops und irgendwelchen logischen Gartern Bulcia Algebra gehört,
außer einen ab noch zumindest jetzt noch eine Einübungsaufgabe soll es das jetzt also gewesen sein,
dann erwähnen wir uns also jetzt ein bisschen hiermit noch mit beschäftigen,
also quasi als Basis von dem, was dann nachher,
also dann wirklich da drauf liegen,
da sie jetzt in SE dann eben an Software drüber liegt.
Gut, damit soll es das dann vor heute gewesen sein,
ein schönes Wochenende und dann bis nächste Woche