#include <string.h> #include <unistd.h> int i = 0; void test() { char buffer[1048576]; memset(buffer, 0, 1048576); usleep(3000000); ++i; if(i == 1) test(); } int main() { usleep(3000000); test(); usleep(3000000); test(); usleep(60000000); return 0; }
- Als in Zeile 19 3 Sekunden lang gewartet wird, verbraucht der Prozess 360 KB an Speicher.
- Nachdem test() in Zeile 20 aufgerufen wird, beträgt der Speicherverbrauch 1408 KB, da die Variable buffer mit 1 MB beschrieben wurde.
- Der 1. Aufruf von test() erzeugt eine Rekursion. test() ruft sich also selber auf und es wird ein neuer Speicherbereich für buffer reserviert. Der Speicherverbrauch vom Prozess beträgt nach dem erneuten Beschreiben von buffer 2200 KB.
- Nachdem test() in Zeile 22 aufgerufen wird, beträgt der Speicherverbrauch immer noch 2200 KB. Es wurde also kein 3. mal ein neuer Speicherbereich für buffer vorreserviert, da der Speicherbereich vom 1. Durchlauf benutzt wurde.
Was mich allerdings wundert ist, dass der Stack von lokalen Variablen nach dem Beenden der Funktion nicht freigegeben wird. Es wird also erst beim Benutzen der lokalen Variable der Speicherbereich reserviert, entsprechend rekursiven Funktionsaufrufen wird das dann in mehreren Ebenen gemacht. Wird eine bereits benutzte Ebene einer Rekursion erneut aufgerufen, wird auch der dementsprechende Speicherbereich benutzt.
Allerdings stört mich dieses Verhalten ein wenig. Der Stack ist normalerweise recht klein (standardmäßig 8 MB bei Ubuntu) und wenn man eine größere Anwendung hat, die aus vielen Funktionen und Variablen besteht, wo es eventuell ein paar Rekursionen gibt, wird der Stack immer weiter gefüllt ohne freigegeben zu werden. Direkt mit free() kann man den Speicher nicht freigeben, aber gibt es eine andere Möglichkeit, den Speicher von diesen Variablen nach dem Beschreiben freizugeben?
Dieser Beitrag wurde von Sworddragon bearbeitet: 03. Dezember 2012 - 10:42