Maximale SRAM-Auslastung bestimmen (AVR)

[Sven S. (schwerminator)]

Hallo,

ich arbeite gerade an einem recht speicher-aufwändigen Projekt und hätte 
gern mal gewusst, ob es eine Möglichkeit den maximal benötigten Speicher 
eines Programms bestimmen zu lassen (evtl. auch inkl. dynamisch 
allokierten Speicher per malloc()).

Nun gibt es ja beim Kompilieren mit dem avr-gcc die "AVR Memory 
Usage"-Ausgabe und da gibt mir die "Data"-Angabe Auskunft über den 
(statischen) Speicherverbrauch. Doch was genau bedeutet diese Angabe? 
Ist Sie das Maximum? Ist da schon Platz für Rücksprungadressen, 
Parameter, etc. mit einkalkuliert?

Ich hoffe ich konnte mein Anliegen einigermaßen klar vermitteln ;)

Gruß Sven

[Oliver (Gast)]

Der statische Speicherverbrauch ist der statische Speicherverbrauch. Der 
enthält nur die globalen und statischen Vaiablen, sonst nichts. Alles, 
was erst zur Laufzeit auf dem Stack oder heap angelegt wird, ist da 
nicht enthalten.

Eine einfache rechnderische Methode, den dynamischen Speicherbedarf zu 
bestimmen, gibt es nicht. Da hilft nur, entweder von Hand den worst-case 
zu ermitteln, oder zur Laufzeit Stack und heap zu überwachen.

Oliver

[Sven S. (schwerminator)]

Oliver schrieb:
> [...] oder zur Laufzeit Stack und heap zu überwachen.

Und die geht das?

[Sebastian .. (zahlenfreak)]

Gesamten speicher auf einen bestimmten wert initialisieren, programm 
laufen lassen und danach schaun, bis wohin der Speicher geändert wurde. 
Von oben müsste der Stack Daten geändert haben, von unten der Heap. 
Irgendwo zwischendrin gibts ungeänderte Bytes.

Benedikt hat in der Codesammlung auch mal ein kleines Tool veröffentlich 
um den RAM-verbrauch zu berechnen. Heißt glaub ich Stack Viewer. Aber 
ich weiß nicht, ob das mit malloc umgehen kann, denke aber ehr nicht. 
Der Stack ist aber drin, solange du keine Rekursion verwendest.

Sebastian

[Uwe B. (boerge)]

MoinMoin,

ich hatte bei der Implementierung meines AVR-BASIC-Interpreters mal ein 
ähnliches Verlangen und wollte herausbekommen, wie so die 
Speicherbelegung in bestimmten Situationen ist. Nach einigem Rumsuchen 
im Netz ist dies entstanden (zusammenkopiert) worden:

#include <avr/io.h>  // RAMEND
#include "mem_check.h"

// Mask to init SRAM and check against
#define MASK 0xaa

// From linker script
extern unsigned char __heap_start;

unsigned int 
get_mem_free (void)
{
  return SP - (uint16_t) &__heap_start;
}

unsigned short 
get_mem_unused (void)
{
   unsigned short unused = 0;
   unsigned char *p = &__heap_start;

   do
   {
      if (*p++ != MASK)
         break;

      unused++;
   } while (p <= (unsigned char*) RAMEND);

      return unused;
}

/* !!! never call this function !!! */
void __attribute__ ((naked, section(".init3"))) init_mem (void);
void init_mem (void)
{
   __asm volatile (
      "ldi r30, lo8 (__heap_start)"  "\n\t"
      "ldi r31, hi8 (__heap_start)"  "\n\t"
      "ldi r24, %0"                  "\n\t"
      "ldi r25, hi8 (%1)"            "\n"
      "0:"                           "\n\t"
      "st  Z+,  r24"                 "\n\t"
      "cpi r30, lo8 (%1)"            "\n\t"
      "cpc r31, r25"                 "\n\t"
      "brlo 0b"
         :
         : "i" (MASK), "i" (RAMEND+1)
   );
}

Dabei liefert get_mem_free() den derzeit freien Speicher zwischen Stack 
und Heap.

get_mem_unused() liefert die Speichergröße, die noch nicht "angerührt" 
wurde. Allerdings funktioniert dies dann aber nicht mehr, wenn man mal 
malloc() aufgerufen hat, weil dann das initialisierte Pattern am 
"Ram-Ende" überschrieben wird.

Grüße Uwe

[Sven S. (schwerminator)]

Besten Dank für die Antworten. Ich werde das mal ausprobieren!

Gruß Sven