Chi stabilisce le dimensioni di Stack e Heap

[Micheles]

Ciao ,
Avrei delle domande che probabilmente ai più sembreranno banali ma avere
delle risposte per me sarebbe importante.
Io ho un programma scritto in linguaggio C++; per quel che ne so, quando lo
stesso va in esecuzione gli vengono riservate 4 zone di memoria così
denominate:
1) Area Codice
2)Area Dati Globali
3)Stack
4)Heap

1)L'Area codice contiene ovviamente il codice del programma
2)L'Area Dati Globali contiene tutte le variabili a cui viene assegnata
memoria in modo statico ovvero per tutta la durata del programma.
Finiscono in questa area:
-variabili globali
-eventuali dati membri statici delle classi
-variabili locali statiche di funzioni
-...........

3) Nello Stack finiscono i record di attivazione delle funzioni che
contengono parametri, variabili locali non statiche, indirizzo di
ritorno,valore restituito dalla funzione.Quando la funzione termina il
record di attivazione viene tolto.Pertanto lo Stack, come l'Heap,varia
dinamicamente.

4)Nell'Heap viene allocata memoria per i puntatori in modo dinamico mediante
le funzioni "new" o "malloc".-

Le dimensioni dell'Area Codice e dell'Area Dati sono note fin dall'inizio
dell'esecuzione del programma.
L'Heap e lo Stack invece variano dinamicamente.La mia domanda è: all'inizio
dell'esecuzione del programma valgono "0" e poi man mano che il programma si
sviluppa variano dinamicamente la propria dimensione? Oppure, fin
dall'inizio al programma viene assegnata un'area Eeap e un'area Stack
entrambe con una certa dimensione e ,quindi, ciò che varia dinamicamente è
la percentuale di occupazione di queste aree con le dimensioni fissate? In
questo secondo caso, chi è che stabilisce quando debba essere grande l'Heap
e quanto debba essere grande lo Stack?Il compilatore? Non ci sarebbe il
pericolo che data una dimensione troppo piccola all'Heap durante
l'esecuzione del programma questa venga prima riempita e poi superata
conducendo il programma al crash?
Suppongo di lavorare in ambiente windows.
Grazie

[Filippo]

On Thu, 20 Jan 2005 11:50:06 +0100, "Micheles"

Post by Micheles
Ciao ,
Avrei delle domande che probabilmente ai più sembreranno banali ma avere

...

Ciao
Sto sviluppando un software in visual c++ e ho lo stesso problema.
Cioè, ho usato un array di circa 2 Mb e il programma mi è andato in
Stack Overflow, perchè lo stack è dimensionato automaticamente a 1 Mb,
a quanto pare.

Come si fa ad aumentare lo stack?
Oppure, avete un esempio per utilizzare la funzione calloc e usare la
Ram per eseguire la funzione richiesta?
Grazie Ciao
F

[Filippo]

On Thu, 20 Jan 2005 23:09:21 GMT, Filippo <***@x.it> wrote:


COME NON DETTO!
Ho appena trovato l'opzione in MS VS6,
Settings->Link->output->Stack Allocations
!!!
'ccipicchia! l'ho cercato tutto oggi e lo trovo alle 0.17 di notte!!!
boh...
Ciao
Filippo

Post by Filippo
On Thu, 20 Jan 2005 11:50:06 +0100, "Micheles"

Post by Micheles
Ciao ,
Avrei delle domande che probabilmente ai più sembreranno banali ma avere

...
Ciao
Sto sviluppando un software in visual c++ e ho lo stesso problema.
Cioè, ho usato un array di circa 2 Mb e il programma mi è andato in
Stack Overflow, perchè lo stack è dimensionato automaticamente a 1 Mb,
a quanto pare.
Come si fa ad aumentare lo stack?
Oppure, avete un esempio per utilizzare la funzione calloc e usare la
Ram per eseguire la funzione richiesta?
Grazie Ciao
F

[Martino Serri]

Post by Filippo
COME NON DETTO!
Ho appena trovato l'opzione in MS VS6,
Settings->Link->output->Stack Allocations
!!!
'ccipicchia! l'ho cercato tutto oggi e lo trovo alle 0.17 di notte!!!
boh...
Ciao
Filippo

A mio avviso, stai sbagliando strada. Non è aumentando lo stack da
compilatore che risolvi il problema. Anziché allocare in modo statico,
usa l'allocazione dinamica (malloc() and friends).

M.

[Filippo]

On Fri, 21 Jan 2005 09:29:01 GMT, Martino Serri

Post by Martino Serri
A mio avviso, stai sbagliando strada. Non è aumentando lo stack da
compilatore che risolvi il problema. Anziché allocare in modo statico,
usa l'allocazione dinamica (malloc() and friends).
M.

Ok, però non ho ben chiaro come funzionano quelle funzioni.

Cioè io ho costruito un array di una struct, per esem.:
struct animali
{
...
};

Animali Leone [1000];

ok,....e adesso?
Come la metto dentro la memoria allocata (che non so bene come
allocare) ?
Avresti mica un esempio?
Grazie
Ciao
F

[mrnt]

Post by Filippo
Ok, però non ho ben chiaro come funzionano quelle funzioni.
struct animali
{
...
};
Animali Leone [1000];
ok,....e adesso?
Come la metto dentro la memoria allocata (che non so bene come
allocare) ?
Avresti mica un esempio?
Grazie
Ciao
F

