Este mentor de ferramenta é aplicável ao uso com sistemas Microsoft Windows e UNIX.

As ferramentas PurifyPlus incluem Rational Purify, Rational PureCoverage e Rational Quantify.

Para saber mais sobre as ferramentas PurifyPlus, leia o manual Getting Started do PurifyPlus (versões Windows ou UNIX).

Para obter informações etapa a etapa sobre como utilizar as ferramentas PurifyPlus, consulte a Ajuda on-line da ferramenta.

Análise de Desempenho de Tempo de Execução 

A análise de desempenho de tempo de execução inclui o seguinte:

• Detecção de erros e fugas de memória (programas C/C++ em Windows e UNIX).
  • Utilize o Purify para apontar com exatidão esses problemas, em seu próprio código e nos componentes utilizados por seu software, mesmo quando você não possui a origem.
  • Utilize o PureCoverage para assegurar que todo o código tenha sido coberto. (Também é possível utilizar o PureCoverage independentemente do Purify para coletar dados de cobertura para código gerenciado C/C++, Java e .NET.)
• Traçado de perfil de uso de memória (código gerenciado Java e .NET no Windows). Utilize o Purify para mostrar onde o uso da memória é ineficiente.
• Traçado de perfil de desempenho (Windows e UNIX). Utilize o Quantify para mostrar onde seu programa está gastando a maior parte do tempo, para que você possa eliminar os maiores gargalos de desempenho.

A análise de tempo de execução com as ferramentas PurifyPlus resulta em código sem erros que é executado em sua eficiência máxima.

Etapas da Ferramenta

Para desempenhar a análise de tempo de execução utilizando as ferramentas PurifyPlus:

1. Execute seu Programa no Purify para Coletar Dados de Erro, Fuga e Cobertura (Programas C/C++ no Windows e UNIX) 

O Purify detecta erros de tempo de execução difíceis de serem localizados, incluindo fugas de memória em seu próprio código e nos componentes utilizados por seu software. Ele relata erros de memória, como erros de limites de matriz, acesso por meio de ponteiros pendentes, leituras de memória não inicializada, erros de alocação de memória e fugas de memória, para que você possa resolvê-los antes que ocorram quaisquer danos. Se o Rational PureCoverage existir em seu sistema, também será possível ver as partes do código que você testou e as que não testou. 

Comece executando seu programa no Purify:

• Em um sistema Windows:
  • Se você estiver trabalhando no Microsoft Visual Studio 6, primeiro selecione o item de menu do Visual Studio Purify > Aplicar Integração do Purify. Se o PureCoverage existir em seu sistema, selecione também Purify > Coletar Dados de Cobertura, orientando o Purify a monitorar a cobertura de código. Em seguida, execute o programa no Visual Studio no modo habitual.
  • Se você estiver utilizando o Purify como um programa independente, não integrado ao Visual Studio, selecione Arquivo > Executar. No diálogo Executar Programa, selecione Coletar dados de erro, fuga e cobertura (ou Coletar dados de erro e fuga se não tiver o PureCoverage em seu sistema) e execute seu programa.
• Em um sistema UNIX, inclua a palavra purify. Coloque isso no início de sua linha de compilação/link. Se você tiver o PureCoverage em seu sistema, inclua também purecov . Por exemplo:
  % purify purecov cc -g hello_world.c
  Em seguida, execute o programa no modo habitual.

Varra os cabeçalhos da mensagem para identificar erros críticos. Expanda as mensagens para ver informações de diagnóstico mais detalhadas, incluindo o código que gerou o erro. No Visualizador, você pode abrir o código fonte em seu editor, na linha em que ocorreu o erro, e fazer a correção diretamente.

Depois de corrigir os erros e reconstruir o programa, verifique suas correções executando novamente o programa atualizado e comparando os novos resultados com a execução anterior. Repita o ciclo de instrumentação e execução, análise e correção até que a execução do programa esteja limpa.

Se você coletou dados de cobertura para as execuções do programa, também poderá ver as partes do código em que não verificou erros. Utilize essas informações para ajustar o escopo de análise de tempo de execução para que possa localizar todos os erros em seu programa, onde quer que ocorram.

Para obter informações adicionais, consulte os seguintes tópicos no índice da Ajuda on-line do Purify:

• Executando Programas
• Mensagens do Purify
• Código Fonte
• Dados de Cobertura

2. Execute seu Programa no Purify para Detectar Uso Ineficiente de Memória (Nó Gerenciado Java e .NET no Windows) 

O Purify ajuda a identificar problemas de memória em código gerenciado Java e .NET. Utilizando o Purify, é possível determinar:

• a quantidade de memória utilizada pelo programa
• a quantidade de nova memória consumida pelo programa para um conjunto específico de ações 
• quais métodos e objetos no programa estão consumindo muita memória 
• quais objetos podem estar impedindo a coleta de lixo de objetos desnecessários 
• onde seria aconselhável forçar uma coleta de lixo para aprimorar o desempenho

