Frequenza fotogrammi

FPS medio

Una frequenza fotogrammi fluida e stabile è fondamentale per offrire un'esperienza di gioco di alta qualità sui dispositivi Android. Quando misuri il rendimento del gioco, devi misurare gli FPS medi come riferimento per avere una comprensione di base dell'esperienza. Per garantire un'esperienza di gioco ottimale, devi ottimizzare il tuo gioco in modo che raggiunga una frequenza fotogrammi media di 60 FPS.

FPS P90 e P99 per la stabilità

Con una media fluida di 60 FPS, un gioco può comunque subire interruzioni intermittenti, micro-scatti e ritardi di input imprevedibili, con conseguente esperienza di gioco scadente.

Pertanto, la stabilità dei fotogrammi è importante quanto il monitoraggio della frequenza fotogrammi media. È qui che devi misurare le metriche della frequenza fotogrammi P90 e P99 come rispettivamente baseline coerente e indicatore di scatti. Queste metriche acquisiscono la "coda" del rendimento per consentirti di ottimizzare la fluidità dell'esperienza del giocatore.

Metriche

  • FPS medio (baseline): questa metrica fondamentale fornisce una baseline generale delle prestazioni del tuo gioco. Sebbene sia un benchmark standard, il calcolo della media significa che non è possibile rilevare cali di frame intermittenti e micro-scatti, il che lo rende insufficiente a rappresentare l'esperienza del giocatore da solo.
  • FPS P90 (baseline coerente al percentile 10%): indica che il 90% dei fotogrammi ha superato questa baseline coerente e solo il 10% più lento dei fotogrammi ha impiegato più tempo per il rendering. Se la frequenza fotogrammi P90 è elevata e vicina alla media, il gioco funziona in modo coerente per la stragrande maggioranza della sessione.
  • FPS P99 (indicatore di stuttering al percentile 1%): indica che il 99% dei frame ha superato questo indicatore di stuttering, isolando in modo specifico l'1% più lento dei frame. Questa metrica è essenziale per rilevare micro-stuttering, ritardi nel caricamento degli asset e picchi improvvisi di rendering con molti asset che causano interruzioni visibili.

Esempi

Confrontando gli FPS medi con le metriche P90 e P99, puoi diagnosticare con precisione il comportamento sottostante di un gioco.

Scenario 1: una curva ottimale (gioco ottimizzato)

  • Media: 60 FPS (16,6 ms)
  • P90: 58 FPS (17,2 ms)
  • P99: 52 FPS (19,2 ms)
  • Analisi: le metriche sono strettamente raggruppate. Il gioco è incredibilmente fluido e uniforme. Non ci sono micro-scatti e anche l'1% peggiore dei fotogrammi è appena percettibile all'occhio umano.

Scenario 2: collo di bottiglia del carico (vincolato a CPU/GPU)

  • Media: 45 FPS (22,2 ms)
  • P90: 40 FPS (25 ms)
  • P99: 38 FPS (26,3 ms)
  • Analisi: la frequenza fotogrammi media è inferiore, ma in modo costante. Il P99 non diminuisce drasticamente rispetto alla media. Ciò indica che il sistema è essenzialmente sovraccarico a causa delle impostazioni grafiche o dei vincoli di risoluzione. Il gioco non sembrerà balbettare, ma piuttosto lento. La riduzione delle impostazioni grafiche in genere aumenta in modo uniforme queste metriche.

Scenario 3: 60 FPS instabili (compilazione degli shader / streaming degli asset con interruzioni)

  • Media: 60 FPS (16,6 ms)
  • P90: 45 FPS (22,2 ms)
  • P99: 15 FPS (66,6 ms)
  • Analisi: questo è lo scenario peggiore. Sebbene la frequenza dei fotogrammi media sembra eccellente, il P99 rivela un problema critico. P99 a 66,6 ms significa che il gioco si blocca completamente per più frame alla volta. Questo indica valori anomali gravi, di solito causati da colli di bottiglia della CPU, ritardi nello streaming delle risorse (ad esempio RAM o spazio di archiviazione lenti) o problemi causati dalla compilazione degli shader.

Misurazione

Per misurare in modo efficace FPS medio, P90 e P99, puoi utilizzare i seguenti due metodi. Il primo metodo consiste nell'analizzare le tracce di sistema utilizzando Android Performance Analyzer (APA), uno strumento di profilazione delle prestazioni. Il secondo metodo consiste nell'utilizzare il comando adb dumpsys SurfaceFlinger --timestats esistente.

1. Misurare utilizzando l'APA