Ma in quel modo il contenuto dell'array non si trova nell'heap, si trova
nel segmento dati; per fare in modo che il contenuto si trovi nell'heap, e
che quindi possa variare dinamicamente le sue dimensioni, devi allocare
l'array con l'operatore new e gestirlo tramite un puntatore, così:

#include <stdlib.h>

struct item {
int content;
};

item *array = NULL;

void main() {
array = new item[5]; // alloco 5 elementi, cioè 5 * sizeof(item) byte
for (int i = 0; i < 5; i++) {
array[i].content = 0;
}
// ...
array = (item*)realloc(array, 7 * sizeof(item)); // ridimensiono
l'array: ora contiene 7 elementi e occupa 7 * sizeof(item) byte
// ...
delete array; // libero tutto
}

[JoGiò]

Post by mrnt

Post by Filippo
Ok, però non ho ben chiaro come funzionano quelle funzioni.
struct animali
{
...
};
Animali Leone [1000];
ok,....e adesso?
Come la metto dentro la memoria allocata (che non so bene come
allocare) ?
Avresti mica un esempio?
Grazie
Ciao
F

Ma in quel modo il contenuto dell'array non si trova nell'heap, si trova
nel segmento dati; per fare in modo che il contenuto si trovi nell'heap, e
che quindi possa variare dinamicamente le sue dimensioni, devi allocare
#include <stdlib.h>
struct item {
int content;
};
item *array = NULL;
void main() {
array = new item[5]; // alloco 5 elementi, cioè 5 * sizeof(item) byte
for (int i = 0; i < 5; i++) {
array[i].content = 0;
}
// ...
array = (item*)realloc(array, 7 * sizeof(item)); // ridimensiono
l'array: ora contiene 7 elementi e occupa 7 * sizeof(item) byte
// ...
delete array; // libero tutto
}

credo sia più corretto delete[]array;

[mrnt]

Post by Micheles
[...]
Le dimensioni dell'Area Codice e dell'Area Dati sono note fin dall'inizio
dell'esecuzione del programma.
L'Heap e lo Stack invece variano dinamicamente.La mia domanda è: all'inizio
dell'esecuzione del programma valgono "0" e poi man mano che il programma si
sviluppa variano dinamicamente la propria dimensione? Oppure, fin
dall'inizio al programma viene assegnata un'area Eeap e un'area Stack
entrambe con una certa dimensione e ,quindi, ciò che varia dinamicamente è
la percentuale di occupazione di queste aree con le dimensioni fissate? In
questo secondo caso, chi è che stabilisce quando debba essere grande l'Heap
e quanto debba essere grande lo Stack?Il compilatore? Non ci sarebbe il
pericolo che data una dimensione troppo piccola all'Heap durante
l'esecuzione del programma questa venga prima riempita e poi superata
conducendo il programma al crash?

Be', il discorso è diverso per le due diverse aree di memoria: lo stack ha
una dimensione fissa stabilita dal compilatore (cerca tra le opzioni di
compilazione), e la "percentuale d'uso", come l'hai giustamente chiamata
tu, non deve mai superare il 100%, altrimenti si ottiene lo stack
overflow, cosa che succede spesso quando si ha a che fare con funzioni
molto ricorsive; l'heap invece cresce dinamicamente: ogni volta che
allochi un nuovo blocco, chiami implicitamente le API del sistema
operativo che ridimensionano l'heap adibito al tuo programma (in Windows:
vedere le funzioni API HeapAlloc e compagne).

[Micheles]

Post by mrnt
Be', il discorso è diverso per le due diverse aree di memoria: lo stack ha
una dimensione fissa stabilita dal compilatore (cerca tra le opzioni di
compilazione), e la "percentuale d'uso", come l'hai giustamente chiamata
tu, non deve mai superare il 100%, altrimenti si ottiene lo stack
overflow, cosa che succede spesso quando si ha a che fare con funzioni
molto ricorsive; l'heap invece cresce dinamicamente: ogni volta che
allochi un nuovo blocco, chiami implicitamente le API del sistema
vedere le funzioni API HeapAlloc e compagne).

Ok.
La dimensione dello Stack la stabilisce il compilatore.
La dimensione dell'Heap cresce dinamicamente con le chiamate alle API.
1)Come fa il sistema operativo a conoscere la dimensione dell'area Stack (in
modo da dare eventualmente errore di Stack Overflow) se questa viene
stabilita dal compilatore?
2)Mentre per quanto concerne l'Heap, presumo che tenga traccia della
memoria allocata per il processo tramite le varie API Heap Allloc e, per
tale motivo, sa qual è l'Heap totale allocata al processo.Giusto?
3)Quando io ho l'errore di Access Violation? Ho sempre pensato che fosse
dovuto ad un puntatore che va a sporcare un'area di memoria che nn fa parte
dell'Heap allocata al processo o dell'area dati globali( perché ovviamente
un puntatore può anche essere indirizzato ad una struttura dati che ho
allocato staticamente). Pertanto se un puntatore va a sporcare lo stack o
l'area codice o una zona di memoria esterna allo spazio di indirizzamento
del processo ho Access Violation. E' così?
Se avessi delle risposte a queste domande mi sarebbe molto utile.
Grazie pere le risposte già fornite.
M