• Se você estiver trabalhando no Microsoft Visual Studio .NET, IBM WSWB ou IBM WSS AD, primeiro selecione o item de menu PurifyPlus > Purify > Aplicar Integração do Purify. Em seguida, execute o programa no modo habitual.
• Se você estiver utilizando o Purify como um programa independente, não integrado ao Visual Studio .NET ou WSWB/WSS AD, selecione Arquivo > Executar na interface com o usuário do Purify. No diálogo Executar Programa, selecione Coletar dados de traçado de perfil de memória e execute o programa.

Depois de obter a captura instantânea, você pode capturar um registro da memória utilizada pelo programa durante sua execução. Execute as partes do programa em que há suspeita de fuga de memória. O Purify exibe um gráfico de alocação de memória que mostra variações em tempo real no uso de memória atual. Quando você observar um aumento na memória alocada, obtenha uma outra captura instantânea.

Compare as duas capturas instantâneas para identificar os métodos com fuga de memória. Saia do programa e compare (ou "diferencie") as duas capturas instantâneas. O Purify exibe um gráfico de chamadas mostrando os métodos responsáveis pelas maiores quantidades de memória alocada durante a execução do programa, entre o tempo da primeira e segunda capturas instantâneas. Você pode manter o foco em métodos específicos no gráfico de chamadas para investigá-los com mais exatidão.

Se a quantidade de memória alocada a um método for inesperadamente grande, examine o código fonte e revise-o, se necessário, para liberar memória que não seja mais necessária.

Depois de identificados os métodos com problemas de memória, analise-os no nível de objeto. Procure objetos que deveriam ser, mas não foram, liberados e submetidos à coleta de lixo, talvez porque outros objetos retêm uma referência desnecessária a eles. 

Para obter informações adicionais, consulte o seguinte no índice da Ajuda on-line do Purify: 

• Executando Programas
• Comparando Execuções
• Navegador de Dados

3. Execute seu Programa no Quantify para Localizar Gargalos de Desempenho (Windows e UNIX).

O Quantify fornece um conjunto completo, exato e fácil de ser interpretado dos dados de desempenho do programa e seus componentes, para que você possa identificar e eliminar gargalos de desempenho no código.

Comece executando o programa no Quantify para coletar dados de desempenho:

• Em um sistema Windows:
  • Se você estiver trabalhando no Microsoft Visual Studio 6, primeiro selecione o item de menu do Visual Studio Quantify > Aplicar Integração do Quantify. Em seguida, execute o programa no Visual Studio no modo habitual.
  • Se você estiver trabalhando no Microsoft Visual Studio .NET, IBM WSWB ou IBM WSS AD, selecione o item de menu PurifyPlus > Quantify > Aplicar Integração do Quantify. Em seguida, execute o programa no modo habitual.
  • Se você estiver utilizando o Quantify como um programa independente, não integrado ao Visual Studio ou WSWB/WSS AD, selecione Arquivo > Executar para executar o programa na interface com o usuário do Quantify.
• Em um sistema UNIX, inclua a palavra quantify no início da linha de compilação/link. Por exemplo:
  

       % quantify cc -g hello_world.c
  

  Em seguida, execute o programa no modo habitual.

À medida que você testa o código, o Quantify registra os dados sobre o desempenho do programa e exibe a atividade de seus encadeamentos e elementos essenciais. Quando você sair do programa, o Quantify terá um perfil exato do desempenho, que pode ser utilizado para localizar e diagnosticar gargalos.

A exibição de dados do Quantify inclui:

• uma janela Gráfico de Chamadas que representa graficamente a estrutura e o desempenho de chamada das funções no programa
• uma janela Lista de Funções classificável que lista todas as funções com dados de desempenho
• uma janela Detalhes da Função que exibe dados para uma função específica, seus responsáveis pela chamada e seus descendentes
• uma janela Origem Anotada que mostra dados de desempenho, linha por linha, em uma cópia do código fonte

Com os dados coletados, você será capaz de identificar gargalos de desempenho, como computações e recomputações desnecessárias, computações antecipadas ou chamadas de bibliotecas excessivas e dispendiosas.

Depois de modificar o código para eliminar ou minimizar os gargalos, execute novamente o programa atualizado no Quantify. Em seguida, compare os novos resultados com a execução anterior, criando um conjunto de dados de "diferenças", que fornece indicações claras de aprimoramentos e regressões de desempenho.

Para obter informações adicionais, consulte os seguintes tópicos no índice da Ajuda on-line do Quantify:

• Executando Programas
• Comparando Execuções
• Janela de Gráfico de Chamadas
• Janela de Origem Anotada