Criação de perfil de aplicativos DirectX

Isso mostra como medir algumas das medidas de tempo de desempenho mais importantes para um aplicativo DirectX usando as ferramentas XPerf e GPUView que são enviadas como parte do Kit de Ferramentas de Desempenho do Windows. Este não é um guia abrangente para entender as ferramentas, mas sua aplicabilidade específica para analisar o desempenho do aplicativo DirectX. Embora a maioria das técnicas discutidas aqui sejam relevantes para todos os aplicativos DirectX, é mais relevante para aplicativos que usam cadeias de troca e não para aplicativos DirectX criados em XAML que usam animações SIS/VSIS e XAML. Orientamos você pelas principais medidas de tempo de desempenho, como adquirir e instalar as ferramentas e fazer rastreamentos de medidas de desempenho e analisá-las para entender os gargalos do aplicativo.

Sobre as ferramentas

Xperf

O XPerf é um conjunto de ferramentas de análise de desempenho criadas com base no ETW (Rastreamento de Eventos para Windows) projetado para medir e analisar o desempenho detalhado do sistema e do aplicativo e o uso de recursos. A partir Windows 8 essa ferramenta de linha de comando tem uma interface gráfica do usuário e é chamada de WPR (Gravador de Desempenho do Windows) e WPA (Windows Performance Analyzer). Mais informações sobre essas ferramentas podem ser encontradas na página da Web do WPT ( Windows Performance Toolkit ): Windows Performance Toolkit.

Um ETW coleta eventos de kernel solicitados e os salva em um arquivo chamado etl (log de rastreamento de eventos). Esses eventos de kernel fornecem informações abrangentes sobre um aplicativo e características do sistema ao executar o aplicativo. Os dados são coletados habilitando a captura de rastreamento, executando o cenário de aplicativo desejado que precisa de análise, interrompendo a captura que salva os dados em um arquivo ETL. Em seguida, você pode analisar o arquivo no mesmo computador ou em um computador diferente usando a ferramenta de linha de comandoxperf.exeou a ferramenta de análise de rastreamento visual xperfview.exe.

GPUView

GPUView é uma ferramenta de desenvolvimento para determinar o desempenho da GPU (unidade de processamento gráfico) e da CPU. Ele analisa o desempenho em relação ao processamento de buffer de DMA (acesso direto à memória) e a todos os outros processamentos de vídeo no hardware de vídeo.

Para aplicativos DirectX que dependem muito da GPU, GPUView é uma ferramenta poderosa para entender a relação entre o trabalho feito na CPU versus GPU. Para obter mais informações sobre GPUView, consulte Usando GPUView.

Semelhante ao XPerf, um rastreamento ETW é primeiro feito iniciando o serviço de rastreamento, exercitando o cenário que precisa de análise para o aplicativo em consideração, parando o serviço e salvando as informações em um arquivo ETL. GPUView apresenta os dados presentes no arquivo ETL em um formato gráfico.

Depois de instalar a ferramenta GPUView , é recomendável ler o tópico "Exibição Principal do GPUView" no menu "Ajuda gpuview ". Ele contém informações úteis sobre como interpretar a interface do usuário do GPUView .

Instalando as ferramentas

XPerf e GPUView estão incluídos no WPT (Windows Performance Toolkit).

O XPerf é fornecido como parte do SDK (Software Development Kit) do Windows para Windows. Baixe o SDK do Windows.

GPUView está disponível no Windows ADK (Kit de Avaliação e Implantação do Windows). Baixe o Windows ADK.

Após a instalação, você deve adicionar os diretórios que contêm XPerf e GPUView à variável "Path" do sistema.

Clique no botão Iniciar e digite "Variáveis do Sistema". A janela Propriedades do Sistema é aberta. Clique em "Editar as variáveis de ambiente do sistema". Selecione "Variáveis de Ambiente" na caixa de diálogo "Propriedades do Sistema". A variável "Path" é encontrada em "Variáveis do sistema". Acrescente o diretório que contém xperf.exe e GPUView.exe ao caminho. Esses executáveis são encontrados no diretório "Kit de Ferramentas de Desempenho do Windows" dentro dos "Kits do Windows". O local padrão é: C:\Arquivos de Programas (x86)\Kits do Windows\10\Kit de Ferramentas de Desempenho do Windows.

Medidas de tempo de desempenho

A maioria dos aplicativos espera ser executada sem problemas e responder à entrada do usuário. No entanto, dependendo do cenário desejado, um aspecto do desempenho pode ser mais importante do que outro. Por exemplo, para um aplicativo de leitor de notícias em execução em um computador tablet touch, o aspecto mais importante é exibir um único artigo de cada vez e fazer pan/zoom/rolar pelo mesmo artigo ou outro. Nesse cenário, a capacidade de renderizar todo o conteúdo de cada quadro não é necessária. No entanto, a capacidade de rolar o artigo sem problemas em um gesto de toque é extremamente importante.

