A publicação apresenta uma implementação de software de ferramentas internas para coletar e acumular informações métricas sobre o tempo de execução de aplicativos gravados em C / C ++ / C #.
A essência da abordagem descrita é baseada na inclusão de "pontos de controle" no código do programa do aplicativo para extrair dados sobre o tempo de execução de componentes estruturais: métodos, funções e {} blocos. As informações métricas extraídas são acumuladas em um banco de dados interno, cujo conteúdo no final do aplicativo é convertido em um formulário de relatório de texto salvo em um arquivo. A adequação do uso dos meios de controle interno do tempo de execução se deve à necessidade de identificar áreas problemáticas do código, analisar as causas da degradação temporária do aplicativo: total ou parcial, ou aparecendo em determinados conjuntos de dados de origem.
Os exemplos de código-fonte C ++ / C # fornecidos demonstram possíveis implementações da abordagem descrita.
1. Introdução
O desenvolvimento de um aplicativo de software a cada iteração (por exemplo, o lançamento do próximo lançamento) de seu desenvolvimento evolutivo inclui as seguintes etapas básicas:
- desenvolvimento e teste de funcionalidade;
- otimização de recursos consumidos de RAM;
- estabilização de métricas de tempo de execução.
Essas etapas requerem uma quantidade significativa de desenvolvedores, não apenas criativos (como o desenvolvimento e implementação de algoritmos eficazes, a construção de uma arquitetura de software flexível etc.), mas também trabalho de rotina. A última categoria inclui atividades destinadas a estabilizar métricas de tempo para execução de aplicativos. Em muitos casos, esse é um procedimento bastante doloroso quando os desenvolvedores se deparam com a degradação, que é uma conseqüência da expansão da funcionalidade do produto de software, da reconstrução da arquitetura do software e do surgimento de novos threads no aplicativo. Ao mesmo tempo, as fontes de degradação exigem alguns esforços para detectá-las, o que é alcançado não apenas pela alta diligência e responsabilidade dos desenvolvedores (condição necessária), mas também pela composição das ferramentas utilizadas para esses fins (condição suficiente).
Uma das abordagens eficazes para resolver o problema de analisar as métricas de tempo do aplicativo é o uso de produtos de software especializados, por exemplo, GNU
gprof . A análise dos relatórios gerados por essas ferramentas permite identificar “gargalos” (métodos e funções de classe), que representam uma quantidade significativa de tempo gasto na execução do aplicativo como um todo. Ao mesmo tempo, a validade do tempo gasto na execução de métodos e procedimentos é certamente qualificada pelos desenvolvedores.
Deve-se notar também que os produtos de software dessa classe, em regra, realizam análises métricas do tempo de execução do código do programa nos níveis de métodos de classes e funções, ignorando os níveis mais baixos (mas mesmo assim significativos do ponto de vista da análise do problema):
{...}, por, enquanto, faça até, se - senão, blocos
try-catch , dentro dos quais não ocorrem despesas menos significativas de tempo de execução.
A seguir, é considerado o conteúdo principal de uma das possíveis soluções para a implementação de ferramentas de controle de tempo de execução internas, com o objetivo de extrair e acumular informações detalhadas sobre as métricas de tempo dos blocos de software controlados com a geração subsequente de relatórios para desenvolvedores.
Métodos para recuperar dados de tempo de execução
A funcionalidade de qualquer aplicativo de software pode ser interpretada como uma
máquina abstrata com um conjunto finito de
estados únicos
{St} e transições
{Tr} entre eles.
Na estrutura dessa abordagem, qualquer fluxo de execução no aplicativo deve ser interpretado como uma sequência ordenada de seus estados e transições entre eles. Nesse caso, a estimativa dos custos do tempo de execução é realizada somando as métricas de tempo em todo o conjunto de estados passados, ignorando os custos das transições de um estado para outro - como valores desprezíveis.
A extração e acumulação de dados no tempo de execução do aplicativo nos pontos de controle especificados é a principal tarefa resolvida pelas ferramentas de controle internas descritas abaixo.
Para cada ponto de interrupção declarado no código-fonte, colocando
A macro
PROFILE_ENTRY C ++, o número de passagens durante a execução do aplicativo é registrado e a métrica de tempo - o tempo total em que o aplicativo esteve no estado desde o momento em que o ponto de verificação passou para o próximo nível da hierarquia do programa (incluindo um bloco, método de classe, função, etc.) conforme ilustrado no diagrama abaixo.
O controle dos pontos de controle (registro inicial e cálculo de suas métricas de tempo) é realizado pelo objeto
'timeManager' , criado em uma única instância. Cada evento de passagem no ponto de verificação é corrigido pelo objeto
'timeManager' e
, durante a primeira passagem, é registrado por ele como observáveis como
'registerEntry' .
No momento de cada passagem do ponto de controle, um
timerObject é criado, fixando o tempo de sua criação. O tempo de execução é fixado no ponto de verificação quando o aplicativo sai do nível atual da hierarquia do software. Nesse momento, o timerObject do objeto é destruído automaticamente, o que é acompanhado pelo cálculo de sua "vida útil" T. Como resultado, o
timeManager aumenta o número de vezes que o ponto de verificação passa e o tempo gasto por
T. Para todos os pontos de controle definidos, o
timeManager acumula dados com a liberação subsequente de um relatório quando o aplicativo termina.
Abaixo está o código C ++ de origem que implementa as ferramentas internas para controlar o tempo de execução do aplicativo.
A estrutura do aplicativo de demonstração é ilustrada abaixo, ilustrando o uso das ferramentas de controle de tempo de execução integradas como exemplo, bem como uma tabela dos resultados obtidos (para obter detalhes, consulte o
Apêndice 1. Código-fonte do aplicativo de demonstração ).
Adendo à Seção
2. O código fonte das ferramentas de controle internas para o tempo de execução do aplicativo C # apresenta uma implementação semelhante das ferramentas de controle internas em C #.
O autor usa pares de
TimeWatcher.StartWatch () e
TimeWatcher.StopWatch () ao determinar o tempo de execução de laboriosos (do ponto de vista computacional) métodos e procedimentos como parte do produto de software
Delta Design desenvolvido pela
EREMEX - um sistema de design auxiliado por computador para equipamentos eletrônicos.
Abaixo está um exemplo de um breve relatório sobre as métricas de tempo de uma das funcionalidades do produto mencionado.
Breves conclusões
As ferramentas descritas podem ser usadas para coletar dados sobre o tempo de execução do aplicativo em várias partes do código do programa, em particular, elas permitem:
- coletar e acumular dados sobre métricas de tempo de threads de execução no aplicativo;
- executar estimativas do tempo de execução do código do programa precisas para construções de linguagem elementar;
- gerenciar o volume de dados extraídos ativando e desativando as ferramentas de controle integradas nas seções correspondentes dos fluxos de execução do aplicativo;
- desenvolver e aplicar testes de regressão que monitoram a estabilidade (e detectam a degradação) das métricas de tempo do aplicativo.
Em conclusão, deve-se notar que fora do escopo desta publicação, havia questões sobre a aplicação das ferramentas de controle internas descritas no contexto de aplicativos
multithreading e nenhuma análise da precisão dos dados obtidos por métricas de tempo foi apresentada de qualquer forma. Este último se deve ao fato de que, na prática, ao identificar as causas da degradação temporária de um aplicativo, os dados sobre
a distribuição relativa dos custos de tempo de execução entre os componentes de software do aplicativo são principalmente relevantes
. Nesse sentido, questões sobre a precisão dos dados obtidos estão desaparecendo em segundo plano.
Apêndice 1. Código Fonte para o Aplicativo Demo
INITIALIZE_PROFILER int main(int argc, char * argv[]) {
Suplemento 2. Código-fonte de aplicativos C # de controle de tempo de execução integrados