Newsgroup: it.comp.os.linux.development
Titolo: memoria

esiste un modo x calcolare la memoria ancora disponibile ad un processo?
intendo dire attraverso una chiamata da una programma scritto in C?
ho guardato un po' la libc e ho dato un occhiata a mallinfo, vedo che
questa struct ritorna solo il numero di blocchi disponibili ma non la
memoria.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 memoria.
getrlimit()/setrlimit() oppure ulimit() se ancora disponibile.
Ciao
Giovanni
-- 
   A computer is like an air conditioner,
   it stops working when you open Windows.
   Registered Linux user #337974  < 
http://giovanni.homelinux.net/
 >

 Giovanni
Grazie Giovanni.
ho provato getrlimit() ma non funziona:
codice:
struct rlimit r;
getrlimit(RLIMIT_AS, &r);
ma r.rlim_cur ritorna sempre il valore 4294967295 indipendentemente dal
consumo di memoria. Possibile che non ci sia un modo per ottenere una cosa
così importante quale la quantità di memoria disponibile ad un processo?


 così importante quale la quantità di memoria disponibile ad un processo?
Giusto da qualche anno esiste il concetto di memoria virtuale, quindi il
concetto di memoria disponibile viene un po' a sparire.
I 4 GB che vedi sono la quantità di memoria virtuale che hai a disposizione. 
Poi può essere mappata in memoria fisica, oppure swappata, mappata su un
file oppure ancora memoria di un device... sapere quanta memoria hai
disponibile (quale memoria?) non ha più molto senso.
Ciao,
-- 
 Daniele Orlandi                                                        つづく

 così importante quale la quantità di memoria disponibile ad un processo?
Come ti e' stato detto e` un valore non molto significativo su un 
sistema unix, in ogni modo se ti interessa con una popen sul comando 
"free" dovresti poter ottenere quello che vuoi:
gabry@vermont:dat/>free
              total       used       free     shared    buffers     cached
Mem:       2006492    1104364     902128          0      76536     646260
-/+ buffers/cache:     381568    1624924
Swap:      4385724        128    4385596
Il parametro che probabilmente ti interessa e` il 3o della prima riga, 
da notare pero' che i bytes consumati da "buffers" possono essere 
reclamati dalle applicazioni in qualunque momento (sono la cache 
dinamica del disco), inoltre lo used puo' scendere se qualcosa viene 
spostato in Swap... insomma forse io ritornerei free + buffers, ma 
nessuna soluzione e` giusta, in realta` nel caso della macchina sopra il 
risultato piu` corretto e` il numerino che quoto nella tua mail :)

 ssdsf wrote:




Ok, grazie mille, probabilmente è quello che cercavo. un'altra cosa come
faccio ad invocare questo commando e a ricavare il risultato da una
funzione in C?
grazie!


 così importante quale la quantità di memoria disponibile ad un processo?
Un processo eredita i le risorse disponibili dal processo che lo fa 
partire.  Quando parte una shell, se non ci sono settaggi imposti nel 
processo di login, le impostazioni sono (nella mia workstation):
$ lsodgf0@monica:~ > ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
file size               (blocks, -f) unlimited
pending signals                 (-i) 3967
max locked memory       (kbytes, -l) 32
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 3967
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited
Queste impostazioni di default possono essere modificate con il 
comando ulimit (o setrlimit() da C).
Il valore 4294967295 è (-1), indica 'unlimited' e significa che il 
processo continuerà ad allocare memoria fintanto che tutta la ram e lo 
swap non saranno esauriti.


 Giovanni
Grazie,
ma mi chiedo come faccio ad invocare i commandi della shell da un codice
in C++? E soprattutto come immagazzino i risultati in una variabile?
grazie!


 in C++? E soprattutto come immagazzino i risultati in una variabile?
Ma non devi invocare un comando della shell. 
Le stesse informazioni che restituisce 'ulimit' possono essere ricavate con
'getrlimit(2)'. 
Le informazioni che restituisce 'free', invece, possono essere ottenute
aprendo e leggendo '/proc/meminfo' come fosse un file ordinario.
Max

 variabile?
Se proprio vuoi leggerli col comando della shell devi usare una
fork()+exec() dirigendo l'output su file o pipe ed usando un parser
per analizzarlo. Oppure, come ti ho scritto in precedenza, usando
getrlimit()/setrlimit().


 fork()+exec() dirigendo l'output su file o pipe ed usando un parser
Esagerato un uso di popen, combinato al comando cut, se non si hanno 
grossi problemi prestazionali e` + che sufficiente:
  if (FILE *f = popen("cat /proc/meminfo | grep ^MemFree | cut -d ':' -f 
2", "r")) {
         char buffer[256], *c = buffer;
         fgets(buffer, sizeof(buffer), f);
         while (*c == ' ' || *c == '\t')
             c++;
         TotalMemoryKB = atoi(c);
         if (strstr(buffer, "MB"))
                 TotalMemoryKB *= 1024;
         else if (!strstr(buffer, "kB"))
                 TotalMemoryKB /= 1024;
         pclose(f);
     }

 Giovanni
No, getrlimit non mi ritorna quello che cerco (mi da' sempre quel numero
"magico" che non mi interessa).  
Anche facendo cat /proc/meminfo mi ritrovo una serie di valori ma non
riesco a capire quale di questi sia effettivamente la memoria che ancora
rimane "free" nel sistema


 rimane "free" nel sistema
quello che alla fine volevo capire è un modo semplice per leggere
i valori ritornati dal commando "free" della shell, pero' invocato da un
programma scritto in C. Devo usare popen? E come si usa?
grazie


 che ancora rimane "free" nel sistema
Nessuna di quelle informazioni ti dice quanta memoria è disponibile ad 
un processo ma dà indicazione su come viene usata la memoria fisica e 
virtuale nell'istante in cui leggi /proc/meminfo.  Il kernel la 
gestisce in modo dinamico per le necessità del sistema quindi quella è 
una foto di un istante.