Em outra instância, um jogo ou um aplicativo de renderização de vídeo que usa muitas falhas de animações se os quadros forem removidos. Nesse caso, a capacidade de apresentar conteúdo na tela sem interação da entrada do usuário é extremamente importante.

Para entender qual parte do aplicativo é problemática, a primeira etapa é decidir sobre os cenários mais importantes. Depois que os principais aspectos do aplicativo são compreendidos e como eles serão exercidos, procurar problemas usando as ferramentas fica mais fácil.

Algumas das métricas de tempo de desempenho mais comuns são as seguintes:

Hora da inicialização

Tempo medido desde a inicialização do processo até o primeiro presente atingindo a tela. Essa medida é mais útil quando o sistema é quente, o que significa que a medida é tomada depois que o aplicativo é iniciado algumas vezes.

Tempo de CPU por quadro

O tempo para o qual a CPU processa ativamente a carga de trabalho do aplicativo para um quadro. Se o aplicativo estiver sendo executado sem problemas, todo o processamento necessário para um quadro ocorrerá em um intervalo de sincronização v. Com a taxa de atualização do monitor de 60Hz, isso chega a 16 ms por quadro. Se o tempo/quadro da CPU for maior que 16ms, as otimizações de CPU poderão ser necessárias para produzir uma experiência de aplicativo sem falhas.

Tempo de GPU por quadro

O tempo para o qual a GPU processa ativamente a carga de trabalho do aplicativo para um quadro. Um aplicativo é associado à GPU quando o tempo necessário para processar um quadro de dados é superior a 16 ms.

Ser capaz de entender se um aplicativo é associado à CPU ou à GPU restringirá a parte problemática do código.

Tomando o rastreamento de medida de tempo de desempenho

Execute estas etapas para fazer um rastreamento:

1. Abra uma janela de comando como administrador.
2. Feche o aplicativo se ele já estiver em execução.
3. Altere os diretórios para o diretório gpuview dentro da pasta Kit de Ferramentas de Desempenho do Windows.
4. Digite "log.cmd" para iniciar o rastreamento de eventos. Essa opção registra os eventos mais interessantes. Outras opções disponíveis registram um escopo diferente dos eventos. Por exemplo, o modo de log 'v' ou detalhado captura todos os eventos que o GPUView está ciente.
5. Inicie o exemplo e exerça o exemplo de uma maneira que abrange o caminho de desempenho que você precisa analisar.
6. Voltar para as janelas de comando e digite "log.cmd" novamente para interromper o registro em log.
7. Isso gera um arquivo chamado "merged.etl" na pasta gpuview . Você pode salvar esse arquivo em outro local e analisá-lo no mesmo computador ou em um computador diferente. Para exibir detalhes da captura de pilha, salve o arquivo de símbolo (.pdb) associado ao aplicativo.

Medidas

Observação

As medidas para a amostra de realização de geometria são feitas em um computador Quad Core com um cartão de elementos gráficos DirectX11 integrados. As medidas variam dependendo da configuração do computador.

 

Esta seção demonstra como medir o tempo de inicialização, a CPU e o tempo de GPU por medidas de quadro. Você pode capturar um rastreamento de desempenho para o mesmo exemplo em seu computador e ver as diferenças nas várias medidas.

Para analisar o rastreamento no GPUView, abra o arquivo "merged.elt" usando GPUView.exe.

Hora da inicialização

O tempo de inicialização é medido pelo tempo total gasto do início do aplicativo até que o conteúdo seja exibido pela primeira vez na tela.

A medida de tempo de inicialização é melhor tomada seguindo as etapas listadas na seção anterior com estas variações:

• Se você fizer as medidas de inicialização na primeira vez que iniciar o aplicativo, ele será chamado de inicialização fria. Isso pode variar de medidas feitas depois que você iniciar o aplicativo algumas vezes em uma pequena duração de tempo. Isso é chamado de inicialização calorosa. Dependendo de quantos recursos um aplicativo cria na inicialização, pode haver uma grande diferença entre os dois tempos de inicialização. Dependendo das metas do aplicativo, medir uma ou outra pode ser desejável.
• Quando você registrar informações de desempenho, encerre o aplicativo assim que o primeiro quadro aparecer na tela.

Calculando o tempo de inicialização usando GPUView

1. Em GPUView, role para baixo até o processo relevante, nesse caso, GeometryRealization.exe.

   

