Dimensione massima dello stack del programma in C / C ++

Voglio fare DFS su un array 100 x 100. (Supponiamo che gli elementi dell'array rappresentino i nodi del grafo) Quindi, supponendo il caso peggiore, la profondità delle chiamate di funzione ricorsive può arrivare fino a 10000 con ogni chiamata che richiede fino a 20 byte. Quindi è fattibile significa che c'è una possibilità di stackoverflow?

Qual è la dimensione massima dello stack in C / C ++?

Specificare per gcc sia per
1) cygwin su Windows
2) Unix

Quali sono i limiti generali?

In Visual Studio la dimensione dello stack predefinita è 1 MB, penso, quindi con una profondità di ricorsione di 10.000 ogni stack frame può essere al massimo ~ 100 byte, il che dovrebbe essere sufficiente per un algoritmo DFS.

La maggior parte dei compilatori, incluso Visual Studio, consente di specificare la dimensione dello stack. Su alcuni (tutti?) Gusti Linux la dimensione dello stack non fa parte dell'eseguibile ma una variabile d'ambiente nel sistema operativo. È quindi possibile controllare la dimensione dello stack con ulimit -se impostarlo su un nuovo valore con, ad esempio ulimit -s 16384.

Ecco un collegamento con le dimensioni dello stack predefinite per gcc.

DFS senza ricorsione:

std::stack<Node> dfs;
dfs.push(start);
do {
    Node top = dfs.top();
    if (top is what we are looking for) {
       break;
    }
    dfs.pop();
    for (outgoing nodes from top) {
        dfs.push(outgoing node);
    }
} while (!dfs.empty())

gli stack per i thread sono spesso più piccoli. È possibile modificare l'impostazione predefinita al momento del collegamento o modificare anche in fase di esecuzione. Per riferimento alcuni valori predefiniti sono:

• glibc i386, x86_64 7,4 MB
• Tru64 5.1 5,2 MB
• Cygwin 1.8 MB
• Solaris 7..10 1 MB
• MacOS X 10.5 460 KB
• AIX 5 98 KB
• OpenBSD 4.0 64 KB
• HP-UX 11 16 KB

Dipendente dalla piattaforma, dipendente dalla toolchain, dipendente da ulimit, dipendente da parametri ... Non è affatto specificato e ci sono molte proprietà statiche e dinamiche che possono influenzarlo.

Sì, esiste la possibilità di overflow dello stack. Gli standard C e C ++ non impongono cose come la profondità dello stack, questi sono generalmente un problema ambientale.

La maggior parte degli ambienti di sviluppo e / o dei sistemi operativi decenti ti permetteranno di adattare la dimensione dello stack di un processo, al collegamento o al caricamento.

È necessario specificare quale sistema operativo e ambiente di sviluppo si sta utilizzando per un'assistenza più mirata.

Ad esempio, in Ubuntu Karmic Koala, l'impostazione predefinita per gcc è 2M riservato e 4K impegnato, ma questo può essere modificato quando si collega il programma. Usa l' --stackopzione di ldper farlo.

Ho appena esaurito lo stack al lavoro, era un database e stava eseguendo alcuni thread, in pratica lo sviluppatore precedente aveva lanciato un grande array sullo stack e lo stack era comunque basso. Il software è stato compilato utilizzando Microsoft Visual Studio 2015.

Anche se il thread aveva esaurito lo stack, non è riuscito silenziosamente e ha continuato, lo stack è andato in overflow solo quando è arrivato il momento di accedere ai contenuti dei dati sullo stack.

Il miglior consiglio che posso dare è di non dichiarare array nello stack, specialmente nelle applicazioni complesse e in particolare nei thread, usa invece l'heap. Ecco a cosa serve;)

Inoltre, tieni presente che potrebbe non fallire immediatamente quando si dichiara lo stack, ma solo all'accesso. La mia ipotesi è che il compilatore dichiari lo stack sotto Windows "ottimisticamente", cioè presumerà che lo stack sia stato dichiarato e sia sufficientemente dimensionato fino a quando non arriva ad usarlo e poi scopre che lo stack non è lì.

Sistemi operativi diversi possono avere criteri di dichiarazione dello stack diversi. Si prega di lasciare un commento se si sa quali sono queste politiche.

Non sono sicuro di cosa intendi facendo una prima ricerca in profondità su un array rettangolare, ma presumo che tu sappia cosa stai facendo.

Se il limite dello stack è un problema, dovresti essere in grado di convertire la tua soluzione ricorsiva in una soluzione iterativa che inserisce valori intermedi su uno stack allocato dall'heap.