Stapelspeicher bei Betriebssystemen

Erste Frage Aufrufe: 46     Aktiv: 28.11.2021 um 10:27

0

Ich verstehe die folgende Abbildung nicht ganz. Ich verstehe die grundlegende Funktionsweise des "Stacks/Stapels". In der Abbildung ist dieses Prinzip im Bezug auf die Programmausführung (Ablauf dessen) gezeigt. Ich kann aber nicht ganz nachvollziehen wie das Prinzip hier gemeint ist. https://pasteboard.co/Zpa4g4ruL75c.pngenter image description here

gefragt

Punkte: 10

 
Kommentar schreiben
1 Antwort
1

Hallo user1dcdd7, leider ist es für „jemand“ der es versteht wiederrum nicht ganz einfach herauszufinden was du nicht verstehst. Ich versuch's mal mit einfachen Worten zu erklären. Wenn du dann was nicht verstehst einfach nochmal nachfragen. Wenn ein Programm unterbrochen wird muss um „was anderes“ zu machen muss sich der Prozessor merken wo es nach dem Ende der Unterbrechung des Programmablaufs weitergeht. Er merkt sich also nicht wo unterbrochen wurde, sondern da wo es später weitergeht. Diese Adresse legt er auf den Stapelspeicher SPH/ARH. Wenn nun die Unterbrechung wieder unterbrochen wird legt der Prozessor die Adresse wo es später weitergeht wieder auf den Stapelspeicher SP1/AR1. Wenn nun diese Unterbrechung wieder unterbrochen wird legt der Prozessor die Adresse wo es später weitergeht wieder auf den Stapelspeicher SP2/AR2. Wenn nun….. :-)

Wenn die letzte Unterbrechung fertig ist nimmt der Prozessor die Adresse der vorletzten Unterbrechung vom Stapel und macht da weiter bis diese Unterbrechung ebenfalls beendet ist. Das Ganze läuft nach dem LIFO Prinzip. Muss es auch, sonst würde ja ein Chaos entstehen. So wie die Kette der Unterbrechungen stattgefunden hat muss sie rückwärts wieder abgebaut werden.

Die Höhe der grauen Kästchen ARx stellen die zeitliche Gültigkeit des jeweiligen Stapelspeichers dar und die Breite der benötigte Platz im Stapelspeicher. Mit jeder Unterbrechung der Unterbrechung wächst natürlich der Stapelspeicher. Da jeder Speicher ein Ende hat kann man das mit den Unterbrechungen also nicht unendlich treiben. Das merkst du am schnellsten wenn du eine rekursive Funktion programmierst.

Stell dir einfach eine russische Matroschka vor die du auspackst. Die größte Figur ist das Hauptprogramm. Die nächste ist die erste Unterbrechung / das erste Unterprogramm. Die stellst du daneben. Das macht du so lange biss du die letzte ausgepackt und daneben gestellt hast. Wenn alles ausgepackt ist hast du die größte „Tiefe“ / den höchsten Speicherbedarf des Stapelspeichers (SP) erreicht. Dann packst du die Matroschka wieder ein. Das geschieht genau in umgekehrter Reihenfolge, sonst passt es ja nicht. Nun überlege dir wie lange die einzelnen Figuren dagestanden haben. Das sind die Höhen der grauen Kästchen SPx/ARx.

Das Diagramm zeigt Senkrecht die Zeit fallend ansteigend und waagrecht den Stapelspeicherbedarf. Links oben im Diagramm startet das Hauptprogramm und läuft eine Weile. Grauer Kasten links oben. Nach einer Zeit x wird das Hauptprogramm unterbrochen, die Rücksprungadresse ARH wandert auf den Stack an die Stelle SPH. Dabei wird der Stackpointer um n Elemente reduziert. Der Stack läuft bei fast allen Prozessoren rückwärts! Jetzt wird Unterprogramm 1 ausgeführt. Grauer Kasten oben mitte. Nach einer Zeit y wird dieses unterbrochen, die Rücksprungadresse AR1 wandert auf den Stack an die Stelle SP1 (= SPH-n). Der Stackpointer zeigt nach dem Ablegen der Adresse auf SP1-n (= SPH-2*n). Jetzt wird Unterprogramm 2 ausgeführt. Grauer Kasten rechts, mitte. Das könnte man jetzt fortsetzen bis der Stack zu Ende geht.

Ist Unterprogramm 2 zu Ende erhöht der Prozessor den Stackpointer um n, holt die Rücksprungadresse von SP1, und kehrt so zum Fortsetzungspunkt des Unterprogramms 1 zurück. Ist auch das Unterprogramm 1 zu Ende erhöht der Prozessor den Stackpointer um n, holt die Rücksprungadresse von SPH und kehrt somit zum Fortsetzungspunkt des Hauptprogramms zurück. Diagramm fertig.

Die grauen Kästen rechts (ARH, AR1) zeigen senkrecht die Zeit an die dieses Werte auf dem Stapelspeicher liegen und somit auch die Gültigkeit des Inhalts. Beim Rücksprung wird der Wert des Stapelspeichers gelesen und der Stackpointer erhöht. Der Wert selbst wird NICHT verändert. Die Adresse AR1 steht nach dem Rücksprung ins Unterprogramm 1 immer noch im Stapelspeicher, ist aber nicht mehr gültig. Wenn nun das Unterprogramm 1 wieder unterbrochen werden würde, würde die neue Rücksprungadresse wieder an die Stelle AR1 / SP1 im Stapelspeicher abgelegt, aber mit den aktuellen Werten.

Wie gesagt, bei Fragen fragen Gruß jobe

Diese Antwort melden
geantwortet

Sonstiger Berufsstatus, Punkte: 395

 

Also mich verwirrt immer noch wie genau man das abzulesen hat. Wieso ist einerseits ARH und AR1 auf der rechten Seite zu sehen und dann auch noch mal auf der linken Seite (Pfeile linksgerichtet darauf)?

Weiterhin dachte ich, dass es vereinfacht gesagt nach folgendem Prinzip funktioniert:
Hauptprogramm wird unterbrochen, Sprung auf Unterprogramm mithilfe der Aufrufparameter; gleichzeitig Vermerkung der Rücksprungadresse.
Dies lässt sich dann x-beliebig verschachteln, solange es die Ressourcen eben zulassen. Wiederum wird dann einfach das ganze von hinten nach vorne wieder durchbearbeitet mithilfe der Rücksprungadressen. Ich kann jetzt aber noch nicht ganz die Funktionsweise des Stacks mit hineinbringen.

  ─   user1dcdd7 27.11.2021 um 19:02

Hallo user1dcdd7, dein Kommentar ist absolut korrekt. So arbeitet der Stack und was du beschreibst IST der Stack. Ich habe meine Antwort noch ergänzt. Ich hoffe es hilft und verwirrt nicht noch mehr.
Gruß jobe

  ─   jobe 28.11.2021 um 10:27

Kommentar schreiben