Überprüfen der verfügbaren Stapelgröße in C

Ich verwende MinGW mit GCC 3.4.5 (mingw-special vista r3).

Meine C-Anwendung verwendet viel Stack, also habe ich mich gefragt, ob es eine Möglichkeit gibt, programmatisch zu sagen, wie viel Stack noch übrig ist, damit ich die Situation sauber handhaben kann, wenn ich feststelle, dass ich kurz davor bin, auszugehen.

Wenn nicht, auf welche andere Weise würden Sie das Problem umgehen, dass möglicherweise der Stapelspeicherplatz ausgeht?

Ich habe keine Ahnung, mit welcher Stapelgröße ich anfange, also müsste ich das auch programmatisch identifizieren.

Die Getrusage-Funktion liefert Ihnen die aktuelle Nutzung. (sehen man getrusage).

Das getrlimit unter Linux würde helfen, die Stapelgröße mit dem abzurufen RLIMIT_STACK Parameter.

#include <sys/resource.h>
int main (void)
{
  struct rlimit limit;

  getrlimit (RLIMIT_STACK, &limit);
  printf ("\nStack Limit = %ld and %ld max\n", limit.rlim_cur, limit.rlim_max);
}

Bitte werfen Sie einen Blick auf man getrlimit. Dieselben Informationen könnten von abgerufen werden ulimit -s oder ulimit -a Stapelgröße Zeile. Schau auch mal rein setrlimit Funktion, die es ermöglichen würde, die Grenzen festzulegen. Aber wie in den anderen Antworten erwähnt, sollten Sie Ihr Design wahrscheinlich überdenken, wenn Sie den Stapel anpassen müssen. Wenn Sie ein großes Array wollen, warum nehmen Sie den Speicher nicht aus dem Heap?

Es würde funktionieren, die Adresse einer lokalen Variablen vom Stack zu nehmen. Dann können Sie in einem stärker verschachtelten Aufruf die Adresse eines anderen Lokals subtrahieren, um den Unterschied zwischen ihnen zu finden

size_t top_of_stack;

void Main()
{
  int x=0;
  top_of_stack = (size_t) &x;

  do_something_very_recursive(....)
}

size_t SizeOfStack()
{
  int x=0;
  return top_of_stack - (size_t) &x;
} 

Wenn Ihr Code Multithreading ist, müssen Sie sich damit befassen, die top_of_stack-Variable pro Thread zu speichern.

Prüfen Sie, ob Ihr Compiler stackavail() unterstützt

Angenommen, Sie kennen die Größe des vollständigen Stapels, könnten Sie wahrscheinlich einen Assembler-Code hinzufügen, um ESP zu lesen.
Wenn Sie ESP lesen und in der Hauptfunktion beiseite speichern, können Sie das aktuelle ESP mit dem ESP vergleichen, das Sie in der Hauptfunktion haben, und sehen, wie viel ESP sich geändert hat. Das gibt Ihnen einen Hinweis darauf, wie viel Stack Sie verwendet haben.

Das ist ein Problem, das ich aufgegeben habe. Mit viel Hacking und (meistens) Beten können Sie eine Lösung erhalten, die zu einem bestimmten Zeitpunkt auf einem bestimmten Computer funktioniert. Aber im Allgemeinen scheint es keinen anständigen Weg zu geben, dies zu tun.

Sie müssen die Stapelposition und -größe von außerhalb Ihres Programms erhalten (unter Linux erhalten Sie sie möglicherweise von /proc/<pid>/maps). In Ihrem Programm müssen Sie irgendwie testen, wo Sie sich am Stack befinden. Die Verwendung lokaler Variablen ist möglich, aber es gibt keine wirkliche Garantie, dass sie sich tatsächlich auf dem Stack befinden. Sie können auch versuchen, den Wert aus dem Stapelzeigerregister mit einer Assembly zu erhalten.

Jetzt haben Sie also den Ort des Stapels, seine Größe und die aktuelle Position und gehen davon aus, dass Sie wissen, in welche Richtung der Stapel wächst. Wann gehst du in den Stack-Overflow-Modus? Machen Sie es besser nicht ganz am Ende, weil Ihre Schätzung (dh Adresse der lokalen Variablen oder Wert vom Stapelzeiger) wahrscheinlich etwas zu optimistisch ist; Es ist nicht ungewöhnlich, Speicher jenseits des Stapelzeigers zu adressieren. Außerdem haben Sie keine Ahnung, wie viel Platz auf dem Stapel eine bestimmte Funktion (und die von ihr aufgerufenen Funktionen) benötigt. Man muss also am Ende ziemlich viel Platz lassen.

Ich kann Ihnen nur raten, sich nicht in diesen Schlamassel zu begeben und zu versuchen, sehr tiefe Rekursionen zu vermeiden. Vielleicht möchten Sie auch Ihre Stapelgröße erhöhen; Unter Windows müssen Sie dies in die ausführbare Datei kompilieren, glaube ich.

Vielleicht hilft dies nur für die Windows-Plattform:

im PE-Header (IMAGE_NT_HEADERS) Ihrer exe gibt es einige Einträge wie:

typedef struct _IMAGE_NT_HEADERS {
    DWORD Signature;
    IMAGE_FILE_HEADER FileHeader;
    IMAGE_OPTIONAL_HEADER32 OptionalHeader;
} IMAGE_NT_HEADERS32, *PIMAGE_NT_HEADERS32;

typedef struct _IMAGE_OPTIONAL_HEADER {
    ...
    DWORD   SizeOfStackReserve;
    DWORD   SizeOfStackCommit;
    ...
}

Es gibt eine einfache Möglichkeit, diese Werte zu erhalten: Die Verwendung von GetModuleHandle(NULL) gibt Ihnen die Imagebase (Handle) Ihres Moduls, Adresse, wo Sie eine IMAGE_DOS_HEADER-Struktur finden, die Ihnen hilft, die IMAGE_NT_HEADERS-Struktur zu finden (Imagebase+IMAGE_DOS_HEADER. e_lfanew) -> IMAGE_NT_HEADERS, und dort finden Sie diese Felder: SizeOfStackReserve und SizeOfStackCommit.

Die maximale Menge an Speicherplatz, die das Betriebssystem Ihrem Stack zuweist, ist SizeOfStackReserve.

Wenn Sie erwägen, dies zu versuchen, lassen Sie es mich wissen und ich werde Ihnen helfen. Es gibt eine Möglichkeit, die an einem bestimmten Punkt verwendete Stapelgröße zu erhalten.

Raymond Chen (Das Alte Neue) hat eine gute Antwort auf diese Art von Frage:

Wenn Sie fragen müssen, machen Sie wahrscheinlich etwas falsch.

Hier sind einige Win32-Details zur Stapelzuweisung: MSDN.

Wenn Sie der Meinung sind, dass Sie möglicherweise durch den Stapelspeicher begrenzt sind, werden Sie mit ziemlicher Sicherheit durch den verfügbaren virtuellen Speicher eingeschränkt sein. In diesem Fall müssen Sie eine andere Lösung finden.

Was genau versuchst du zu tun?