A história de um hacker

A data é 12/02/10. Os dias que antecederam o Natal estão acabando e eu praticamente atingi um grande obstáculo como programador de janelas. Estou usando o AQTime, tentei sonolento, brilhante e com muito sono e, enquanto falamos, o VTune está sendo instalado. Eu tentei usar o VS2008 profiler, e ele tem sido positivamente punitivo e muitas vezes insensível. Eu usei a técnica de pausa aleatória. Examinei as árvores de chamada. Eu disparei vestígios de funções. Mas o triste e doloroso fato da questão é que o aplicativo com o qual estou trabalhando tem mais de um milhão de linhas de código, provavelmente com mais um milhão de linhas de aplicativos de terceiros.

Eu preciso de ferramentas melhores. Eu li os outros tópicos. Eu tentei cada perfil listado em cada tópico. Simplesmente tem que haver algo melhor do que essas opções caras e caras, ou quantidades absurdas de trabalho para quase nenhum ganho. Para complicar ainda mais, nosso código é muito encadeado e executa vários loops de eventos Qt, alguns dos quais são tão frágeis que travam sob instrumentação pesada devido a atrasos de tempo. Não me pergunte por que estamos executando vários loops de eventos. Ninguém pode me dizer.

Existem opções mais semelhantes às do Valgrind em um ambiente Windows?
Existe algo melhor do que a longa faixa de ferramentas quebradas que eu já tentei?
Existe algo projetado para integrar com o Qt, talvez com uma exibição útil de eventos na fila?

Uma lista completa das ferramentas que tentei, com as que foram realmente úteis em itálico:

• AQTime: Bastante bom! Tem algum problema com recursão profunda, mas o gráfico de chamadas está correto nesses casos e pode ser usado para esclarecer qualquer confusão que você possa ter. Não é uma ferramenta perfeita, mas vale a pena experimentar. Pode atender às suas necessidades, e certamente foi bom o suficiente para mim a maior parte do tempo.
• Ataque aleatório ataque no modo de depuração: Não há informações suficientes o suficiente.
  Uma boa ferramenta, mas não uma solução completa.
• Parallel Studios: a opção nuclear. Obtrusivo, estranho e loucamente poderoso. Acho que você deve acessar a avaliação de 30 dias e descobrir se é uma boa opção. É muito legal também.
• AMD Codeanalyst: Maravilhoso, fácil de usar, muito propenso a falhas, mas acho que isso é uma coisa do ambiente. Eu recomendo tentar, pois é grátis.
• Luke Stackwalker: Funciona bem em pequenos projetos, está um pouco tentando fazê-lo funcionar no nosso. Alguns bons resultados, porém, e definitivamente substituem Sleepy por minhas tarefas pessoais.
• PurifyPlus: Não há suporte para ambientes Win-x64, principalmente o Windows 7. Caso contrário, excelente. Vários colegas de outros departamentos juram isso.
• Profiler VS2008: Produz saída na faixa de mais de 100 shows no modo de rastreamento de função na resolução necessária. No lado positivo, produz resultados sólidos.
• GProf: Requer que o GCC seja moderadamente eficaz.
• VTune: o W7 do VTune suporta fronteiras criminais. Caso contrário, excelente
• PIN: eu precisaria hackear minha própria ferramenta, então esse é o último recurso.
• Sonolento \ Muito sonolento: Útil para aplicativos menores, mas falhando comigo aqui.
• EasyProfiler: Nada mal se você não se importar com um pouco de código injetado manualmente para indicar onde instrumentar.
• Valgrind: * nix apenas, mas muito bom quando você está nesse ambiente.
• OProfile: apenas Linux.
• Proffy: Eles atiram em cavalos selvagens.

Ferramentas sugeridas que eu não tentei:

• XPerf:
• Glowcode:
• Devpartner:

Notas: Ambiente Intel no momento. VS2008, impulsiona bibliotecas. Qt 4+. E o desgraçado de todos eles: integração Qt / MFC via trolltech.

---

Agora: quase duas semanas depois, parece que meu problema foi resolvido. Graças a uma variedade de ferramentas, incluindo quase tudo na lista e alguns dos meus truques pessoais, encontramos os principais gargalos. No entanto, vou continuar testando, explorando e testando novos criadores de perfil, além de novas tecnologias. Por quê? Porque devo isso a vocês, porque vocês são demais. Isso diminui um pouco a linha do tempo, mas ainda estou muito animado para continuar testando novas ferramentas.