2. A fila de CPU de contexto representa a carga de trabalho de gráficos enfileirada no hardware, mas não necessariamente sendo processada pelo hardware. Quando o arquivo de rastreamento é aberto, ele mostra todos os eventos registrados entre o momento em que o rastreamento foi feito. Para calcular a hora de inicialização, selecione a região de interesse, amplie a parte inicial da primeira Fila de CPU de Contexto (essa é a que mostra a atividade) usando Ctrl +Z. Mais informações sobre controles GPUView podem ser encontradas na seção arquivo de Ajuda gpuview "Resumo dos controles GPUView ". A figura abaixo mostra apenas o processo de GeometryRealization.exe ampliado para a primeira parte da Fila de CPU de Contexto. A cor da Fila de CPU de Contexto é indicada pelo retângulo logo abaixo da fila e os mesmos pacotes de dados de cor na fila mostram o trabalho de GPU enfileirado no hardware. O pacote de padrão de hachura na fila de contexto mostra o pacote atual, o que significa que o aplicativo deseja que o hardware apresente o conteúdo na tela.

   

3. A hora de inicialização é a hora em que o aplicativo é iniciado pela primeira vez (nesse caso, o módulo de ponto de entrada do thread da interface do usuário SHCORE.dll) até a hora em que o contexto aparece pela primeira vez (marcado por um pacote de hachura). A figura aqui destaca a área de interesse.

   Observação

   As informações atuais atuais são representadas na fila de inversão e, portanto, a tomada de tempo é estendida até que o pacote atual seja realmente concluído na fila de inversão.

    

   A barra de status completa não está visível na figura abaixo, que também mostra o tempo decorrido entre as partes realçadas. Essa é a hora de inicialização do aplicativo. Nesse caso, para o computador mencionado acima, ele saiu para cerca de 240ms.

   

Tempo de CPU e GPU por quadro

Há algumas coisas a serem pensadas ao medir o tempo de CPU. Procure as áreas no rastreamento em que você exerciou o cenário a ser analisado. Por exemplo, no exemplo de realização de geometria, um dos cenários analisados é a transição entre os primitivos de renderização 2048 e 8192, todos não realizados (como em, geometria não é mosaicado a cada quadro). O rastreamento mostra claramente a diferença na atividade de CPU e GPU antes e depois da transição no número de primitivos.

Dois cenários estão sendo analisados para calcular o tempo de CPU e GPU por quadro. Eles são os seguintes.

• Transição da renderização de primitivos não realizados de 2048 para 8192 primitivos não realizados.
• Transição da renderização de primitivos realizados 8192 para 8192 primitivos não realizados.

Em ambos os casos, observou-se que a taxa de quadros caiu drasticamente. Medindo o tempo de CPU e GPU, a relação entre os dois, bem como alguns outros padrões no rastreamento, pode fornecer informações úteis sobre áreas problemáticas no aplicativo.

Calculando o tempo de CPU e GPU quando primitivos de 2048 estão sendo renderizados não realizados

1. Abra o arquivo de rastreamento usando GPUView.exe.

2. Role para baixo até o processo de GeometryRealization.exe.

3. Selecione uma área para calcular o tempo de CPU e amplie-a usando CTRL + Z.

   

4. Mostrar informações de sincronização v alternando entre F8. Manter o zoom até que seja fácil ver claramente um valor vsync de dados. As linhas azuis são onde os tempos de sincronização v. Normalmente, eles ocorrem uma vez a cada 16 ms (60 fps), mas se o DWM estiver encontrando um problema de desempenho, ele é executado mais lentamente para que ocorram uma vez a cada 32 ms (30 fps). Para ter uma noção de tempo, selecione de uma barra azul para a próxima e, em seguida, examine o número de ms relatado no canto inferior direito da janela GPUView .

   

5. Para medir o tempo de CPU por quadro, meça o tempo gasto por todos os threads envolvidos na renderização. Pode valer a pena restringir o thread que deve ser mais relevante do ponto de vista do desempenho. Por exemplo, no exemplo de realização de geometria, o conteúdo é animado e precisa ser renderizado na tela a cada quadro, tornando o thread de interface do usuário o mais importante. Depois de determinar qual thread examinar, meça o comprimento das barras nesse thread. A média de alguns desses gera tempo de CPU por quadro. A figura abaixo mostra o tempo gasto no thread da interface do usuário. Ele também mostra que esse tempo se encaixa bem entre duas sincronizações v consecutivas, o que significa que ele está atingindo 60FPS.

   

   Você também pode verificar examinando a fila de inversão para o período de tempo correspondente, o que mostra que o DWM é capaz de apresentar cada quadro.

   

6. O tempo de GPU pode ser medido da mesma forma que o tempo de CPU. Amplie a área relevante como no caso de medir o tempo de CPU. Meça o comprimento das barras na Fila de hardware de GPU com a mesma cor que a cor da Fila de CPU de Contexto. Desde que as barras caibam em sincronizações v consecutivas, o aplicativo está sendo executado sem problemas em 60FPS.

   

