monitorare C ++ allocazioni di memoria

Question

Sto cercando un modo per monitorare le allocazioni di memoria in un programma C ++. Io sono non interessati a perdite di memoria, che sembrano essere ciò che la maggior parte degli strumenti stanno cercando di trovare, ma piuttosto la creazione di un profilo di utilizzo della memoria per l'applicazione. uscita ideale sarebbe o una grande lista di nomi delle funzioni più numero di byte massimo allocati nel tempo o, meglio ancora, una rappresentazione grafica del mucchio nel corso del tempo. ad asse orizzontale è il tempo, asse verticale lo spazio di heap. Ogni funzione otterrebbe un proprio colore e disegnare le linee in base al byte heap allocati. punti bonus per identificare tipi di oggetto assegnati pure.

L'idea è quella di trovare i colli di bottiglia della memoria / di visualizzare ciò che funzioni / thread consumano la maggior parte della memoria e dovrebbero essere di mira per un'ulteriore ottimizzazione.

ho brevemente guardato Purify, BoundsChecker e AQTime, ma non sembrano essere quello che sto cercando. Valgrind sembra adatto, però, io sono su Windows. Memtrack sembra essere molto promettente, ma richiede modifiche significative al codice sorgente.

Le mie capacità di Google devono mi hanno fallito, perché non sembra essere una richiesta così raro? Tutte le informazioni necessarie per creare uno strumento come questo dovrebbe essere già disponibili presso i simboli di debug del programma più chiamate API di runtime -? No

Answer 1

monitoraggio dell'utilizzo memoria del proprio PC per sviluppo del gioco contiene un quasi perfetto esempio di quello che stavo cercando. C'è voluto un po 'per farlo funzionare, ma l'autore di questo articolo è stato molto utile. È possibile trovare il codice sorgente per lo strumento qui Memtracer .

Ho anche avuto un sacco di risposte utili su SWENG (Mailing List Software Engineering). Il filo si chiama "[Sweng-GameDev] monitoraggio C ++ utilizzo della memoria?".

Answer 2

Utilizzare Valgrind e il suo strumento Massif. La sua uscita esempio (una parte di esso):

99.48% (20,000B) (heap allocation functions) malloc/new/new[], --alloc-fns, etc.
->49.74% (10,000B) 0x804841A: main (example.c:20)
| 
->39.79% (8,000B) 0x80483C2: g (example.c:5)
| ->19.90% (4,000B) 0x80483E2: f (example.c:11)
| | ->19.90% (4,000B) 0x8048431: main (example.c:23)
| |   
| ->19.90% (4,000B) 0x8048436: main (example.c:25)
|   
->09.95% (2,000B) 0x80483DA: f (example.c:10)
  ->09.95% (2,000B) 0x8048431: main (example.c:23)

Quindi, si ottengono informazioni dettagliate:

• CHI allocata la memoria (funzioni: g (), f (), e main () nell'esempio di cui sopra); si ottiene anche completa backtrace che porta alla funzione di allocazione,
• alla quale struttura di dati nella memoria è andata (no strutture dati in esempio di cui sopra),
• quando è successo,
• Quale percentuale di tutta la memoria allocata è (g: 39,7%, f: 9,95%, principale: 49,7%).

Ecco Massiccio manuale

È possibile tenere traccia di allocazione heap e stack di allocazione (disattivata per impostazione predefinita).

PS. Ho appena letto che siete su Windows. Lascerò la risposta, però, perché dà un quadro di ciò che si può ottenere da un possibile strumento.

Answer 3

Microsoft sono ben documentati funzioni di tracking di memoria. Tuttavia, per qualche motivo non sono in realtà ben noti nella comunità degli sviluppatori. Si tratta di funzioni di debug CRT. Buon punto di partenza sarà funzioni CRT Debug Heap .

Controlla i seguenti link per maggiori dettagli

1. Heap funzioni di reporting di stato
2. di monitoraggio richieste di allocazione di heap . Probabilmente questo è la funzionalità che si sta cercando.

Answer 4

Per una generica memoria inseguitore C ++ avrete bisogno di sovraccaricare il seguente:

global operator new
global operator new []
global operator delete
global operator delete []
any class allocators
any in-place allocators

La parte difficile è ottenere informazioni utili, gli operatori di overload hanno solo informazioni di dimensione per allocatori e puntatori di memoria per le eliminazioni. Una risposta è quella di utilizzare le macro. Lo so. Cattiva. Un esempio - posto in un colpo di testa che è incluso da tutte le file di origine:

#undef new

void *operator new (size_t size, char *file, int line, char *function);
// other operators

#define new new (__FILE__, __LINE__, __FUNCTION__)

e creare un file di origine con:

void *operator new (size_t size, char *file, int line, char *function)
{
  // add tracking code here...
  return malloc (size);
}

È possibile che questo funziona solo se non si dispone di qualsiasi operatore nuovo definito a portata di classe. Se avete un po 'a portata di classe, fare:

#define NEW new (__FILE__, __LINE__, __FUNCTION__)

e sostituire 'nuovo tipo di' con 'NEW Tipo', ma che richiede la modifica di un sacco di codice potenzialmente.

Come è un macro, rimuovendo il tracker di memoria è molto semplice, l'intestazione diventa:

#if defined ENABLED_MEMORY_TRACKER
#undef new

void *operator new (size_t size, char *file, int line, char *function);
// other operators

#define NEW new (__FILE__, __LINE__, __FUNCTION__)
#else
#define NEW new
#endif

e il file di implementazione:

#if defined ENABLED_MEMORY_TRACKER
void *operator new (size_t size, char *file, int line, char *function)
{
  // add tracking code here...
  return malloc (size);
}
endif

Answer 5

Prova anche questo: memoria Validator

Answer 6

In Mac OS X, è possibile utilizzare il codice di profiling Shark strumento per fare questo, IIRC.

Answer 7

In Xcode, è possibile utilizzare strumenti per monitorare le allocazioni, l'utilizzo di VM, e molti altri parametri. Per lo più popolare tra gli sviluppatori iOS, ma vale la pena provare.

Answer 8

"Una rappresentazione grafica del mucchio nel corso del tempo" - vicino a quello che stai cercando è implementato in Intel (R) singolo evento API , i dettagli possono essere trovati in questo articolo (la sua piuttosto grande per metterlo qui).

Si mostra cronologia degli stanziamenti per-block-size e permette di aggiungere bollo supplementare fino al vostro codice per capire l'intero quadro migliore.

Answer 9

L'IDE di Visual Studio è dotato di supporto mucchio profiling (dal 2015), che è probabilmente il più facile da iniziare. Essa offre una vista grafiche di utilizzo di heap nel corso del tempo, e in grado di monitorare le allocazioni per funzione / metodo.

• misurare l'utilizzo della memoria in Visual Studio

Il CRT ha anche il supporto di debug e il profilo, che è più dettagliato e più a basso livello. Si potrebbe monitorare i dati e tracciare i risultati utilizzando qualche altro strumento:

• CRT heap di debug Dettagli

In particolare, guarda _CrtMemCheckpoint e funzioni correlate.