Stack-Größe festlegen

[Heiko Thole (Gast)]

Hallo ihr.

Ich habe vor kurzem mit dem IAR-Compiler gearbeitet. Bei dem
musste/konnte man die Größe vom Stack einstellen.
Ist das auch beim AVR-GCC möglich? Oder geschieht das automatisch?

Danke
Heiko

[Joerg Wunsch (Gast)]

Das geschieht automatisch: der Stack wächst von der höchsten RAM-Zelle
nach unten.  Variablenspeicher wird hingegen von der niedrigsten
RAM-Zelle aufsteigend belegt.  Der Bereich dazwischen ist als Stack
und ggf. Heap verfügbar.  Siehe auch die Doku, insbesondere die zu
malloc().

Einen separaten Daten- und Return-Stack benutzt der GCC nicht.

[Heiko Thole (Gast)]

Also dürfte nichts passieren, solange ich noch genügend freien
SRAM-Speicherplatz habe?
Ich habe mir das mal mit avr-sizex ausgeben lassen:
    Flash     SRAM     EEPROM
    -----     ----     ------
      45%      53%         0%
    13144     1103          0    bytes used
    15528      945       1024    bytes free
    28672     2048       1024    bytes capacity

MfG
Heiko

[Joerg Wunsch (Gast)]

> Also dürfte nichts passieren, solange ich noch genügend freien
> SRAM-Speicherplatz habe?

Sofern es wirklich genügend ist (auch für alle auto-Variablen,
rekursiven Funktionsaufrufe :), Interrupts etc. pp.), ja.

[Heiko Thole (Gast)]

Wird das von dem Tool nicht berücksichtigt? :(
Gibt es denn die Möglichkeit sich den Speicherbedarf im "Worst-Case"
anzeigen zu lassen?

[Joerg Wunsch (Gast)]

Wenn Du drüber nachdenkst, kommst Du ziemlich schnell drauf, daß nur
Du selbst das wissen kannst.  Oder wie sollte das Tool beispielsweise
feststellen, wie oft eine rekursive Funktion rekursiert?

Nein, da wird nur der statische RAM-Verbrauch angezeigt.  Die Größe
der Stackframes (genauer: der lokalen Variablen im Stackframe, Du hast
noch Overhead für die Framestruktur) steht im vom Compiler generierten
Assemblercode als Kommentar.  Zusammen mit Deinem
Funktionsaufrufgraphen kannst Du Dir daraus die maximale Stacktiefe
ausrechnen, wenn Du willst.  (Aber bitte kein /Disassembler/listing,
sondern wirklich das vom Compiler generierte File ansehen -- ein
Disassembler kann Dir keine Compiler-Kommentare zurückholen. ;-)

[Fiffi (Gast)]

Hallo Jörg,

Ein solches Tool, was den Stackverbrauch berechnet wäre wirklich toll
!!!

>Oder wie sollte das Tool beispielsweise feststellen, wie oft eine
rekursive Funktion rekursiert?

Diesen Fall würde Ich bei der Berechnung "ausklammern".


Dann wäre das zwar nicht 100% exakt, aber es wäre eine riesige Hilfe !


Wie schätzt du ungefähr den Aufwand für ein solches Tool ein, für einen
C-Programmierer, der noch nie die Innereien von GCC usw. gesehen hat ?


Gruß

Fiffi

[Joerg Wunsch (Gast)]

> Wie schätzt du ungefähr den Aufwand für ein solches Tool ein, für
> einen C-Programmierer, der noch nie die Innereien von GCC
> usw. gesehen hat ?

Das hängt vom C-Programmierer ab...  Mit den Innereien eines GCC mußt
Du Dich ringsum überhaupt nicht befassen.  Du brauchst sowas wie
cxref, daraus mußt Du den Graphen berechnen, welche Funktion was wie
aufrufen kann.  Das klingt einfacher, als es ist, stell Dir nur sowas
vor:

int something;

void bar(void);

void
foo(void)
{
  if (something)
    bar();
}

void
bar(void)
{
  if (!something)
    foo();
}

Zwar ist durch den Kontext klar, daß sie foo() und bar() nie endlos
rekursiv rufen können, aber ein sturer Versuch, den Graphen zu
ermitteln, muß die Endlosschleife zumindest erkennen und nach der
ersten vollständigen Rekursion abbrechen.

Den Stackframeverbrauch selbst liest Du am besten wirklich aus den vom
Compiler generierten Assemblerfiles.

Den Verbrauch der Interruptfunktionen kann man extra ermitteln und
einzeln dazu auflisten.