Sinopse
Entre muitos outros problemas, vários componentes foram recentemente trocados para o modelo de encadeamento incorreto, causando sérios problemas devido ao fato de que o código abaixo de nós de repente não era mais multithread. Não posso dizer mais nada porque viola meu NDA, mas posso dizer que isso nunca foi encontrado por inspeção casual ou mesmo pela revisão normal do código. Sem perfis, caligráficos e pausas aleatórias em conjunto, ainda estaríamos gritando nossa fúria no belo arco azul do céu. Felizmente, trabalho com alguns dos melhores hackers que já conheci e tenho acesso a um incrível verso cheio de ótimas ferramentas e ótimas pessoas.

Gentlefolk, eu aprecio isso tremendamente, e só lamento não ter representantes suficientes para recompensar cada um de vocês com uma recompensa. Ainda acho que essa é uma pergunta importante para obter uma resposta melhor do que as que temos até agora no SO.

Como resultado, a cada semana, durante as próximas três semanas, estarei oferecendo a maior recompensa que posso pagar e concedendo a resposta com a melhor ferramenta que acho que não é de conhecimento comum. Depois de três semanas, esperamos ter acumulado um perfil definitivo dos criadores de perfil, se você perdoar minha punição.

Take-away
Use um perfilador. Eles são bons o suficiente para Ritchie, Kernighan, Bentley e Knuth. Eu não ligo para quem você pensa que é. Use um criador de perfil. Se o que você tem não funcionar, encontre outro. Se você não encontrar um, codifique um. Se você não pode codificar um, ou é um desligamento pequeno, ou está apenas preso, use uma pausa aleatória. Se tudo mais falhar, contrate alguns alunos de pós-graduação para fazer um perfil.

---

Uma visão mais longa
Então, achei que seria legal escrever um pouco de uma retrospectiva. Optei por trabalhar extensivamente com o Parallel Studios, em parte porque ele é realmente construído sobre a Ferramenta PIN. Tendo mantido relações acadêmicas com alguns dos pesquisadores envolvidos, senti que isso provavelmente era uma marca de alguma qualidade. Felizmente, eu estava certa. Embora a GUI seja um pouco terrível, achei o IPS incrivelmente útil, embora não possa recomendá-lo confortavelmente a todos. Criticamente, não há uma maneira óbvia de obter contagens de hits no nível da linha, algo que o AQT e vários outros criadores de perfil fornecem, e eu achei muito útil para examinar a taxa de seleção de ramificações, entre outras coisas. Na net, eu também gostei de usar o AQTime, e achei o suporte deles bastante responsivo. Novamente, tenho que qualificar minha recomendação: Muitos de seus recursos não funcionam tão bem, e alguns deles são propensos a falhas no Win7x64. O XPerf também teve um desempenho admirável, mas é extremamente lento para os detalhes de amostragem necessários para obter boas leituras em certos tipos de aplicativos.

No momento, devo dizer que não acho que exista uma opção definitiva para a criação de perfil de código C ++ em um ambiente W7x64, mas certamente existem opções que simplesmente não conseguem executar nenhum serviço útil.

Primeiro:

Os criadores de perfil de amostragem de tempo são mais robustos que os criadores de perfil de CPU. Eu não estou extremamente familiarizado com as ferramentas de desenvolvimento do Windows, então não posso dizer quais são quais. A maioria dos criadores de perfil é amostragem de CPU.

Um criador de perfil de amostragem de CPU pega um rastreio de pilha a cada N instruções.
Essa técnica irá revelar partes do seu código vinculadas à CPU. O que é incrível se esse for o gargalo da sua aplicação. Não é tão bom se os threads do seu aplicativo passam a maior parte do tempo brigando por um mutex.

Um criador de perfil de amostragem de tempo captura um rastreio de pilha a cada N microssegundo.
Essa técnica se concentrará no código "lento" . Se a causa está vinculada à CPU, bloqueando IO, mutex ou cache, traga seções de código. Resumindo, qualquer parte do código que esteja diminuindo a velocidade do aplicativo se destacará.

Portanto, use um criador de perfil de amostragem de tempo, se possível, especialmente ao criar um perfil de código encadeado.

Segundo:

Os criadores de perfil de amostragem geram grandes quantidades de dados. Os dados são extremamente úteis, mas geralmente há muito para ser facilmente útil. Um visualizador de dados de perfil ajuda tremendamente aqui. A melhor ferramenta que encontrei para a visualização de dados de perfil é o gprof2dot . Não deixe que o nome o engane, ele lida com todos os tipos de saída do profiler de amostragem (AQtime, Sleepy, XPerf, etc). Depois que a visualização apontar as funções ofensivas, volte para os dados brutos do perfil para obter melhores dicas sobre qual é a causa real.