Calculando o tempo de CPU e GPU quando primitivos 8192 estão sendo renderizados não realizados

1. Se você seguir as mesmas etapas novamente, o rastreamento mostrará que todo o trabalho da CPU para um quadro não se ajusta entre uma v-sync e a próxima. Isso significa que o aplicativo está associado à CPU. O thread da interface do usuário está saturando a CPU.

   

   Olhando para a fila de inversão, também está claro que o DWM não é capaz de apresentar todos os quadros.

   

2. Para analisar onde o tempo está sendo gasto, abra o rastreamento no XPerf. Para analisar o tempo de inicialização no XPerf, primeiro localize o intervalo de tempo em GPUView. Passe o mouse sobre a esquerda do intervalo e a direita e anote o tempo absoluto mostrado na parte inferior da janela GPUView . Em seguida, abra o mesmo arquivo .etl no XPerf e role para baixo até o grafo "Amostragem de CPU por CPU", clique com o botão direito do mouse e selecione "Selecionar Intervalo..." Isso permite digitar no intervalo de interesse que foi descoberto examinando o rastreamento de GPU.

   

3. Vá para o menu Rastreamento e verifique se "Carregar Símbolos" está marcado. Além disso, vá para Rastreamento –> Configurar Caminhos de Símbolo e digite o caminho do símbolo do aplicativo. Um arquivo de símbolo contém informações de depuração sobre um executável compilado em um banco de dados separado (.pdb). Esse arquivo é comumente chamado de PDB. Mais informações sobre arquivos de símbolo podem ser encontradas aqui: Arquivos de Símbolo. Esse arquivo pode estar localizado na pasta "Depurar" do diretório do aplicativo.

4. Para obter o detalhamento de onde o tempo está sendo gasto no aplicativo, clique com o botão direito do mouse no intervalo selecionado na etapa anterior e clique em Tabela de Resumo. Para obter uma visão geral de quanto tempo é gasto em cada dll, desmarque "Stack" no menu "Colunas". Observe que a coluna "Contagem" aqui mostra quantos exemplos estão dentro da dll/função fornecida. Como aproximadamente uma amostra é obtida por ms, esse número pode ser usado como uma melhor estimativa de quanto tempo é gasto em cada dll/função. Verificar a "Pilha" no menu Colunas dará o tempo inclusivo gasto em cada função no grafo de chamadas. Isso ajudará a dividir ainda mais os pontos problemáticos.

5. Informações de rastreamento de pilha para primitivos não realizados de 2048 revelam que 30% do tempo de CPU é gasto no processo de realização de geometria. Desse total, cerca de 36% do tempo está sendo gasto em mosaico de geometria e acariciamento.

6. Informações de rastreamento de pilha para primitivos não realizados 8192 revelam que cerca de 60% do tempo de CPU (4 núcleos) é gasto na realização de geometria.

   

Calculando o tempo de CPU quando 8.192 primitivos estão sendo renderizados

Está claro nos perfis que o aplicativo está associado à CPU. Para reduzir o tempo gasto pela CPU, as geometrias podem ser criadas uma vez e armazenadas em cache. O conteúdo armazenado em cache pode ser renderizado a cada quadro sem incorrer no custo de mosaico de geometria por quadro. Ao examinar o rastreamento em GPUView para a parte realizada do aplicativo, fica claro que o DWM é capaz de apresentar todos os quadros e o tempo de CPU diminuiu drasticamente.

A primeira parte do grafo mostra primitivos 8192 realizados. O tempo de CPU correspondente por quadro é capaz de se ajustar a duas sincronizações v consecutivas. Na parte posterior do grafo, isso não é verdadeiro.

Olhando no XPerf, a CPU fica ociosa por mais tempo, com apenas cerca de 25% do tempo de CPU sendo gasto no aplicativo de realização de geometria.

Resumo

GPUView e XPerf e ferramentas avançadas para analisar o desempenho de aplicativos DirectX. Este artigo é uma cartilha para usar essas ferramentas e entender as medidas básicas de desempenho e as características do aplicativo. Além de entender o uso de ferramentas, primeiro é importante entender o aplicativo que está sendo analisado. Comece encontrando respostas para perguntas como o que o aplicativo está tentando alcançar? Quais threads no sistema são mais importantes? Que compensações você está disposto a fazer? Ao analisar rastreamentos de desempenho, comece examinando locais problemáticos óbvios. A CPU ou a GPU do aplicativo estão associadas? O aplicativo é capaz de apresentar todos os quadros? As ferramentas, juntamente com uma compreensão do aplicativo, podem fornecer informações muito úteis para entender, localizar e, finalmente, resolver problemas de desempenho.