Questa guida ai tool è valida per sistemi Microsoft Windows e UNIX.
I tool PurifyPlus sono Rational Purify, Rational PureCoverage e Rational Quantify.
Per ottenere
ulteriori informazioni sui tool PurifyPlus, consultare il manuale Guida introduttiva per PurifyPlus (versione
per Windows o UNIX).
Per
informazioni dettagliate su come utilizzare i tool PurifyPlus, consultare la guida in linea per il tool.
Analisi delle prestazioni del runtime
L'analisi delle prestazioni del runtime comprende:
-
Rilevamento degli errori di memoria e perdite di dati (programmi C/C++ su Windows e UNIX).
-
Purify consente di identificare con precisione questi problemi, nel codice generato e nei componenti da
esso utilizzato, anche quando non si dispone di un codice sorgente.
-
PureCoverage consente di garantire che tutto il codice è dotato di copertura. (PureCoverage può essere
utilizzato anche indipendentemente da Purify per raccogliere i dati sulla copertura per codice gestito da
C/C++, Java e .NET).
-
Creazione di profili per l'utilizzo della memoria (codice gestito da Java e .NET in Windows). Servirsi di
Purify per identificare dove la memoria viene utilizzata in maniera inefficiente.
-
Creazione di profili sulle prestazioni (Windows e UNIX). Servirsi di Quantify per identificare dove il
programma rallenta e così eliminare importanti strozzature nelle prestazioni.
L'analisi del runtime con i tool di PurifyPlus produce un codice privo di errori eseguibile al massimo dell'efficienza.
Modalità d'uso del tool
Per eseguire l'analisi del runtime utilizzando i tool di PurifyPlus:
1. Eseguire il programma generato con Purify per raccogliere errori, perdite di dati
e dati sulla copertura (programmi in C/C++ in Windows e UNIX)
Purify rileva errori di runtime difficili da identificare, comprese perdite di dati di memoria nel codice generato e
nei componenti di cui si serve. Questo tool riporta errori di memoria, quali superamento dei limiti di matrice, accesso
con puntatori non più validi, letture di memoria prive di inizializzazione, allocazione errata di memoria e perdite di
dati di memoria, in modo da poterli risolvere prima che possano provocare danni. Se il sistema dispone di Rational
PureCoverage, è anche possibile individuare le parti del codice generato che sono state o meno sottoposte a
verifica.
Eseguire il programma generato con Purify:
-
In un sistema Windows:
-
In Microsoft Visual Studio 6, selezionare innanzitutto la voce di menu Purify > Engage Purify
Integration (Attiva integrazione di Purify). Se il sistema dispone di PureCoverage, selezionare anche
Purify > Collect Coverage Data (Raccogli dati sulla copertura), per monitorare la copertura
del codice. Quindi eseguire come sempre il programma generato in Visual Studio.
-
Se si utilizza Purify come programma autonomo, non integrato con Visual Studio, selezionare File >
Run (Esegui) . Nella finestra di dialogo Run Program (Esegui programma), selezionare Collect error,
leak, and coverage data (Raccogli dati su errori, perdite e copertura) (oppure, se non si dispone
PureCoverage, selezionare Collect error and leak data [Raccogli dati su errori e perdite]) ed
eseguire il programma.
-
In un sistema UNIX, aggiungere il termine purify. Posizionarlo al
principio della riga di compilazione/collegamento. Se il sistema dispone di PureCoverage, aggiungere anche purecov . Ad esempio:
% purify purecov cc -g hello_world.c
Quindi eseguire il programma come sempre.
Durante la prova del programma, Purify elenca gli errori del runtime nel visualizzatore. Quando si esce dal programma,
Purify riporta le perdite di dati di memoria.
Analizzare le intestazioni messaggi per identificare errori critici. Espandere i messaggi per ottenere informazioni più
dettagliate, tra cui il codice responsabile dell'errore. Dal visualizzatore, è possibile aprire il codice sorgente
nell'editor alla linea dove si è verificato l'errore che consente di eseguire la correzione direttamente.
Dopo aver corretto gli errori e generato un nuovo build del programma, verificare le correzioni immesse rieseguendo la
versione aggiornata ed eseguendo un confronto tra i nuovi risultati e l'esecuzione precedente. Ripetere il ciclo di
monitoraggio nonché di esecuzione, analisi e correzione fino a quando si ottiene un'esecuzione priva di errori.
Se sono stati raccolti dati sulla copertura durante l'esecuzione del programma, sarà possibile identificare le parti
del codice che non sono state controllate. Utilizzare queste informazioni per regolare la portata dell'analisi del
runtime per poter individuare tutti gli errori nel programma, dovunque essi siano.
Per
ulteriori informazioni, esaminare le seguenti sezioni nell'indice della guida in linea di Purify:
-
running programs (esecuzione programmi)
-
Purify messages (messaggi di Purify)
-
source code (codice sorgente)
-
coverage data (dati sulla copertura)
2. Eseguire il programma generato con Purify per rilevare eventuale utilizzo
inefficiente della memoria (codice gestito da Java e .NET in Windows)
Purify aiuta a identificare problemi di memoria nel codice gestito da Java e .NET. Con Purify, è possibile determinare:
-
quanta memoria viene utilizzata dal programma
-
quanta memoria nuova viene consumata dal programma per eseguire un insieme specifico di azioni
-
quali metodi e oggetti nel programma consumano troppa memoria
-
quali oggetti stanno impedendo la raccolta di oggetti obsoleti
-
dove si consiglia di eseguire una raccolta dati obsoleti per migliorare le prestazioni
Eseguire il programma generato con Purify.
-
In Microsoft Visual Studio .NET, IBM WSWB, o IBM WSS AD, selezionare innanzitutto la voce di menu
PurifyPlus > Purify > Engage Purify Integration (Attiva integrazione di Purify). Quindi
eseguire il programma come sempre.
-
Se si utilizza Purify come programma autonomo, non integrato con Visual Studio .NET o WSWB/WSS AD, selezionare
File > Run (Esegui) nell'interfaccia utente di Purify. Nella finestra di dialogo Run Program (Esegui
programam), selezionare Collect memory profiling data (Raccogli dati per creazione profili di memoria) ed
eseguire il programma generato.
Dopo che il programma ha finito la procedura di inizializzazione, utilizzare il comando istantanea di Purify per avere
un punto di riferimento dell'utilizzo della memoria al momento. L'istantanea rappresenta la base per determinare
come il programma utilizza la memoria in fase di esecuzione.
Una volta ottenuta l'istantanea, è possibile catturare un record della memoria utilizzata dal programma in fase di
esecuzione. Eseguire le parti del programma sospettate di produrre perdita di dati. Purify visualizza un grafico
dell'allocazione di memoria che mostra le variazioni correnti nell'uso della memoria. Quando si osserva un aumento
nell'allocazione di memoria, eseguire un'altra istantanea.
Confrontare le due istantanee per identificare i metodi che perdono dati. Uscire dal programma e confrontare (o
differenziare) le due istantanee. Purify visualizza un grafico chiamate che mostra i metodi responsabili per la
quantità maggiore di memoria allocata durante l'esecuzione di un programma, generato con i dati rilevati tra la prima e
la seconda istantanea. È possibile isolare metodi specifici nel grafico chiamate per sottoporli ad un esame più
approfondito.
Se la quantità di memoria allocata per un metodo è più abbondante del previsto, esaminare il codice sorgente e
revisionarlo, se necessario, per liberare memoria quando non è più utilizzata.
Una volta identificati i metodi che riportano problemi di memoria, analizzarli a livello di oggetto. Individuare gli
oggetti che dovrebbero essere, e che non sono, liberi e privi di dati obsoleti, forse perché altri oggetti fanno ancora
riferimento ad essi senza motivo.
Per ulteriori informazioni,
esaminare le seguenti sezioni nell'indice della guida in linea di Purify:
-
running programs (esecuzione programmi)
-
comparing runs (confronto esecuzioni)
-
data browser (browser di dati)
Quantify fornisce un insieme di dati sulle prestazioni componenti, completo, accurato e di facile interpretazione
relativo al programma generato e ai suoi componenti che consente di identificare ed eliminare strozzature nelle
prestazioni del codice.
Iniziare avviando il programma con Quantify per raccogliere i dati sulle prestazioni:
Durante la prova del programma, Quantify registra i dati relativi alle prestazioni del programma e visualizza
l'attività dei relativi thread e fibre. Quando si esce dal programma, Quantify dispone di un profilo preciso delle sue
prestazioni da utilizzare per identificare e diagnosticare strozzature.
Il display dei dati di Quantify riporta:
-
una finestra Call Graph (Grafico chiamate) con l'illustrazione grafica delle strutture chiamanti e delle
prestazioni delle funzioni del programma
-
una finestra Function List (Elenco funzioni) che è possibile ordinare e che riporta tutte le funzioni con relativi
dati sulle prestazioni
-
una finestra Function Detail (Dettagli funzione) che visualizza i dati di una funzione specifica e relativi
chiamanti e discendenti
-
una finestra Annotated Source (Sorgente con commenti) che mostra i dati sulle prestazioni riga per riga su una
copia del codice sorgente
Con i dati raccolti, sarà possibile identificare strozzature delle prestazioni quali elaborazioni e rielaborazioni
superflui, elaborazioni premature oppure chiamate eccessive e dispendiose alla libreria.
Dopo aver modificato il codice per eliminare o ridurre al minimo le strozzature, rieseguire il programma aggiornato con
Quantify. Eseguire un confronto tra i nuovi risultati e quelli della prova precedente creando un dataset
"differenziato", che offre indicazioni chiare sui miglioramenti e regressioni nelle prestazioni.
Per ulteriori informazioni, esaminare le seguenti sezioni nell'indice della guida in linea di Quantify:
-
running programs (esecuzione programmi)
-
comparing runs (confronto esecuzioni)
-
call graph window (finestra grafico chiamate)
-
annotated source window (finestra sorgente con commenti)
|