Utilizzando l'API, puoi registrare una traccia di sistema e analizzare con precisione i dati dei frame tramite query SQL. Segui questi passaggi per misurare le metriche:

  1. Acquisire la traccia con APA: esegui il gioco e utilizza APA per acquisire una traccia di sistema durante il segmento che vuoi analizzare (ad esempio, un punto durante il gameplay in cui sospetti cali di frame). Una volta connesso il dispositivo e completata la registrazione della traccia, i dati della traccia verranno caricati nell'interfaccia APA.

    Schermata di acquisizione della traccia o schermata della traccia caricata

  2. Fai clic sulla scheda SQL in APA: una volta aperta la schermata di analisi delle tracce, fai clic sulla scheda SQL nell'area di navigazione superiore o laterale dell'interfaccia utente per aprire l'ambiente del processore di tracce, dove puoi eseguire query sui dati direttamente.

  3. Incolla la query SQL nella scheda SQL APA: copia la seguente query SQL e incollala nel campo di immissione della query. Questa query identifica il processo SurfaceFlinger, calcola gli intervalli di frame in base ai timestamp di aggiornamento del display effettivi e deriva la media di FPS, il 10% inferiore (P90) di FPS e l'1% inferiore (P99) di FPS.

    WITH target_process AS (
-- 1. Get SurfaceFlinger process ID where frames were identified in debugging step 3
SELECT upid
FROM process
WHERE name = '/system/bin/surfaceflinger'
),
actual_present_times AS (
-- 2. Calculate the hardware display timestamps when SurfaceFlinger actually updated the screen
SELECT
    (ts + dur) AS present_ts
FROM actual_frame_timeline_slice
WHERE upid IN (SELECT upid FROM target_process)
    AND dur > 0
),
present_intervals AS (
-- 3. Calculate intervals between physical screen refreshes
SELECT
    (LEAD(present_ts) OVER (ORDER BY present_ts ASC) - present_ts) / 1000000.0 AS p2p_ms
FROM actual_present_times
),
valid_intervals AS (
-- 4. Filter for valid frame intervals
SELECT p2p_ms
FROM present_intervals
WHERE p2p_ms IS NOT NULL AND p2p_ms > 0
),
ordered_frames AS (
-- 5. Sort in ascending order to calculate percentiles
SELECT
    p2p_ms,
    ROW_NUMBER() OVER (ORDER BY p2p_ms ASC) AS row_num,
    COUNT(1) OVER () AS total_frames
FROM valid_intervals
)
-- 6. Output final metrics
SELECT
(SELECT COUNT(1) FROM valid_intervals) AS total_presented_frames,
ROUND(1000.0 / NULLIF((SELECT AVG(p2p_ms) FROM valid_intervals), 0), 2) AS average_fps,
ROUND(1000.0 / NULLIF((SELECT p2p_ms FROM ordered_frames WHERE row_num = CAST(total_frames * 0.90 AS INT)), 0), 2) AS low_10_fps,
ROUND(1000.0 / NULLIF((SELECT p2p_ms FROM ordered_frames WHERE row_num = CAST(total_frames * 0.99 AS INT)), 0), 2) AS low_1_fps;

  4. Fai clic su "Esegui query": fai clic sul pulsante Esegui query (o sull'icona di esecuzione) vicino al campo di immissione della query. Una volta completata l'esecuzione della query, i frame totali misurati (total_presented_frames), la frequenza fotogrammi media (average_fps), la frequenza fotogrammi inferiore al 10% (low_10_fps) e la frequenza fotogrammi inferiore all'1% (low_1_fps) verranno visualizzati in una tabella nel riquadro dei risultati.

    Schermata che mostra la query SQL eseguita e le quattro metriche risultanti visualizzate in una tabella

2. Misurare utilizzando adb (dumpsys SurfaceFlinger)

Per misurare in modo efficace FPS medio, P90 e P99, puoi utilizzare il comando timestats dumpsys surfaceflinger di Android. Questo strumento fornisce l'FPS medio e un istogramma di temporizzazione presentToPresent per tutti i livelli in fase di rendering. Il tempo presentToPresent di un frame è l'intervallo tra il frame corrente e il frame precedente in fase di disegno.

Ecco le istruzioni passo passo per raccogliere e calcolare queste metriche per il tuo gioco:

  1. Avvia la registrazione: esegui questo comando con i flag enable e clear per avviare l'acquisizione delle informazioni:

    adb shell dumpsys SurfaceFlinger --timestats -clear -enable

  2. Informazioni sul dump: quando il gioco è stato giocato abbastanza a lungo, esegui di nuovo il comando con il flag di dump per visualizzare le informazioni:

    adb shell dumpsys SurfaceFlinger --timestats -dump

  3. Filtra per livello: le informazioni dumpate forniscono dati per tutti i livelli visualizzati da SurfaceFlinger. Devi trovare la sezione corrispondente al tuo gioco filtrando in base a layerName (ad esempio, layerName = SurfaceView[com.example.yourgame...]).

    layerName = SurfaceView[com.google.test/com.devrel.MainActivity]@0(BLAST)#132833

  4. Identifica la media di FPS: la media di FPS per ogni livello viene calcolata automaticamente e viene mostrata direttamente nell'output del dump (ad esempio, averageFPS = 30.179).

    ...
averageFPS = 30.179
...

  5. Calcola FPS P90 e P99: per trovare le metriche P90 e P99, devi analizzare totalFrames e l'istogramma di temporizzazione presentToPresent fornito nel dump.

    totalFrames = 1000
...
presentToPresent histogram is as below:
0ms=0 1ms=0 2ms=0 3ms=0 4ms=0 5ms=0 6ms=0 7ms=0 8ms=0 9ms=0 10ms=0 11ms=0 12ms=0
13ms=0 14ms=0 15ms=0 16ms=850 17ms=0 18ms=0 19ms=0 20ms=0 21ms=0 22ms=0 23ms=0
24ms=0 25ms=0 26ms=0 27ms=0 28ms=0 29ms=0 30ms=0 31ms=0 32ms=0 33ms=100 34ms=0
36ms=0 38ms=0 40ms=0 42ms=0 44ms=0 46ms=0 48ms=0 50ms=35 54ms=0 58ms=0 62ms=0
66ms=10 70ms=0 74ms=0 78ms=0 82ms=0 86ms=0 90ms=0 94ms=0 98ms=0 102ms=5 106ms=0
110ms=0 114ms=0 118ms=0 122ms=0 126ms=0 130ms=0 134ms=0 138ms=0 142ms=0 146ms=0
150ms=0 200ms=0 250ms=0 300ms=0 350ms=0 400ms=0 450ms=0 500ms=0 550ms=0 600ms=0
650ms=0 700ms=0 750ms=0 800ms=0 850ms=0 900ms=0 950ms=0 1000ms=0

    A. Esempio concettuale (tabella di distribuzione cumulativa) Supponiamo che la sessione di gioco abbia registrato un conteggio totalFrames pari a 1000. Per trovare P90 e P99, calcola le soglie in millisecondi in cui il conteggio cumulativo dei frame raggiunge rispettivamente 900 frame (90%) e 990 frame (99%), contando a partire dal bucket in millisecondi più basso.

    Durata frame (ms) Conteggio frame (istogramma) Conteggio frame cumulativo Stato / calcolo del percentile
    16ms 850 850 85,0%
    33ms 100 950 95,0%
    (P90 Target of 900 Reached! → 1000/33 = 30.3 FPS)
    50ms 35 985 98,5%
    66ms 10 995 99,5%
    (P99 Target of 990 Reached! → 1000/66 = 15,1 FPS)
    102ms 5 1000 100%

    B. Logica di implementazione (pseudocodice) Se automatizzi questa analisi utilizzando uno script Python o un parser dei log, la logica per estrarre i valori P90 e P99 dall'istogramma può essere implementata nel seguente modo:

    # Define target thresholds based on total frame count
p90_target = totalFrames * 0.90
p99_target = totalFrames * 0.99

cumulative_frames = 0
p90_fps = None
p99_fps = None

# Iterate through the parsed SurfaceFlinger histogram data (sorted by millisecond)
for ms_bucket, frame_count in present_to_present_histogram:
    cumulative_frames += frame_count

    # Capture P90 when cumulative frames cross the 90% threshold
    if p90_fps is None and cumulative_frames >= p90_target:
        p90_fps = 1000 / ms_bucket

    # Capture P99 when cumulative frames cross the 99% threshold
    if p99_fps is None and cumulative_frames >= p99_target:
        p99_fps = 1000 / ms_bucket
        break # Optimization: stop iterating once both targets are found

  6. Interrompi acquisizione: dopo aver raccolto tutte le informazioni necessarie, devi disattivare le statistiche temporali utilizzando il flag di disattivazione:

    adb shell dumpsys SurfaceFlinger --timestats -disable

Sessioni lente

Sessioni lente identifica problemi di rendimento diffusi nel mondo reale. Una sessione è "lenta" se oltre il 25% dei frame scende al di sotto di una soglia (ad esempio, 20 FPS). Sebbene sia utile per individuare problemi di build critici, questa metrica da sola non può garantire un'esperienza sostenibile e di alta qualità. Un gioco potrebbe evitare la soglia di sessione lenta, ma comunque soffrire di micro-scatti che compromettono un'esperienza fluida a 60 FPS.

Sebbene entrambi derivino dai tempi dei frame, "Sessione lenta" e "Frequenza fotogrammi" svolgono ruoli diversi. Le metriche FPS medio, P90 e P99 misurano la qualità e la sostenibilità delle prestazioni, rilevando cali istantanei e andamento incoerente che la metrica Sessione lenta potrebbe trascurare.

Conclusione

L'ottimizzazione delle prestazioni richiede una strategia completa. Gli sviluppatori devono utilizzare le sessioni lente come radar principale per rilevare gravi degradazioni delle prestazioni, quindi esaminare FPS medio, P90 e P99 per diagnosticare le cause sottostanti e verificare l'effettiva fluidità del gameplay. Integrando queste metriche, puoi assicurarti che la tua applicazione offra un'esperienza utente costantemente sostenibile ed eccezionale.

Risorse aggiuntive

Per scoprire di più sulle tecniche di profilazione avanzate, sull'implementazione dell'API Frame Pacing e sulle strategie di ottimizzazione specifiche per il motore, consulta la documentazione ufficiale per gli sviluppatori Android: