Gut, ja, bevor ich jetzt mit der Vorlesung
gleich weitermachen, noch kurz zwei Ansagen.
Also zum einen der Tal mit den Betriebssystemen wird ja quasi
jetzt neu hinzukommen. Ist zurzeit noch heftig im Entstehen,
sagen wir also für diese Woche habe ich genügend Folien.
Alaba, das Kapitel selber ist noch nicht ganz fertig.
Ich habe also das, was jetzt also quasi jetzt aktuell ist,
sprich Stand von Vorhin, jetzt,
also hier schon mal soweit auf die Webseite getan,
finale Version wird dann aber erst Anfang nächster Woche letztendlich fertig sein.
Ansonsten, zweite Sache, Übungen bzw. Übungsbetrieb.
Wir sind inzwischen ja mit der letzten Übungsaufgabe durch bzw. heute
um Mitternacht. Das ist dann quasi finale Abgabe.
Neue Übungsaufgaben wird es jetzt also nicht weitergeben.
Zur Vorbereitung auf die Klausur
Es wird ja dann auch mal die Frage kommen, ja,
was ist denn jetzt hier eigentlich mit den Sachen Betriebssystemen,
mit den Sachen,
Rechenarchitektur 2, die ich jetzt noch quasi vorgestellt habe,
wo er seine Übungen also auch jetzt bis auf die letzte oder in den letzten Aufgabenzettel zwei Teillaufgaben da auch nichts weiter daran gekommen ist.
Da wird es eben so sein,
dass es da in einer Probeklausur, die wir noch machen werden,
und es gibt dann auch nochmal so eine Frage- und Antwortstunde,
das Ganze wird nach jetziger Planung am Montag vor der Klausur stattfinden.
Also wir haben jetzt in Ladas Pech oder Glück,
kann man jetzt so oder so sehen,
dass die Klausur aus jetzt gleich direkt in der übernächsten Woche eher schon ist.
Eine Vorteil, man vergisst nicht, vielleicht nicht ganz so schnell,
auf der anderen Seite Vorbereitungszeit ist er natürlich schon so ein bisschen enger.
Gut, jedenfalls,
also dazu werde ich dann also auch noch mal ein bisschen was sagen,
beziehungsweise Informationen hier auf die Webseite von den Rechnerstrukturen stellen,
also sprich hier unter aktuelles,
wird dann also noch mal ein bisschen was dazustehen zu dem Ablauf.
Wie gesagt, ich werde dann also auch noch mal sowas wie eine Probeklausur anbieten.
Das heißt, da kann man dann also schon mal sehen,
welche Arten von Aufgaben drankommen und so weiter. Ansonsten auch nächste Woche wird es dann in den Übungsgruppen,
wo ja dann noch mal quasi ein bisschen Nachbesprechung jetzt des letzten Zettels ist,
der jetzt quasi heute abgegeben würden soll,
wird es daran auch noch mal den zweiten Satz der Musterlösung fertig ausgedruckt geben,
dass man dann also quasi letztendlich als hauptsächliche Prüfungsvorbereitung dann eben wirklich diese Musterlösung hat,
weil wie gesagt, bis auf eine Aufgabe,
die jetzt also sich vielleicht mit den anderen Themen beschäftigt,
wird eigentlich in der Klausur alles so sein,
wie das in den Übungsaufgaben beziehungsweise in den Musterlösungen auch entsprechend dokumentiert beziehungsweise vorgekommen ist.
Das heißt, Jetzt diese ganzen letzten Sachen,
die ich jetzt zum Beispiel auch noch zum Betriebssystem vorstellen werde,
muss ich immer sagen, okay, jetzt fängt es an,
langsam mal interessant und spannend zu werden.
Aber keine Angst, das wird dann also, wenn,
dann in der Closure quasi nur qualitativ abgefragt.
Also sprich, man soll dann, also vielleicht mal so
ein paar einfache Sachen machen. Aber wie gesagt,
also dazu wäre dann in der Probeclosure dann also auch nochmal was Vergleichbares mit auftauchen, dass man da nochmal so sieht, was da vielleicht maximal noch dran kommen kann. Gut,
dann Ich hatte ja letzte Woche im Prinzip aufgehört,
mit diesem Teil Rechnerarchitektur US2,
wo ich also nochmal kurz die Speicherhierarchie vorgestellt habe,
bin damit ja nun nicht ganz fertig geworden,
das werde ich jetzt nochmal im Schnelldurchlauf soweit nochmal beenden,
wie gesagt, unter Speicherhierarchie ist jetzt eben erstmal gemeint,
dass man sieht, okay, ich habe,
ähnlich wie in so einer Pyramide angeordnet, vergleichsweise aufwendigen,
teuren, aber dafür sehr schnellen Speicher,
da der aber eben entsprechend teuer ist quasi für das System davon eben nur entsprechend sehr wenig,
also sprich die Register im Prozessor,
dann eben quasi alles,
was irgendwie Speicherhierarchie über Cash ist.
Das ist das, was ich jetzt gleich noch mit vorstellen werde.
Nicht, dann habe ich eigentlich das,
was ich als Hauptspeicher sehe und Konzepte dann festplatten bzw. Virtual Memory
wird dann also noch in den Betriebssystemen mitkommen und ja.
Gut, was hier auch immer noch wichtig ist,
weil auch das und das ist immer noch ein paar Mal begegnen,
im Prinzip die unterschiedlichen Geschwindigkeiten,
dass man jetzt eben einfach erstmal sagen kann, okay,
also CPU ist erstmal um, Größenordnung,
schneller als Zugriff auf den Hauptspeicher.
Das ist nämlich dann gleich der Grund, weswegen wir im Prinzip Cash-Speicher brauchen.
Wenn ich dann sehe, wie schnell eine Festplatte oder eine volle State-Disk ist,
dazwischen liegt dann eben auch nochmal ein bisschen was. Und das ist eben das,
was dann teilweise durch die Hardware teilweise,
aber eben auch durch Komponenten des Betriebssystems gemacht wird,
dass man letztendlich dafür sorgt,
dass quasi jetzt für den Programmierer mehr oder minder transparent das Ganze so aufgelöst wird,
beziehungsweise die Daten eben so transferiert werden,
dass ich also jetzt von meinem Programmiermodell her immer sage,
ich habe einen beliebig großen Adressraum,
der ist irgendwo auf den Speicher abgebildet.
Und trotzdem läuft das Ganze im Idealfall eben mit voller Prozessorgeschwindigkeit,
obwohl der Speicher mit der Geschwindigkeit, die die Daten liefern könnte.
Das ist also das, was sich da dann eben in
der Speicherhierarchie daneben noch mit verbirgt.
Gut, was haben wir da jetzt? Also auf unterster
Ebene letztendlich die Register im Prozessor? Das ist also das,
was wir also irgendwie ganz früher dann mal unter Schaltwerke kennengelernt haben,
also sprich blöd ausgedrückt, einfach erst mal Flipflops,
mit denen man dann also quasi seine Witz speichert.
Da kann ich jetzt natürlich wirklich mit voller Taktfrequenz irgendwie was lesen.
Oder S-RAM-Speicher, mit denen man dann eben auch noch relativ schnell unterwegs ist. Nicht,
dann hat man eigentlich die ganzen Halbleiterspeicher, also sprich von S-RAM,
den Zellen, die jetzt also quasi was wie Cash sind,
bis zu dem war es also die Rahmenspeicher,
ist das, was wir, sagen wir mal so,
als Speicherriegel typischerweise kennen und bei uns dann irgendwie in den
Computer reindrücken
Was? Dem dann eigentlich immer gemein ist,
also sprich von CPU bis zu vierter Ebene Speicher,
ist dann eben letztendlich, wenn ich Strom ausschalte, ist Informationen verloren.
Das heißt, dauerhaftes Speichern von Informationen geht dann eben nur auf Festplatte beziehungsweise Solid State Disc.
Da habe ich dann eben eine sehr hohe Speicherkapazität,
also von typischerweise, wenn ich inzwischen,
also irgendwie mehreren Terabyte, die man, sagen wir so,
im Consumer-Bereich sich dann also irgendwo da reinsteckt und wo dann eben letztendlich alle Daten dauerhaft und darauf im Zugriff sind,
wenn das System startet,
wird von dort aus dann also eben auch letztendlich Betriebssystemen,
aber eben auch sämtliche Anwendungsprogramme dann eben in den Hauptspeicher geladen,
von dort aus dann eben ausgeführt.
Und das passiert dann eben teilweise durch die Hardware teilweise dann eben bei Anwendungsprogrammisches Betriebssystemen.
Zusätzlich kommt dann noch ein Effekt dazu, dass Festplatten,
das werden wir dann über ein Betriebssystem gleich noch sehen,
dann noch als zumindest von der Idee her sowas darstellen wie Virtual Memory,
das heißt, Dadurch wird eben auch ein Konzept realisiert,
dass der Benutzer bzw. das Benutzerprogramm eben erstmal beliebig viel Speicher zur Verfügung hat, unabhängig davon,
wie viel Hauptspeicher jetzt wirklich physikalisch in dem Rechner verbaut ist.
Also im Prinzip kann ich eben irgendwo ein Programm schreiben,
wo ich sage, okay, da adressiere ich jetzt,
was weiß ich,
also irgendwie 128 Gigabyte Speicher und rechne da irgendwie was mit drauf rum.
In der Regel wird mein Rechner also erstmal nicht so viel Speicher haben.
Trotzdem würde das Programm laufen In dem Fall dann eben nur unendlich langsam,
weil dann eben zum Tragen kommt, dass Teil des Speichers zwischenzeitlich einfach auf die Festplatte ausgelagert werden.
Früher, als man noch nicht so viel Hauptspeicher hatte,
war sowas also gang und gäbe inzwischen bei den meisten Rechnern,
muss man sagen, die sind eigentlich immer so weit ausgestattet,
dass solche Effekte rein praktisch möglicherweise nicht mehr zum Tragen kommen.
Wenn ja, dann würde man das also auch relativ schnell merken,
weil dann also wirklich der Rechner sich also auf einmal
sehr,
sehr zäh anfühlt
Gut, aber wie gesagt,
dieses Konzept dahinter gibt es nach wie vor immer noch,
Virtual Memory wird auch von allen Betriebssystemen unterstützt,
beziehungsweise so gemacht,
weil das nämlich auf der anderen Seite dann auch wieder der Mechanismus ist,
der dafür sorgt,
dass ich in meinem Benutzerprogramm quasi jetzt von Adresse 0 bis Adresse irgendwas adressieren kann und ein anderes Benutzerprogramm das genauso macht und das Betriebssystem eben dafür sorgt,
dass diese Programme an unterschiedliche Stellen im Hauptspeicher wieder abgebildet werden,
damit die sich nicht gegenseitig ins Gehege kommen.
Das ist also das, diese Umsetzung, die dann also
letztendlich eben auch sich hinter diesem Virtual Memory verbirgt.
Wie gesagt, das wird uns dann im nächsten Kapitel dann also
auch noch schätzensweise Ende dieser Woche oder Anfang nächster Woche dann nochmal begegnen. Gut,
und dann hat man natürlich noch irgendwie, Hintergrund spare ich ja nicht,
das können also im Prinzip jetzt also irgendwelche Backup-Systeme sein,
das können jetzt also irgendwelche Netzwerkspeicher sein,
das kann also irgendwie Cloud sein,
was jetzt also Cloud-Speicher,
der dann also im Prinzip über das Internet dann eben auch noch hält,
also irgendwie ein ganz externer mit angebunden ist,
also da lässt sich dann auch
beliebig viel machen
Gut, hier nochmal aus dem Buch von Hennessey und Patterson,
also nochmal grob, wie jetzt das Sommerarbeit typischen Systemen, die Speicher Hierarchie aussieht.
Also bei Standardrechnern, also hier stehen noch Server drin,
ich habe CPU, ich habe dann irgendwie drei Ebenen in Cash,
ich habe immer Hauptspeicher und dann also irgendwelchen Plattenplatz, Personal Mobile Device,
das wäre jetzt also irgendwie zum Beispiel sowas wie ein Smartphone.
Also auch da muss man sagen,
bei den Geräten ist die Technik eigentlich so, dass man sagen kann,
also im Vergleich bzw. auch von den Konzepten zu der Desktop-Rechner, beziehungsweise Laptop-Rechnern, nimmt sich das da dann nämlich auch nicht zu sonderlich viel. Gut,
hier nur noch mal grob zusammengefasst, wie gesagt,
ich habe zum einen schnellen Speicher,
ich habe dann zum anderen, also vielleicht bei so günstigen Speicher,
der dann aber eben eine sehr große Kapazität hat,
nicht hier auch nur noch mal so grob aufgeschätzt,
beziehungsweise ich weiß gar nicht,
also das waren glaube ich noch die Preise vom letzten Jahr,
da hat sich jetzt allerdings glaube ich nicht ganz so viel getan,
also Hauptspeicher kann man eben sagen, Kosten pro Gigabyte,
irgendwo so im Euro-Bereich, bei Festplatten ist man da also über ein paar Cent,
Solid Status, liegt man da also noch ein bisschen höher,
aber und das einmal zu den Kosten.
Auf der anderen Seite dann eben hier die Zugriffsgeschwindigkeiten,
also weit beim Hauptspeicher bin ich da, also irgendwie im Nanosekundenbereich,
vom anderen Zahllings immer noch nicht bei Gigahertz ist,
sondern eben auch noch irgendwie ein paar mehr Takte braucht,
nicht dann Festplatten im Millisekundenbereich,
also bis dann Hardware-Prozesse schon mehrere Millionen Taktzyklen gemacht,
bis also irgendwie was von der Festplatte vielleicht überhaupt mal anfangen kann zu lesen.
Und gut, tolle Status,
das ist auch nochmal ein bisschen schneller,
aber trotzdem immer noch unendlich viel langsamer als die CPU
Gut, jetzt nochmal zu dem Thema Cash.
Warum braucht man das oder warum wird das eigentlich benutzt?
Also wenn man sich mal, Grafik ist zwar jetzt nicht ganz neu,
obwohl die also aus dem Buch von in der Auflage von 2016 ist,
aber die geht auch nur bis
2005. Trotzdem der Trend ist, ist nach wie vor da,
beziehungsweise es gilt nach wie vor so.
Also wir haben hier Mooslow, exponentiellen Anstieg. Bei den Prozessoren,
wo man dann sagen kann, die sind also quasi pro Jahr,
zumindest so bis Mitte der 2000er Jahre immer irgendwie so um 55 Prozent schneller geworden.
Inzwischen, das ist also hiermit so ein bisschen angedeutet,
ist das eigentlich so ein bisschen abgeflacht, weil,
hatte ich auch schon gesagt, da ist dann einfach das Problem,
die Leistungsaufnahmen oder macht das also relativ wenig Sinn,
die Systeme dann noch sehr viel schneller zu takten,
weil ich die dann nicht mehr gepühlt bekomme.
So, beim Zugriffsgeschwindigkeiten auf den Hauptspeicher,
kann ich auch sagen, habe ich auch ein exponentielles Wachstum,
das heißt, bei so einer lugarithmischen Skala,
die jetzt also quasi hier unter Performance mal angegeben ist,
kriege ich dann auch immer so mehr oder minderschöne Grade reingelegt.
Was man aber hier sieht, ist, dass diese
gerade quasi entsprechend weniger stark wächst. Das heißt,
da ist dazu Wachs, also so, dass man sagen kann,
also sieben bis neun Prozent pro Jahr wird der Hauptspeicher schneller.
Das heißt, ich habe hier einfach Geschwindigkeitsmäßig irgendwo so einen Unterschied von,
ich inzwischen also irgendwie zwei Größenordnungen, also sprechen Faktor 100,
der also irgendwie da an Geschwindigkeit dazwischen liegt. Und wie gesagt,
das läuft oder ist eben eine ganze Zeit lang wirklich extrem auseinandergelaufen,
wird inzwischen nicht mehr ganz so schlimm,
aber es ist eben einfach erst mal so,
dass die CPU die Geschwindigkeit eben deutlich schneller ist als das,
was also letztendlich der Hauptspeicher ist.
So, und um das Ganze jetzt auszugleichen,
wird da jetzt eben quasi dieser Cash-Speicher mit reingebaut,
ist dann eben S-RAM, also etwas aufwendigere Speicherbaustein,
von daher dann eben auch teurer.
Deswegen wird er dann eben auch nur in geringerer Menge letztendlich verbaut.
Sieht dann eben so aus, dass das Ganze beziehungsweise Programmier quasi transparent ist,
weil automatisch von der Hardware verwaltet wird. So, und das,
was da passiert, beziehungsweise was die Idee dahinter ist,
dass im Cash-Speicher eben die Teile des Programms quasi zwischengespeichert werden,
auf die das Programm gerade zugreift. Das war etwas,
was sich in der letzten Woche auch schon mal kurz angedeutet hatte,
dass man sagen kann, wenn ich jetzt hier irgendwo meinen Speicher habe,
dass man dann also typischerweise während des Laufs von irgendwie einem Programm A
mal für die Daten irgendwo hier in so einem bestimmten Speicherbereich bleibt,
beziehungsweise für den Programmcode eben auch hier irgendwo in einem bestimmten Speicherbereich.
Vielleicht wären da jetzt noch irgendwelche Systemfunktionen aufgerufen,
die liegen auch hier irgendwo im Hauptspeicher,
aber dass man zumindest während des Programmlaufs von A,
Mechasie, Soundan, hier soll irgendwie Code,
hier soll irgendwie gescherte Bibliotheken sein,
während des Programmlaufs von A eben zumindest zeitweilig immer irgendwie in einem oder mehreren bestimmten Adressbereichen im Speicher arbeitet.
Das ist eben diese Idee dieser Lokalität,
nicht dass man eben sagen kann,
Wenn ich jetzt nicht gerade Sprünge mache, groß unter Programmaufrufe auch,
ganz extrem mache, greift man ihm in der Regel.
Also erst mal nur auf relativ wenig Adressen zu. Nicht wenn,
dann also in der Funktionalität sich groß was endet,
dann ändert sich also da auch in diesen Bereichen vielleicht mal was.
Also die Daten bleiben natürlich, aber hier im Programmcode mag sich was ändern.
Aber das ist dann also einmal ein abrupter Wechsel.
Und auch dann habe ich eben wieder so eine gewisse Lokalität,
die da letztendlich gilt. Das ist eben im Prinzip genau das,
was also durch den Cash-Speicher ausgenutzt wird,
dass wenn der CPU irgendwo einen Speicherzugriff stattfindet,
wird eben gleichzeitig quasi jetzt in allen Ebenen des Cashs und gleichzeitig im Hauptspeicher geguckt,
was ist nicht.
Also das Programm gibt jetzt also hier irgendwie eine Adresse raus.
Habe ich hier den gültigen Wert, habe ich hier
den gültigen Wert oder habe ich hier den gültigen Wert?
Und je nachdem, wer dann also quasi als erster das Ergebnis liefert,
hoffentlich der Cash, dann kann eben entsprechend das Programm hier direkt weiterarbeiten.
Und in dem Fall würden dann eben alle anderen Zugriffe,
also auf den Hauptspeicher oder auf den Second Clevel Cash
abgebrochen werden
Also das ist erst mal grob die Idee. Kann man jetzt also in unterschiedlichen Varianten machen,
am einfachsten natürlich erst mal, dass ich sage,
ich habe in meinem Hauptspeicher Instruktionen und Daten,
dazwischen jetzt eben diesen kleineren, aber eben schnelleren Cash,
wo ich dann eben teile hiervon reinkopiert habe und die CPU arbeitet nur da drauf,
was wir seit letzter Woche zum Thema Pipelining erwissen, ist,
dass man, wenn man jetzt also wirklich Pipelining machen möchte,
dann Zumindest auf dieser untersten Ebene,
was dann also der sogenannte First-Level-Cash ist,
eben getrennt hat, Instruktionen und Datenspeicher,
auf die dann quasi in dem Pipelining-Betrieb gleichzeitig drauf zugegriffen werden kann.
Im eigentlichen Hauptspeicher habe ich dann wieder das Ursprüngliche von Neumann-Konzept,
Rechner, ein gemeinsamer Speicher für Instruktionen und Daten.
Gut, Gehfolie können wir kurz rüberspringen. Dann nochmal ein bisschen was zu den Adressen bzw. zu diesen Adressumsetzung,
aber auch das wirkt sich dann immer so ein bisschen noch auf den Cash aus,
beziehungsweise die Art und Weise, wo der angeordnet ist.
Ich hatte ja gesagt, also das,
was im Betriebssystem dann eben unter anderem noch passiert, ist,
dass die Adressen, die in meinem Programmcode drin stehen,
natürlich nicht identisch sind mit den Adressen,
wo das Programm nachher im Speicher liegt,
sondern gibt es dann eben irgendwie Abbildungstabellen, die dafür sorgen,
dass beispielsweise ich in meinem Programm die Adresse 0 bis N habe.
Hier habe ich jetzt irgendeine bestimmte Adresse. Und die Adressen
wären dann einfach jetzt quasi mit dem Offset noch hinzuaddiert.
Und dann lande ich eben letztendlich bei diesen Adressen. So,
das ist dann eben so eine Adressumsetzung, die dann eben dafür sorgt,
dass unterschiedliche Programme dann eben quasi so über den Speicher verteilt werden können.
Das ist das, was dieser Block Memory Management Unit macht. So,
jetzt kann ich sagen, wenn ich den Cash speicher,
vor dieser Adressumsetzung mache, Dann habe ich einen sogenannten logischen Cash. Das heißt,
da finde ich im Cash jetzt nicht die Adressen,
die im Hauptspeicher drin stehen, sondern die Adressen,
die quasi jetzt außen Programmcode herauskommen,
nämlich meinetwegen jetzt von 0 bis 1. Und da ist,
so rum gesehen, jetzt natürlich der Vorteil,
dass ich diese Adressumrechnung nicht machen muss.
Die kostet ja auch wieder zusätzlich Zeit.
Nachteil von dem ganzen Verfahren ist aber,
dass wenn ich einen Kontextwechsel mache, also sprich,
wenn das Betriebssystem sagt,
es soll jetzt nicht mehr Programm A
auf der CPU laufen,
sondern Programm
Da Bären nun auch quasi mit den Adressen von null bis irgendwas rechnet,
muss dies hier dann alles entsprechend ungültig gemacht werden.
Das ist eben das Cash-Learn-Number-Kontextwechsel. Auf der anderen Seite physikalischer Cash,
das ist dann eben genau das, was dann quasi nach dieser Umrechnung passiert.
Nicht, den muss ich nie lernen,
aber dafür muss dann eben diese Umrechnung vorher passiert worden sein.
So, typischerweise ist das eben die Unterscheidung bei uns in
den Systemen auch. An der Stelle sitzt der First-Level-Cash.
Hier haben wir dann einen Second-Level-Cash und so weiter und so fort.
Also das nur zu den Begriffen beziehungsweise Bilderflichkeiten.
Typischerweise hat man das dann eben auch so Und dass
der Ebene getrennt Innstruktionen und Daten dann eben in der Regel oder logischerweise dann eben auch als mit den noch nicht umgerechneten Adressen,
nicht dann im Second-Level-Cash,
ein gemeinsamen Cash für sowohl Innstruktionen als auch Daten,
die dann im Prinzip hier mit den physikalischen Adressen arbeiten und bei mehr Kernsystemen,
das heißt in einer CPU mehrere oder auf einem Chip mehrere CPUs mit drauf,
hat man dann eben noch so einen gemeinsamen sehr großen Third-Level-Cash,
der dann also letztendlich jetzt wieder von allen Prozessorkern
die Daten zusammenfassen kann
So, nicht? Und wie gesagt,
das Ganze wird jetzt als irgendwie schick von der Hardware verwaltet.
Darum muss sie mich nicht kümmern. Allerdings kann es dabei und immer doch zu einigen Problemen kommen,
die dann eben auch dazu führen, dass also sagen wir mal,
dieser Entwurf oder diese Verwaltung durch die Hardware,
also auch nicht so ganz trivial ist.
Ganze nennt sich dann Cash-Kohärenz, werde ich also auch gleich nochmal ein kurzes Beispiel sagen.
Nicht, was dann auch immer noch entscheidend ist,
das ist jetzt wieder eine Sache,
die dann also teilweise die Hardware teilweise das Betriebssystem dann eben auch verwaltet,
ist die Fragestellung, Welche Daten sollen den Cash?
Jetzt kann ich natürlich immer sagen, ja gut,
eigentlich bräuchte ich jetzt hier mal eine Glaskugel und sage,
okay, das, wo das Programm jetzt gerade rumrechnet,
das möchte ich schon vorher in den Cash geladen haben und dann kann ich immer damit rechnen.
Das heißt, eigentlich das,
was man irgendwo in der Zukunft benötigt, funktioniert eben aufgrund,
sowohl also dieser zeitlichen Lokalität, also der räumlichen Lokalität,
dass ich eben in bestimmten Bereichen jetzt in meinem Programmcode letztendlich sagen kann,
A, zum einen, also Adressen,
die in der Nähe von dem Ganzen sind und eben mit zeitlicher Lokalität,
dass man sagen kann,
insgesamt jetzt über den Speicher eben auch nur in bestimmten relativ eingegrenzten Adressbereichen.
So nicht. Und da kann man jetzt sagen, okay,
was ich dann immer noch brauche, sind jetzt also verschiedene Strategien,
was passiert, wenn ich Daten ändere, in den Cash schreibe,
wann schreibe ich die auf die Platte zurück, was passiert,
wenn der Cash voll ist, irgendwas rausgeschmissen werden muss,
wonach wähle ich das aus?
Nicht, dass dann eben das, was hier mit Ersetzungsrückschreibestrategien gemeint ist. Ansonsten,
das, was dann also mit dem Cash erreicht ist,
letztendlich das, was also hier mit der Cash-Performance,
also mal so in so einem Beispiel,
wenn man eben grob durchgerechnet ist, dass ich sage,
ich habe oder betrachte also quasi als Hit,
wenn ich jetzt mit einer Adresse meine Daten im Cash finde,
als Mist,
wenn ich irgendwas nicht im Cash finde und es dann eben erst mal relativ aufwendig von der nächsten Speicherebene mir irgendwo laden müsste.
So, dann kann man jetzt eben einfach erst mal über
Wahrscheinlichkeiten sowas wie eine Trefferrate bzw. wie eine Fehlerrate definieren,
hat dann also wohl für das Lesen aus dem Cash als auch für das Lesen,
wenn ich also im Cash das nicht finde.
Das heißt, das von der Speicher oder von der Hauptspeicher geladen werden muss,
entsprechende Zeiten. Da kann man jetzt eben sagen,
insgesamt ergibt sich jetzt eben so eine mittlere Speicherzugriffszeit,
die sich dann eben berechnet, also einmal,
wie lange braucht es, wenn ich das finde,
wenn ich es nicht finde,
kommt da dann eben nochmal hinzu,
die Zeit,
die ich dann brauche,
um es aus dem Hauptspeicher
zu lesen
Ganz dann eben entsprechend multiplizierter mit der entsprechenden Fehlerrate.
So nicht. Und wenn ich jetzt eben sagen kann,
ich schaffe es, beziehungsweise die Hardware schafft es,
den Cash also hinreichend gut zu füllen. Also wie gesagt,
hier hatte ich jetzt ja irgendwie echt dieses mit den 20 Prozent
oder dass man da eben vielleicht auch noch besser ist.
Also hier ist es jetzt mal mit 5 Prozent gerechnet.
Das ist also eine Missrate von 5 Prozent aus dem Cash
was lesen, kriege ich das in einem Tag.
Beim Missbrauche ich 20 Takt, wenn es die mittlere Speicherzugriffszeit dann eben dadurch,
dass diese Missrate hinreichend klein ist, dann eben zwei Takte.
Das heißt, das ganze System läuft da dann doch immer noch entsprechend effizient. Gut,
wie ist der Cash aufgebaut, beziehungsweise wie funktioniert das jetzt überhaupt,
dass sich da also in der Hardware irgendwie was mit in den Abressen irgendwo zwischenspeichert?
Das ist das, was also jetzt hier in den folgenden Folie
noch kurz vorgestellt wird. Also man kann es sich vorstellen,
als ein Reh von Speicherbereichen, das ist also erstmal das,
was also hier Entsprechend jetzt zyanfarbig gekennzeichnet ist.
In jedem dieser Sets habe ich jetzt mehrere Zahlen,
in denen quasi die Werte stehen und die eigentlichen Werte sind dann also in mehreren Datenblöcken in so einer Zeile organisiert.
Das, was da dann also die Idee ist,
ist, dass man eben sagt, also das,
was ich hier also an diesen Datenblöcken habe, die sind,
beziehungsweise also der Inhalt in diesen Zahlen ist eben für verglichen mit so einer Beitweisen-Adressierung im Speicher oder auch mit den Speicherworten,
die ich jetzt also physikalisch in einem Rahmenbaustein habe,
eben sehr groß.
Das heißt also, ich habe hier in so einer Cash-Zeile
dann eben gleich einen relativ großen Speicherbereich dann also irgendwo im Zugriff.
Gut, wie funktioniert das jetzt mit den Adressen?
Also im Programm habe ich jetzt meine Adresse A stehen,
die ist also irgendwie so und so viel Bit lang,
also in diesem Fall MBit.
Von dieser Adresse A nehme ich jetzt die untersten Bit und adressiere damit jetzt also hier Ein Block-off-Set,
das heißt also hier diese Blöcke in den Cash-Zahlen,
werden dann eben auch, oder sollten dann eben typischerweise natürlich zwei Potenzen sein.
Und dann kann ich jetzt eben sagen, was weiß ich,
also wenn ich jetzt beispielsweise hier sechs Bitch spendiere,
dann könnte ich damit also entsprechend jetzt hier 64 Blöcke unterscheiden.
So, anschließend geht es danach, wie viele von diesen Sets,
also von diesen Mengen, Uncash-Speicher gibt es dann noch,
die werden auch wieder einfach jetzt, wie näher durchgezählt.
Das macht dann eben die Nächsten, Bits aus,
die bezeichnen dann eben diesen Set-Index. Das heißt,
mit einer Zahl hier kann ich dann eben entsprechend null
bis S minus 1 von diesen Sets unterscheiden.
So, jetzt ist die Adresse natürlich noch deutlich länger,
als jetzt meinetwegen hier sechs Bit und hier nochmal irgendwie acht
Bit oder wie viel auch immer das sein mögen.
Die restlichen Bits, die ich jetzt also hier noch nicht verwurstet habe,
bleiben letztendlich über und bilden das, was man Tag nennt.
Gut, wie funktioniert dann der Zugriff auf Den Cash-Speicher.
Dazu gibt es im Prinzip drei mögliche Verfahren,
beziehungsweise drei unterschiedliche Arten von Cashes erstmal.
Also zum einen allereinfachstes sogenannte Direct-Map oder direkt abgebildeter Cash.
Dann gibt es Enfach-assoziativen Cash- und Fall-assoziativen Cash.
So, was ist damit gemeint? Fangen wir also mit
dem allereinfachsten an Direct-Map-Cash. Also ich habe hier meinen Hauptspeicher
. Das ist jetzt also nicht so wahnsinnig groß.
Fünf-Bit-Adressen und ich habe mir meinen Cash,
in dem habe ich
acht Einträge
Und das, was man jetzt einfach macht, ist,
dass man also eine feste Zuordnung hat, von Hauptspeicheradressen,
indem ich jetzt also beispielsweise hier irgendwie die unteren drei mitnehme und sage,
mit diesen drei Bit adressiere ich dann quasi jetzt hier diese Cash-Sets.
Demzufolge, was man dann also hier auch sehr schön sieht,
ist natürlich, dass also quasi Speicheradressen,
die jetzt also hier beispielsweise das,
was es hier orange gekennzeichnet ist,
die also quasi jetzt hier diese Adressen identisch haben,
werden dann also auf die gleiche Cash-Zeile bzw. im
gleichen Cash-Set abgebildet
Das heißt, wieder zurück, also auf diese Grafik von Brandon Royaleron.
Ich habe in meinem Set nur eine einzige Zeile pro Set.
Was man damit dann aber eben machen kann, ist,
dass man damit sehr einfach sehr große Cashes generieren kann.
Allerdings ein Nachteil von dem Ganzen,
was man also hier an dem Beispiel auch schon gesehen hat,
ist, dass natürlich dadurch,
dass ich immer diese feste Abbildung habe, wenn ich jetzt,
also da war ja nach dem Zugriff auf die Adresse hätte,
auf die Adresse hätte, auf die Adresse hätte,
die würden jetzt eben alle quasi auf die Leiche Cash-Speicherzelle zugreifen.
Demzufolge kann es dann eben sein,
dass wenn ich jetzt also hier einen Zugriff habe,
das Datum wird irgendwie im Cash gespeichert, anschließend mal in Zugriff 4 von,
ich dann natürlich den Wert nicht finde, sondern wieder einen Miss habe,
das Ganze würde dann quasi diesen Tal hier verdrängen.
Und man hat dann eben so einen Effekt,
der sich dann Cash-Freshing nennt, wo dann im Prinzip so bei solchen Zugriffen,
wo ich dann also quasi Adresse und Adresse plus N mal ist,
habe, die dann eben quasi immer auf den gleichen Set letztendlich abgebildet werden.
Gut, der Zugriff selber,
jetzt kommen wir jetzt also nochmal zu diesen Adressberechnungen zurück,
sieht dann eben so aus, ich nehme den Set-Index,
damit kann ich jetzt hier sagen,
welches Set hier gemeint ist, also beispielsweise eins,
würde jetzt also quasi jetzt hier diesen von dieser Adresse jetzt eben diesen Set eins adressieren.
Anschließend wird geguckt, sind die Daten überhaupt gültig?
Dafür gibt es ein Validbit. Das wird halt eben gesetzt,
wenn jetzt überhaupt mal vorher dort was Gültiges reingesetzt wurde.
Ansonsten ist das eben gleich null. Wenn ich einen Kontext wechsel gemacht habe,
wird das eben auch vielleicht nur auf null Gesetzen fertig ist.
So, dann wird das sogenannte Line-Matching gemacht. Da wird
nämlich jetzt vorwunders geguckt. Also mit dem Set-Index habe ich
gesagt, das muss hier unter Adresse einstehen. So,
die restlichen Bits der Adresse die ja quasi von der ursprünglichen Adresse
noch über sind, wurden ja einfach in den Tag reingeschrieben.
Das heißt, es wird jetzt eben verglichen,
sind die Bits und diese Bits, die also ich,
die ich in einem Cash finde, identisch. Wenn die identisch sind,
dann habe ich also quasi einen richtigen Set und dann habe ich den richtigen Teil von der Adresse hier,
dann kann ich mit dem Blog-off-Set jetzt eben gucken,
wo ich meine Daten jetzt also auch quasi aus diesem, von diesen ganzen Cash-Blöcken rauslesen kann.
Wenn die nicht identisch sind, dann habe ich einen Cash-Mith,
weil da kann man sich vorstellen,
im Cash steht beispielsweise der Inhalt unter dieser Adresse,
ich greife jetzt aber mit dem hier drauf zu und Das,
was in diesem Fall dann letztendlich den Unterschied machen würde,
ist, dass dann eben für das Take,
in dem Beispiel 0-0 drin stehen würde und ich hier dann also quasi als Tech 0-1 sehe,
wenn ich in dem Zufolge dann eben Cash-Mess habe.
Nicht, dass also die Art und Weise,
wie das Ganze im Prinzip bei diesem direkt abgebildeten Cash funktioniert.
Gut lässig, auch relativ einfach direkt in Hardware umsetzen.
Ich nehme einfach die Adresse,
schneide mir hier quasi immer irgendwie entsprechende Bereiche raus,
mit denen ich dann eben Zum einen Speicher adressiere,
beziehungsweise der dann in den Vergleich geht,
wo ich dann eben mit diesem gespeicherten Tech quasi vergleichen muss.
Stimmt das Tech überein, wenn es nicht übereinstimmt,
steht hier was anderes drin, wenn es übereinstimmt,
geht man weiter vor. Ja,
dann würde ich dann also quasi jetzt dieses Speicherwort hier auslesen
und würde dann eben quasi jetzt mit diesem Blog-off-Set dann eben über einen Multiplexer sagen,
welcher Tal hier dann letztendlich an Daten ausgelesen wird.
Ich lässt sie also relativ einfach straightford in Hardware
auch umsetzen
So bei diesen assoziativen Cashes sieht das Ganze jetzt eben so aus,
dass man einfach sagen kann,
in den Sets habe ich jetzt nicht nur eine Zeile,
sondern mehrere. Das heißt, hier kann eben,
oder können jetzt eben entsprechend unterschiedliche Daten drin stehen,
die sich jetzt eben dadurch unterscheiden, dass dann eben unterschiedliche Takes haben.
Das ist eigentlich entsprechend schon alles. Das, was jetzt
hier angezeigt ist, ist dann eben ein sogenannter Zweifach assoziativer Cash.
Bei Vierfachen hätte ich dann eben entsprechend vier mögliche Einträge.
Achtfach hat man noch, und das war es dann also,
zumindest soweit ich weiß, bei den aktuellen Architekturen dann
eigentlich auch
Gut, ansonsten Verfahren ist eigentlich identisch. Mit dem Set-Index
wähle ich aus, welcher von diesen Cash-Sets meine Daten enthalten könnte.
Dann muss quasi gleichzeitig dieses Tech der Adresse mit allen Techs aus den Cashes
verglichen oder aus diesen Zahlen in dem Set verglichen werden.
Wenn ich da irgendwie was finde, war es sich eben okay,
es ist entsprechend jetzt dieser Eintrag und mit dem Blog-off-Set würde ich dann dementsprechend wieder die Daten direkt auslesen.
Auch das lässt sich dann jetzt mit entsprechend Mehraufwand, aber auch noch relativ einfach, direkt in Hardware umbauen. Das einzige,
was jetzt also hier wirklich deutlich aufwendiger ist,
ist jetzt also hier nicht der doppelte Speicher,
weil dafür habe ich ja den Möglichkeiten, zwei Werte zu speichern,
sondern diese Vergleichseinheiten, die dann eben entsprechend sagen, okay,
nicht habe ich davon zwei, habe ich davon vier,
habe ich davon acht nicht und irgendwann lohnt sich das dann einfach nicht mehr,
weil dann da der Hardwareaufwand größer ist gut und wie man sich dann denken kann,
voll assoziativ ist,
das geht dann eben nur für ganz kleine Cashes,
ich habe nur einen einzigen großen Satz und müsste dann also
komplett sämtliche Tags miteinander vergleichen
Sodass eigentlich zu den Atem der Cashes, dann kann man sich jetzt natürlich noch fragen,
wie viele Bits spendiere ich sinnigerweise jetzt hier für diesen Blog-off-Set oder sinnigerweise jetzt also hier für die Menge dieser Sets,
nicht weil das ist ja letztendlich das, was man da jetzt irgendwo noch frei wählen kann. Und da kann man halt eben sagen,
das, was ich bei den Cashes ja mache,
ist, dass ich letztendlich die ordentliche Lokalität irgendwo ausnutzen möchte,
dass ich eben die Vorteile habe,
dass man dann eben deutlich größere Speicherwörter,
also sprich sowieso schon mal keine Bytes,
aber eben auch mehr oder breitere Datenbündel quasi überträgt,
als jetzt also vom Hauptspeicher und das,
was man da dann eben auch immer noch macht,
ist, dass eine sogenannte Birst-Adressierung macht, das war etwas,
was ich also bei dem Teil Rechnerarchitektur 1,
als ich mal DRAM vorgestellt habe, irgendwie so ganz kurz angesprochen habe,
dass der Speicher so funktioniert,
dass man also im Prinzip sowas wie eine Startadresse vorgibt und dann einfach sagen kann, automatisch,
gib mir mal ein und noch im Wald und noch im Wald.
Und der Speicher zählt dann automatisch rauf und man muss nicht
jedes Mal sagen, ich möchte von der Adresse lesen.
Ich möchte von der Adresse lesen, ich möchte von der
Adresse lesen, das von Hand quasi umschalten.
Nicht das ist also das, was dann immer mit diesen Burst-Modus-Modus-Mody gemeint ist.
Gut, aber Cash-Dimensionierung, also was hat man da typischerweise?
Quintessenz ist, es gibt sowas wie ein lokales Minimum jetzt für die mittlere Zugriffszeit.
Woraus ergibt sich das? Wenn ich jetzt sage,
ich mache in dem Cash eine kleine Blockgröße,
Blockgröße war, wie viele Bytes ich hier drin habe.
Dann heißt das, natürlich, dass ich,
wenn ich jetzt also eine Menge an so und so viel Byte insgesamt jetzt in meinem Cash-Speicher,
dass ich dann bei einer kleinen Blockgröße sehr viele Sets bekomme.
Damit kann man natürlich jetzt sehr gut diese zeitliche Lokalität ausnutzen,
weil ich dann eben sagen kann,
ich kann jetzt eben aus meinem Hautspeicher sowohl Adressen hier in
dem Bereich als auch Adressen hier in dem Bereich,
als auch Adressen hier in dem Bereich gleichzeitig in dem Cash haben,
weil der Cash dann eben flexibel auf unterschiedliche Speicherbereiche angepasst werden kann.
Was da aber dann nicht so gut ist, ist die räumliche Lokalität,
weil ich da dann eben erstmal entsprechend wenig Werte habe und
ich habe eben dann eben aber auch noch jetzt wieder als Vorteil,
also eine kleinere Miss Penalty, weil in der Cashline selber,
kleine Blockgröße muss sie nur wenig Daten übertragen.
Dafür habe ich aber eben sehr viele von diesen Sats.
Wenn ich die Blockgröße groß mache, habe ich den Forto
und dann kann ich in so einem Block vielleicht schon mal einen gesamten Teil,
den ich jetzt also hier adressiere, beim nächsten Zugriff wiederfinden.
Das heißt, ich habe einmal einen Cashmith und danach finde ich alles.
Das heißt, da wird dann also diese räumliche Lokalität
sehr gut unterstützt. Nachteil ist aber natürlich,
ich muss dann also sehr große oder sehr vier Datenbereiche im
Falle eines Cashmiths austauschen,
weil ich noch
sehr wenig gesetzt habe
Jedem dieser Sets, aber jetzt eben sehr viele Daten sind,
die dann also einmal komplett weggeworfen werden,
beziehungsweise dann eben aus dem Hauptspeicher neu nachgeladen werden. So,
und nicht interessieren dann eben Effekte, die insgesamt dazu führen,
dass wenn man das jetzt also irgendwie entsprechend statistisch untersucht und macht und tut,
man dann eben irgendwo sowas hat,
wo dann eben für bestimmte Größen sowas wie lokale minimal bei rauskommen.
Und okay, da kann man also erstmal von ausgehen,
nicht das haben die Prozessorhersteller, also sprich die Hersteller Hardware,
eben sagen wir jetzt über die letzten 30 Jahre entsprechend genauestens untersucht.
Das heißt, da kann man schon davon ausgehen,
wenn heute AMD oder Antel sagt,
also der Cash ist so und so aufgebaut,
dass das also für, ich sag jetzt mal,
unsere Programme eigentlich schon genau diesen Fall erschlägt.
Also hier sind so die typischen Bloggrößen, nicht zwischen 32 und 1928 byte.
Beim First-Level-Cash habe ich dann eben von 4 bis 256 Keybee-Byte
als insgesamt Menge des Cashes beim Second Level Cash dann dementsprechend größer,
dann hat man hier sowas dann also entsprechend aufgeplottet
Gut, was beim Cashuan eben auch noch passieren kann,
ist, was passiert, wenn ein sogenannter Cashmiss kommt,
also sprich, die Daten sind nicht da.
Kann zum einen passieren, dass der Cash sowieso noch leer ist. Nicht,
dann kann es sein,
dass sich sowas wie ein Konfliktmiss habe,
das ist also genau das, was ich gesagt habe,
zum Beispiel jetzt beim direkt abgebildeten Cash,
wenn ich also entweder mit meinen Adressen immer der Reihe nach gegenseitig
auf die gleiche Cash-Seile zuweise oder wenn letztendlich die Daten dann eben immer auf identische Blöcke abgebildet werden.
Dann habe ich also jedes Mal einen Cash-Konflikt. Ich finde da jetzt also
nur irgendwas, wo der Technik stimmt und musste was machen.
Und die andere Sache ist dann eben die sogenannte Capacity-Miss.
Typischerweise kann man den Programm dann immer irgendwie so eine Art Working-Set zuordnen.
Also Working-Set ist quasi die Menge des Speichers, die das Programm insgesamt belegt.
Im Idealfall muss man eben sagen, okay,
wenn der Cash größer ist als The Working Set und ich eine gute Lokalität in dem Programm habe,
dann habe ich im Prinzip alles an Daten und alles an Instruktionen,
mit denen das Programm arbeitet,
irgendwann komplett im Cash und dann läuft das Programm auch komplett aus,
dem Cash und dann eben auch entsprechend schnell.
Wenn der Working Set zu groß ist und das gar nicht mehr
in den Cash passt, dann kriege ich eben Cash-Missis.
Das war im Prinzip das,
was also auch bei der einen Aufgabe dann
zumindest partiell gesehen werden konnte
Gut, ja, was passiert? Ersetzungsstrategie. Ich habe einen Cashmith.
Ich muss mir entscheiden, welche Daten schmeiße ich raus.
Beim direkt abgebildeten Cash ist das also kein Thema.
Da ist es also klar, welche Sachen rausfallen.
Ansonsten bei irgendwie so assoziativen Cases kann man dann eben sagen,
least recently used, also sprich der Älteste nicht benutzte Eintrag.
Das heißt, ich muss dann eben für mein Set,
also sprich für alle Einträge, die ich hier drin habe,
eben quasi mitprotokollieren, wo er das letzte Mal drauf zugegriffen ist und der in Anführungszeichen
Älteste fliegt dann eben letztendlich raus. Das kann man dann
in unterschiedlichen Arten und Weisen irgendwie realisieren. Nicht,
dann gibt es noch so andere Strategien, liest Frequent Leuse,
wo man dann eben einfach erstmal Zugriffszähler hat und sagt,
das, was in der Vergangenheit oft genug zugegriffen wurde,
das wird vielleicht demnächst nochmal wiederkommen.
Nicht, das sind, wie gesagt, diese Sachen,
wo man letztendlich dann immer gucken muss,
insgesamt möchte ich dann möglichst gutes Ergebnis haben,
dass sich eben die Missrate möglichst klein mache
Andere Sache ist dann eben auch immer diese Schreibstrategie. Was passiert jetzt,
wenn ich in dem Datenbereich in einer Variablen und irgendwelchen Datenstrukturen was schreibe?
Die Daten liegen jetzt ja auch erst mal im Cash.
Ich schreibe drauf. Dann schreibe ich natürlich nicht in den Hauptspeicher,
weil der ist also erst mal im Faktor 100 langsamer als der Cash,
sondern das wird erst mal nur in den Cash reingeschrieben.
Jetzt ist aber die Frage, wann mache ich das wieder
im Hauptspeicher gültig? Eine Strategie wäre dann eben right through,
das heißt beim Schreiben werden die Daten auch direkt im Hauptspeicher modifiziert.
Dann habe ich eben dieses Problem der sogenannten Cash-Koferenz nicht.
Aber wenn ich da jetzt also sowas wie irgendwelche Laufvariablen habe,
mit denen ich da auf einmal erstmal nur rumzähle,
die werden im Cash andauernd überschrieben und werden dann auch jedes Mal auf,
wenn ich einen Hauptspeicher zurückgeschrieben,
was ja also Hauptspeicherzugriff ja langsam ist.
Auf der anderen Seite sind das Werte, wo ich dann
am Ende vielleicht mal irgendwo ein gültiges Ergebnis haben muss,
aber dann nicht eben sämtliche Zwischenschritte.
Nicht dadurch kann es ein Right Through da dann eben
auch jetzt wieder, je nach Programm gut sein,
aber ihm vielleicht auch sehr ineffizient
Das, was häufig gemacht wird,
was sie vielleicht anbietet, ist dann eben Ride Back.
Das heißt, ich habe in dem Cash die
geänderten Daten im Hauptspeicher stehen noch die alten Daten.
Und nur, wenn die Einträge aus dem Cash rausfliegen,
wird das in den Hauptspeicher entsprechend zurückgeschrieben und aktualisiert.
Hört sich erstmal wunderbar effizient an. Problem ist dann aber
eben diese Cash-Kohärenz. Das wird uns dann jetzt eben
gleich noch auf den nächsten Folien begegnen.
Also Cash-Kohärenz bezeichnet, Cashes und Hauptspeicher
haben identische Daten
Interessant wird das, wenn ich Symmetric Multi-Processing mache.
Das heißt, ich habe nicht nur eine CPU,
die auf dem Speicher drauf zugreift, sondern ich habe mehrere.
Weil dann kann ich nämlich das Problem haben,
dass in einer CPU im Cash irgendwelche Daten sind,
da wird irgendwas modifiziert im Hauptspeicher, sind die alten Daten.
Und was passiert jetzt, wenn ein Prozess,
der auf einer anderen CPU in meinem Rechner läuft,
auf diese Daten drauf zugreift, die Nicht in seinem Cash
aktuell drin sind und die im Hauptspeicher aber auch schon veraltet sind.
Das ist eben das, was sich Cash-Kohärenz nimmt. So, wie gesagt,
das Ganze betrifft natürlich nur die Daten, also jetzt nicht die Instruktion,
weil die sind ja dann typischerweise Red Only, sollten es zumindest sein.
Und dazu gibt es dann eben relativ viele relativ aufwendige Protokolle,
basieren eigentlich alle so ein bisschen auf so einer Idee,
was sich also irgendwie Snooting nennt,
also sprich vom englischen Schnüffeln, dass die Prozessoren quasi Adressen,
die jetzt also irgendein anderer Prozess auf den Adressbus schickt,
quasi mithorchen und eben gucken, möchte der irgendwas adressieren,
was jetzt aber in meinem Cash liegt.
Wenn das passiert, würde dann eben letztendlich vor irgendeiner Fall eintreten,
dass also ein Prozess auf Daten zugreift,
die in einem anderen Cash liegen und gegebenenfalls muss dann eben
dieser Prozess so jetzt entweder ein Cash aktualisieren,
ungültig machen oder muss irgendwelche Daten liefern,
wie auch immer
Gut, wie gesagt, dazu gibt es relativ viele
mehr oder minder aufwendige Protokolle. Ich bekannte es davon,
wenn man es in der Literatur guckt, nennt sich es ja immer mesi.
Da gibt es also quasi vier Grundzustände, Modified, Exclusive,
Shared and Valled. Auch sowas wird dann immer gerne,
also nur mal zu dem Thema endliche Automaten, wofür braucht man das?
In so einem Automatendiagramm beschrieben, wo dann also drinsteht,
wenn das und das auf dem Bus passiert und bei mir das und das ist,
wie habe ich dann Zustandsübergang, wie funktioniert das Ganze?
Wie gesagt, das will ich jetzt also hier nicht im
Einzelnen also irgendwie runterwehten. Hier nur mal kurz veranschaulicht,
wie man sich sowas vorstellen muss, beziehungsweise ist Snooping.
Also ich habe eine CPU 1,
die lädt einen Wert aus dem Hauptspeicher,
kriegt jetzt quasi in ihrem Cash hier irgendwo erstmal dieses Flag E für Exclusive,
weil sie hat es eben exklusiv, die Daten von dieser Adresse.
Nicht. Wenn die CPU jetzt also schreiben,
darauf zugreift, dann die Daten modifiziert,
geht dieser Automat dann quasi in den Zustand M für Modified.
So, und jetzt kommt irgendwie
eine andere CPU
Über den Adressbus und möchte jetzt aus dem Hauptspeicher A laden. Und das,
was jetzt passiert, ist, dass diese CVU ja quasi jetzt mitlauscht,
was passiert auf dem Bus, feststellt, okay,
es soll was von A geladen werden,
mein Zustand ist aber modified,
dann muss eben dafür gesorgt werden,
dass quasi dieses Lesen von der zweiten CPU an der Stelle gestoppt wird.
Und die CPU jetzt also quasi hier den Wert
direkt an die andere CPU gibt,
beziehungsweise an den Hauptspeicher schreibt und dann von da aus
gelesen werden kann
Das wäre also jetzt mal grob so eine Grundidee,
wie man mit diesen Inkonsistenzen umgehen könnte. Und je nachdem,
ob dieses Protokoll jetzt zwei oder vier oder fünf Zustände hat,
sieht das dann eben entsprechend unterschiedlich mit der Abarbeitung aus.
Also das wird zu dem Thema,
was ist da mit Cash-Kohärenz gemeint? Gut, ja,
damit sind wir jetzt eigentlich mit den Cashs auch schon quasi durch.
Jetzt nochmal die Auflösung ganz am Anfang. Ich glaube,
im allerersten Kapitel war ja mal also ein bisschen was zu
diesem Protokoll
Programm, wo also ein Java-Programm war, wo also im
Prinzip eine zweidimensionales RA einmal zahlenweise einmal spaltenweise durchlaufen wurde.
Das wurde mit irgendwelchen Reelzahlen initialisiert. Und was dann also erstaunlicherweise bei rumgekommen ist, ist,
dass man also festgestellt hat, also zum einen berechnet es,
ob ich ihn entweder suche oder so durchlaufe, unterschiedliche Werte.
Und zum anderen dauert das eben auch unterschiedlich lange.
Hatte ich damals motiviert unter diesem Stichwort Rückwirkungen von den unteren Ebenen.
Das heißt also, das,
was hier eigentlich so ein bisschen vermittelt worden sein soll,
wie wirkt sich Hardware auf mein Programmcode aus?
So, und das war jetzt was, was sie eben eigentlich wissen sollte,
ist also zum einen die unterschiedlichen Berechnungsergebnisse ergeben sich quasi aus Rundungseffekten.
Bei der Fließkommerzahndarstellung, das war also dann dieses Kapitel zu den Zahlendarstellungen.
Und die unterschiedlichen Geschwindigkeiten, also sprich dieser Faktor 5,
der da also irgendwie mit drin ist, das ergibt sich im Prinzip aus Effekten aus dem Caching. Nämlich,
dass man sagen kann, also in dem einen Fall,
typischerweise wird das ein zahlenweises durchlaufen sein,
zumindest bei X86 Prozessoren, habe ich eben immer,
dass ich mit den Cashes quasi dann immer mehrere aufeinanderfolgende Argumente ganz gut in den Cash-Zahlen finde,
während wenn ich das spaltenweise mache und gerade wenn man die Datenstrukturen dann eben auch noch entsprechend groß macht,
dann kann man nämlich auch irgendwie so ein Cash-Trashing provozieren,
dann läuft das eben nur über Cash-Misses und dann ist das Ganze sehr viel langsamer.
Und wie gesagt, das ist eben die Gründe dafür,
warum das in dem Programmcode,
wenn ich also hier einmal die Laufindizes,
Roe und Carlom vertausche,
warum das eben einmal schneller,
einmal deutlich langsamer geht
Gut. Das, wie gesagt, zu dem Caching. Ja,
ansonsten in der Regel, man sollte es als Programmierer eben so grob wissen,
wie Datenstrukturen quasi auf den Speicher abgebildet werden,
wie sich das dann eben letztendlich auswirkt.
Nicht ansonsten auch immer nur die allgemeine Empfehlung,
damit die Hardware quasi diese Lokalitätseffekte möglichst gut auswählen kann,
kleinen Working Set, das heißt also nicht unnötig viel große,
globale Datenstrukturen, die man nicht in seinem Programm vielleicht gar nicht braucht.
Und in dem Programm jetzt nicht, sagen wir es mal,
unmotiviert von A nach B und wieder zurückspringen.
Also oder mit entsprechenden Unterprogrammen aufrufen, das Ganze gemacht. Dadurch,
dass man da eben quasi diese räumliche Lokalität beim Programmcode hat,
wo man dann eben mit relativ kleinen Adressbereichen arbeitet.
Gut, damit kommen wir jetzt Zu dem Titel Betriebssysteme besteht
zurzeit jetzt eben so ein bisschen was aus. Hintergrund,
dann Teaminterraptsprozesse, Synchronisation und was da noch kommen wird,
wird sein, Scaledooling,
wird er da speichern und vielleicht noch ein bisschen was zu Dateien,
also IO-Behandlung in dem Fall
Gut, ansonsten muss ich jemand sagen,
also als ich jetzt angefangen habe, wie die Sachen zusammenzustellen,
also ich habe mir über Weihnachten mal so irgendwie so schickerweise zwei Bücher Betriebssysteme reingetan,
also jedes von denen, also irgendwie so knapp 800 Seiten stark,
kann man sagen, okay,
also dummerweise kann man damit dann eben auch beliebig viele eigene Vorlesungen füllen,
gab es früher in der Informatik auch mal,
ist zurzeit jetzt eben nicht mit drin, zum Einweis,
also keine Professur für Betriebssysteme bei uns gibt,
beziehungsweise noch nicht gibt,
soll ja irgendwann auch mal wieder was kommen.
Zum anderen, weil das dann eben so ein bisschen in anderen Sachen mit drin war,
also früher war das in Grund langende Systemsoftware.
Jetzt ist es also eben teilweise jetzt seit diesem Semester hier gelandet.
Demzufolge muss sie jetzt eben sagen, das,
was ich jetzt hier vorstelle, sind eben wirklich nur so die Barsysteme,
die man so ein bisschen kennen sollte zu Betriebssystemen,
worauf ich jetzt allerdings nicht weiter eingehen kann,
sind dann eben jetzt wirklich praktische Beispiele.
Also in den Lehrbüchern wird dann also relativ viel immer von
wirklich aktuellen Betriebssystemen nochmal was gemacht,
die auch nochmal ein bisschen miteinander verglichen
Teilweise auch ganz spannend. Bei den meisten Büchern krankt das so ein bisschen daran,
dass dort dann also irgendwie ein BSD-Unix-System 3 vorgestellt wird und ein Windows 95 damit verglichen wird,
wo man sagen muss, das sind nicht mehr so ganz die aktuellen Betriebssysteme.
Deswegen, wie gesagt,
fällt es mir da jetzt also nicht ganz so schwer,
da jetzt irgendwie was zu machen,
weil ich ja sowieso in einem Buch überhaupt mal
ein bisschen was zur aktuelleren Sachen gesehen habe,
wo dann eben mal zumindest in Windows 8 mit drin war und
also auch mal irgendwie sowas wie ein Android und also irgendwie jetzt ist es Linux,
wobei auch mal mit älteren Körner-Versionen
da dann vorgestellt wurden
So andere Sachen, Dateisysteme, Virtualisierungstechnik, Containertechnik, also auch alles Sachen,
die man da so heutzutage hat, relativ häufig braucht.
Ist ja auch nicht mit drin. Einige Teilaspekte von Betriebssystemen
sind jetzt in der Vorlesung von Hannes Federath betrifft,
verteilte Systeme und Systemsicherheit. Also einmal natürlich dieser Sicherheitsaspekt.
Er wird dann aber auch nochmal also auf diese Rate-Level,
da geht das dann also letztendlich um Art und Weise,
wie Platten arbeiten, zusammengeschaltet werden,
wie da dann die Dateisysteme dann teilweise aussehen.
Das zumindest mal ganz kurz vorgestellt. Ein paar Sachen sind in der Vorlesung
eingebettete Systeme, das kann ich insofern ganz gut sagen,
weil ich den dann auch immer irgendwie noch halte.
Da geht es dann also quasi um eingebettete Betriebssysteme und um Echtzeitverhalten,
was ich jetzt also hier aus den Sachen also auch noch rausnehme,
rausnehmen werde, weil, wie gesagt, also entsprechend wenig Zeit.
Eingebettete Systeme oder eingebettete Betriebssysteme ist dann eben typischerweise das,
wo man jetzt sagt, ich habe jetzt nicht irgendein nichtsartiges.
MacOS, Windows, Linux, was auch immer irgendwie so als Betriebssystem.
Android kann ich im Prinzip oder iOS auch noch mit hinzunehmen,
sondern das, wo man euch sagen kann, okay,
ich habe irgendeinen Steuergerät bei mir im Auto verbaut und das soll jetzt eben der Reihe nach die und die Aufgaben machen.
Also was weiß ich, jetzt also irgendwie die Motorsteuerung abhängig von Klopfsensor
zu dem Zeitpunkt und so weiter, dann eben irgendwie entsprechend alles machen.
Solche Sachen. Auch da Mikrocontroller, jede Menge Sensoren,
ganzen Satzaktoren und dann eben sowas wie ein eingebettetes System,
dann aber eben auch teilweise wieder andere Anforderungen hat,
weil man da dann eben häufig zum Beispiel sowas wie Echtzeitverhalten haben will,
also zumindest in dem Sinne, dass man sagen kann,
nach der und der Zeit soll das System eine Antwort liefern,
das brauche ich in meinem PC nicht.
Ich möchte natürlich schon möglichst schnell auf meine Benutzereingabe irgendwie eine Reaktion haben,
aber es ist nicht lebensnotwendig,
dass diese Reaktionen nach maximal zehn Millisekunden stattfindet,
während wenn ich das jetzt irgendwie hier bei der AWS oder Airbag-Regelung mache,
wobei zehn Millisekunden da auch zu lang wäre.
Nicht nur, wer das dann also dann im
wahrsten Sinne des Wortes tödlich
Gut, also wie gesagt, das sind dann noch andere Anforderungen.
Da hat man an ihm teilweise noch wieder andere Algorithmen und so weiter,
dann dahinter, also gerade in Bezug, also auf die Scheduling,
werde ich dann da sicher auch noch mit rauslassen.
Ansonsten habe ich jetzt also relativ viel,
beziehungsweise bislang eigentlich nur alles an Grafiken,
also aus dem Buch von Starlings genommen, Operating Systems,
was ich also persönlich jetzt für so mit das Beste halte,
was er zurzeit also hier im Fachbereich haben.
Aber wie gesagt,
das sieht zwar nicht ganz so dick aus,
aber das sind,
ist dann also ein
relativ größerer Sching
Gut, zum Inhalt. Also, was sind Betriebssysteme?
Im Prinzip ist ein Betriebssystem nichts anderes, als jedes andere Stück Software.
Also kann ich genauso sagen, das ist ein Programm,
besteht aus irgendwie Assembler-Code und rechnet also auf der CPU rum,
auf der Hardware, genau das Gleiche, was mein HelloWorld-Programm genauso macht.
Das, was Betriebssysteme natürlich machen, ist jetzt natürlich wieder
ein bisschen speziell. Da kann man jetzt wieder sagen,
okay, wozu dienen die oder was soll da passieren?
Also das, was eigentlich Grundaufgabe vom Betriebssystem ist, ist,
dass man sagt, also die Hardware oder die Hardware-Einheiten sollen eben irgendwie möglichst optimal genutzt werden.
Das ist also der Prozessor oder die Prozessoren,
wenn ich jetzt also irgendwie ein, mehr Kernsystem habe,
das sind die Systembusse, das ist der Hauptspeicher,
nicht, wie kriege ich den möglichst gut gefühlt,
dass es dann eben quasi das Ansprechen jetzt von irgendwelchen Plattensystemen als dauerhaften Speicher und das ist eben die Ein- und Ausgabe in Bezug auf Ein- und Ausgabeeinheiten,
also sei es Tastatur, Monitor, aus,
was weiß ich auch immer,
was man sich da jetzt noch denkt.
Also letztendlich alles, was daran da auch noch mit dranhängt. So,
und was dabei dann eben auch noch unter anderem mit passiert,
ist, hat er eben schon gesagt,
also in Bezug jetzt also auf Speicher, Hierarchie und Käsche.
Man hat eben teilweise zwischen diesen Geräten eben sehr starke Geschwindigkeitsunterschiede.
Also wenn ich jetzt Prozessoren und Festplatten nehme, dann kann ich sagen, okay,
da liegt jetzt eben Faktor von mehreren Millionen dazwischen. Nicht,
wenn ich jetzt also irgendwie so eine Ausgabe nehme und sage jetzt,
also hier die Maus oder die Tastatur nicht,
dann kann ich sagen, okay,
also zumindest bei meiner Schreibgeschwindigkeit so mit Fingersuchssystemen oder so kann man sagen,
es war also pro Sekunde irgendwie damit ein paar Eingaben dabei.
Nicht im Vergleich zu den Milliarden Prozessortakten,
die währenddessen stattfinden, ist das also
unendlich langsam
Das ist also das,
was da also bei den Betriebssystemen passiert,
dann letztendlich eben die Koordination jetzt also aller Programme und Dienste und Benutzer,
also hier haben wir typischerweise sitzen wir jetzt also hier an unseren Rechnern natürlich vor allem Single-User-System rein praktisch können die Betriebssysteme,
also unix-artige Systeme können das sowieso, aber auch Windows,
also kann ich jetzt sagen,
das müssen in den Server-Varianten,
kann man eben auch sagen,
können sich auch mehrere Benutzer gleichzeitig
darauf einloggen und da dann eben entsprechend auf einem Rechner gleichzeitig
drauf arbeiten
Und dann geht es eben um die Frage,
wer darf auf was zugreifen, wer kriegt jetzt welche Ressourcen,
Speicher, Prozessor, Plattenplatz und so weiter und eben entsprechend zugeteilt.
Dann in Bezug auf die Programmierung, stellt das Betriebssystem dann
eben einen ganzen Satz von unterschiedlichen Diensten bereit.
Die dienen zum einen natürlich dazu,
diese Ressourcen jetzt erstmal irgendwie nach außen hin zu verteilen und
da zu abstrahieren und eben für die Programmierung gibt es dann eben auch Schnittstellen,
Programmierschnittstellen, auf die du Programmierer rauf zugreifen kann.
Das heißt, wenn ich jetzt eben von der Tastatur irgendwie was lesen möchte,
nicht, dann gibt es da eben eine einheitliche Systemschnittstelle,
wo ich dann eben quasi über einen entsprechenden Riedbefehl da jetzt sage,
okay, da möchte ich jetzt also irgendwie ein Zeichen oder einen String oder was auch immer, was von lesen.
Ich muss mich jetzt aber nicht darum kümmern,
wie ist diese Tastatur über USB und dann über Sonstiges irgendwie
in irgendwelche Speicher- oder Adressbereiche des Rechners eingebettet ist
Wie, was passiert jetzt, wenn der Benutzer eine Taste drückt?
Da muss ich auch nicht selber abfragen. Ist diese Taste
jetzt gerade gedrückt oder nicht? Sondern das passiert dann eben
durch entsprechende Schnittstellen, die sich da ergeben. Und wie gesagt,
da ist dann eben letztendlich dann das entscheidende Wort dann also System Call oder System Service,
dass man dann eben quasi als Programmierer da die Möglichkeit hat,
genau das zu machen.
Was sich dahinter dann auch mitverbirgt, sind zum einen Sicherheitsaspekte,
das heißt, da wird erstmal geguckt,
darf Meda jetzt irgendwie auf dieser Tat darauf zugreifen oder gehört
die vielleicht irgendeinem anderen Benutzer
Raffe ich dahinter dann eben auch noch mit verbirgt, ist,
also einmal diese ganze Zugriffsgeschichte und dann eben auch noch,
wenn ich jetzt also irgendwie darauf zugreife,
dass ich dann eben das Ganze wirklich vergleichsweise einfach handhaben kann und mich da jetzt,
also gut, also Tastatur war jetzt ein einfaches Beispiel,
aber wenn ich zum Beispiel zu was wie Grafik oder Grafikausgabe habe, nicht,
dass ich der Daten da jetzt also nicht gucken muss,
macht das jetzt die Chipsatzgrafik oder habe ich da eine Grafikkarte von der AMD oder von Nvidia drin?
Oder wie sieht das da jetzt genau aus? Sondern da gibt es dann also quasi nochmal so eine Abstraktionsschicht,
die dann in diesem Fall dann der Gerätetreiber letztendlich ist und auf,
der wird dann eben vom Betriebssystem verwaltet und aus Sicht des Benutzers mache ich dann eben nur einen entsprechenden Zeichenbefehl,
der dann darüber dann eben umgesetzt wird,
ihn in so einen System-Call, der das Ganze eben macht.
Gut, ja, wie gesagt, passiert relativ viel,
in der Regel auch nicht als ein monolithisches Programm,
sondern so ein ganzer Satz von Deswegen auch Services, also Systemdiensten.
Insgesamt kann man aber erstmal sagen, typischerweise sind eben Betriebssysteme eigentlich erstmal die komplexeste Software,
die ich also in der Regel auf dem Computer habe.
Gut, kommen wir so ein bisschen zur historischen Entwicklung,
weil dann werden eigentlich die ganzen einzelnen Aufgaben,
also auch immer doch schon relativ gut eigentlich beschrieben.
Also wenn man sich so anguckt, erste Computer,
also sprich diese riesen Schränke, an denen man was irgendwie programmieren konnte,
da gab es kein Betriebssystem,
sondern der Programmierer hat sich eben jetzt direkt mit ja,
Konsole oder eben ganz früher mit irgendwelchen komischen Steckbrettern,
wie auch immer das Dinge programmiert wurde.
Mit dem Computer auseinandergesetzt. Und wenn jetzt also quasi mehrere Benutzer
den Computer nutzen wollten, dann ging das eben wirklich nur ganz strikt nacheinander.
Das heißt, es gab dann also irgendwie,
wie auch immer, Garte, das rotes Buch.
Und das musste man sich eintragen und sagen,
übermorgen möchte ich von 12 Uhr bis 13.30 Uhr
meine Rechenzeit haben für meinen Job
Sofern habe ich schon irgendwie anders reserviert war.
Und man sich da überhaupt anmelden durfte. Und während der Zeit
konnte man dann eben entsprechend exklusiv auf den Computer draufzugreifen.
Ein Nachteil von diesem Ganzen ist natürlich, ja, okay,
was passiert, wenn ich jetzt in diesen anderthalb Stunden nicht fertig werde?
Nicht der Nächste steht da schon hinter mir und dann kann man entweder sagen,
das wird radikal geregelt, das heißt,
da zieht einen einen Stecker und der Nächste dauert,
kann darauf losarbeiten und mein Job wird nicht fertig.
Und ich kann irgendwann nochmal später, vielleicht dann mit
einem Zwei-Stunden-Limit versuchen,
mich einzutragen
Oder eben diese ganzen Reservierungen verschieben sich. Das ist natürlich
auch nicht so schön. Auf der anderen Seite,
wenn ich jetzt sage, gut,
wunderbar, ich reserviere mir da fünf Stunden,
rechne aber nur eine Stunde drauf,
dann wird dieser Computer letztendlich vier Stunden lang nicht genutzt.
Dafür, dass sie damals also wirklich Einzelanfertigungen waren und
entsprechend teuer auch nicht sinnvolle Nutzung. Hinzu kommt dann eben noch das,
was man so als Rüstzeit bezeichnet, also sprich,
wie kriege ich meinen Algorithmus,
mein Programm in das Ding
jetzt rein
Das heißt, vor dem eigentlichen Start des Programms ist erst mal,
was weiß ich, wie viel Stunden oder Vorbereitungszeit dann also letztendlich notwendig,
bis man sagen kann, okay,
in dem Speicher habe ich jetzt meine Instruktion irgendwie mit reinkodiert.
Das, was ich vielleicht an Daten persistent erst mal brauche,
um loszulaufen, ist auch irgendwo reinkodiert.
Und dann kann ich den Schalter umlegen und sagen,
okay, jetzt läuft normal Befehl, hohen Befehl,
dekodieren,
wie viel abarbeiten muss
Gut, also wie gesagt, nicht sonderlich effizient.
Demzufolge kam dann irgendwann als nächster Schritt, also das,
auf was man also als Badge-System bezeichnet, also Badge in dem Sinne,
dass die einzelnen Programme dann quasi als einen Job irgendwo gebündelt wurden.
Der Benutzer eigentlich gar keinen direkten Sprit auf das System
hat und es eben einen Operator gibt,
der sich also letztendlich dann mit dem System auseinandersetzt
, sah früher dann eben beispielsweise so aus,
dass man sein Programm irgendwelche Lochkarten oder Lochstreifen reingestanzt hat.
Das hat man also beim Operating irgendwo abgegeben. Der hat das dann entgegengenommen,
aus so einem Stapellochkarten an so ein Stapellochkarten gemacht,
wo dann also mein Programm da war und irgendwie anderen Programme dann davor oder dahinter.
Nicht, das ging dann irgendwann in, sagen wir mal,
so einem großen Eingabesfloord nicht. Und irgendwann,
wenn der Rechner jetzt mit einem Programm durch war,
wurden dann eben quasi jetzt die entsprechenden Karten oder die entsprechenden
Informationen an zu dem nächsten Programm dann eben entsprechend eingelesen,
das Ganze lief
So das wurde dann eben rein technisch verwahrt von einer Komponente,
die sich dann also Monitor nannte. Also sprich,
ein im Prinzip auch nichts anderes als ein stinknormales Programm,
wo dann eben so ein paar einfache, also Sachen mitgemacht wurden.
Also sprich, ein Ausgabegeräte wurden damit schon verwaltet. Nicht aber ansonsten ging es darum,
also letztendlich diese einzelnen Jobs immer nur der Reihe nach in Speicher zu lesen.
Und anschließend dann eben Ähnlich wie jetzt beim Unterprogrammaufruf zu sagen,
okay, wenn dieser Job jetzt in den Schweicher gelesen worden ist,
dann wird eben die Kontrolle anders Benutzerprogramm übergeben, also quasi analog zum Prozeduraufruf.
Der rechnet hier vor sich hin und hoffentlich ist das Ganze dann eben so aufgesetzt,
beziehungsweise dafür sorgt dann eben der Monitor auch,
dass am Ende des Programms, wenn das quasi beendet ist,
eben der Rücksprung erfolgt und dann eben hier in dem Monitor dann eben die Daten von dem nächsten Job verarbeitet wurden.
Das Ganze konnte man dann immer noch über so ein Job-Control-Language dann,
also irgendwie steuern, die dann eben quasi jetzt gesagt haben,
zu einem Programm beispielsweise, wie lang ist die Maximallaufzeit?
Also sie ist jetzt darum ging,
wenn ich also in meinem Programm eine Endlosschleife drin habe,
dass irgendwann mal die Kontrolle wieder an den Monitor zurückgeht und er sagt,
naja gut, der ist jetzt also irgendwie sechs Stunden gelaufen,
da ist irgendwie Schrott rein programmiert nicht und demzufolge fliegt das jetzt raus und dann kommt das nächste Programm.
Gut, wie gesagt, das waren einfache Matchsysteme,
das Ganze lief dann eben wirklich so in der Art und Weise,
als ob das nun ein Loch Kartenlochstreifen oder irgendwelche Magnetteile waren,
also sprich diese klassischen Magnetwänder Prinzip,
aber das waren dann eben so diese einfachen Badge-Systeme.
So, was ist da an dem System dann aber schon gab,
war, also sind halt Speicherschutz, weil,
wenn ich jetzt also hier in meinem Programm bin und da irgendwie was mache,
dann soll natürlich jetzt nicht, also dies soll jetzt jemand der Hauptspeicher sein,
irgendwas von dem Monitor vom Programm aus überschrieben werden dürfen.
Nicht, weil, dass wir dann also auch schon mal schlecht,
was das nicht sein soll. Gut, Simon hatte ja schon gesagt,
dass man dann eben quasi auch noch über irgendwelche Mechanismen dafür sorgen muss,
dass gegebenenfalls beispielsweise über ein Interrabt dieses Programm hier irgendwann beendet wird bzw. unterbrochen wird und dann eben gesagt wird,
okay, time outside, die sechs Stunden sind abgelaufen,
jetzt kommt was anderes.
Zu dem zufolge hatten die Systeme dann eben auch schon sowas wie unterschiedliche Arten von Instruktionen,
nämlich welche, die also nur durch den Monitor ausführbaren,
ausführbar waren und welche, die dann eben durch den Benutzer ausführbar waren.
Das führt dann eben dazu, dass man nur sagen kann,
also ich habe im Prinzip auch schon unterschiedliche Betriebsmodi,
nämlich Amann sogenannten User-Mode,
das ist nämlich das,
wo dann da eigentlich
ein Badshop läuft
Wo ich aber nicht auf allen Speicher darauf zugreifen kann und
nicht alle Befehle ausführen kann. Und eben den Curnal Mood,
das, wo er jetzt der Monitor drin läuft,
wo dann im Prinzip der gesamte Speicher und eben alle Arten von Befehlen ausgeführt werden können.
So, diese Begriffe begegnen uns auch heutzutage eigentlich bei allen Betriebssystemen immer noch,
was man eben auch immer sagen kann, okay,
wenn ich jetzt mein Programm habe und das ausführe, dann läuft es quasi User Mood.
Und wenn ich einen System Call mache,
also sprechen Zugriff meinetwegen jetzt, also auf die Grafikschnittstelle,
weil ich ja was zeichnen möchte und so weiter,
nicht dann passiert, dass der Grafiktreiber dann quasi letztendlich startet,
der startet dann im Colonel-Modus,
weil der darf dann natürlich direkt an den Grafikspeicher von der Grafikkarte irgendwie was machen und damit arbeiten,
was ich als normalsterbliche Benutzer nicht darf, vielleicht auch nicht,
zwingend nicht will, weil ich da nämlich genau diese Unterscheidung brauche,
welche Grafikhardware ist da drin, wie wird die angesprochen,
so ist das eben über diese System-Calls letztendlich gekapselt.
Also wie gesagt, diese unterschiedlichen Modi,
das kann man jetzt noch feiner unterteilen,
gibt es heutzutage auch, wie gesagt,
das wird dann auch unter anderem in Sicherheit in verteilten Systemen bei Hannes Federatern,
also auch noch mit drin sein.
Gut, ja, dann Interakts werde ich dann heute,
glaube ich, nicht mehr,
aber im Prinzip dann also spätestens übermorgen noch kurz was zu sagen,
wofür man die braucht.
Das ist dann eben auch noch ein Mechanismus,
um die Jobs entsprechend besser kontrollieren zu können.
Ja, Vor- und Nachteile von unserem System.
Ich habe natürlich für den Monitor selber zusätzlichen Speicherbedarf,
weil der ist quasi immer und ständig
im Speicher
Was ich jetzt also vorher bei den einfachen Systemen erstmal nicht hatte.
Und von der Rechenleistung sieht das natürlich so aus,
dass die Prozesse dann eben zwischenzeitlich war,
der immer zwischen den Monitoren den Benutzerprogrammwechsel,
dann eben auch noch diese Befehle hier.
Also sprich die Monitor selber abarbeiten muss. Andererseits,
da natürlich jetzt immer nicht auf irgendwelche Eingaben in
den Benutzerprogrammen oder diese Grundkonfiguration gewartet werden muss,
kriegt man unterm Strich trotzdem natürlich eine deutlich bessere Auslastung
des Computers bei so einem Badge-System
Gut, dann nächste Stufe war dann eigentlich,
dass man sagt, ich habe ein Multi-Programm-Beatch-System, weil was passiert,
ich hatte schon gesagt, sehr stark unterschiedliche Geschwindigkeiten.
Wenn ich nur ein Programm habe in so einem Badge-System,
das läuft und jetzt möchte ich in dem Programm irgendwas von der Festplatte lesen.
Das dauert jetzt also eine ganze Zeit lang,
bis die Festplatte dann also irgendwo den Kopf dahin bewegt,
wo also vielleicht mal eine Daten sind und irgendwann kommen dann
auch mal Daten an
So während der Zeit muss der Prozess eigentlich die ganze Zeit warten.
Das habe ich jetzt hier bei so einem Batch-System einfach erstmal
als tote Zeit. Wenn ich das jetzt schaffe,
in dem System quasi mehrere Jobs lauffähig zu haben,
kann ich eben sagen, okay, wie ein Programm A,
auf die Festplatte wartet, starte ich Programm B,
was also hoffentlich erstmal keine IO-Operation macht.
Das kann laufen, bis es vielleicht auch jetzt auf
irgendein Gerät warten muss und dann wird eben entsprechend das nächste
Programm gestartet
Das heißt, mit diesem Multi-Programming oder auch Multitasking,
erreiche ich dann eben eine deutlich bessere Ausnutzung des Prozessors,
indem ich dann einfach sagen kann,
diese Wartezeiten auf irgendwelche externen Ereignisse kosten mich jetzt nicht mehr Rechenzeit,
sondern ich kann dadurch dann eben, okay,
das einzelne Programm läuft natürlich nicht schneller.
Das ist so genau wie mit Durchsatz und Latenz in der Pipeline,
aber ich kann eben dann quasi jetzt parallel mehrere Programme
gleichzeitig laufen lassen oder mehrere Tasks like zeitig laufen lassen
und kriege dadurch natürlich dann also quasi einen höheren Durchsatz hin
Nicht, das heißt also lange der Job irgendwie auf eine Ausgabe wartet,
wechselte Monitor zum anderen Job, führt aber natürlich dazu,
dass dann der Speicherbedarf dadurch, dass sich dann ja alle Jobs irgendwo laufähig im Speicher halten muss, dann natürlich nochmal größer wird.
Gut, hier ist nochmal kurz aufgezeigt,
wie man sich das vorstellen muss,
das ist jetzt hier für drei Jobs,
die dann also unterschiedliche Anforderungsprofile haben,
also die dann hier erstmal nur vor sich hin rechnen,
hier irgendwelche einen Ausgabeoperationen machen, hier unterschiedliche Anforderungen an Speicherplatz,
an irgendwelche Geräte haben, Gut, das ist jetzt erstmal einfach nur so als Beispiel ausgedacht.
Wenn man das jetzt also eben quasi ansieht,
wie das also letztendlich beim Uni oder beim Multi-Programming aussieht,
ist ja im Prinzip ja so in dieser Grafik so ein bisschen visualisiert,
dass man einfach sagen kann, mit diesem Multi-Programming kann ich ebenso lang,
also beispielsweise spare ich ihn noch nicht ausgeschöpft,
ist dann eben alle drei Jobs hier quasi reintun.
Und damit dann eben gern Abarbeitung, sprich das,
was da zwischenzeitlich eben an Wartezeiten drin ist,
was also hier aber in diesen CPU-Zeiten immer mit drin ist,
dann eben ineinander verschachteln.
Das ist also erstmal das, was da hoch ist,
dass die Idee ist. Gut, nächste Erweiterung war dann
eigentlich das, was man als Timesharing-Betrieb bezeichnet.
Bislang waren das eigentlich alles irgendwelche Offline-Operationen. Das heißt,
na gut, also eben stand es zwar auch schon Terminal drauf,
aber von der Idee her, dass man gesagt hat, okay,
ich habe jetzt Lochkarten oder Magnetbände oder was weiß ich auch immer,
gebe da also jetzt quasi mein Programm rein und das läuft dann also irgendwie durch.
Oder in diesem Fall dann eben beim Multi-Programming dann eben auch schon mehrere Programme.
Time-Sharing-Betrieb ist jetzt eben, dass man sagt, okay,
ich erweitere dies Multitasking dann eben auch noch nichts für interaktive Sachen.
Also sprich, ich habe Benutzer an den Rechnern.
Das war dann die Art und Weise, wie man sag mal so,
in den 60er, 70er Jahren dann letztendlich.
Also die Computer hatte, da muss man sich dann eben auch immer vorstellen.
Große, grau oder wie auch immer, bunt lackierte Kisten. An denen hing dann quasi einfache Terminals,
also sprich ursprünglich waren das mal für alte Fernschreiber später dann also auch so die ersten Grafik-Terminals,
wo man dann also quasi über eine Tastatur Eingaben machen konnte,
wo man dann also quasi jetzt einfach über so eine Zeilenweise Text ein beziehungsweise Ausgabe dann eben sehen konnte,
was habe ich da reingegeben beziehungsweise was ist die Antwort von dem System und daran konnte man dann eben entsprechend interaktiv arbeiten.
Das heißt also jetzt kommen nicht nur fertige Programme rein,
sondern jetzt kommt eben auch noch der Benutzer,
der sagt, ich möchte Programm A starten,
Programm B starten oder ich was weiß ich,
also starte in Editor, schreibe in mein Programm,
lasse es durch den Compiler laufen,
versuche es dann auszuführen und so weiter.
So, das heißt, da geht es jetzt darum,
dass man also die Ressourcen dann eben auch noch zwischen mit Nutzern teilt.
Wie gesagt, Zugriff dann eben über solche entweder Kommandozahlen,
später kam dann grafische Oberfläche.
Hier hatten wir jetzt im Vergleich zu Multitasking dann eben
auch noch zusätzlich nochmal ein anderes Optimierungsziel.
Beim Multi-Programming bzw. Multitasking geht es erstmal darum,
maximale Prozesse und Nutzung
zu erreichen
Wenn ich sowas wie ein Time-Sharing-System habe, möchte ich sagen,
okay, da hängen jetzt also irgendwie 200 Terminals ran.
Und jeder Benutzer soll die Idee oder die Vorstellung haben,
das ist mein Rechner, der ist nur für mich.
Und von den anderen 199 benutzt, dann kriege ich erstmal
nichts mit. Was also so lange funktioniert,
solange jetzt nicht einer von den anderen jetzt also quasi exklusiv beispielsweise die CPU belegt,
eine Endlosschleife da reinbaut, nicht weil dann würde ich eben einfach sehen,
ich versuche da was einzutimmen und der Corsa meldet sich nie wieder,
da tut sich nichts.
Das ist dann eben Und das,
was dann eben mit diesem Time-Sharing-Betrieb typischerweise gemacht wird,
dass man dann eben sagen kann,
okay, das System reagiert letztendlich auf Benutzereingaben,
nicht mehr, also auf irgendwie so eine Job-Kontrollsprache.
Und die Zuteilung der Ressourcen,
oder in diesem Fall dann also erstmal zentrale CPU oder des Computers,
an die einzelnen Benutzer funktioniert dann eben nach so einem Zeitscheibenverfahren.
Das heißt, jeder Benutzer kriegt jetzt eben erstmal so und
so viele Millisekunden Zeit zugewiesen und das Systemwechsel dann eben
der Reihe nach einfach erstmal zwischen allen Benutzern durch
Und wenn der Rechner eben schnell genug ist und jetzt nicht gleichzeitig zufällig Benutzer dranhängen,
dann habe ich eben dadurch, dass ich selber natürlich,
also jetzt mit nur so und so viele Ereignisse pro Sekunde da produzieren kann,
jetzt erstmal das Gefühl der Computer ist,
also letztendlich exklusiv für mich da.
Das ist also das, was da dann gemacht wird.
Also es gibt dann eben regelmäßig jetzt,
also quasi nach Ablauf dieser Zeitscheibe dann eben immer ein interrapscheder System,
startet quasi jetzt also nicht mehr,
oder läuft auf der CPU jetzt also quasi nicht mehr mein Terminal-Programm,
sondern läuft wieder das Betriebssystem.
Das guckt jetzt, möchte ein anderer Benutzer was rechnen,
beziehungsweise in diesem Fall ist er über irgendein anderes Terminal jetzt eine Eingabe aktiv.
Dann kriegt er dann eben quasi seinen Zeitslord.
Und mein Prozess wird dann eben letztendlich unterbrochen. Alles,
was sich da jetzt irgendwo an Status habe,
also sprich Inhalte der Prozessoregister in der CPU,
sowas wie Program-Counter, Verweis auf Speicherbereiche, Datenstrukturen,
wird eben gegebenenfalls gesichert.
Für den anderen Prozess entsprechend wiederhergestellt und der läuft dann eben
entsprechend weiter. Und wenn dessen Zeitscheibe abgelaufen ist,
dann eben genau
das gleiche Spiel
Gut, ja, dann mal gucken, wie viel habe ich denn jetzt hier?
Das ist ein bisschen länger. Ja, dann werde ich
jetzt also mal pünktlich Schluss machen. Und jetzt nochmal diese Sachen,
wo es das jetzt quasi nochmal so um die Aufgaben aktuell oder grob
die Grundkonzepte aktueller Betriebssysteme gibt, dann am Freitag vorstellen.
Und dann im Prinzip dann noch ein bisschen genauer dann eben
auf diese Elemente, was sind Jobs, wie kommunizieren die miteinander.
Dann entsprechend übermorgen eingehen. Gut, ja,
damit dann schönen Abend und tschüss