Ja, also, Endsport, Betriebssysteme. Ich hatte ja vorgestern angefangen mit dem,
oder mit der Vorstellung der, oder von unterschiedlichen Scaduling-Algorithmen,
also Scaduling im Betriebssystem, kann man immer erst mal grob sagen,
ist eigentlich so das zentrale Thema, also sprich das,
was die Betriebssysteme hauptsächlich machen,
also alle möglichen Arten von Ressourcen zu verwalten.
Nicht sei das Hauptspeicher,
sei das also irgendwie den Zugriff auf die Geräte,
IO oder eben logischerweise die Rechenzeit auf der CPU,
auf dem Rechner
Da gab es jetzt drei Unterscheidungen, je nachdem,
um welche Ressource es sich da eigentlich handelt oder wie man das, das sieht.
Zum einen kann man sagen, Long Trump Scheduling,
da geht es eben erst nur darum, wie viele Prozesse insgesamt
quasi gleichzeitig von dem System betrachtet werden oder zugelassen werden.
Medium Term ist dann eben die Zuweisung,
dass Prozesse oder Teile von Prozessen eben im Speicher sind,
was überhaupt erst mal die Voraussetzung ist,
dass sie also irgendwann mal rechnen dürfen und das rechnen dürfen,
ist dann eben das Short Term Scheduling
Gut an, Algorithmen dazu, hatte ich auch nur ganz kurz abgehakt. Kann man sich jetzt eben unterschiedliche Strategien vorstellen,
also einmal First Come, First Surf, das heißt,
die Prozesse oder Tasks sind eben einfach in einer,
das ist nur einfach organisierten Warteschlange,
wo also quasi hier unter Ready dann eben alles drin steht,
wo also die relevanten Teile im Hauptspeicher sind und die eben darauf warten,
dass irgendwann sie also dann mal rechnen dürfen und in genau der Reihenfolge,
in der sie in der Q sind,
werden sie dann eben entsprechend abgearbeitet.
Round Robin ist dann eben so dieses übliche Zeitscheibenverfahren.
Das heißt, genau das Gleiche, wenn der Prozess startet,
läuft aber im Prinzip ein Timer los.
Und entweder der Prozess oder der Task macht einen System Call
beziehungsweise wartet jetzt noch auf irgendwelche Signale oder Events von außen,
dann würde er entsprechend auch erst mal wieder in eine von
den anderen Prozesszuständen oder Cues quasi reingeschoben werden,
weil er dann nicht weitermachen kann.
Also Beispiel für System Call wäre jetzt eben Zugriff auf ein Ausgabegerät.
Das dauert eben erstmal sehr lange und da lohnt es sich jetzt also nicht,
quasi jetzt mehrere Millionen Tagzüglin zu warten,
sondern da ist es dann eben deutlich effizienter,
quasi mit was anderem weiterzurechnen.
Ansonsten, wenn das nicht der Fall ist,
habe ich dann eben ein preamtives Verhalten.
Das heißt also, irgendwann sagt der Timer, okay,
dein Sideslot ist abgelaufen. Du wirst erstmal zwischendurch unterbrochen.
Das ist dann eben diese Preamption und der nächste Prozess
darf arbeiten
Gut, dann hatte ich jetzt noch gesagt,
oder kurz vorgestellt,
also man kann sich jetzt eben unterschiedliche Metriken ausdenken,
nach denen also die Prozesse quasi noch verarbeitet werden,
wo man dann eben gezielt welche aus den Cues quasi rausnimmt oder rausnehmen kann.
Und zwar geht es da ja darum,
dass man sagt, bei den Prozessen,
die haben quasi als Parameter einmal,
wie lange rechnen sie
Insgesamt war es jetzt natürlich immer erstmal irgendwo ein Geschätzter wert ist.
Und dann kann man da eben noch mit reinnehmen,
wie lange war bislang die Wartezeit des Prozesses, beziehungsweise wie viel,
wenn ich zum Beispiel sowas wie ein Zeitscheibenverfahren habe oder wenn
der Prozess jetzt also irgendwie auf An- und Ausgaben wartet,
wie viel von der geschätzten Rechenzeit wurde schon verbraucht.
Und quasi im Umkehrschluss, wie viel Zeit ist noch über.
In Hindern kann man dann eben sagen, okay,
short is process next, also der, wo man sagt,
kürzeste Ausführungszeit, das wird der Nächste.
Damit erreicht man jetzt natürlich in vergleichsweise hohen Durchsatz,
da man also quasi immer sehr effizient,
kurze Prozesse quasi vorschiebt und da so eine hohe Anzahl an Prozessen oder an Tags abarbeiten kann.
Auf der anderen Seite ist natürlich dann ein Riesennachteil, langlaufende Prozesse verhungern.
Also das ist dann dieser Begriff der Stervation. Sprich,
wenn genügend Prozesse mit kurzen Laufzeiten da sind, werden die quasi nie ausgeführt.
Ein bisschen fairer kann man das dann machen über Shorts,
Remaining Time, wo dann eben nochmal geguckt wird,
wie viele Prozesse oder wie viel Zeit bleibt den Prozessen, wenn sie jetzt gelaufen sind, letztendlich auch nach und danach versucht man dann eben entsprechend zu optimieren. Allerdings auch da ist dann eben möglich,
dass Prozesse quasi nie bedient wurden und um das jetzt eben auch noch ein bisschen mit zu berücksichtigen,
gibt es dann eben diesen Begriff dieses Response Ratio,
wo man dann also im Prinzip sagt,
ich gucke eben, wie lang war die Wartezeit,
wie lang ist die geschätzte Laufzeit und eben über diesen Quotienten hier wird dann eben geguckt,
wie groß also quasi jetzt dieses Antwort oder Disponsratio,
also quasi die Antwort, Verhalten oder Protzent da letztendlich ist,
was dann eben dazu führt, dass also Prozesse,
die jetzt sehr lange laufen und erstmal lange warten,
da natürlich also hier eine lange Wartezeit bekommen und irgendwann,
also dadurch dann eben auch bei einer Langlaufzeit,
ist,
die dann also entsprechend in den Prioritäten raufrutschen und irgendwann dann eben auch mal bedient werden.
Und als letztes, das hatte ich jetzt am Mittwoch noch vergessen,
dann sowas wie so ein Nancy-Feedback-Scaduling,
das ist dann eben auch so ein Verfahren,
wo man jetzt eben sagt,
es gibt Im Prinzip ein Zahlscheibenverfahren, also ein Raun-Robin-Verfahren.
Es gibt dann quasi unterschiedliche Warteschlangen oder Cues,
die dann eben unterschiedliche Prioritäten haben. Ein neuer Prozess würde quasi
immer erstmal in der Q mit der höchsten Priorität laufen.
Wenn der jetzt also irgendwann mal unterbrochen wird,
war jetzt also beispielsweise eine Zeitscheibe abgelaufen ist,
würde er dann eben quasi in der Priorität runterrutschen, nicht auch dadurch wird
Auf der einen Seite natürlich also auch wieder so eine Präferenz für Kurzlaufende Prozesse gemacht.
Auf der anderen Seite ist es aber eben so,
dass dann eben auch langlaufende Prozesse dann hier entsprechend in diesen
Prioritäten dann immer noch mit drin sind.
Gut, hier ist das Ganze nochmal im Vergleich.
Auch dazu nur der Vollständigkeit halber, also die Tabelle wird
so sicherlich nicht in der Klausur abgefragt werden.
Deswegen werde ich die jetzt also hier auch nicht nochmal irgendwie lang und breit runterbeten. Interessant,
da ist jetzt eigentlich eher nochmal sowas, also zum Grundverständnis der Algorithmen,
wo man jetzt also sieht, ich habe hier ein Beispiel,
in diesem Fall jetzt also hier mit Fünf Prozessen,
die haben jetzt hier also irgendwie eine bestimmte Ankunftszeit,
die haben eine bestimmte Laufzeit, also das,
was dann immer dieses Kleine ist, dieses Service-Time ist.
Und dann sind hier einfach mal so die unterschiedlichen Algorithmen grafisch aufgezeichnet,
also sprich, wann würde welcher Prozess letztendlich laufen.
Nicht bei First, Come, First, Surf,
ist klar, laufen die also in der Reihenfolge, A,
B, C, D. Das Ganze ist nicht unterbrechend,
also nicht Pre-Emptive, das heißt,
die laufen dann eben bis zum Ende durch und dann kommt entsprechend der Nächste,
Zeitscheibenverfahren, sie dann halt eben immer so aus,
dass die Prozesse jetzt bei einer Zahlscheibe eine länger eins,
sich dann eben immer der Reihe nach quasi abwechseln.
Wobei dann natürlich, je nachdem wann, beziehungsweise wie spät die dann kommen,
man also natürlich erst mit einem einzigen Prozess anfängt und es dann eben im Laufe der Zeit dann eben entsprechend mehr werden.
Und da sieht man eben auch schon,
wie letztendlich dieser Parameter Länge der Zahlscheibe dort dann eben mit allen geht,
weil wenn ich die Zeit schreibe, eben entsprechend länger mache,
sieht man dann also hier dann auch so eine Abwechslung,
aber dadurch,
dass also die meisten Prozesse dann hier schon mit dieser Zeitscheibe der Länge vier quasi abgearbeitet werden können,
nämlich der und der ergibt sich dann nur noch für den Prozess B und D jeweils,
dass die also irgendwann nochmal unterbrochen werden und dann nochmal wieder neu aufgesetzt werden.
Und wenn ich letztendlich die Zahlscheibe länger mache,
als das, was insgesamt maximale Laufzeit ist,
dann bin ich, also ich wieder beim First-Come-First-Surf gelandet.
Gut, Short is Process Next. Short is
do maining time und so weiter. Also wie gesagt,
das sind nur so ein bisschen die Grafiken dazu würde sich als Übungsaufgabe anbieten,
quasi sowas mal irgendwie zu machen und zu zeigen.
Haben wir nicht, wird in der Klausur also so auch nicht drankommen.
Von daher keine Angst. Ansonsten zu den Klausuraufgaben, zu
diesem ganzen Teil Betriebssystem. Ich werde das oder ein Beispiel dazu
dann also nochmal so ein bisschen in der Probeklausur am Montag vorstellen,
beziehungsweise ich hatte auch schon einige gehört, die jetzt also natürlich,
weil vielleicht andere Termine irgendwie parallel sind, also dann am Montag nicht kommen können.
Noch habe ich die Probeklausur nicht ganz fertig. Wenn das fertig ist,
werde ich hier auch nochmal so ungefähr für eine Woche lang
auf die Webseite ins Netz stellen bzw. mit Stine verlinken.
Ich schicke dazu dann auch nochmal eine Mail entsprechend passend rum,
dass man also mal so grob sieht, was das ist.
Zu dem Teil Betriebssysteme wird es dann sowohl in der Probeklausur als auch in der Klausur so aussehen,
dass da relativ einfache Verständnisfragen kommen, bevorzugt, das muss ich nochmal sehen,
wie ich das jetzt mit den Themen hinkriege, irgendwas,
wo man also Multiple Choice zum Ankreuzen hat,
kann man sich dann also vorstellen, also ähnlich wie bei irgendwie Führerscheinprüfungsfragen,
nicht, also es gibt da irgendwie Wasser,
stehen jetzt also irgendwie fünf mögliche Antworten und von 0 bis 5 Kreuzen kann man da vielleicht machen.
Das ist dann aber eigentlich noch relativ fair zu machen,
zu bewerten. Man muss jetzt nicht zwingend hier irgendwelche Sachen
ausrechnen, irgendwelche komischen Grafiken entwickeln und so weiter.
Also von daher zu dem Thema keine Angst, nicht,
aber so ein Grundverständnis von der Funktionalität von Betriebssystemen und dem,
was also jetzt hier in den letzten beiden Wochen passiert ist
Sollte da dann also auch noch mit reinkommen. Ja,
gut, wie kann man jetzt diese unterschiedlichen Algorithmen bewerten,
beziehungsweise diese Performancer Scaduling sich ansehen?
Also auch dazu findet man dann in den Lehrbüchern,
also immer relativ viel an Material. Letztendlich muss man jetzt immer unterscheiden,
also es geht natürlich erstmal darum, was soll der Rechner leisten?
Ist das jetzt ein Desktop-Rechner? Ist das jetzt irgendein Kontrollrechner für
irgendein eingebettetes System? Ist das jetzt also ein Server,
der jetzt also irgendwelche Dienste anbietet? Oder ist das eben irgendwie sowas wie so ein Großrechner,
Supercomputer oder sowas, alles, was in diesem Bereich HPC,
das Akku steht dann für High-Performance-Computing, steht in der Richtung ist.
Weil da habe ich natürlich dann immer doch entsprechend unterschiedliche Anforderungsprofile und würde,
wenn man so ein System aufsetzt, dann eben auch entsprechend den Scheduling-Algorithmus,
beziehungsweise diese Parameter, soweit ich das einstellen kann,
dann eben auch entsprechend dahingehend trimmen, dass man sagen kann,
unter den Voraussetzungen für diesen Systemeinsatz wähle ich da jetzt eben irgendwie einen geeigneten Algorithmus.
Also von den hier vorgestellten kann man auch nur sagen,
es gibt also auch noch deutlich mehr,
auch da Kann man nur sagen, das habe ich jetzt,
also hier weggelassen, weil teilweise sind das dann Sachen,
wo es also quasi zum periodische Prozesse geht,
teilweise Sachen, die dann für Echtzeitaufgaben,
Real-Time-Scaduling drin sind, da kann ich nur sagen,
das wird also in der optionalen Vorlesung eingebettete Systeme dann unter anderem noch kurz mit vorkommen,
wo da dann nochmal ein ganz anderer Satz von Algorithmen auch noch mit vorgestellt werden wird.
Gut, dann natürlich, wie gesagt, wofür wird der Rechner genutzt?
Nicht dann kann man dafür dann letztendlich also irgendwelche Anwendungsszenarien sich überlegen,
also sprich, welche Prozesse, wie viele Prozesse, was soll damit gemacht werden.
Dann ist das Ganze davon abhängig, welche Ein- und Ausgabegeräte habe ich,
die da dranhängen. Und letztendlich bei diesen ganzen Algorithmen,
wenn man das bewertet, wie aufwendig, ist da eigentlich ein Scaduling-Algorithmus selber und wie aufwendig ist der Kontextwechsel. Weil das ist ja dann auch immer so eine Sache,
wenn ich jetzt sage, gut,
also hier habe ich zum Beispiel bei so einem Rau und Robin mit einer kurzen Zeitscheibe,
dann kann man sagen, ja wunderbar,
das ist ja eigentlich irgendwie optimal fair, aber man sieht natürlich,
man hat also wirklich letztendlich in jedem Zeitschritt sowas wie Kontext,
Wechsel, Kontextwechsel heißt, ich habe ja meinen Prozesskontrollblock,
da steht jetzt eben irgendwie drin, die relevanten Informationen zu dem Prozess,
sprich, wo sind die Daten im Hauptspeicher,
wo ist der eigentliche Programmcode im Speicher abgelegt,
wie ist der Status des Prozesses,
Inhalte der Register jeweils und sonstige Metainformation,
also Flag-Register und, und,
und.
Das muss also jedes Mal beim Kontextwechsel irgendwo in den Stack,
des Betriebssystems quasi gesichert werden als Prozesskontrollblock,
anschließend wird dann eben quasi der nächste Prozess, der geladen wird,
oder wird Verdienern eben entsprechend diese ganzen Registerinhalte umgesetzt.
Nicht und dann gibt das Betriebssystem quasi die Kontrolle ab.
Das heißt, es springt eben zu der entsprechenden Startadresse in den Programm-Counter
und dann läuft der Prozess dann eben als im User-Mode.
Und wenn der am Ende ist, beziehungsweise entsprechend durch den Interrab,
also in diesem Fall eine Zeitscheibe unterbrochen wird,
würde dann eben quasi das ganze System wieder in Colonel-Mode wechseln,
ist wieder entsprechend zurückgesetzt werden und so weiter.
Das kostet natürlich auch relativ viel Zeit. Nicht deswegen ist dann
eben hier so ein Umschalten zwischen den Prozessen eben auch nicht umsonst,
sondern ist dann also, wenn man jetzt Performance-Untersucht, dann eben auch noch wichtig.
Und die andere Sache ist dann eben, wie aufwendig ist der Algorithmus jetzt,
der jetzt also im Prozess aufwählt, nicht bei Ra und Robin,
das ist Zeitscheibe, das ist einfach.
Nicht, da habe ich eine Q, sage,
okay, den ersten nehme ich und so weiter,
lasse ihn laufen, Zeitscheibe ist abgelaufen, dann kommt der Nächste.
Da muss man sich also jetzt nicht größer drum kümmern.
Wenn ich jetzt also hier irgendwie sowas wie ein Highs Responsive Ratio ausrechne,
dann ist eben wirklich auszurechnen für jeden Prozess,
der also quasi in dieser Reddicue ist,
wie ist entsprechend dessen Wert und ist der jetzt also quasi geeignet als nächstes zu laufen oder ein anderer,
nicht demzufolge sind das dann eben auch entsprechend Sachen.
Gut, ansonsten diese ganze Modellierung von Prozessen,
wie ich das jetzt für welche Systeme einsetze, also da muss dann sagen,
kommt dann also relativ viel von der Mathematik beziehungsweise von den theoretischen Grundlagen der Informatik mit rein,
wo man dann sagt, das wird dann eben über stochastische Prozesse modelliert,
also wie häufig sind Prozesse mit welchen Wahrscheinlichkeitsverteilung tauchen die auf,
damit man also versucht, das System dann also quasi simulativ nachzubilden,
um dann eben zu gucken, wie geeignet ist dann eben ein bestimmter Algorithmus dafür.
Gut, wenn man jetzt sagt,
ich habe nicht nur einen Prozess, sondern Multiprozessorsystem,
also sprich das, was unsere moderneren CPUs ja typischerweise machen,
kann man dann eben auch nochmal das Ganze weiter unterteilen,
wo man dann sagt, okay, sind das jetzt The metrical multiprocessing,
also sprich das, was man in den CPUs hat.
Alle CPUs haben identischen Zugriff auf Speicher und auf irgendwie IO-Ressourcen,
beziehungsweise auf den Bus. Oder sind das schwach gekoppelte Systeme,
also sowas wie Cluster-Rechner,
wo ich also ein Reck voll habe mit jetzt also irgendwie unterschiedlichen Rechnern,
wo man sagen kann, also meinetwegen die 64 Kerne in so einem Einschub,
die können sich also direkt miteinander unterhalten,
wenn da aber jetzt mit irgendwie einem anderen Teil kommunizieren möchte,
dann geht das eben über entsprechende Hochgeschwindigkeitsbusse,
die dann da also beispielsweise in den klassischen Großrechnern
da dann also irgendwie verbaut sind
Nicht, dann kann man sich jetzt eben auch noch fragen,
wie sieht das aus, wenn ich jetzt noch irgendwelche Spezialprozessoren oder Co-Prozessoren habe,
wie sie das machen oder das da mit dem Scheduling?
Auch das ist eine Sache, wo man sagen kann,
ja gut, das war früher irgendwo im High-Performance-Bereich interessant.
Inzwischen muss ich jetzt auch sagen, vieles an Algorithmen
wird heutzutage einfach wegen einer großen Fließkomma-Rechenleistung auf Grafikkarten gerechnet.
Und so rumgesehen kann ich dann eben sagen, die Grafikkarte,
beziehungsweise die GPU da drauf, ist dann eben letztendlich ein Co-Prozessor.
Und da kann man natürlich dann auch versuchen, also Eigenschaften von den Algorithmen,
da dann eben auch noch mit rein zu modellieren,
was dann gegebenenfalls dann eben auch noch ein Scheduling-Algorithmus beeinflusst,
weil das nützen wir jetzt nichts.
Wenn ich jetzt also irgendeinen Rendering-Algorithmus für irgendwas letztendlich beim Scadio
da drauf habe, nicht, aber die Grafikkarte sagt,
mir fehlen dann noch irgendwelche Daten oder irgendwas anderes
läuft da nicht richtig.
Also auch da ergeben sich dann noch gegebenenfalls
einige Abhängigkeiten
Gut, und dann eben die Frage hinsichtlich der Synchronisation zwischen den Prozessen.
Nicht habe ich jetzt also Parallelität im Strädt,
habe ich Malti-Threading oder eben mehrere gekorporate Prozesse,
kommunizieren die jetzt also direkt über einen Hauptspeicher oder sind die
über Netzwerkmechanismen verteilt oder sind das also völlig unabhängig voneinander laufende Prozesse.
Nicht auch da muss man sagen,
gibt es dann noch vieles an Scaduling-Algorithmen,
wo man versucht sowas dann also auch noch mit zu beschreiben und die Prozesse zu Prozessgruppen zusammenfassen kann,
also in dem iOS von Mac ist,
das ist im Prinzip zum Beispiel mit drin und in einigen Unix-Systemen kann man das auch machen.
Also wie gesagt, da gibt es noch relativ viel an Vertiefung,
wenn man jetzt also eigentlich so in entsprechender Hardware Architekturen dann reinguckt.
Nicht ansonsten Multi-Prozess, Oscar-Julien kann man eigentlich immer sagen,
habe ich als Aufgabenstellung Zuordnung von Prozessen zu Prozessoren,
das kann man dynamisch machen, wo man sagt,
ich habe also irgendwie jetzt hier an meinem Laptop irgendwie 30, rechenwillige Prozesse.
Hab da jetzt irgendwie ein 4-Kern-CPU drin und das Betriebssystem kann dann eben sagen,
wenn eine CPU-Frage ist, der Prozess da,
wenn er jetzt entsprechend ready ist, darf da entsprechend drauf arbeiten.
Man kann das auch statisch machen,
was dann letztendlich das Scheduling einfacher macht,
was dann also auch bei solchem Groovescado-Link gegebene Fahrtteile hat,
hat dann aber das Problem, wenn ich jetzt also einen Prozess habe,
der jetzt eben einmal irgendwie eine bestimmten CPU oder einem Kern zugeordnet wurde,
Der wird dann quasi unterbrochen.
Hinterher könnt ihr jetzt also irgendwie irgendwann zum späteren Zeitpunkt weiterrechnen.
Jetzt ist aber nicht genau diese CPU widerfrei, sondern eine andere.
Nicht beim dynamischen System würde er dann er gegebenenfalls woanders weiterrechnen beim Statischen eben nicht.
Dann müsste man dann also entweder ein Leerlauf in Kauf nehmen oder so ein Loadbalancing machen.
Nicht in dem Zusammenhang kommt dann eigentlich auch noch das,
was ich, hatte ich glaube ich auch schon mal angesprochen,
oder was man so als Process-Srashing bezeichnet.
Das ist also im Prinzip so ein Effekt, den man teilweise dann also auch,
sagen wir mal so, jetzt im Betriebssystem sehen kann.
Also hier habe ich jetzt zum Beispiel immer irgendwie so ein bisschen Monitor,
habe jetzt also hier irgendwie vier CPUs, die dann also gelegentlich mal was tun.
Und wenn man jetzt also irgendwie länger laufende Prozesse hat,
dann sieht man das also irgendwie öfter,
dass also die also irgendwie erst mal auf einer CPU laufen,
dann, weil es um eine Unterbrechung kommt,
sind sie dann wieder runter.
Und dann ist aber auf einmal die Lot,
also auf einem anderen Kern. Das heißt,
da sind die dann also quasi von einem Kern zu irgendeinem anderen Kern gewandert.
Das wäre dann also letztendlich dann Indiz für einen dynamische Scheduling
Nee, kann ich jetzt irgendwie nicht so schön machen,
weil damit verschieße ich mir gleich die Folien,
weil ich hätte sonst also einen schönen Prozess, der ein bisschen länger läuft.
Da würde man das dann also im Prinzip sehen. Gut,
also wie gesagt, das,
diese Zuordnung nicht und dann kann man eben auch noch sagen,
wenn ich jetzt ein System habe mit meinetwegen jetzt hier viel CPUs,
der Scadular läuft ja immer fest auf einem Kern,
kann der selber auch irgendwie zwischen den Kernen wandern oder ist das also irgendwie sowas Verteiltes?
Da kann man sich dann eben auch sagen,
also das geht von irgendwelchen Masterslave-Anordnungen bis zu irgendwelchen verteilten Systemen,
wo man dann auch je nach Aufgabenstellung dann eben sagen kann,
okay, Masterslave ist einfacher zu implementieren.
Ich habe weniger Overhead. Andererseits, wenn der Scadulingbit-Prozess quasi ausfällt,
dann habe ich das gesamte System irgendwie am Stehen.
Das ist also letztendlich das, was man dann als Komplettabsturz bezeichnen würde,
wo man sagen kann, okay, bei Desktop-Betriebssystemen,
Linux, Windows, was weiß ich was oder so,
ist es eben ärgerlich.
Nicht lebensnotwendig, nicht wenn das also irgendwo bei der Flugzeugsteuerung
auftritt, darf sowas eben genau nicht sein.
Also da müsste man dann eben Mechanismen haben,
dass ich eben nicht so ein Single Point of Failure habe
Gut. Dann letztes Kapitel, Speicherverwaltung.
Da geht es jetzt also im Prinzip darum,
wie jetzt der Speicher bzw. das Speichersystem den Prozessen zugeordnet wird,
wo man jetzt eben sagen kann, was macht das Betriebssystem dabei?
Zum einen soll es natürlich,
also die Prozesse bzw. die Adressräume der Prozesse irgendwie voneinander trennen.
Es soll also den Speicher dabei dynamisch verwalten.
Es soll gegebenenfalls die Modularität in Programmen unterstützen
Dass man eben sagt, wenn ich ein Programm laufen habe,
war es jetzt viel Speicher benötigt, dann ist es ja nicht zwingend so,
dass quasi der gesamte Speicherbedarf immer während der Laufzeit vorhanden ist,
sondern es kann sich halt eben irgendwie dynamisch gegebenenfalls verändern.
Das ist also das,
was immer unter diesem Begriff Working Set bzw. Lokalität aufgetaucht ist in den vorigen Kapiteln,
wo man dann eben sagen kann,
in der Abarbeitung meines Programms brauche ich jetzt nicht zwingend von
dem gesamten Code quasi alle Datenstrukturen und alle Programmteile,
sondern letztendlich natürlich nur das, wo ich gerade arbeite,
was dort also quasi an Datenstrukturen direkt im Zugriff ist,
was da lokal definiert ist.
Wenn ich jetzt also irgendwie ein Unterprogramm bin und vom Code
logischerweise dann eben auch in diesem Gewissen Kontext.
Nicht das soll also entsprechend irgendwie unterstützt werden. Ja,
und dann soll das System natürlich also Einige wichtige Schutzfunktionen liefern.
Also das ist dann in Foul SS, also verteilte Systeme
und Systemsicherheit, dann noch ein bisschen genauer mit drin.
Also zum einen in dem Sinne die Integrität der Daten,
also sprich jetzt keine Verfälschung von irgendwie Datenwerten.
Da kann man auch sagen, na gut,
wenn mir jetzt also irgendwo im Speicher irgendwo mal eine Eins
durch eine Null ersetzt wird oder umgekehrt.
Nicht, dann ist das ärgerlich, wenn das im Programmcode passiert,
kann das sein, dass es ein unuldiger Befehl wird,
dann stürzt mir das Programm ab.
Wenn das in den Daten passiert, dann habe ich irgendwie falsche Daten,
das Programm rechnet vielleicht auch irgendwas Falsches, ist aber erstmal eben auch nicht so sonderlich entscheidend.
Zumindest im Desktop-Bereich nicht. Bei Serversystemen hat man typischerweise zum Beispiel schon mal so,
dass der Hauptspeicher quasi nicht nur interne Fehlererkennung, sondern gegebenenfalls auch eine Fehlerkorrektur macht. Das heißt,
da habe ich dann ein Byte mit,
entsprechend jetzt irgendwie deutlich mehr Bett kodiert, dann ist man wieder bei der Kodierung,
was wir da also irgendwann mal hatten, Hemmingabstand und so weiter,
wo dann entsprechend gewährleistet ist, dass also irgendwie auf Serversystem,
wenn ich einem Kunden anbiete, du lässt es,
also was weiß ich, hier deine Cloud-Instanz laufen,
es dort dann eben nicht zu solchen Ausfällen kommt,
was auf der anderen Seite dann aber den Preis natürlich,
also in etwas andere Regionen schraubt,
wo man da dann eben auch mal sind will.
Also das ist also Integrität der Daten,
auf der anderen Seite natürlich Schutz in dem Sinne,
Zugriff auf die Daten, sprich,
wenn ich jetzt mehrere Prozesse oder von mehreren Tagsdaten und Programmcode im Hauptspeicher habe,
dass nicht von dem einen Prozess in den Adressraum eines anderen Prozesses irgendwie was gelesen werden kann.
Nicht, dass ist dann eben das, was dann also
beispielsweise in VSS also auch noch ein bisschen genauer angesprochen werden wird.
Gut, und das, was das Betriebssystem dann eigentlich auch
immer noch macht oder machen muss, Realisierung von Landzeitspeicher,
sprich Dateisysteme. Also für uns eigentlich selbstverständlich,
ich habe meine Daten irgendwie in Dateien und auch das Programm
und alles andere liegt irgendwo auf Solid State Disk oder Festplatte
Weil, wenn der Rechner ausgeschaltet ist, ist eben alles,
was Hauptspeicher und Cash und Register ist, quasi vergessen.
Wenn ich dem zuvor gehe, kann da dann eben einsprechen,
die Sache. Gut, dann zu den Begriffen virtueller Speicher
. Das ist im Prinzip das Konzept,
was jetzt eigentlich hinter dieser gesamten Speicherverwaltung in den Betriebssystemen steht,
dass man eben sagt, ich habe sekundären Speicher,
also Festplatten,
auch betrachte ich eigentlich auch erstmal als ein Teil des Speichers
Und das, was ich in meinem Programmcode,
also das, was der Assembler jetzt,
also quasi aus dem Hochsprachencode irgendwie heraus generiert und übersetzt habe.
Und ich habe dann irgendwie meinen Binärcode da drin stehen.
Das, was in dem Programmcode drinsteht, also die dort vorhandenen
logischen Adressen sind eben unabhängig von dem physikalisch vorhandenen Speicher.
Und die sind unabhängig von den Adressen, die dann also
wirklich zur Laufzeit irgendwie beachtet, wie er betrachtet werden.
Nicht, weil, hatte ich auch schon gesagt,
ich habe meinen Code irgendwann durch das Betriebssystem,
wird er in den Speicher geladen.
Und in meinem Code hatte Assembler also irgendwelche geträumten Adressen von 0 bis N irgendwie reingebaut.
Wenn das nachher im Hauptspeicher liegt, liegt das an beliebig vielen anderen Adressen.
Das ist dann eben etwas, was da dann eben auch noch passiert.
Und natürlich, dass ich also dadurch dann eben auch gewährleiste,
dass mehrere Prozesse beziehungsweise Jobs gleichzeitig im Speicher sind. Gut,
das heißt, das, was ich im Code an Adressen habe,
das nennt sich dann eben nachher virtuelle Adresse,
entspricht dann eben der wirklich dort sexuell drinstehenden Adresse und irgendeine Art von Übersetzung,
die so rumgesehen haben,
typischerweise in Form von Tabellen irgendwie abgelegt ist,
dass man sagen kann,
also für den Prozess werden die Adressen von null bis irgendwas eben übersetzt,
indem ich da so beispielsweise ein Offset mit hinzuaddiere.
Das ist dann immer das typische Verfahren. Gut, dann
auch noch zu den Begriffen. Man betrachtet dann als Frame,
also ich verzichte jetzt mal so auf die etwas eltlicheren deutschen Begriffe,
Kachel und Seite, beziehungsweise Seitenadressierung, ja,
das ist im Prinzip ein Block fester Größe im Hauptspeicher
Eine Page ist ein blockfester Größe im sekundären Speicher,
also sprich auf der Festplatte. Und das,
was dann quasi als Abbildung passiert,
das ist dann eben der Mechanismus, das Paging, ist,
dass ein Block von der Festplatte quasi in den Hauptspeicher geladen wird,
dort irgendwo abgelegt wird und dort dann eben letztendlich dann auf seinen Frame abgebildet wird.
Im Gegensatz dazu, also jetzt hier mit diesen festen Größen,
gibt es dann immer noch den Begriff der Segmente,
das sind also Blöcke variabler Größe
Im Sekundärspeicher, also sprich auf Festplatte,
der dann also entweder temporär in einen passenden Bereich im Hautspeicher
kopiert wird, dann spricht man ihm von Segmentierung.
Oder diese Segmente, diese Blöcke werden dann eben quasi in Größen,
die also der Page entsprechend quasi nochmal unterteilt und dann eben,
wie beim Paging, entsprechend auf Frames abgebildet.
Dann hat man also Segmentierung und Paging quasi als gemeinsames Konzept.
So diese drei Mechanismen werde ich jetzt gleich nochmal kurz vorstellen,
wie man sich das im Prinzip vorstellen kann.
Wie gesagt, das war was Grundidee von dem Ganzen ist,
was da immer passieren soll, ist letztendlich diese Adressumsetzung oder Relocation.
Nicht, dass man sagt, ich habe die logischen Adressen,
das ist also letztendlich das, was im Programmcode steht.
Ich habe, oder in der Regel sind diese logischen Adressen dann eben relative Adressen.
Das heißt, die sind dann immer bezogen auf irgendwelche Startadressen.
Und auf der anderen Seite habe ich dann zur Laufzeit
die physikalischen oder absoluten Adressen,
also sprich wohl
das Ganze im Speicher steht
Und dann kann man jetzt immer sagen,
wenn ich jetzt also hier so einen Process-Control-Block habe,
also sprich die Information zu dem Prozess, den Code,
die zugehörigen Daten zu dem Prozess,
dass man da dann eben sagen kann,
wenn ich in dem Programm jetzt irgendwelche Sprünge habe oder wenn ich mit dem Programm irgendwelche Referenzen zu Daten habe,
nicht dann sind das letztendlich dann immer relative Adressen,
die sich dann daraus ergeben,
die ich dann quasi bezogen auf diesen Startpunkt hier,
wo ich also quasi jetzt hier mit Adresse nur meinetwegen loslege,
dann eben entsprechend in meiner Regel relativ angeben kann.
So, und das, was dann eben so ein Memory-Management macht,
ist, dass man eben da macht,
eine Abbildung von diesen logischen auf physikalische Adressen.
Sprich, ich habe zur Laufzeit,
wenn ich das Ganze jetzt also wirklich im Hauptspeicher habe,
irgendwo in einer Datenstruktur, Registertabelle, wo auch immer,
abgelegt,
letztendlich die Startadresse,
wo das Ganze also hier quasi losgeht
Die relative Adresse wird dann eben einfach quasi als Offset entsprechend drauf addiert.
Dann habe ich also entsprechend hier meine Adressen. Das ist dann eben eine absolute Adresse. Und als Sicherheitsmechanismus gibt es dann eben nicht nur diese Basisadresse,
sondern quasi noch, oder kann es geben,
sowas wie eine obere Grenze,
wo ich dann eben sagen kann, hier endet der Adressbereich,
dass ich jetzt also hier quasi jetzt nicht irgendwelche Adressen habe oder auf die darauf zugreife,
die dann letztendlich außerhalb dieses Adressbereichs liegen,
beziehungsweise wenn ich jetzt also auf irgendwelche Daten drauf zugreife,
sollte dann eben auch gewährleistet sein,
dass die Adresse sich dann also hier nicht in den Programmbereich befindet.
Nicht, weil dann habe ich nämlich auch einen Effekt,
den man nicht haben möchte, dass sie also auf einmal
irgendwie selbst modifizierenden Code habe oder in einem Programm da irgendwie was umgebaut wird.
Gut, daneben kann dann eben auch noch ein Mechanismus mit reinkommen,
der dann Swapping heißt, also sprechenden Prozess,
der jetzt also irgendwie im Hauptspeicher mal drin ist
Wird jetzt unterbrochen beispielsweise durch irgendeine Interrupt oder weil das Betriebssystem
jetzt also irgendwie den Hauptspeicher für irgendeine andere Aufgabe noch mitbraucht.
Dann wird da also quasi wieder auf Festplatte ausgelagert oder ist
entsprechend dort dann ja immer noch aktuell und irgendwann später,
wenn der Prozess fortgesetzt wird,
wird er dann ja auch gegebenenfalls dann oder logischerweise dann wieder in den Hauptspeicher geladen,
damit wir überhaupt erstmal in der Ready Q ist.
Dann kann aber eben auch gewährleistet sein oder muss eben auch gewährleistet sein,
dass das Ganze immer noch funktioniert, wenn er an eine andere Stelle im Speicher geladen ist.
Nicht in das funktioniert eben dadurch,
dass sich also hier wenn der Prozess jetzt reduziert wird,
also woanders hingeladen wird, dass man dann eben sagen kann,
okay, was sich ändert, ist dann eigentlich immer nur dieses Basisregister. Und dadurch, dass ich dann hier mit dieser relativen Adressierung arbeite, bin ich damit dann eben entsprechend unabhängig von dem Ganzen. So,
und was dabei dann eben auch noch alles Mögliche passieren kann,
oder was man dann eben typischerweise macht, in diesen Informationen,
was ist also hier Basisadresse von dem Prozess,
wie sind jetzt also hier gegebenenfalls,
also irgendwelche Obergrenzen gemacht, wo darf er hier nicht,
also irgendwie oder unter bestimmten Bedingungen nicht drauf zu greifen,
dass man dann in diesen Tabellen lassen dann also Segmente oder Seitentabellen,
dass man da dann eben auch noch irgendwie so Zugriffsrechte mit hat,
um eben zu sagen, ein Prozess darf jetzt nicht in sein,
da in seinen Instruktionsbereich reinschreiben,
darf überhaupt nicht jetzt in die Bereiche von anderen Prozessen schreiben oder gegebenenfalls,
wenn die Prozesse jetzt über gemeinsame Speicher kommunizieren,
in den Datenbereich vom anderen Speicher,
wo man dann eben auch noch von einem anderen Prozess,
wo man dann eben auch noch sagen kann,
darf er das nur lesen oder darf er da auch reinschreiben,
nicht je nachdem,
wie das Ganze gemacht wird.
Dadurch ergeben sich dann eben Unterschiedliche Varianten, was dann also im Prinzip machbar ist.
Das ist also hier alles so ein bisschen angedeutet. Nicht aber,
wo ich hier jetzt drei Prozesse A, B und C habe,
oberhalb der gestrichelten Linie, sondern es ist immer quasi die Instruktion.
Da brauchen wir jetzt also irgendwelche Daten sein. Und da kann ich eben sagen,
also das, was also schon mal gar nicht gehen darf,
ist, dass der Prozess also hier irgendwie in Teile des Betriebssystems quasi reinfuschen darf,
Referenzen in Seine Daten sind natürlich zulässig, das fehlt jetzt hier.
Verzweigung in andere Prozesse,
so und jetzt also erst zum Beispiel nicht möglich sein,
gegebenenfalls Referenzen auf die Daten, ja,
sofern das also irgendwie durch irgendwelche Mechanismen,
also auch abgesichert oder freigegeben ist, wobei man dann eben sagen kann,
also für welche Prozesse darf man also auf die Daten drauf zugreifen oder nicht.
Nicht das geht dann also genau wieder in diesem Bereich
Critical Section, Mutual Exclusion, wo man dann eben sagen kann,
wie kriege ich da jetzt also die Zugriffe geregelt auf unterschiedliche oder gemeinsam genutzte Ressourcen? Gut,
ich hatte ja gesagt,
es gibt im Prinzip drei Mechanismen von dieser Trennung zwischen logischer und physikkarischer oder physischer Organisation,
Segmentierung, Paging und eben beides zusammen,
was da dann eigentlich auch immer noch wichtig ist,
hat er ja auch schon gesagt, also dass man sagt,
es müssen eben nicht zwingend alle Segmente,
beziehungsweise gerade beim Paging alle Seiten des Prozesses gleichzeitig im Hauptspeicher sein.
Ich nehme zuvor kann man immer sagen,
es gibt dann sowas für einen Prozess zur Laufzeit an Resident Set,
also sprich das,
was jetzt gerade in den Hauptspeicher geladen ist und ein Working Set ist,
was gerade benutzt wird.
Im Idealfall sollten die natürlich,
oder sollte der Working Set eben natürlich genau so sein,
dass der Prozess dann eben immer entsprechend weiterlaufen kann.
Das heißt also,
der Resident Set soll dann eben eine minimal größere Obermenge von
dem hier sein
Dass man da dann also auch nicht zu viel Platz verschwendet. Gut,
und während des Programmlaufs sieht das Ganze dann eben so aus,
dass ja, was passiert jetzt,
wenn ich jetzt eben nur ein Teil des Programms im Speicher
habe und es wird jetzt also irgendeine Adresse referenziert,
die jetzt also nicht im Speicher ist.
Gut, dann gibt es eben ein Interrap, der Prozess würde in Blogd wechseln,
weil der kann jetzt sowieso erstmal nicht weiterarbeiten. Dadurch,
dass das Ganze gegebenenfalls jetzt auch ein bisschen länger Zeit dauert,
wird dann in der Regel der Prozess dann quasi vom Schedular,
also auch Im Hintergrund,
also in dieser Block Cue dann erstmal verbleiben und ein anderer Prozess gestartet werden.
Und im Idealfall, das ist also das, was die
Systeme dann heutzutage eigentlich typischerweise machen. Wird dieser Datentransfer,
also das heißt, die fehlenden Daten in den Hauptspeicher zu transferieren,
dann eben im Hintergrund stattfinden durch eine eigene Hardware-Einheit.
Das ist dieses DMA-Direct-Memory-Access, wo man sagen kann, wenn die CPU weiterrechnet, werden Von der,
aus dem Virtual Memory,
also beispielsweise von der Platte irgendwelche Daten in den Hauptspeicher geladen,
wenn die dann wieder da sind, dann könnte das System weiterarbeiten,
beziehungsweise teilweise dann eben auch schon in die Cash-Hierarchie vorgeladen,
das ist jetzt wieder so ein bisschen davon abhängig,
wie da das System das Ganze umsetzt.
Jedenfalls also dieser Datentransfer,
wo dann im Hintergrund stattfinden,
der Dispatcher lässt dann also einen anderen Prozess rechnen,
wenn das Ganze fertig abgearbeitet ist,
gibt es dann einen Interrapt und der Prozess würde dann eben
von dieser Blog-Queue wieder in die Ready-Queue wechseln und wäre dann
also je nach Scaduling-Algorithmus irgendwann
wieder branen
Ja, was erreiche ich jetzt also mit diesen ganzen Memory-Management-Mechanismen?
Also zum einen verwaltet man damit natürlich,
dass man für einen Prozess erstmal nur einen kleineren Prozessraum braucht,
als das, was er vielleicht insgesamt tat.
Nicht, weil ich könnte ja sagen, okay,
diese Probleme hier mit dem Working-Set kann ich dadurch umgehen,
dass ich quasi den, alles,
was der Prozess an Instruktion und Daten hat, komplett in Hauptspeicherlade.
Dann habe ich nämlich dieses Problem hier nicht. Heißt aber,
dass wenn der Prozess jetzt viel Speicherplatz benötigt,
dass sich dann gegebenenfalls nur einen einzigen Prozess in meinem System laufen lassen kann,
beziehungsweise wenn der Prozess noch mehr Daten braucht und ich jetzt irgendwie entsprechend schwach ausgerüsteten Rechner habe mit Taufspeicher,
wäre das, könnte der also überhaupt nicht laufen.
Deswegen, man wählt eben Ausschnitte des Adressraums,
hat dadurch insgesamt mehr Prozesse in Systemen,
die dann also quasi jetzt in dem Sinne Long-Term-Scaduling möglich sind.
Und das führt dann natürlich eben auch zu einer
deutlich besseren CPU-Auslastung
Andere Sache, Prozesse können eben damit größer sein als der Gesamtvorhandene Hauptspeicher.
Ich muss mich da also in der Programmierung nicht drum kümmern.
Und das Schöne für uns als Programmierer, das Ganze wird vom Betriebssystem von der Hardware verwaltet.
Ich muss mir da jetzt das auch nicht zwingend Gedanken drüber machen,
wie sie das mit den Datenstrukturen aus. Nichtsdestotrotz, ich denke,
das wird in SE dann auch irgendwie immer gelegentlich mal so ein bisschen gestresst oder angesprochen,
ist es natürlich schon ganz sinnig, dass man sich also überlegt,
Was brauche ich wirklich an Datenstrukturen, wie organisiere ich das irgendwie effizient,
dass man da jetzt also nicht unendlich viel speichert,
sich also irgendwie holt und sagt, ja gut,
das ist jetzt sowieso alles da und das kann immer alles also mehr sein als irgendwie so und so viel Gigabyte an Hauptspeicher.
Gut, hier auch nur als Tabelle der Vollständigkeit halber,
wo man vielleicht später mal nachgucken kann,
wenn man einem sowas nochmal begegnet, die unterschiedlichen Techniken zur Speicherverwaltung.
Die wichtigsten werde ich jetzt hier nochmal kurz in Beispielen vorstellen,
also das, was man früher teilweise noch gemacht hatte,
inzwischen eigentlich, so lädt es, ist Partitionierung des Speichers.
Das heißt, ich habe meinen gesamten Hauptspeicher und unterteile den in irgendwelche Bereiche einer festen Größe.
Und wenn ein Programm jetzt eben größer ist als irgendwie dieser Bereich,
dann, und das musste man dann also früher im Programm selber einbauen,
habe ich da dann eben irgendwelche Overlay-Techniken,
die dann eben sagen, okay,
wenn ich jetzt also zu den und den Unterprogrammen oder Prozeduren springe,
dass dann eben quasi dieser Teil einmal komplett ausgetauscht werden kann und dann die Bearbeitung entsprechend weitergeht.
Das kann man sich jetzt denken mit gleichgroßen Partitionen oder mit unterschiedlich Großen,
womit ich dann also vielleicht noch gewährleisten kann,
dass er sich jetzt also für mehr kleine oder mehr größere Programme da ein bisschen effizienter sind,
was man sich natürlich denken kann, was ein Problem sein wird,
ist etwas, was sich dann also quasi interne Fragmentierung nennt.
Sprich, wenn ich jetzt also hier so ein System habe und mein Programm,
also typischerweise jetzt nicht acht, sondern nur zwei,
me, be byte irgendwie an Instruktionen und Daten umfasst,
dann ist das quasi der Rest dieser Partition letztendlich ungenutzt.
Das ist dann das, was sich interne Fragmentierung nennt.
Wie gesagt, dem kann man so ein bisschen begegnen,
wenn man das jetzt, also irgendwie nicht live verteilt,
aber auch da hat man natürlich Probleme, wie viele von welcher Größe brauche ich.
Man kann das Ganze auch irgendwie dynamisch machen,
ist dann also hier nochmal in so einem Ablauf quasi ein bisschen skizziert,
nicht wo man sagt, ich fange hier mit einem Prozess an,
der belegt also hier irgendwie so und so viel Platz,
dann läuft ein zweiter Prozess, belegt irgendwelcher Platz, dann kann ich hier noch einen dritten unterbringen
Dann ist irgendwann zur Laufzeit, also der Prozess 2 fertig.
Dann habe ich also hier entsprechend diese Lücke, neuer Prozesse starte,
nicht der würde dann also entsprechend hier irgendwie reingepackt.
Nicht der erste wird frei, dann wird also der zweite mal wieder gescaduled,
der läuft dann also hier unter anderem unsere Ressen.
Nicht in was man also ihr schon sieht, ist also wirklich dieser Effekt,
dass ich also in dem Fall jetzt keine interne Fragmentierung habe,
also sprich feste Größen von denen, was ungenutzt wird, sondern externe Fragmentierung.
Das heißt, insgesamt ist der Speicher oder Speicherbereich jetzt immer
in diese festen Blöcke unterteilt und dazwischen sind Lücken,
die sich dann eben auch irgendwie dynamisch zur Laufzeit mal größer, mal kleiner ergeben. Nicht,
da kann man jetzt immer noch gucken,
entweder ich versuche da noch eine Kompaktierung zu machen,
ist natürlich dann auch wieder entsprechend zeitaufwendig,
nicht dann ist die Sache, wenn jetzt ein neuer Prozess kommt,
ich habe jetzt hier ein entsprechend fragmentierten Speicher,
nicht wo packe ich den rein, First Fit, Best Fit,
Next fit, wenn ich jetzt also hier quasi so einen Pointer habe, wo jetzt also quasi die letzte Aktion stattgefunden hat.
Nicht jedenfalls kann man also unterschiedliche Strategien verfahren,
die sind dann alle je nach Aufgabenstellung mal besonders gut oder mal nicht so gut geeignet,
aber man sieht schon, es ergeben sich da eben letztendlich Probleme,
weil da spare ich ja Ausnutzung.
Gut, macht nun heutzutage eigentlich nicht mehr so. Das andere Thema,
also wäre dann die Segmentierung, Segmentierung entspricht eigentlich dem,
wie wir als Programmierer so ein Programm sehen.
Da habe ich nämlich eine logische Unterteilung in den Eigentlich ein Binärkot des Programms,
also sprich das, was Instruktionen sind, nennt sich also dann beispielsweise,
wenn ich jetzt also an die Gnu-Toolshain denke, dort dann immer Text,
Textsegment, also das, was der Assembler-Code ist.
Und da gibt es dann eben noch Data oder Data-Segment,
wo dann also letztendlich die Daten sind, nämlich die statischen Daten,
die ich also irgendwo in meinem Programm habe, jetzt an irgendwelchen Datenstrukturen.
Und dynamisch aluziierten Speicher, den ich dort dann eben drin habe.
Und gut, Programmcode sollte richtig only sein, Datenstrukturen sind logischerweise Readride. Nicht,
das ist also das, was eigentlich für mich jetzt als Programmierer irgendwo wichtig oder sichtbar ist,
wird dann eben auch entsprechend zusammengefasst, dann eben zu Text und Datensegmenten,
die dann natürlich, je nachdem, was mein Programm braucht, eine Variable Größe haben.
Nicht dadurch ist das Ganze so rum gesehen,
ähnlich dieser dynamischen Partitionierung, die ich vorgestellt habe,
nicht wo man sagen kann, ich habe zwar keine interne Fragmentierung,
weil ich also immer genau die Größe für Text und für Daten habe,
die den Programmcode entspricht,
aber ich habe im Speicher eben immer diese Lücken,
die dann also letztendlich während der Laufzeit entstehen
Gut, die Abbildung von dem Ganzen passiert dann eben über eine Segmenttabelle. Das heißt,
wenn ich jetzt also hier meine Adresse im Programmcode habe,
nimmt man eben irgendwie einige von den Bits, je nachdem,
wie groß die Segmenttabelle ist, wo ich dann eben sagen kann,
damit habe ich dann in der Tabelle diese beiden Werte,
Startadresse im Hauptspeicher,
wenn das Programm jetzt irgendwo anders hin verlagert wird und eben die Länge des Segments,
was dann eben quasi genau das ist,
was In dem Fall dann hier mit Bowns letztendlich verglichen wurde.
Nicht also Startadresse wäre dann eben dieses,
nicht das wäre hier Text-Section, dieses beides zusammen ist dann Data-Section,
nicht und mit dem Bowns sage ich dann,
also okay, wenn die Adresse größer als das wird,
dann gibt es eine entsprechende Fehlermeldung zur Laufzeit.
Nicht, also das ist die Art und Weise,
wie dann also im Prinzip aus der Adresse in dem Programmcode,
dann eben so eine physikalische Adresse gemacht wird,
wie wenn das Programm jetzt eben irgendwo hin in den Speicher
geladen wird
Rausfliegt wieder neu reingeladen wird. Nicht,
dann sind eben entsprechend immer nur jeweils hier diese Basisadressen zu ändern,
beziehungsweise bei unterschiedlichen Programmen haben die dann eben entsprechend an den Stellen unterschiedliche Längen.
So, und in diesen Tabellen kann man dann eben auch noch so als Information mitführen,
ist das Read only, ist das Read-Ride,
dass dadurch dann eben auch solche Zugriffsmechanismen letztendlich auch noch mitverwaltet werden.
Gut, kann man sich dann immer so vorstellen.
Ich habe hier also im Prinzip meine virtuelle Adresse, diesen Rest,
der dann quasi ein Offset darstellt, mit dieser Segmentnummer,
gehe ich dann also quasi oder versucht man sich dann eben aus der Segmenttabelle, diese beiden Informationen raus.
Nicht daraus wird dann also quasi die physikalische Adresse berechnet. Nicht,
dass wir ja dann dementsprechend der Offset und über die Länge
wird dann eben noch quasi zur Laufzeit geprüft,
was in der anderen Grafik dann noch mit drin war,
dass ich dann also hier diese Segmente nicht verlasse.
Und damit ist es dann eben auch möglich,
dass es jetzt also hier in der Folien angedeutet,
die ist jetzt also nicht aus dem Starlinks-Buch,
wie im Prinzip jetzt unterschiedliche Programme,
die jetzt also hier alle irgendwie mit Startadresse Null bis 400 oder beziehungsweise 3.000 und 0 bis 1.000,
4.000,
dann eben in den Speicher abgebildet werden und da dann eben entsprechend dort jetzt in Form von diesen Blöcken,
also diesen Segmenten da dann entsprechend da drin stehen und dort dann eben auf beliebige Adressen des Speichers abgebildet werden.
Zweiter Mechanismus, Paiging, also das,
was jetzt die Seitenadressierung ist. Auch da habe ich jetzt
im Programm wieder
meine Nummer
Oder meine virtuelle Adresse. Auch da wird ein Tal quasi jetzt als Offset genommen.
Der andere Teil ist dann eben in diesem Fall dann eben eine Seitennummer.
Und ich habe da dann eben auch wieder jetzt so eine Tabelle,
in der im Prinzip aus dieser Seitennummer eine Frame-Number,
also eine Nummerierung des Hauptspeichers zugeordnet wird.
Und beim Pageing hatte ich ja gesagt, das sind jetzt Bereiche fester Größe,
sowohl bei den Pages als auch bei den Frames.
Das heißt, da habe ich dann eben eine
einfache Abbildung in Eine Anzahl von entsprechend festen Teilen.
So und diese Abbildung funktioniert dann eben sowohl für Instruktionen als auch für Daten.
Also bei der Segmentierung habe ich jetzt ja so quasi dynamische Größe für Instruktionen und für Daten,
beim Paging nehme ich quasi jetzt diese Information nicht,
sondern würde dann eben sagen, ich habe quasi alles,
was ja eine Instruktion habe,
bilde ich eben auf so und so viele Pages ab.
Alles, was ich an Daten habe,
will ich eben auf so und so viele Pages ab und
habe dann eben auch wieder so eine Abbildung in so einer Tabelle,
wo man dann eben sagen kann, okay,
eine Seite kann an einer beliebigen Stelle im Hauptspeicher stehen oder sie kann eben auch auf einen Sekundärspeicher ausgelagert werden.
Wie gesagt, was Ganze passiert dann eben durch so
eine Adressübersetzung, Memory Management, You Net.
Und das Schöne für den Programm ja transparent.
Das heißt, da muss ich damit echt drum kümmern.
So, hier ist das Ganze mal angedeutet.
Also ich habe hier beispielsweise zwei Programme, die haben jetzt
also hier einmal elf Pages und hier einmal irgendwie sieben Pages.
Und die werden dann eben im Hauptspeicher jetzt irgendwie beliebig auf Blöcke,
also auf diese Frames, die jetzt genauso groß sind, abgebildet.
Und wie man hier dann auch sieht, also das müssen
jetzt nicht mehr zusammenhängende Bereiche sein, sondern es kann beliebig irgendwie verteilt werden.
Demzufolge habe ich dann jetzt natürlich keine externe Segmentierung,
das heißt, ich nutze den Hauptspeicher möglichst gut aus.
Was man natürlich haben kann, ist letztendlich eine interne,
eine Segmentierung, Fragmentation, eine interne Fragmentation, wo ich dann eben,
wenn das Programm jetzt also beispielsweise hier weniger Daten braucht,
als jetzt also letztendlich dann hier so eine Page-Größe ist,
dass dann also hier irgendwo ein ungenutzter Bereich quasi noch überbleiben würde.
Ja, wie gesagt, also hier sieht man,
dass die Seiten dann eben entsprechend auf die Frames abgebildet werden und
das auch nicht zwingend alle Seiten komplett im Hauptspeicher sein müssen.
Das war aber eben eine der Sachen oder eine der Features,
die ich dann also zu dem Thema Virtual Memory auch schon angedeutet hatte.
Sorry. Das ist ein Unterschied, zur größten Zeit
Ich glaube, er verteidigt sich, das wird immer verschüttet. Also die Frage war jetzt,
ob das einen Unterschied macht beim Zugriff auf die Datenstrukturen,
wenn die Pages oder diese Blöcke jetzt eben entsprechend hier unterteilt sind,
so wie das also jetzt hier der Fall ist oder ob die jetzt in kontinuierlichen Bereichen abgebildet werden.
Und da muss man sagen, das ist also beim Paging,
macht das also keinerlei Unterschied, weil diese Das,
was hier eigentlich dem Ganzen zugrunde liegt,
ist dann also im Prinzip hier damit abgedeutet,
ist ja also auch wieder so eine Adressübersetzung,
wo ich im Prinzip eine Tabelle habe.
Ein Teil der Adresse, die quasi im Programmcode drinsteht,
adressiert mir jetzt also hier diese Process-Page-Table,
wo ich dann eben sagen kann, für die Page 0,
wo die im Speicher beginnt und die Page 1, wo die im Speicher beginnt.
Und das müssen hier jetzt ja nicht mehr zwingend 0-1,
2-3 aufeinanderfolgende Bereiche sein,
was dann also quasi hier kontinuierlichen Bereichen entsprechen würde,
sondern die können eben beliebig umgesetzt sein und der eine geht also jetzt hier beispielsweise auf Page 5,
der hier also auch falsch sechs und der dann irgendwo noch weiter unten,
also dass man das dann entsprechend macht.
Was da aber natürlich schon mit reinkommt,
was sowohl für Pageing als auch für Segmentierung gilt,
ich gehe jetzt mal, springe schon mal wieder ein bisschen vor,
ist natürlich die Sache,
ich habe hier noch mal irgendwie so eine Übersetzung über irgendwelche Tabellen.
Nicht in diese Tabellen ist natürlich auch immer die Frage,
wo liegen die? Die liegen auch wieder nur im Speicher,
das kostet mich ja natürlich dann also auch erstmal wieder Zeit. Das heißt,
diese ganzen Zugriffsmechanismen Pfosten gegebenenfalls Zeit,
was man da jetzt wieder macht oder machen muss,
nein, also auch, ja, ist,
dass diese Datenstrukturen dann eben typischerweise konstant in irgendwelchen Cashes gehalten werden,
beziehungsweise man da dann noch irgendwelche Cashing-Mechanismen hat,
dass sich da nicht jedes Mal irgendwelche entsprechend langdauernden,
aufwendigen Speicherzugriffe haben muss.
Und diese Tabellen selber, also sprich die Datenstrukturen des Betriebssystems,
Da wird auch dafür gesorgt, dass die in der Regel
vollständig im Speicher sind und nicht teilweise irgendwie dann auf der Platte ausgelagert sind.
Nicht, weil das wurde natürlich extrem lange dauern,
die dann also nochmal nachzuholen. Nicht,
aber das sind also wirklich dann die Arten und Weisen,
wie das Ganze dann eben letztendlich nachher wirklich von den Betriebssystemen gehandhabt und umgesetzt wird.
Also wie gesagt, hier auch nur nochmal dieser Mechanismus,
wo ich dann über so eine Tabelle gehe.
Da kommen wir jetzt nämlich zum, also hier nochmal ein Beispiel dazu,
wo ich jetzt also hier vier Nein, fünf Prozesse habe,
die dann eben der Reihe nach hier irgendwie mal in einen Speicher geladen werden.
Hier wird was freien, nicht dann kommt hier irgendwann ein Prozess.
Und bei der Segmentierung würde man jetzt eben sagen,
okay, dieser Prozess, die,
der jetzt also in dem Fall jetzt,
also hier irgendwie fünf Pages braucht oder entsprechend Speicher dieser Größe,
könnte bei der Segmentierung hier also gar nicht mehr reingebracht werden.
Nicht beim Pageing kann ich den eben entsprechend aufteilen und sagen,
das wird dann eben hier entsprechend so verteilt.
Was da jetzt noch mit reinkommt, ist,
dass man jetzt sagen kann, okay,
wie groß mache ich jetzt wieder
diese Seitengröße
Nicht, wenn ich die jetzt sehr groß mache,
ist das natürlich also vergleichsweise effizient für den Datentransfer zur Festplatte,
weil es da eben so Automatismen gibt,
dass das Ganze entsprechend automatisch und mit solchen Blogtransfers abläuft.
Wenn ich den jetzt, führt dann aber dazu,
dass ich da natürlich gegebenenfalls viel interne Fragmentierungen habe und ich vielleicht kann jetzt sagen,
okay, Seitengröße 16, Gibibyte,
ich habe jetzt aber im Prinzip ein ganz kleines Programm,
was jetzt also wirklich nur ein Bruchteil davon benötigt,
das wird immer eine volle Seite
Anspruch nehmen. Wenn ich die Seiten jetzt sehr klein mache,
heißt das dann aber wieder, ich muss, habe zwar weniger interne Fragmentierung,
ich muss aber sehr viele Seiten letztendlich verwalten.
Diese Prozesstabelle, wo ja also quasi auch die Seiten für
die Prozesse mit drin stehen, wird dann also deutlich größer.
Und eben das, was ich zu ihm gesagt hatte,
also ich hatte das jetzt nur andersrum argumentiert,
der Datentransfer zum sekundären Speicher ist eben für große Seiten effizienter.
Und das ist dann eben etwas,
was da dann auch noch mit reinschlägt, wenn ich jetzt kleinere Seitengrößen habe,
dass ich also im Prinzip so viele Seiten habe,
dass die Verwaltung dieser seinen Tabellen also auch nicht mehr trivial ist,
weil ich dann also auf einmal irgendwie eine Million Seiten verwalten muss.
Das geht dann auch jetzt wieder nur über mehrstufige Tabellen,
wo ich da natürlich das Problem, dass der Zugriff langsame Esser nochmal habe. Also das ist im Prinzip ein Mechanismus,
wie das also bei X86-Prozessoren, damals noch beim 32-Bit-System,
gang und gäbe war,
wo man das dann also über so eine zweistufige Tabelle hat,
wo ich dann also quasi in der ersten Tabelle ein sogenanntes
Page-Table Directory habe und dann die einen damit erstmal eine Page-Table selber adressiere und dann von diesen Page-Tables dann dort die eigentlichen Seitentabellen dann wieder adressiere, dass man da dann eben so ein mehrstufiges Verfahren dahinter legt.
Andere Idee ist eine sogenannte Inverted-Page-Table,
da werden jetzt also nicht mehrere Tabellen hier gemacht,
sondern es gibt halt eben von, in dem Prozess habe ich eine virtuelle Adresse stehen.
Ein Teil der Bits nehme ich jetzt also quasi als Seite
und dann gibt es eben eine Hash-Funktion, die jetzt also quasi versucht,
daraus einen Index zu errechnen von irgendeiner Arrey-Datenstruktur.
Und ich dann eben in diesem Eintrag drinstehen habe,
wie jetzt eben letztendlich der Frame ist. Dadurch,
dass jetzt natürlich mehrere Prozesse hier also irgendwo ja auch identische Adressen haben,
kann es sein, dass ich also hier eben noch vergleichen muss,
ist das jetzt also der Prozess A oder der Prozess B.
Und dann eben für mehrere Prozesse,
die dann also hier quasi auf das mit dieser Hash-Funktion,
also auf das Gleichen, Eintrag abgebildet werden, dann eben so eine verkettete Liste erzeugen.
Das ist auch nicht so ganz trivial von der Verwaltung,
ist aber schon teilweise ein bisschen effizienter. Das,
was man heutzutage typischerweise noch hart ist, ein sogenannter Translation-Locasside-Buffer,
das ist im Prinzip ein voll assoziativer Cash-Speicher,
wo ich dann also quasi über diese Page-Nummer direkt adressiere,
Wie groß oder welche Frame-Nummer das ist, der ist natürlich vergleichsweise klein.
Das heißt, er hat nicht so viele Einträge wie die Page-Table,
aber solange ich im bestimmten Bereich bin,
habe ich da so eine relativ gute Chance, dass ich da was finde.
Und nur wenn da ein Miss ist, dann muss eben
erstmal auf diese Page-Table oder eben auf so ein zweistufiges Verfahren zurückgegriffen werden.
Also sieht man auch, also das ist, also diese Speicherzugriffe,
die dann also jetzt bei dem Speicherverwaltung im Virtual Memory ablaufen,
sind also auch nicht so ganz trivial.
Also hier ist nochmal,
also wie das im Prinzip normale Abbildung ist über so
eine Tabelle und dann eben über diese Hash-Funktion und dann diesen Speicher letztendlich dann passiert.
Dann muss man ja sagen, kommt zu dem Ganzen,
dann die eigentliche Speicherhierarchie noch, wo ich dann eben sagen kann,
hier habe ich die Umbesetzung mit TR Translation Occasat Buffer und
mit Page-Tabelle,
also auf einer Adresse
Und dann habe ich ja nochmal die Speicherhierarchie davor, wo ich dann eben gegebenenfalls nochmal gucke,
finde ich das Ganze nochmal irgendwo im Cash und kommt das dadurch dann,
oder kriege ich darüber direkt mal einen Wert oder muss sie das jetzt wirklich aus dem Hauptspeicher lesen?
Gut, auch da kann man nur sagen,
wenn man da so ein bisschen sich überlegt ans Eingemachte geht,
wie das dann also wirklich technisch umgesetzt werden würde,
ich also nicht umsonst sind, heutzutage die Betriebssysteme da,
also irgendwie mit irgendwelchen Techniken,
die da also irgendwie über 40 Jahre lang gereift sind,
wo das also ziemlich ausgeknautscht ist, wo man glücklicherweise sagen muss,
in der Regel sind das alles Sachen,
die muss ich mich als Programmierer nicht darum kümmern.
Zumindest konzeptuell erst mal nicht, wenn ich jetzt meine Programme schreibe.
Wichtig, nur man soll das eben mal gehört haben,
was ich dahinter noch verbergen kann, welche Probleme es da gegebenenfalls geben kann.
Und als Quintessenz vielleicht eben aus dem Ganzen,
was sie also auch schon ein paar Mal gesagt habe,
beim guten Programm ist halt eben dieser Working Set möglichst klein.
Das heißt, ich springe da im Code jetzt nicht mit,
unterschiedlich vielen Modulen irgendwie kreuz und quer hin und her.
Und ich habe jetzt eben auch nicht beliebig viel an Datenstrukturen quasi gleichzeitig in der Abarbeitung,
sondern habe da eben auch eine gewisse Lokalität mit drin.
Nicht, weil dann funktionieren nämlich eigentlich diese ganzen Cashing-Mechanismen,
diese ganzen Abbildungsmechanismen, also mit irgendwelchen TLB-Baffen und so weiter,
dann eben auch alle entsprechend gut.
Gut, hier sind die Mechanismen also nochmal kurz miteinander verglichen.
Partitionierung, guter passiert jetzt also gar nichts weiter.
Beim Paging dann eben die Abbildung an Die Frames,
also die Teile mit identischer Größe, wo ich dann eben gegebenenfalls,
wenn die Daten dann insgesamt nachher kleiner sind,
eben hier noch diese interne Fragmentierung habe,
weil ich dann also die eine Page dann beispielsweise nicht komplett brauche.
Segmentierung dann eben als die Technik,
wo man insgesamt hiermit variablen Größen arbeiten kann. So,
das, was nun heutzutage typischerweise macht, ist,
dass man natürlich das Gute aus allen Welten zusammenfasst,
Segmentierung und Paaging
Nicht, dass ich also auf der einen Seite die logische Trennung,
hinsichtlichte Inhalte habe, auf der anderen Seite die vergleichsweise effiziente Verwaltung.
Und dann dahinter dann eben auch so ein mehrstufiges System läuft,
wo man dann eben von der Adresse ein Teil dann eben als Segment sieht,
um jetzt eben zu sagen, das sind Daten, das sind Instruktionen.
Nicht damit, also schon mal den einen Teil der Übersetzung
macht und dann den Rest dann also noch in so einer Page-Table,
wo ich dann mit diesen festen Größen arbeiten kann und das
Ganze dann eben auch beliebig über einen Hauptspeicher verteilen kann.
Das ist dann im Prinzip das,
was hier auf dieser Grafik dann eben noch so ein bisschen angedeutet ist,
wo ich dann also jetzt hier auf der einen Seite die Idee von diesen Segmenten habe,
auf der anderen Seite dann eben diese Seitenadressierung mit den identischen Größen nicht.
Und wenn man es zusammennimmt, nicht,
dass man dann eben sagen kann,
ich kriege dann eben hier diese Segmente dann letztendlich auf Seiten abgebildet und je nachdem,
wie viel benötigt wird,
kann man das dann aber eben im Prinzip immer in
freie Seiten reinbringen
Gut, was sah dann noch ein Problem mit auftauchen kann oder Schwierigkeiten mit auftauchen kann,
ist dann eben letztendlich alles, was das Betriebssystem ist eben passiert.
Das heißt, wann werden Seiten geladen? Also für den Prozessablauf ist es natürlich am günstigsten,
wenn ich jetzt alles an Daten da habe,
was der Prozess braucht und alles in Anstruktionen da habe, was der Prozess braucht. Nicht,
aber mache ich das jetzt immer auf Anfrage oder mache ich da so etwas,
was ich Pre-Paging nennt, wo man jetzt eben sagt,
okay, Ich habe eine gewisse Lokalität,
ich bin in dem und dem Adressraum und alles,
was jetzt also an Adressen so ein bisschen da drüber,
ein bisschen da drunter liegt,
da lade ich dann eben die entsprechenden Pages also auch schon in den Speicher.
Ich dann gibt es da auch da wieder diese Problematik mit
Platzierungs- und Ersetzungsstrategie, welche Seiten werden wann ausgelagert,
wenn ich jetzt also letztendlich Platz brauche, nicht dann Multi-Programming,
spricht das, was dann die Slong-Tump-Scaduling ist.
Wie groß ist die Anzahl der Prozesse? Also im Prinzip
kann ich jetzt natürlich mit diesem Paging-Mechanismus sagen, okay,
ich habe also irgendwie so und so viele tausend Pages im Speicher
und dem zuvor kann ich auch so und so viele tausend Prozesse drauf zulassen.
Dann hat aber jeder natürlich nur eine Page.
Naja gut, das macht jetzt nicht so richtig viel Sinn.
Aber wie viele lasse ich jetzt zu bzw. andersrum gesagt,
wie viele Prozesse könnten dann parallel laufen? Auch da möchte man natürlich eine Obergrenze haben,
sodass man sagen kann, damit das System löslich läuft und reagiert,
sollte natürlich von den Prozessen das, was dieser Working Set ist,
also quasi immer abgedeckt sein,
dass sich nicht andauernd irgendwie so ein Pagefold bekomme,
weil also irgendwelche Daten oder Instruktionen angefordert werden,
die jetzt also gerade nicht in den Hauptspeicher abgebildet sind.
Nicht, also auch dazu gibt es dann also unterschiedlichste Szenarien,
die man sich da ausdenken kann, unterschiedliche Algorithmen, die man daran einsetzen kann.
Gut, dann habe ich jetzt hier eigentlich noch so ein bisschen angefangen,
was zu dem Thema Ein- und Ausgabegeräte zusammenzustellen.
Also sprich, wo man jetzt so sagt, okay,
wie sieht das jetzt mit Ein- und Ausgabe aus?
Dann würde eigentlich kommen, sowas wie Dateisysteme und Dateiverwaltung,
wo man jetzt sagen kann, okay,
was ist da typisch, wonach werden die unterschieden,
wie sieht das da mit dem Scheduling aus und, und, und.
Diese Folien werde ich jetzt aber soweit eigentlich komplett überspringen und
dann kommen wir jetzt zu dem Ende.
Gut, jetzt sind wir wieder beim Morsequot angekommen.
Nicht Friefrix fragen, wie man sieht. Gut, nee,
also, ich finde, das macht jetzt also wenig Sinn jetzt,
dass ich noch irgendwelche weiteren Kapitel dann und dann nochmal groß anzufangen.
Also dazu würde ich dann also in der Klausur auch nichts weiterfragen und was mir dann wieder so ein bisschen fehlt,
also um das Ganze abzurunden,
da müsste ich jetzt eigentlich dann also auch noch ein bisschen mehr zu Lateisystemen sagen,
also wie jetzt für Zeichnisstrukturen sind Adeilsysteme, da wäre es dann wieder schön,
da bräuchte man aber dann deutlich mehr Zeit,
das Ganze dann wirklich mit Praxisbeispielen zu machen.
Das heißt, wir sind jetzt also wirklich aktuelle Dateisysteme in Betriebssystemen,
also beispielsweise NTFS, oder irgendwelche Linux-Dateisysteme als Beispiel und gut,
dann sitzen wir hier noch,
also bis zum Ende der vorlesungsfreien Zeit,
deswegen sind werde ich da jetzt also irgendwie nicht länger queren,
heute mal alles, was ihr an Zeit überzogen habe.
An der Stelle, je weit, zu weit beenden. Ja,
und dann kann ich jetzt nur sagen, beziehungsweise vielleicht nochmal zwei,
zwei Worte zur Klausur oder zu dem allgemeinen Prozedere dann nochmal sagen,
ich werde das im Zweifelsfall am Montag auch nochmal kurz wiederholen.
Also wie gesagt,
es gibt ja am Montag dann eine Probeklausur,
die wird dann eben stattfinden im Konrad Zuse-Hörsaal und in dem
einen etwas größeren Hörsaal oder Arbeitsraum
in Haus
Die Klausuren, wie gesagt, für alle, die nicht kommen können,
werde ich dann also auch noch entsprechend in das Netz stellen.
Ansonsten sollte das erstmal so eine Idee sein,
dass man sich da mal hinsetzt und sagen wir mal so,
ähnlich wie das dann in der Klausur sein wird, 13,
14 Aufgaben, wo viele das dann auch immer sein werden.
Und der vergleichbaren Bedingungen einfach mal selber machen sollen, mal sieht,
wie das so ein bisschen ist. Ansonsten, oder ja,
dann danach werde ich dann also im Konnor Zusehhörsaal nochmal die Probeklausur durchsprechen.
Also da gibt es jetzt keine fertige Musterlösung zu,
sondern da hat dann quasi letztendlich jeder seinen Zettel und ich werde
das also irgendwie durchsprechen oder so auf Zuruf durchrechnen lassen und anschließend kann man das dann eben nochmal so ein bisschen korrigieren,
zusammenfassen und ganz am Ende soll es dann eben nochmal Fragestunde geben,
wo dann also nochmal so allgemeine Fragen auch nochmal andiskutiert werden,
was jetzt vielleicht nicht zwingt,
was mit der Klausur zu tun hat.
So, sie haben noch... Ach genau,
was passen denn an der DFO davon
Ich habe mich bestätigt. Das war meine Privatsumsel, was
frei wird. Ähm... Gut, also die Frage weiß,
wenn nicht alle in die 125 fassen und Konrad Zuhörer sein,
muss ich zugeben, bin ich jetzt also seit dem Umbau nicht wieder drin gewesen.
Ich war jetzt immer der Meinung,
dass man dort dann also auch noch zumindest jetzt irgendwie neu,
also auch noch irgendwie ein bisschen was schreiben kann,
okay, wenn das nicht der Fall ist,
spricht also auch nichts dagegen zu sagen, okay,
also wir greifen uns also bei uns oder woanders,
wo ich noch irgendwo derer Haarpasch werde,
irgendwelche Seminarräume mit Tischen
Und es wird dort geschrieben, weil, wie gesagt,
also Probeklausur, da geht es einfach nur darum,
dass man also letztendlich einmal sagt,
ich nehme jetzt wirklich mal diese knapp zwei Stunden und versuche in der Zeit mal die Aufgaben zu lösen.
Das ist jetzt natürlich nicht,
wie jetzt also bei der richtigen Klausur, sondern er war das,
man sollte sich das eigentlich schon mal so ein bisschen so unter
diesem Aspekt Zeitdruck und so ein bisschen Prüfungsstress, also irgendwie antun.
Naja gut, also jedenfalls, wenn das mit den Räumen nicht hinhaut,
übers Informatikum verschmieren. Also da spricht ja nun nichts dagegen,
weil, also ob man nun da oder da sitzt,
da muss jetzt nicht, wie in der Klausur irgendwie einer,
beziehungsweise in der Klausur werden wir dann also irgendwie,
ich denke mal, fünf oder sechs Leuten auflaufen.
Da ist also kontrollieren und durch die Gegend springen und sonstiges machen,
sondern da kann man sich im Zweifelsfall irgendeinen studentischen Arbeitsraum auch zurückziehen und das dort entsprechend machen.
Mich aber interessant ist einfach nur,
das möchte ich nochmal so ein bisschen betonen,
dass man das also auch mal so ein bisschen sich unter diesem Zeitaspekt anguckt,
beziehungsweise damit mache.
Weil man muss jetzt auch zu sagen,
also das vielleicht gleich nochmal als Tipp zu den Klausuren.
In der Regel ist es so, die Klausuren sind so
aufgebaut oder so und so ein bisschen so aufgebaut sein,
dass das also natürlich schon so einen gewissen Zeitdruck erzeugt.
Das heißt, es ist jetzt nicht so, dass wir sagen,
wir haben jetzt also irgendwie knapp zwei Stunden Bearbeitungszeit,
also nominell hatte ich das, glaube ich, immer für anderthalb oder so ausgeschrieben.
In der Regel machen wir dann immer irgendwie so knapp zwei Stunden draus,
dass man sagt,
also ich habe irgendwie die und die Bearbeitungszeit nicht und man setzt
sich hin und ist locker nach einer halben Stunde fertig und gibt dann ab oder dreht Däumchen,
sondern es ist also schon so, dass man,
wenn man das macht,
also auch wenn ich mich oder wenn einer von den Kollegen
sich da hinsetzen würde,
dass wir also auch
irgendwie letztendlich diese Zeit brauchen
Da muss er ja auch nur sagen, das wird eigentlich bei allen Klausuren
irgendwo hier in der Universität typischerweise so sein. Andererseits,
wenn die Klausur eben vernünftig gemacht oder vernünftig konzipiert ist,
dass man sagen kann, okay, also wirklich die,
die sehr gut sind, die schaffen das auch alles in der Zeit.
Nebenzufolge gibt es dann also auch die Einsernoten. Der Rest sollte natürlich
immer noch irgendwie durchkommen. Dann machen wir das oder mache ich das jetzt zum Beispiel bei Rechnerstrukturen so,
dass man sagen kann, von den so so viele Punkten,
die da also vergeben werden, 50 Prozent,
also die Hälfte ist dann die 4,0 und danach geht dann also quasi bis zur vollen Punktzahl,
dass einfach quasi immer in gleichen Punktabschnitten wird dann einfach irgendwie noch raufgezählt.
Dazu dann noch als Tipp, also wie gesagt,
mit diesem Zeitdruck, wie geht man so eine Klausur ran,
wie setzt man sich dahin oder was,
was macht man da?
In den Aufgaben steht dann immer mit drin,
typischerweise wie viele Punkte man dafür bekommt
Und man sollte sich jetzt also im ersten Durchlauf,
wenn man jetzt weiß, also da ist vielleicht so ein bisschen Zeitproblem.
Also jetzt nicht gleich von vorne nach hinten so durcharbeiten,
dass man sich an irgendeiner Aufgabe festbeißt.
Sondern wenn man jetzt also sagt, okay, gucken,
anfangen, das kann ich, dann fängt man an,
die Aufgabe zu bearbeiten.
Wenn man jetzt erstmal keine Idee hat oder das um Gottes Willen,
das allgemeine Hassthema in den Übungsaufgaben war,
Aufgabe überspringende andere machen.
Dass man also
erstmal möglichst kurzer Zeit möglichst viele Punkte zusammenbekommt
So, und wenn man dann vorher fertig ist,
dann kann man immer noch sagen, okay, jetzt gucke ich das alles nochmal durch.
Und jetzt wage ich den Aufgabenteil an, den Aufgabenteil nochmal an.
Ich aber... Es ist also häufig dann immer so,
dass man sich wirklich an irgendwelchen Aufgaben, also festweist, fest rechnet.
Und dann sagen wir jetzt für seine 5 Punkte oder 10 Punkte,
die Aufgabe dann einbringt, eine halbe Stunde ans Zeit verbrät.
Und das ist dann nicht so in der Sache,
weil dann wird man letztendlich dann nicht auf die notwendigen Punkte für eine 4 kommen.
Auf der anderen Seite muss ja auch immer sagen,
im Vergleich zu den Übungsaufgaben und den Musterlösungen,
denen du auch alles verteilt sind, bei insgesamt knapp zwei Stunden, die die Klausur umfasst.
Wir werden jetzt also keine Aufgaben kommen, wo man an einer Teilaufgabe eine Viertelstunde lang dran rumrechnet. Das heißt,
das, was da teilweise in den Übungsaufgaben mit drin ist,
also irgendwie ein, was weiß ich,
Schalsagebranchen-Ausdruck in Riedmalla-Form umzurechnen,
wo also solche Therme macht und ja wieder irgendwie einkürzt,
es kann vorkommen,
dass was mit Riedmalla-Form ist,
aber es gibt dann deutlich weniger Variablen und das ist
irgendwie deutlich kürzer zu machen und deutlich schneller als das,
was teilweise eine Übungsaufgaben ist
Gilt für andere Aufgabenteile genauso, weil logischerweise, wie gesagt,
es sollte eigentlich eine gesamte Stoff irgendwo abgebildet werden und demzufolge kann man jetzt nicht sagen,
also für irgendwie eine Aufgabe wird, also irgendwie ein Großteil der Zeit letztendlich benötigt werden.
Also wie gesagt,
das nochmal so ein bisschen zu dem Zeitmanagement und ja,
ich denke mal, alles andere wird sich dann entsprechend ergeben bzw. dann bei der Besprechung der Klausur oder bei den Nachfolgenden Fragen,
wo ich dann also auch nochmal hoffe,
nochmal so ähnlich wie in so einem Tutoriumstermin dann nochmal die letzten offenen Fragen,
die sich jetzt vielleicht während der Klausurvorbereitung ergeben haben, da nochmal ein bisschen weiterzuhelfen.
Nicht ansonsten kann ich auch immer nur sagen,
auch wenn sich das in der Klausur immer anders anfühlt,
in der Regel will der Dozent natürlich erstmal das man jetzt nicht sagt,
also ich habe als Minimalziel 80 Prozent der Studenten auszusieben,
sondern ich habe eigentlich immer als Ziel,
also dass möglichst alle irgendwo durchkommen, weil wenn ich,
ist das für mich immer,
ich habe die Vorlesung schlecht gemacht und man hat mich nicht verstanden.
Also deswegen muss man sagen, also nicht zwingend die Angst haben,
dass man da ist, also dass da möglichst viel ausgesiebt wird.
Andere Sache auch noch vielleicht zu der Bewertung von den Klausuren,
beziehungsweise wenn jetzt also irgendwelche Sachen sind,
wo jetzt also irgendwie was zu rechnen ist,
was teilweise auch in den Jungsaufgaben vorgekommen ist,
wo es aufeinander aufbauende Teilaufgaben gibt
Bei der Bewertung von den Klausuren machen wir das typischerweise so,
dass wenn sich jemand irgendwo verrechnet hat,
vielleicht irgendwo mal ein falsches Zwischenergebnis hat,
dann aber damit wieder richtig weiter gerechnet hat,
dass es dann logischerweise einen Punktabzug gibt,
aber das nicht ganz am Ende der Rechnung geguckt wird,
kommt da 42 raus und wenn es das nicht ist,
gibt es null Punkte, sondern da wird eben wirklich nur geguckt,
okay, irgendwo mal verrechnet, ein kleiner Punkteabzug,
nicht aber ansonsten, wenn das Verfahren verstanden wurde,
was man da dann eigentlich immer sieht,
dann kann er eben auch mit diesem falschen Zwischenergebnis weitergerechnet werden.
Gilt natürlich jetzt nicht,
wenn wir jetzt irgendwelche Sachen so weit vereinfacht,
dass dann also der Rest der Aufgabe quasi trivial wird,
aber darum gehe ich da nicht aus,
dass jetzt also Anfang die Aufgabe so umzubauen,
also irgendwelche Schaltfunktionen dann also irgendwie auf eine Variable zu reduzieren und mit der dann weiterzumachen und ja.
Gut, jetzt habe ich da noch mal zehn Minuten geredet,
jetzt war es das aber wirklich gewesen sein für dieses Semester
und im Zweifelsfall sehen wir uns Montag und sonst entweder bei
der ersten oder zweiten Klausur.
Ja,
dann Ende