A ferramenta gprof2dot gera uma descrição do gráfico de pontos que você alimenta em uma ferramenta graphviz . A saída é basicamente um callgraph com funções codificadas por cores pelo impacto na aplicação.

Algumas dicas para que o gprof2dot gere uma saída agradável.

• Uso --skew0.001 em meus gráficos para poder ver facilmente os caminhos de código quente. Caso contrário, o int main()dominará o gráfico.
• Se você está fazendo algo louco com modelos C ++, provavelmente desejará adicionar --strip. Isto é especialmente verdade com o Boost.
• Eu uso o OProfile para gerar meus dados de amostragem. Para obter uma boa saída, preciso configurá-lo para carregar os símbolos de depuração das minhas bibliotecas de terceiros e do sistema. Certifique-se de fazer o mesmo, caso contrário, você verá que o CRT está gastando 20% do tempo do seu aplicativo, quando o que realmente está acontecendo mallocé destruir a pilha e consumir 15%.

O que aconteceu quando você tentou uma pausa aleatória? Eu o uso o tempo todo em um aplicativo monstro. Você disse que não forneceu informações suficientes e sugeriu que precisa de alta resolução. Às vezes, as pessoas precisam de uma pequena ajuda para entender como usá-lo.

O que faço, no VS, é configurar a exibição da pilha para que não me mostre os argumentos da função, porque isso torna a exibição da pilha totalmente ilegível, IMO.

Então eu colho cerca de 10 amostras pressionando "pausa" durante o tempo que está me fazendo esperar . Eu uso ^ A, ^ C e ^ V para copiá-los no bloco de notas, para referência. Depois, estudo cada um deles, para tentar descobrir o que estava no processo de tentar realizar naquele momento.

Se ele estava tentando realizar algo em 2 ou mais amostras, e isso não é estritamente necessário, encontrei um problema em tempo real e sei aproximadamente quanto a correção será salva.

Há coisas que você realmente não precisa saber, como porcentagens precisas não são importantes, e o que acontece no código de terceiros não é importante, porque você não pode fazer nada sobre isso . O que você pode fazer é sobre o rico conjunto de pontos de chamada no código que você pode modificar exibido em cada amostra de pilha. Esse é o seu campo de caça feliz.

Exemplos dos tipos de coisas que encontro:

• Durante a inicialização, pode ter cerca de 30 camadas de profundidade, no processo de tentar extrair seqüências de caracteres internacionalizadas de recursos DLL. Se as strings reais forem examinadas, pode facilmente acontecer que as strings não precisem ser internacionalizadas, como se fossem strings que o usuário nunca vê.

• Durante o uso normal, algum código define inocentemente uma propriedade Modified em algum objeto. Esse objeto vem de uma superclasse que captura as alterações e aciona notificações que se propagam por toda a estrutura de dados, manipulando a interface do usuário, criando e destruindo objetos de maneiras difíceis de prever. Isso pode acontecer muito - as consequências inesperadas das notificações.

• Preenchendo uma planilha linha por linha, célula por célula. Acontece que se você criar a linha de uma só vez, a partir de uma matriz de valores, será muito mais rápido.

PS Se você é multithread, quando você o pausa, todos os threads pausam. Dê uma olhada na pilha de chamadas de cada segmento. As chances são de que apenas um deles seja o verdadeiro culpado e os outros estejam ociosos.

Eu tive algum sucesso com o AMD CodeAnalyst .

Você tem uma função MFC OnIdle? No passado, eu tinha um aplicativo quase em tempo real que precisava corrigir os pacotes seriais que estavam caindo quando configurados na velocidade de 19,2K, que um PentiumD deveria ter conseguido acompanhar. A função OnIdle era o que estava matando as coisas. Não tenho certeza se o QT tem esse conceito, mas eu verificaria isso também.

No VS Profiler - se estiver gerando arquivos tão grandes, talvez o seu intervalo de amostragem seja muito frequente? Tente abaixá-lo, pois você provavelmente tem amostras suficientes de qualquer maneira.

E, idealmente, verifique se você não está coletando amostras até estar realmente exercitando a área do problema. Portanto, comece com a coleta em pausa, faça com que seu programa faça sua "atividade lenta" e inicie a coleta. Você só precisa de no máximo 20 segundos de coleta. Pare a coleta depois disso.

Isso deve ajudar a reduzir o tamanho dos arquivos de amostra e capturar apenas o necessário para sua análise.

