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(%)).

    Tela que mostra a consulta SQL executada e as métricas da API Rendering resultantes exibidas em uma tabela

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