Você pode olhar sob o capô do código ou ver o dispositivo CLR interno usando várias ferramentas. Este post nasceu de um tweet e eu tenho que agradecer a todos que ajudaram a fazer uma lista de ferramentas adequadas. Se eu perdi algum deles, escreva nos comentários.
Primeiro, devo mencionar que um bom depurador já está presente no Visual Studio e no VSCode . Também existem muitas boas ferramentas de criação de perfil .NET (comerciais) e ferramentas de monitoramento de aplicativos . Por exemplo, recentemente tentei trabalhar com o Codetrack e fiquei impressionado com seus recursos.
No entanto, a postagem restante é dedicada a ferramentas para executar tarefas individuais , o que ajudará a entender melhor o que está acontecendo. Todas as ferramentas são de código aberto .
PerfView é uma ótima ferramenta que venho usando há vários anos. Ele funciona com base no Windows Event Tracing (ETW) e permite entender melhor o que está acontecendo no CLR, além de oferecer a oportunidade de obter um perfil de utilização de memória e CPU. Para dominar a ferramenta, você terá que absorver muitas informações, por exemplo, com a ajuda de vídeos de treinamento , mas vale a pena o tempo e o esforço.
A ferramenta é tão útil que os próprios engenheiros da Microsoft a usam e muitas das recentes melhorias de desempenho no MSBuild apareceram após a análise de gargalos usando o PerfView.
A ferramenta é baseada na biblioteca Microsoft.Diagnostics.Tracing.TraceEvent , que você pode usar para criar suas próprias ferramentas. Além disso, como o código fonte da biblioteca está aberto, graças à comunidade, muitas funções úteis apareceram nela, por exemplo, gráficos de chama :
O SharpLab surgiu como uma ferramenta para verificar o código IL gerado pelo compilador Roslyn e acabou se transformando em algo mais :
O SharpLab é um ambiente interativo para executar o código .NET, que exibe as etapas intermediárias e os resultados da compilação do código. Algumas funções da linguagem são apenas invólucros para outras, por exemplo, usando () torna-se try / catch. Com o SharpLab, você verá o código como o compilador o vê e entenderá melhor a essência das linguagens .NET.
A ferramenta suporta C #, Visual Basic e F #, mas as funções mais interessantes são Descompilação / Desmontagem:
As funções de descompilação / desmontagem podem ser usadas para:
- C #
- Visual basic
- IL
- JIT Asm (código ASM nativo)
Você entendeu corretamente: a ferramenta gera o código do assembler que o .NET JIT gera a partir do seu código C #:
Com essa ferramenta, você pode analisar a estrutura dos objetos .NET na memória, ou seja, como o JITter organizou os campos pertencentes à sua classe ou estrutura. Isso é útil ao escrever código de alto desempenho. Também é bom ter uma ferramenta que faça o trabalho duro para nós.
Não há documentação oficial que descreva a estrutura do campo, pois os autores do CLR se reservam o direito de alterá-la no futuro. Mas o conhecimento da estrutura pode ser útil se você estiver trabalhando em um aplicativo de alta velocidade.
Como você pode estudar a estrutura? Você pode examinar a memória não processada no Visual Studio ou usar o !dumpobj na extensão de depuração do SOS . Ambas as abordagens exigem muito esforço, portanto, criaremos uma ferramenta que exibirá a estrutura do objeto em tempo de execução.
De acordo com o exemplo no repositório GitHub, se você usar TypeLayout.Print<NotAlignedStruct>() com código semelhante:
public struct NotAlignedStruct { public byte m_byte1; public int m_int; public byte m_byte2; public short m_short; }
A saída a seguir será exibida, mostrando com precisão como o CLR organizará a estrutura na memória com base nas regras de otimização e preenchimento.
Size: 12. Paddings: 4 (%33 of empty space) |================================| | 0: Byte m_byte1 (1 byte) | |--------------------------------| | 1-3: padding (3 bytes) | |--------------------------------| | 4-7: Int32 m_int (4 bytes) | |--------------------------------| | 8: Byte m_byte2 (1 byte) | |--------------------------------| | 9: padding (1 byte) | |--------------------------------| | 10-11: Int16 m_short (2 bytes) | |================================|
Conforme declarado na página do GitHub , o TUNE é uma ferramenta promissora. Ele o ajudará a aprender sobre os componentes internos do .NET e como melhorar o desempenho experimentando o código C #
Informações detalhadas sobre ele podem ser encontradas nesta postagem , mas em um nível alto, ele funciona da seguinte maneira :
- escreva um exemplo de código C # que contenha pelo menos uma classe com um método público que use um parâmetro de seqüência de caracteres. O código é iniciado usando o botão Executar. Você pode incluir qualquer número de métodos e classes. Mas lembre-se de que o primeiro método público da primeira classe pública será executado usando o primeiro parâmetro da janela de entrada sob o código;
- clique no botão Executar para compilar e executar o código. Além disso, ele será compilado no código IL e no código do montador nas guias correspondentes;
- enquanto o Tune está em execução (inclusive em tempo de execução), a ferramenta cria um gráfico que exibe dados do coletor de lixo. Ele contém informações sobre tamanhos de geração e sessões de coleta de lixo (representadas como linhas verticais com um número abaixo, que indica em qual coleta de lixo de geração é realizada).
É assim:
Ferramentas de diagnóstico de memória CLR (ClrMD)
Finalmente, vamos dar uma olhada em uma certa categoria de ferramentas. Desde o lançamento do .NET, os desenvolvedores sempre conseguiram usar o WinDBG e a extensão de depuração SOS para ver o que acontece no tempo de execução do .NET. No entanto, essas não são as ferramentas mais fáceis para um primeiro conhecido e, como afirmado no próximo tweet, nem sempre são as mais produtivas:
Felizmente, a Microsoft disponibilizou a biblioteca ClrMD (também conhecida como Microsoft.Diagnostics.Runtime ) e agora qualquer um pode criar uma ferramenta para analisar despejos de memória para programas .NET. Informações detalhadas podem ser encontradas no blog oficial . Eu também recomendo dar uma olhada no ClrMD.Extensions , que "... fornece integração com o LINPad e facilita o uso do ClrMD" .
Eu queria montar uma lista de todas as ferramentas existentes e pedir ajuda no Twitter . Lembrando-se: tenha cuidado com os tweets. O gerente responsável pelo WinDBG pode lê-los e ficar chateado!
A maioria dessas ferramentas funciona com base no ClrMD, porque é mais fácil. Mas se desejar, você pode usar interfaces COM diretamente . Também deve ser observado que qualquer ferramenta baseada no ClrMD não é multiplataforma , já que o próprio ClrMD foi projetado apenas para Windows. As opções de plataforma cruzada são descritas em Analisando um .NET Core Core Dump no Linux .
Por fim, para manter o equilíbrio de alguma forma, uma versão aprimorada do WinDBG apareceu recentemente, e eles imediatamente tentaram adicionar funcionalidade:
Depois de todas essas palavras, vá para a lista:
- SuperDump ( GitHub )
- Ferramenta para análise automática de despejo de memória ( apresentação )
- msos ( github )
- Um ambiente com uma interface de linha de comando, como o WinDbg, para executar comandos do SOS na ausência do SOS.
- MemoScope.Net ( GitHub )
- Uma ferramenta para analisar a memória do processo no .NET. Você pode despejar a memória do aplicativo em um arquivo e lê-lo mais tarde.
- O arquivo contém todos os dados (objetos) e informações sobre os threads (estado, pilha, pilha de chamadas). O MemoScope.Net analisará os dados e o ajudará a encontrar vazamentos de memória e conflitos.
- dnSpy ( github )
- Depurador e editor de assembly .NET
- Pode ser usado para editar e depurar assemblies, mesmo se você não tiver código fonte.
- MemAnalyzer ( GitHub )
- Uma ferramenta de análise de memória para código gerenciado. Existe uma interface de linha de comando.
- O
!DumpHeap no !DumpHeap pode determinar quais objetos ocupam mais espaço no heap sem precisar instalar um depurador.
- DumpMiner ( GitHub )
- Rastrear CLI ( GitHub )
- Ferramenta para depuração e rastreamento durante a operação
- Galpão ( GitHub )
- Shed é um aplicativo que analisa a execução de um programa no .NET. Ele pode ser usado para analisar malware, a fim de obter dados sobre quais informações são armazenadas quando esse software é iniciado. Galpão pode:
- Recuperar todos os objetos armazenados no heap gerenciado
- exibir linhas armazenadas na memória;
- crie um instantâneo de heap no formato JSON para processamento adicional;
- despejar todos os módulos carregados na memória.
Você pode encontrar muitas outras ferramentas que usam o ClrMD . A disponibilização foi uma boa ideia da Microsoft.
Outras ferramentas
Outras ferramentas que vale a pena mencionar:
- Debugdiag
- A ferramenta DebugDiag foi projetada para corrigir problemas como congelamentos, baixo desempenho, vazamentos de memória ou fragmentação, além de falhas nos processos no modo de usuário (agora com integração ao CLRMD).
- SOSEX (talvez não esteja mais sendo desenvolvido)
- ... uma extensão para depurar código gerenciado que reduz minha insatisfação com o SOS.
- VMMap da Sysinternals
- O VMMap é uma ferramenta para analisar a memória virtual e física dos processos.
- Usei-o para analisar o uso de memória no CLR