Utilizei com sucesso o PurifyPlus para Windows. Embora não seja barato, a IBM fornece uma versão de avaliação que está um pouco aleijada. Tudo o que você precisa para criar um perfil com quantify são arquivos pdb e vincular com / FIXED: NO. Única desvantagem: Não há suporte para Win7 / 64.

Easyprofiler - ainda não o vi mencionado aqui, então não tenho certeza se você já o viu. É preciso uma abordagem um pouco diferente na maneira como coleta dados métricos. Uma desvantagem de usar sua abordagem de perfil em tempo de compilação é que você precisa fazer alterações na base de código. Portanto, você precisa ter uma idéia de onde pode estar o lento e inserir o código de perfil lá.

Indo por seus comentários mais recentes, porém, parece que você está, pelo menos, fazer alguns progressos. Talvez essa ferramenta possa fornecer algumas métricas úteis para você. Se nada mais, ele tem alguns gráficos e fotos realmente purdy: P

Mais duas sugestões de ferramentas.

Luke Stackwalker tem um nome bonito (mesmo que esteja se esforçando um pouco para o meu gosto), não vai custar nada e você recebe o código-fonte. Ele também afirma apoiar programas multiencadeados. Portanto, certamente vale a pena dar uma volta.

http://lukestackwalker.sourceforge.net/

Também Glowcode, que eu havia apontado para mim como vale a pena usar:

http://www.glowcode.com/

Infelizmente, eu não trabalho com PC há um tempo, então não tentei nenhum deles. Espero que as sugestões sejam úteis de qualquer maneira.

Caixa XPerf

Este é um perfil gratuito, não invasivo e extensível, oferecido pela MS. Foi desenvolvido pela Microsoft para criar um perfil do Windows.

Se você suspeita do loop de eventos, pode substituir o QCoreApplication :: notify () e a criação de perfis manuais dosome (um ou dois mapas de remetentes / eventos para contagens / hora)?

Eu estou pensando que você primeiro registra a frequência dos tipos de eventos, depois examina esses eventos com mais cuidado (qual objeto envia, o que contém, etc.). Os sinais nos encadeamentos são enfileirados implicitamente; portanto, eles acabam no loop de eventos (bem como conexões enfileiradas explícitas também, obviamente).

Fizemos isso para interceptar e relatar exceções em nossos manipuladores de eventos; portanto, realmente, todo evento passa por lá.

Apenas uma ideia.

Edit: Vejo agora que você mencionou isso em seu primeiro post. Droga, eu nunca pensei que seria esse cara.

Você pode usar o Pin para instrumentar seu código com granularidade mais fina. Acho que Pin permitiria que você criasse uma ferramenta para contar quantas vezes você entra em uma função ou quantos relógios você gasta lá, emulando aproximadamente algo como VTune ou CodeAnalyst. Em seguida, você pode descobrir quais funções são instrumentadas até que seus problemas de tempo acabem.

Eu posso te dizer o que eu uso todos os dias.

a) Analista de código AMD

• É fácil e fornece uma visão geral rápida do que está acontecendo. Vai ficar bem na maior parte do tempo.
• Com os processadores AMD, ele fornece informações sobre o pipeline da CPU, mas você só precisa disso se tiver loops pesados, como em motores gráficos, codecs de vídeo etc.

b) VTune.

• Está muito bem integrado no vs2008

• depois de conhecer os pontos de acesso, você precisa provar não apenas o tempo, mas outras coisas, como falhas de cache e uso de memória. Isso é muito importante . Configure uma sessão de amostragem e edite as propriedades. Eu sempre procuro por tempo, leitura / gravação de memória e falhas de cache (três execuções diferentes)

Mais do que a ferramenta, você precisa ter experiência com criação de perfil. E isso significa entender como a CPU / Memória / PCI funciona ... então, esta é a minha terceira opção

c) Teste de unidade

Isso é muito importante se você estiver desenvolvendo um grande aplicativo que precisa de um desempenho enorme. Se você não conseguir dividir o aplicativo em algumas partes, será difícil rastrear o uso da CPU. Não testei todos os casos e classes, mas tenho execuções codificadas e arquivos de entrada com recursos importantes.

Meu conselho é usar amostragem aleatória em vários pequenos testes e tentar padronizar uma estratégia de perfil.

Eu uso o xperf / ETW para todas as minhas necessidades de criação de perfil. Ele tem uma curva de aprendizado acentuada, mas é incrivelmente poderoso. Se você está criando um perfil no Windows, deve conhecer o xperf. Eu freqüentemente uso esse criador de perfil para encontrar problemas de desempenho no meu código e no código de outras pessoas.

