Heap und Stack abfragen?

Stack wird meist überwacht. Man schreibt einen Pattern rein, und checkt 
zyklisch wo sich der Pattern endet. Das ganze kann man ja über mehrere 
Zeitschlitzen verteilen, so muss man nicht das ganze Stack immer 
durchsuchen. Dann wenn einmal Ende gefunden ist, muss man ja nur gucken 
ob der Stack sich weiter befüllt hat oder nicht. Damit bekommst du dann 
den Maximalwert.

Aktueller Wert macht ja auch nicht viel Sinn, weil du ja immer am 
gleiche Stelle abfragen würdest. Außer du hast ja Tracer und willst 
genau wissen. Das ist ja aber kein C++ Thema mehr.

Der Stack ist ein durchgehender Bereich vom Anfang bis zum Stackpointer. 
Wie du diese Sachen abfragst, hängt vom Compiler und µC ab.

Beim heap ist es schwieriger, denn der kann erstens fragmentiert sein 
und zweitens könnte die C++ Library ihn Blockweise belegen und diese 
Blöcke dann wiederum in klienren Stücken dem Programm übergeben.

Hier kommt es vor allem darauf an, wie sich deine C++ Library verhält, 
sowie die implementierung von calloc() in der zugrunde liegenden C 
Library (bzw Assembler-Code).

Jedenfalls gibt es beim Heap nicht DEN freien Bereich, sondern viele 
freie Bereiche. Diese einfach zusammen zu addieren wäre aber falsch. 
Wenn du 10 mal 1kB frei hast, dann kann es trotzdem sein, daß du nicht 
1x10kB belegen kannst.

Also ist die Frage: Was genau willst du am Heap messen?

Und: Welcher Compiler, welche C und C++ Libraries und welcher Prozessor?

> Nur woher nehme ich die Gewissheit, dass sie richtig dimensioniert
> wurden und nicht überlaufen?

Absolut sicher bist du nur, wenn du auf dynamische Speicherverwaltung 
komplett verzichtest. Also kein malloc(), calloc(), new und auch keine 
Klassen bentuzen, die unter der haube diese Funktionen nutzen. Ganz 
böser Klassiker ist die String Klasse, die verleitet einen gerade dazu, 
den heap zu fragmentieren.

Ich Benutze SW4STM32 GCC, FreeRtos, C++ 11, STM32F4

> Ich Benutze SW4STM32 GCC, FreeRtos, C++ 11, STM32F4

Ok, und was genau willst du abfragen?

Wenn du sowieso FreeRTOS nutzt, kannst du folgende calls verwenden:
xPortGetFreeHeapSize() und uxTaskGetStackHighWaterMark(NULL);

Ich nutze das für alle LOG Ausgaben, so dass man im log immer sehen 
kann, wie sich stack und heap entwickeln. Wenn du die LOG Ausgabe für 
jede task mit einer anderen Farbe (ANSI codes) machst, sieht man sofort, 
welche task Probleme machen wird.

pitschu

Beitrag "Re: Stack richtig dimensionieren"

so bekommst du raus was deine funktionen in den task für speicher 
enötigen


FreeRTOS hat aer die runtimestats ... da kannst dir anzeigen lassen 
wieviel stack frei ist und wieviel rechenleistung jeder task enötigt



vlt noch hilfreich:

xPortGetFreeHeapSize()            xPortGetMinimumEverFreeHeapSize()
vTaskGetRunTimeStats( ... );

Dein gcc kann so etwas:

-fstack-usage               Output stack usage information on a 
per-function

Ist manchmal recht nützlich..

sven schrieb:
> Ist es möglich mit C++ auf einem Mikrocontroller  die aktuell benötigte
> Heap- und Stack- Größe abzufragen

Es ist i.A. möglich, Heap- und Stackoperationen überwacht ausführen zu 
lassen, es gibt also eine Fehlermeldung beim Überschreiten der 
Speichergrenzen. Nur hilft das bei einem Controller nicht wirklich 
weiter, weil ja keiner da ist um die Fehlermeldung irgendwie zur 
Kenntnis zu nehmen. Überhaupt stellt sich die Frage, was tun - meistens 
bleibt nur der Neustart, entweder durch die Funktion ausgelöst oder 
durch den Watchdog, und die Fehlerinformation ist verloren. Man könnte 
höchstens ein Log führen und die Fehlermeldung aufzeichnen, aber wer 
wertet das aus?

Unter einem Debugger bekommt man den Fehler natürlich mit, aber es gibt 
halt keine Garantie, dass der Worstcase, der zum Überlauf führt, beim 
Debuggen jemals auftritt.

Georg