Depurar alto uso da CPU no .NET Core

Este artigo aplica-se a: ✔️ SDK do .NET Core 3.1 e versões posteriores

Neste tutorial, você aprenderá a depurar um cenário de uso excessivo da CPU. Usando o exemplo fornecido ASP.NET repositório de código-fonte do aplicativo Web Core , você pode causar um deadlock intencionalmente. O ponto de extremidade deixará de responder e experimentará acúmulo de threads. Você aprenderá como usar várias ferramentas para diagnosticar esse cenário com vários dados de diagnóstico.

Neste tutorial, irá:

Investigue o alto uso da CPU
Determinar o uso da CPU com contadores de pontos
Usar dotnet-trace para geração de rastreamento
Desempenho do perfil no PerfView
Diagnosticar e resolver o uso excessivo da CPU

Pré-requisitos

O tutorial usa:

SDK do .NET Core 3.1 ou uma versão posterior.
Exemplo de destino de depuração para disparar o cenário.
dotnet-trace para listar processos e gerar um perfil.
contadores dotnet para monitorar o uso da CPU.

Contadores de CPU

Antes de tentar este tutorial, instale a versão mais recente dos contadores dotnet:

dotnet tool install --global dotnet-counters

Se seu aplicativo estiver executando uma versão do .NET mais antiga que o .NET 9, a interface do usuário de saída dos contadores de pontos terá uma aparência ligeiramente diferente; Consulte contadores de pontos para obter detalhes.

Antes de tentar coletar dados de diagnóstico, você precisa observar uma condição de CPU alta. Execute o aplicativo de exemplo usando o seguinte comando do diretório raiz do projeto.

dotnet run

Para verificar o uso atual da CPU, use o comando dotnet-counters tool:

dotnet-counters monitor -n DiagnosticScenarios --showDeltas

A saída deve ser semelhante à seguinte:

Press p to pause, r to resume, q to quit.
    Status: Running

Name                                                            Current Value      Last Delta
[System.Runtime]
    dotnet.assembly.count ({assembly})                               111               0
    dotnet.gc.collections ({collection})
        gc.heap.generation
        ------------------
        gen0                                                           8               0
        gen1                                                           1               0
        gen2                                                           0               0
    dotnet.gc.heap.total_allocated (By)                        4,042,656          24,512
    dotnet.gc.last_collection.heap.fragmentation.size (By)
        gc.heap.generation
        ------------------
        gen0                                                     801,728               0
        gen1                                                       6,048               0
        gen2                                                           0               0
        loh                                                            0               0
        poh                                                            0               0
    dotnet.gc.last_collection.heap.size (By)
        gc.heap.generation
        ------------------
        gen0                                                     811,512               0
        gen1                                                     562,024               0
        gen2                                                   1,095,056               0
        loh                                                       98,384               0
        poh                                                       24,528               0
    dotnet.gc.last_collection.memory.committed_size (By)       5,623,808               0
    dotnet.gc.pause.time (s)                                           0.019           0
    dotnet.jit.compilation.time (s)                                    0.582           0
    dotnet.jit.compiled_il.size (By)                             138,895               0
    dotnet.jit.compiled_methods ({method})                         1,470               0
    dotnet.monitor.lock_contentions ({contention})                     4               0
    dotnet.process.cpu.count ({cpu})                                  22               0
    dotnet.process.cpu.time (s)
        cpu.mode
        --------
        system                                                         0.109           0
        user                                                           0.453           0
    dotnet.process.memory.working_set (By)                    65,515,520               0
    dotnet.thread_pool.queue.length ({work_item})                      0               0
    dotnet.thread_pool.thread.count ({thread})                         0               0
    dotnet.thread_pool.work_item.count ({work_item})                   6               0
    dotnet.timer.count ({timer})                                       0               0

Concentrando-se nos Last Delta valores de , eles nos dizem quantos segundos dentro do período de dotnet.process.cpu.timeatualização (atualmente definido como o padrão de 1 s) a CPU esteve ativa. Com o aplicativo Web em execução, imediatamente após a inicialização, a CPU não está sendo consumida e esses deltas são ambos 0. Navegue até a api/diagscenario/highcpu rota com 60000 o parâmetro route:

https://localhost:5001/api/diagscenario/highcpu/60000

Agora, execute novamente o comando dotnet-counters .

dotnet-counters monitor -n DiagnosticScenarios --showDeltas

Você deve ver um aumento no uso da CPU como mostrado abaixo (dependendo da máquina host, espere variar o uso da CPU):

Press p to pause, r to resume, q to quit.
    Status: Running

Name                                                            Current Value      Last Delta
[System.Runtime]
    dotnet.assembly.count ({assembly})                               111               0
    dotnet.gc.collections ({collection})
        gc.heap.generation
        ------------------
        gen0                                                           8               0
        gen1                                                           1               0
        gen2                                                           0               0
    dotnet.gc.heap.total_allocated (By)                        4,042,656          24,512
    dotnet.gc.last_collection.heap.fragmentation.size (By)
        gc.heap.generation
        ------------------
        gen0                                                     801,728               0
        gen1                                                       6,048               0
        gen2                                                           0               0
        loh                                                            0               0
        poh                                                            0               0
    dotnet.gc.last_collection.heap.size (By)
        gc.heap.generation
        ------------------
        gen0                                                     811,512               0
        gen1                                                     562,024               0
        gen2                                                   1,095,056               0
        loh                                                       98,384               0
        poh                                                       24,528               0
    dotnet.gc.last_collection.memory.committed_size (By)       5,623,808               0
    dotnet.gc.pause.time (s)                                           0.019           0
    dotnet.jit.compilation.time (s)                                    0.582           0
    dotnet.jit.compiled_il.size (By)                             138,895               0
    dotnet.jit.compiled_methods ({method})                         1,470               0
    dotnet.monitor.lock_contentions ({contention})                     4               0
    dotnet.process.cpu.count ({cpu})                                  22               0
    dotnet.process.cpu.time (s)
        cpu.mode
        --------
        system                                                         0.344           0.013
        user                                                          14.203           0.963
    dotnet.process.memory.working_set (By)                    65,515,520               0
    dotnet.thread_pool.queue.length ({work_item})                      0               0
    dotnet.thread_pool.thread.count ({thread})                         0               0
    dotnet.thread_pool.work_item.count ({work_item})                   6               0
    dotnet.timer.count ({timer})                                       0               0

