Vulkan- oder OpenGL ES-API für das Rendern von Spielen ermitteln

Bei der Entwicklung oder Optimierung von Android-Spielen kann es oft hilfreich sein, zu wissen, welche Grafikpipeline Ihre Engine verwendet. Engines können Vulkan oder GLES ohne eindeutige, für Entwickler zugängliche Signale auswählen. Leider gibt es Situationen, in denen es unzuverlässig sein kann, sich auf logcat zu verlassen, um zu prüfen, ob ein Spiel auf Vulkan läuft oder im Hintergrund auf OpenGL ES zurückgegriffen wurde.

In diesem Leitfaden erfahren Sie, wie Sie den Android Performance Analyzer (APA) und benutzerdefinierte Perfetto-SQL-Abfragen verwenden, um die aktive Rendering-API eines Spiels eindeutig zu identifizieren.

Einschränkungen der logbasierten Überprüfung

  • Bereinigte Logs: In Produktions-Builds werden oft Initialisierungs- und Treiberlade-Footprints ausgeblendet.
  • Falsch positive Ergebnisse: Einige Spiel-Engines laden beim Start sowohl Vulkan- als auch OpenGL ES-Bibliotheken und geben Initialisierungsprotokolle für beide aus, auch wenn eine der beiden schließlich fehlschlägt und ein Fallback auslöst.
  • Stille Fallbacks: Wenn die Vulkan-Initialisierung aufgrund gerätespezifischer Treiberprobleme fehlschlägt, greifen Engines häufig auf OpenGL ES zurück, ohne kritische Fehler auszugeben.

Mit APA messen

Mit dem Android Performance Analyzer kannst du einen System-Trace aufzeichnen und Frame-Daten mithilfe von SQL-Abfragen genau analysieren. So messen Sie die Nutzung von Vulkan und GLES:

  1. Trace mit APA erfassen: Führe dein Spiel aus und verwende APA, um einen System-Trace während des Segments zu erfassen, das du analysieren möchtest, z. B. an einem Punkt im Gameplay, an dem du Frame-Drops vermutest. Nachdem das Gerät verbunden und die Trace-Aufzeichnung abgeschlossen ist, werden die Trace-Daten in der APA-Oberfläche geladen.

  2. Klicken Sie in APA auf den Tab „SQL“: Wenn der Bildschirm für die Trace-Analyse geöffnet ist, klicken Sie im Navigationsmenü der Benutzeroberfläche auf den Tab SQL, um die Trace-Prozessor-Umgebung zu öffnen, in der Sie die Daten direkt abfragen können.

  3. Fügen Sie die folgende SQL-Abfrage in den APA-SQL-Tab ein: Kopieren Sie die folgende SQL-Abfrage und fügen Sie sie in das Eingabefeld ein. Mit dieser Abfrage wird der Trace nach Zeichen-API-Ereignissen wie eglSwapBuffers, QueuePresentKHR und vkQueuePresentKHR durchsucht. Sie werden nach Prozessnamen gruppiert und die Anzahl der Rendering-APIs sowie die prozentuale Verteilung der Vulkan- und OpenGL ES-Rendering-Aufrufe werden berechnet:

    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. Abfrage ausführen: Klicken Sie neben dem Eingabefeld auf den Button Abfrage ausführen. Nachdem die Abfrage ausgeführt wurde, wird im Ergebnisbereich eine Tabelle mit dem Prozessnamen (process_name), der Anzahl der OpenGL ES-Präsentationen (egl_count), der Anzahl der Vulkan-Präsentationen (vulkan_count), der Gesamtzahl der Präsentationen (total_count) und dem Prozentsatz der jeweils verwendeten API (egl_percentage(%) und vulkan_percentage(%)) angezeigt.

    Bildschirm mit der ausgeführten SQL-Abfrage und den resultierenden Rendering API-Messwerten in einer Tabelle

Häufige Schwierigkeiten

  • SurfaceFlinger-Verwechslungen vermeiden: Beschränke deine Suche immer auf den Anwendungsthread deines Spiels (RenderThread). Systemweite Compositor-Prozesse wie SurfaceFlinger können Vulkan- oder EGL-Tracks anzeigen, die das Rendering der System-UI darstellen, nicht die interne Rendering-Pipeline deines Spiels. Wenn Sie Ihr Spiel isolieren möchten, entfernen Sie die Kommentarzeichen für die optionalen Filter in der WHERE-Klausel der SQL-Hauptabfrage und ersetzen Sie 'com.example.mygame' durch den Paketnamen Ihres Spiels:

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

  • Aufwärmphase: Zeichne den Trace immer nachdem die Haupt-3D-Szene des Spiels vollständig geladen wurde auf. Das Erfassen während Splash Screens oder Ladeübergängen kann zu irreführenden Initialisierungen führen.

Anforderungen an die Trace-ID für LevelUp-Ausnahmen

Wenn du den Android Performance Analyzer (APA) verwendest, um einen Trace zu erfassen, der für eine Ausnahme im Rahmen des Google Play Games LevelUp-Programms erforderlich ist, gelten bestimmte Hardwareanforderungen, damit der Trace gültig ist.

Es wird dringend empfohlen, den Trace mit einem der Level Up-Referenzgeräte zu erfassen.

Außerdem darf der Trace nicht auf einem Gerät mit einer ANGLE-GPU erstellt werden, um eine genaue Validierung zu ermöglichen. Insbesondere können Sie die folgenden Geräte nicht verwenden, um den Trace für die LevelUp-Ausnahme aufzuzeichnen:

  • Alle Geräte, bei denen der GPU-Anbieter SLSI (Samsung) ist, der AMD Xclipse-GPUs verwendet
  • Das Pixel 11