Identificar a API de renderização de jogos Vulkan x OpenGL ES

Ao desenvolver ou otimizar jogos para Android, geralmente é útil entender qual pipeline de gráficos seu mecanismo está usando. Os mecanismos podem escolher o Vulkan ou o GLES sem indicadores claramente acessíveis ao desenvolvedor. Infelizmente, há situações em que confiar em logcat para verificar se um jogo está sendo executado no Vulkan ou se voltou silenciosamente para o OpenGL ES pode não ser confiável.

Neste guia, mostramos como usar o Android Performance Analyzer (APA) e consultas SQL personalizadas do Perfetto para identificar definitivamente a API de renderização ativa de um jogo.

Limitações da verificação baseada em registros

• Registros removidos: as versões de produção geralmente ocultam as pegadas de inicialização e carregamento de drivers.
• Falsos positivos: alguns mecanismos de jogo carregam as bibliotecas do Vulkan e do OpenGL ES durante a inicialização, imprimindo registros de inicialização para ambos, mesmo que um deles falhe e acione um substituto.
• Substituições silenciosas: se a inicialização do Vulkan falhar devido a problemas de driver específicos do dispositivo, os mecanismos geralmente vão usar o OpenGL ES sem gerar erros críticos.

Medir usando a APA

Com o Android Performance Analyzer, é possível gravar um rastreamento do sistema e analisar com precisão os dados de frames usando consultas SQL. Siga estas etapas para medir o uso do Vulkan e do GLES:

1. Capturar o rastro com o APA: execute o jogo e use o APA para capturar um rastreamento do sistema durante o segmento que você quer analisar, como um ponto durante o jogo em que você suspeita que haja quedas de frames. Depois que o dispositivo é conectado e a gravação do trace é concluída, os dados do trace são carregados na interface do APA.

2. Clique na guia SQL no APA: quando a tela de análise de trace estiver aberta, no menu de navegação da interface, clique na guia SQL para abrir o ambiente do processador de trace, onde é possível consultar os dados diretamente.

3. Cole a seguinte consulta SQL na guia "APA SQL": copie a consulta SQL abaixo e cole-a no campo de entrada de consulta. Essa consulta verifica o rastro em busca de eventos de API de desenho, como eglSwapBuffers, QueuePresentKHR e vkQueuePresentKHR. Ele os agrupa por nome de processo e calcula as contagens de API de renderização e a distribuição percentual de chamadas de renderização Vulkan versus OpenGL ES:

   WITH raw_slices AS (
     -- 1. Map each slice (API call) to its corresponding process or package via UTID and UPID
     SELECT
       p.name AS process_name,
       s.name AS slice_name
     FROM slice s
     JOIN thread_track tt ON s.track_id = tt.id
     JOIN thread t USING (utid)
     JOIN process p USING (upid)
     WHERE (s.name LIKE 'eglSwapBuffers%'
       OR s.name IN ('QueuePresentKHR', 'vkQueuePresentKHR'))
       -- Optional: To isolate your game, uncomment the following and filter by package name and thread name:
       -- AND p.name = 'com.example.mygame'
       -- AND t.name = 'RenderThread'
   ),
   process_stats AS (
     -- 2. Aggregate counts per individual process
     SELECT
       process_name,
       SUM(CASE WHEN slice_name LIKE 'eglSwapBuffers%' THEN 1 ELSE 0 END) AS egl_count,
       SUM(CASE WHEN slice_name IN ('QueuePresentKHR', 'vkQueuePresentKHR') THEN 1 ELSE 0 END) AS vulkan_count
     FROM raw_slices
     GROUP BY process_name
   ),
   process_totals AS (
     -- 3. Calculate total counts for denominator calculation
     SELECT
       process_name,
       egl_count,
       vulkan_count,
       (egl_count + vulkan_count) AS total_count
     FROM process_stats
   )
   -- 4. Calculate final percentage shares per row, preventing division by zero errors
   SELECT
     process_name,
     egl_count,
     vulkan_count,
     total_count,
     ROUND(CAST(egl_count AS REAL) * 100 / NULLIF(total_count, 0), 2) AS "egl_percentage(%)",
     ROUND(CAST(vulkan_count AS REAL) * 100 / NULLIF(total_count, 0), 2) AS "vulkan_percentage(%)"
   FROM process_totals
   ORDER BY total_count DESC;
   

4. Execute a consulta: clique no botão Executar consulta perto do campo de entrada. Depois que a consulta é executada, uma tabela aparece no painel de resultados mostrando o nome do processo (process_name), a contagem de apresentações do OpenGL ES (egl_count), a contagem de apresentações do Vulkan (vulkan_count), a contagem total de apresentações (total_count) e a porcentagem de cada API usada (egl_percentage(%) e vulkan_percentage(%)).

   

Armadilhas comuns

• Evite confusão com SurfaceFlinger: sempre limite o escopo da pesquisa à linha de execução do aplicativo do jogo (RenderThread). Processos de composição em todo o sistema, como SurfaceFlinger, podem mostrar faixas do Vulkan ou da EGL que representam a renderização da IU do sistema, não o pipeline de renderização interno do jogo. Para isolar seu jogo, remova a marca de comentário dos filtros opcionais na cláusula WHERE da consulta SQL principal e substitua 'com.example.mygame' pelo nome do pacote do jogo:

  -- AND p.name = 'com.example.mygame'
  -- AND t.name = 'RenderThread'
  

• Período de aquecimento: sempre registre o rastro depois que a cena 3D principal do jogo for totalmente carregada. A captura durante telas de apresentação ou transições de carregamento pode resultar em inicializações enganosas.

Requisitos de rastreamento de isenção do LevelUp

Se você estiver usando o Android Performance Analyzer (APA) para capturar um trace e se qualificar para uma isenção do LevelUp do Google Play Games, há requisitos de hardware específicos para que o trace seja válido.

É altamente recomendável que você capture o rastro usando um dos dispositivos de referência do Level Up.

Além disso, para garantir uma validação precisa, o trace não pode ser feito em um dispositivo que use uma GPU ANGLE. Especificamente, não é possível usar os seguintes dispositivos para capturar o rastro de isenção do LevelUp:

• Qualquer dispositivo em que o fornecedor da GPU seja SLSI (Samsung), que usa GPUs AMD Xclipse
• O Pixel 11