Newsgroup: it.comp.os.linux.development
Titolo: Dubbio sulla dimensione di stack e heap

Ho un piccolo dubbio riguardante la dimensione dello stack e delle heap.
In UNIX in generale, e Linux in particolare, esistono una syscall e un 
corrispodente comando da cui posso ottenere l'attuale dimensione massima 
dello stack, dell'heap, etc.
Ora mi chiedo, quando viene caricato un programma in memoria e viene 
assegnata la memoria per lo stack e per l'heap al processo, che 
dimensione viene usata?
E' qualcosa stabilito dall'OS, dal compilatore (che magari usa dei 
valori standard, ma con magari la possibilità di specificare dei valori 
alternativi) o cosa?
Grazie
PS. MI riferisco in particolare a Linux e al compilatore c gcc, ma mi 
interessa sapere anche in generale come vengono gestire queste cose.
-- 
Marco Iannaccone
FAKEci...@email.it
(togliere 'FAKE' dall'indirizzo - remove 'FAKE' from the address)
Ubuntu - Umanity to others
Sono quel che sono a causa di chi noi tutti siamo.
I am what I am because of who we all are.
Mozilla Firefox 1.0: 
http://www.mozillaitalia.org
, 
http://www.mozilla.org
Mozilla Thunderbird 1.0: 
http://www.mozillaitalia.org
, 
http://www.mozilla.org
OpenOffice 1.1.3: 
http://it.openoffice.org
, 
http://www.openoffice.org
The GIMP 2.2.1: 
http://www.gimpitalia.it/
, 
http://www.gimp.org/

 alternativi) o cosa?
Il compilatore genera indirizzi relativi che vengono rilocati dall'OS in 
esecuzione verso indirizzi assoluti, prendendo l'offset di pagina e 
sommandolo all'indirizzo relativo. Il gcc genera istruzioni di push e 
pop sullo stack (muovendo il puntatore avanti e indietro secondo 
necessità), e se va fuori dalla pagina l'OS dice "braaap! segmentation 
fault! stai cercando di mettere il naso in cose che non ti riguardano".
er... spero di non aver sparato troppe castronerie. a logica, penso che 
ogni processo possa al max occupare una pagina di memoria (max 4Gb), ma 
non vorrei dire una falsità.


Matteo Settenvini ha scritto:

Beh, ok, a grandi linee tutto ok, però queste sono tutte cose che 
sapebo. Io ho chiesto un'altra cosa, ovvero in base a cosa è decisa, 
all'avvio di un processo, la dimensione che avrà lo stack! :-P
Chi è che decide (e come) che lo stack è grande ad esempio X e non Y?


 Chi è che decide (e come) che lo stack è grande ad esempio X e non Y?
Da quello che so io, in Unix (e penso anche in Linux) lo stack non ha
una dimensione prefissata, ma cresce dinamicamente.
Rappresentando graficamente quello che ti ha spiegato Matteo, l'area di
memoria virtuale di un processo misura 4 Gb, disposti cosi`:
0--------------   ... --------------4Gb
codice......                   ...stack
In pratica il codice parte da 0 e cresce verso l'alto. Lo stack parte da
4Gb e cresce verso il basso.
Quando si incontrano il processo ha finito la sua area di memoria
virtuale e occupa 4Gb (e qualcosa) in memoria fisica.
Bye.

 virtuale e occupa 4Gb (e qualcosa) in memoria fisica.
A grandi linee è così, in realtà il kernel si tiene un pezzetto della
memoria virtuale per i propri usi.
Semplice esperimento:
#include <stdio.h>
int a;
int main(int argc, char *argv[])
{
 int b;
 printf("%p %p\n",&a, &b);
 return 0;
}
Su una macchina x86-64:
orlandi@nabla:~> ./a
0x500904 0x7fbfffedbc
Su una macchina x86-32:
bastard:~ # ./a
0x8049628 0xbffff3c4
(kernel 2.6 - SuSE 9.2)
Più o meno di dà un'idea di quanto sia lo spazio disponibile a stack e heap,
511 GiB per le macchine x86-64 e 2943 MiB per l'architettura i386.
Ciao!
-- 
Daniele Orlandi

 interessa sapere anche in generale come vengono gestire queste cose.
Posso risponderti quello che so circa Linux (su i386) anche perché alcune
risposte che ti hanno dato mi sembravano un po' sbagliate.
La dimensione dell'heap è dinamica: parte da 0 (immagino) e cresce fino a
quanto ne viene richiesta (man mano che mallochi) nei limiti di memoria
presente nel sistema (ram + swap) (se la memoria è finita malloc()
ritorna NULL)
La dimensione dello stack non è illimitata come ti hanno suggerita
(se per prova richiami ricorsivamente una funzione di continuo ottieni un
SIGSEGV). Oltre non so spiegarti: so però che:
sul mio sistema un normale processo ha 8kb di stack.
se sono su bash e prima di lanciare un processo smanetto un po' col
comando "ulimit" posso modificare la dimensione dello stack per il
processo che andrò a eseguire dopo (col comando "ulimit -a" posso vedere
i vari limiti).
Ed ecco che ora con un semplice "man ulimit" mi sono accorto che esiste
una funzione a cui forse vorrai dare un'occhiata:
int getrlimit(int resource, struct rlimit *rlim);
int setrlimit(int resource, const struct rlimit *rlim);
tra le altre cose si può impostare anche la dimensione dello stack.
Ciao
Matic

 alternativi) o cosa?
OS.
Luca
-- 
Home: 
http://kronoz.cjb.net
Recursion n.:
	See Recursion.

 i vari limiti).
Questa si chiama policy ;) E` una limitazione artificiale posta per
ragioni di sicurezza. La dimensione dello stack è limitata solo dallo
spazio di indirizzamento disponibile (e dalla memoria fisica).
Luca
-- 
Home: 
http://kronoz.cjb.net
Se alla sera, dopo una strepitosa vittoria, guardandoti allo
specchio dovessi notare un secondo paio di palle, che il tuo 
cuore non si riempia d'orgoglio, perche` vuol dire che ti 
stanno inculando -- Saggio Cinese

 memoria virtuale per i propri usi.
Il GB "alto" AFAIK viene usato per mappare le syscall.
-- 
  Giuseppe "Cowo" Corbelli \/\ My software: 
http://cowo.yoda2000.net
    **ANTI-SPAM** -- **Substitute IHATESPAM with cowo to reply by mail**
           -<! Failure is not an option...it's bundled with Microsoft !>-