Durante toda a duração da solicitação, o uso da CPU irá pairar em torno do valor aumentado.

Sugestão

Para visualizar um uso ainda maior da CPU, você pode exercer esse ponto de extremidade em várias guias do navegador simultaneamente.

Neste ponto, você pode dizer com segurança que a CPU está funcionando mais alto do que o esperado. Identificar os efeitos de um problema é fundamental para encontrar a causa. Vamos usar o efeito do alto consumo de CPU, além de ferramentas de diagnóstico para encontrar a causa do problema.

Analise a alta CPU com o Profiler

Ao analisar um aplicativo com alto uso de CPU, você precisa de uma ferramenta de diagnóstico que possa fornecer informações sobre o que o código está fazendo. A escolha habitual é um profiler, e há diferentes opções de profiler para escolher. dotnet-trace pode ser usado em todos os sistemas operacionais, no entanto, suas limitações de viés de ponto seguro e pilhas de chamadas somente gerenciadas resultam em informações mais gerais em comparação com um profiler com reconhecimento de kernel como 'perf' para Linux ou ETW para Windows. Se sua investigação de desempenho envolver apenas código gerenciado, geralmente dotnet-trace será suficiente.

Linux
Windows

A perf ferramenta pode ser usada para gerar perfis de aplicativo .NET Core. Vamos demonstrar esta ferramenta, embora dotnet-trace também possa ser usado. Saia da instância anterior do destino de depuração de exemplo.

Defina a DOTNET_PerfMapEnabled variável de ambiente para fazer com que o aplicativo .NET crie um map arquivo no /tmp diretório. Este map arquivo é usado por para mapear endereços de CPU para funções geradas por perf JIT por nome. Para obter mais informações, consulte Exportar mapas de perf e jit dumps.

Execute o destino de depuração de exemplo na mesma sessão de terminal.

export DOTNET_PerfMapEnabled=1
dotnet run

Exerça novamente o ponto de extremidade da API de alta CPU (https://localhost:5001/api/diagscenario/highcpu/60000). Enquanto ele estiver sendo executado dentro da solicitação de 1 minuto, execute o comando com sua ID de perf processo:

sudo perf record -p 2266 -g

O perf comando inicia o processo de coleta de desempenho. Deixe-o funcionar por cerca de 20 a 30 segundos e pressione Ctrl+C para sair do processo de coleta. Você pode usar o mesmo perf comando para ver a saída do rastreamento.

sudo perf report -f

Você também pode gerar um gráfico de chama usando os seguintes comandos:

git clone --depth=1 https://github.com/BrendanGregg/FlameGraph
sudo perf script | FlameGraph/stackcollapse-perf.pl | FlameGraph/flamegraph.pl > flamegraph.svg

Este comando gera um flamegraph.svg que você pode visualizar no navegador para investigar o problema de desempenho:

No Windows, você pode usar a ferramenta dotnet-trace como um criador de perfil. Usando o destino de depuração de exemplo anterior, exercite o ponto de extremidade de CPU alto (https://localhost:5001/api/diagscenario/highcpu/60000) novamente. Enquanto ele estiver sendo executado dentro da solicitação de 1 minuto, use o collect comando, com a providers opção de especificar o provedor desejado: Microsoft-DotNetCore-SampleProfiler, para coletar um rastreamento do aplicativo da seguinte maneira:

dotnet-trace collect -p 22884 --providers Microsoft-DotNETCore-SampleProfiler

Deixe o dotnet-trace ser executado por cerca de 20 a 30 segundos e pressione Enter para sair da coleção. O resultado é um nettrace arquivo localizado na mesma pasta. Os nettrace arquivos são uma ótima maneira de usar as ferramentas de análise existentes no Windows.

Abra o nettrace com PerfView navegando até samples/core/diagnostics/DiagnosticScenarios/ e clicando na seta ao lado do nettrace arquivo. Abra o 'Thread Time (with StartStop Activities) Stacks' e escolha a guia 'CallTree' perto da parte superior. Depois de marcar a caixa à esquerda de um dos tópicos, seu arquivo deve ser semelhante ao mostrado abaixo.

Analisando dados de alta CPU com o Visual Studio

Todos os arquivos *.nettrace podem ser analisados no Visual Studio. Para analisar um arquivo Linux *.nettrace no Visual Studio, transfira o arquivo *.nettrace, além dos outros documentos necessários, para uma máquina Windows e, em seguida, abra o arquivo *.nettrace no Visual Studio. Para obter mais informações, consulte Analisar dados de uso da CPU.

Consulte também

dotnet-trace para listar processos
contadores dotnet para verificar o uso de memória gerenciada
dotnet-dump para coletar e analisar um arquivo de despejo
dotnet/diagnóstico

Próximos passos

Depurar um deadlock no .NET Core

Feedback

Esta página foi útil?

Last updated on 2025-11-22