Na configuração que eu uso:

• O xperf pega amostras de CPU de todos os núcleos que executam código a cada ms. A taxa de amostragem pode ser aumentada para 8 KHz e as amostras incluem o modo de usuário e o código do kernel. Isso permite descobrir o que um thread está fazendo enquanto está em execução
• O xperf registra cada alternância de contexto (permitindo a reconstrução perfeita de quanto tempo cada segmento usa), além de pilhas de chamadas para quando os threads são ativados, além de pilhas de chamadas para qual thread preparou outro thread, permitindo o rastreamento de cadeias de espera e descobrindo por que um thread não está correndo
• O xperf registra todas as E / S de arquivos de todos os processos
• O xperf registra todas as E / S de disco de todos os processos
• O xperf registra qual janela está ativa, a frequência da CPU, o estado de energia da CPU, os atrasos na interface do usuário, etc.
• O xperf também pode registrar todas as alocações de heap de um processo, todas as alocações virtuais de todos os processos e muito mais.

São muitos dados, todos em uma linha do tempo, para todos os processos. Nenhum outro criador de perfil no Windows pode fazer isso.

Eu escrevi em blogs extensivamente sobre como usar o xperf / ETW. Essas postagens no blog e alguns vídeos de treinamento com qualidade profissional podem ser encontrados aqui: http://randomascii.wordpress.com/2014/08/19/etw-training-videos-available-now/

Se você quiser descobrir o que pode acontecer se você não usar o xperf, leia estas postagens no blog: http://randomascii.wordpress.com/category/investigative-reporting/ Essas são histórias de problemas de desempenho que encontrei no código de outras pessoas , que deveria ter sido encontrado pelos desenvolvedores. Isso inclui o mshtml.dll sendo carregado no compilador VC ++, uma negação de serviço nos arquivos de localização do VC ++, aceleração térmica em um número surpreendente de máquinas clientes, passo único lento no Visual Studio, uma alocação de 4 GB em um disco rígido. driver de disco, um bug de desempenho do powerpoint e muito mais.

Acabei de terminar a primeira versão utilizável do CxxProf , uma biblioteca de perfis instrumentada manual portátil para C ++.

Cumpre os seguintes objetivos:

• Fácil integração
• Remova facilmente a lib durante o tempo de compilação
• Remova facilmente a lib durante o tempo de execução
• Suporte para aplicativos multithread
• Suporte para sistemas distribuídos
• Mantenha o impacto no mínimo

Esses pontos foram extraídos do wiki do projeto , dê uma olhada lá para mais detalhes.

Disclaimer: Sou o principal desenvolvedor do CxxProf

Apenas para jogar fora, mesmo que não seja um profiler completo: se tudo o que você procura são loops de eventos suspensos que demoram muito tempo processando um evento, uma ferramenta ad-hoc é uma questão simples no Qt. Essa abordagem pode ser facilmente expandida para acompanhar quanto tempo cada evento levou para processar, e quais eram esses eventos e assim por diante. Não é um criador de perfil universal, mas centrado no loop de eventos.

No Qt, todas as chamadas de slot de sinal entre linhas são entregues por meio do loop de eventos, assim como timers, notificações de porta serial e de rede e toda interação do usuário. Portanto, observar os loops de eventos é um grande passo para entender onde o aplicativo está gastando seu tempo.

O DevPartner, originalmente desenvolvido pela NuMega e agora distribuído pela MicroFocus, já foi a solução de escolha para criação de perfil e análise de código (vazamentos de memória e recursos, por exemplo). Eu não tentei recentemente, então não posso garantir que isso o ajudará; mas uma vez obtive excelentes resultados, portanto, é uma alternativa que considero reinstalar em nosso processo de qualidade de código (eles fornecem uma avaliação de 14 dias)

embora seu sistema operacional seja win7, o programa não pode ser executado no xp? que tal perfil sob xp e o resultado deve ser uma dica para win7.

Existem muitos criadores de perfil listados aqui e eu tentei alguns deles pessoalmente - no entanto, acabei escrevendo os meus com base nisso:

http://code.google.com/p/high-performance-cplusplus-profiler/

É claro que exige que você modifique a base de código, mas é perfeito para reduzir gargalos, deve funcionar em todos os x86s (pode ser um problema com caixas com vários núcleos, ou seja, ele usa rdtsc, no entanto - isso é apenas para tempo indicativo) - então acho que é suficiente para minhas necessidades ..)

Eu uso o Orbit Profiler, fácil, de código aberto e poderoso! https://orbitprofiler.com/