Visualização das marcas de tempo em uma pilha de chamadas

Question

Eu estou tentando ajustar o desempenho da minha aplicação. E estou curioso que métodos estão tomando mais tempo para processo e, portanto, deve ser olhou para quaisquer oportunidades de otimização.

Existem algumas ferramentas livres existentes que vão me ajudar a visualizar a pilha de chamadas e quanto tempo cada método está demorando para completar? Estou pensando em algo que exibe a pilha de chamadas como um gráfico de barras empilhadas ou um treemap por isso é fácil de ver que MethodA () levou 10 segundo para completar, porque chamado MethodB () e Método (C) , que teve 3 e 7 segundos para ser concluído.

Será que algo assim existe?

Answer 1

Sim, eles são chamados de perfis de desempenho. Confira RedGate ANTS e JetBrains dotTrace, não é livre mas muito barato e muito melhor do que qualquer alternativa livre que tenho visto.

Answer 2

Vários perfis estão disponíveis. Eu só estou familiarizado com um (o incluído no Visual Studio Team Suite), mas não é livre. Devo dizer, tem sido poderoso / confiável o suficiente para que eu não tinha nenhum desejo de tentar mudar para outra. O outro eu ouvi falar é profiler .NET da Red Gate (também não livre). Ambos têm conjuntos de recursos, incluindo, mas definitivamente não se limitando a, o que você está depois. Se isto é para o desenvolvimento de aplicações comerciais, definitivamente vê-los. :)

Answer 3

A forma como isto é medido é por qualquer instrumentação ou de amostragem dentro de um gerador de perfil.

Instrumentação

Instrumentação faz o equivalente aproximado de reescrever todo o código para fazer o seguinte:

public void Foo()
{
   //Code
}

para

public void Foo()
{
   InformTheProfilingCodeThatFooStarted();
   //Code
   InformTheProfilingCodeThatFooEnded();
}

Uma vez que o profiler sabe quando tudo começa e pára ele pode conseguiu uma pilha de quando thisngs iniciar e parar e fornecer essa informação mais tarde. Muitos permitem que você faça isso em um nível de linha (fazendo a mesma coisa, mas instrumentar ainda mais antes de cada linha.

Este recebe o seu 100% de informações precisas sobre o 'gráfico de chamadas' em sua aplicação, mas fá-lo com o custo de:. Prevenir inlining de métodos e adicionando uma sobrecarga considerável para cada chamada de método

Amostragem

Uma abordagem alternativa é a amostragem.

Em vez de tentar obter gráficos 100% de chamada precisos, mas com menos de precisas real vezes essa abordagem em vez funciona na base de que, se verificar em uma base regular o que está acontecendo em seu aplicativo ele pode lhe dar uma boa idéia de quanto tempo ele sepnds em várias funções sem realmente ter que gastar muito esforço trabalhando isso. A maioria dos perfis de amostragem saber como 'análise' a pilha de chamadas quando se interromper o programa para que eles possam ainda dar uma ideia razoável do que está chamando que a função e quanto tempo isso parece tomar, mas não será capaz de dizer se isso foi (digamos) 10 chamadas para Foo (), que fez dez chamadas para Bar () ou uma chamada para Foo () que estava no uma chamada para Bar (), que só passou a durar tanto tempo que foi amostrado 10 vezes.

Ambas as abordagens têm seus prós e contras e resolver problemas diferentes. Em geral, o método de amostragem é o melhor para começar com a primeira vez que é menos invasiva e, portanto, deve dar informações mais precisas sobre o que é tendo tempo , que é muitas vezes a primeira pergunta mais importante antes de trabalhar fora por .

Eu sei de apenas um profiler de amostragem livre para código .net que é o profiler redistributable livre que está ligado com o lançamento Team System VS 2008 (mas que pode ser baixado separadamente). A saída resultante não possa ser facilmente visualizados com nada, mas o (muito caro) Edição Team System do Visual Studio.

Red Gate ANTS não suporta amostragem (neste momento), Jetbrains (dotTrace) e MS Visual Studio Team System tem profilers que suportam ambos os estilos. Qual você prefere em uma base de custo-benefício é uma questão de opinião.

Answer 4

Este é o método I utilização. Se você tem um IDE com um botão de pausa não custa nada e funciona muito bem.

O que ele diz é mais ou menos o% do tempo de relógio de parede é gasto em cada rotina, e mais precisamente, em cada declaração. Isso é mais importante do que a duração média de execução da rotina ou declaração, porque fatores automaticamente na contagem de invocação. Por amostragem tempo relógio de parede que inclui automaticamente CPU, IO, e outros tipos de hora do sistema.

Ainda mais importante, se você olhar para as amostras em que sua rotina é na pilha de chamadas, você pode ver não só o que está fazendo, mas por . A razão por que é importante é que o que você está procurando realmente é o tempo gasto que poderia ser substituído por algo mais rápido. Sem o "porquê" da informação, você tem que adivinhar o que é.

BTW: Esta técnica é pouco conhecida, principalmente porque os professores não ensinam isso (mesmo se eles sabem disso), porque eles raramente têm de trabalhar com software monstruosa como a que temos no mundo real, então eles gprof deleite como o paradigma fundação de criação de perfil.

Aqui está um exemplo de usá-lo.

P.S. Espere as porcentagens para adicionar até muito mais do que 100%. A maneira de pensar sobre as porcentagens é, se uma declaração ou rotina está na pilha X% do tempo (como estimado a partir de um pequeno número de amostras), que é mais ou menos quanto tempo relógio de parede irá diminuir se a declaração ou rotina pode ser feito para levar muito menos tempo.