Guida al tool: Analisi delle prestazioni del runtime utilizzando i tool di Rational PurifyPlus (Windows e UNIX)
Questa guida ai tool descrive come utilizzare i tool Rational PurifyPlus per ottenere un codice che sia privo di errori di memoria e perdite di dati, che utilizzi la memoria in maniera efficiente e offra ottime prestazioni.
Strumento: Rational PurifyPlus
Relazioni
Descrizione principale

Questa guida ai tool è valida per sistemi Microsoft Windows e UNIX.

I tool PurifyPlus sono Rational Purify, Rational PureCoverage e Rational Quantify.

Book icon Per ottenere ulteriori informazioni sui tool PurifyPlus, consultare il manuale Guida introduttiva per PurifyPlus (versione per Windows o UNIX).

helpbook icon 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.

helpbook icon 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. 

helpbook icon 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)

3. Eseguire il programma generato con Quantify per rilevare eventuali strozzature nelle prestazioni (Windows e UNIX).

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:

  • In un sistema Windows:
    • In Microsoft Visual Studio 6, selezionare innanzitutto la voce di menu Quantify > Engage Quantify Integration (Attiva integrazione di Quantify) . Quindi eseguire come sempre il programma generato in Visual Studio.
    • In Microsoft Visual Studio .NET, IBM WSWB o IBM WSS AD, selezionare la voce di menu PurifyPlus > Quantify > Engage Quantify Integration (Attiva integrazione di Quantify) . Quindi eseguire come sempre il programma generato in Visual Studio.
    • Se si utilizza Quantify come programma autonomo, non integrato con Visual Studio o WSWB/WSS AD, selezionare File > Run (Esegui) per eseguire il programma nell'interfaccia utente di Quantify.
  • In un sistema UNIX, aggiungere il termine quantify al principio della riga di compilazione/collegamento. Ad esempio:
         % quantify cc -g hello_world.c
    
    Quindi eseguire il programma come sempre.

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)