Come faccio a sapere la quantità di memoria viene lasciato in GNU C ++ su Linux
https://stackoverflow.com/questions/391107
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Sto scrivendo un programma in C ++ (compilato con gcc e in esecuzione su RedHat Linux). Il programma ha bisogno di sapere in fase di esecuzione quanto spazio è rimasto sullo stack e quanto viene lasciato in mucchio. Realizzo non ci può essere una risposta definitiva a questa domanda (circa il mucchio), quindi in alternativa, ho potuto utilizzare la quantità di memoria già allocata dall'heap invece. C'è una funzione chiamata di una biblioteca / sistema che mi darà questi dati?
Mi piacerebbe aggiungere che ho solo bisogno di questo per il debug, e solo bisogno di stime approssimative, così soluzioni rapide-e-sporco sono perfettamente accettabili. Tuttavia, devo interrogare l'utilizzo della memoria molto frequentemente, quindi sborsare per un'utilità Unix cmd-linea e l'analisi sua uscita non è accettabile.
Nessuna soluzione corretta
Altri suggerimenti
Probabilmente si può creare il proprio nuovo ed eliminare le funzioni che racchiude la vera new e delete operatori e prendere nota del utilizzo della memoria, allo stesso tempo.
Per pila, c'è un trucco in C, dove si dà un'occhiata all'indirizzo della prima variabile locale definita nella funzione corrente per avere un'idea approssimativa di dove lo stack pointer è in questo momento. Credo che dovrebbe funzionare in C ++, ma non l'ho provato.
su linux si può leggere / proc / pid / Stato
Si noti che nei sistemi a 32 bit, lo stack cresce verso il basso e il mucchio cresce verso l'alto, e le due potrebbe incontrare qualche parte nel mezzo. Lo spazio può, pertanto, essere allocato a pila o mucchio, ma non entrambi allo stesso tempo. Si noti che i segmenti di memoria condivisa (se li usi) complicano la mappa di memoria. Così può caricare dinamicamente le librerie (condivisi).
+------------+
| stack | high addresses
| | |
| v |
+------------+
| |
| unused |
| |
+------------+
| |
| ^ |
| | |
| heap |
| |
+------------+
| |
| bss |
| |
+------------+
| |
| data |
| |
+------------+
| |
| text |
| | low addresses
+------------+
In un sistema a 64 bit, non v'è spazio di indirizzi sufficiente che si esegue fuori la memoria reale e virtuale prima che si verifichino collisioni.
Si noti inoltre che (almeno alcune versioni di) Linux sono disposti a dire di più di memoria può essere allocata di quello che in realtà possono sostenere - hanno over-commit. Che non è molto buona. Vuol dire che gli esperimenti pratici come le allocazioni di memoria di prova può dare un falso senso di sicurezza.
Molto probabilmente, si sta meglio fuori che chiede 'è la x MB (GB?) Di spazio sinistra', piuttosto che 'quanti MB (GB?) Di spazio è lasciato'. Altre persone hanno indicato il file /proc sistema come una fonte di informazione per la quantità di memoria è in uso. Io non sono sicuro se ti dice in modo affidabile su quanto la memoria è disponibile per afferrare.
Questa è una funzione C per restituire la quantità di memoria libera sul PI lampone. Funziona con la lettura / proc / meminfo. Non sono sicuro se funziona per gli altri sistemi.
#include <stdio.h>
#include <string.h>
// Return the amount of free memory in kbytes.
// Returns -1 if something went wrong.
int getfreememory()
{
int returnValue;
const int BUFFER_SIZE = 1000;
char buffer[BUFFER_SIZE];
FILE *fInput;
int loop;
int len;
char ch;
returnValue = -1;
fInput = fopen("/proc/meminfo","r");
if (fInput != NULL)
{
while (!feof(fInput))
{
fgets(buffer,BUFFER_SIZE-1,fInput);
if (feof(fInput))
{
break;
}
buffer[BUFFER_SIZE-1] = 0;
// Look for serial number
if (strncmp(buffer,"MemFree:",8)==0)
{
// Extract mem free from the line.
for(loop=0;loop<BUFFER_SIZE;loop++)
{
ch = buffer[loop];
if (ch == ':')
{
returnValue = 0;
continue;
}
if (ch == 0)
{
break;
}
if (returnValue >=0)
{
if (ch >='A')
{
break;
}
if ((ch >='0') && (ch <='9'))
{
returnValue = returnValue * 10 + (ch-'0');
}
}
}
break;
}
}
fclose(fInput);
}
return returnValue;
}
È possibile controllare nel / proc spazio dei nomi dei file / proc /
Controlla questo blogpost fuori.
strumento Massiccio del Valgrind supporta sia stack e heap profiling . Si consiglia di controllare il suo codice sorgente per vedere come lo fa.
Per la parte mucchio, forse si stanno colpendo un limite di risorse. Scopri questo .
È possibile utilizzare Valgrind per lo stack profiling, ma che cosa hai intenzione di fare con esso? Pila non è come Heap. Tu dici, si vuole fare questo per il debug. Se il programma funziona bene, allora non ci sono problemi di stack (in relazione alle sue dimensioni, almeno).
È possibile impostare la dimensione dello stack per i fili creati e controllare il valore del puntatore dello stack, cercando nella variabile locale (che non deve essere ottimizzato-out) indirizzi. Basta fare un po 'di matematica utilizzando la dimensione iniziale, valore iniziale stack pointer e il valore di stack pointer corrente, si otterrà alcuni numeri piacevoli. Basta non dimenticare di scoprire la direzione dello stack prima. Questo potrebbe cambiare da una piattaforma all'altra.
Credo che se vi preoccupate così tanto per utilizzo di heap, quindi il programma probabilmente perdite di memoria. In questo caso, Valgrind può puntare nella direzione giusta. Valgrind
getrlimit con un paramater di RLIMIT_STACK vi dirà quanto spazio stack è lì in totale. Con un parametro di rlimit_as si può scoprire quanto la memoria virtuale che ci sia.
Per ulteriori informazioni consultare http://linux.die.net/man/2/ getrlimit
