Eseguire il benchmark dei profili di riferimento con la libreria Macrobenchmark

Ti consigliamo di utilizzare Jetpack Macrobenchmark per testare il rendimento di un'app quando i profili di riferimento sono abilitati e poi confrontare i risultati con un benchmark con i profili di riferimento disattivati. Con questo approccio, puoi misurare l'avvio di app tempo (tempo di attesa per la visualizzazione iniziale e completa) o il rendering in fase di runtime per vedere se i frame prodotti possono causare jank.

I macrobenchmark ti consentono di controllare la compilazione pre-misurazione utilizzando l'API CompilationMode. Utilizza valori di CompilationMode diversi da confrontare con diversi stati di compilazione. Il seguente snippet di codice mostra come utilizzare il parametro CompilationMode per misurare il vantaggio dei profili di riferimento:

@RunWith(AndroidJUnit4ClassRunner::class)
class ColdStartupBenchmark {
    @get:Rule
    val benchmarkRule = MacrobenchmarkRule()

    // No ahead-of-time (AOT) compilation at all. Represents performance of a
    // fresh install on a user's device if you don't enable Baseline Profiles—
    // generally the worst case performance.
    @Test
    fun startupNoCompilation() = startup(CompilationMode.None())

    // Partial pre-compilation with Baseline Profiles. Represents performance of
    // a fresh install on a user's device.
    @Test
    fun startupPartialWithBaselineProfiles() =
        startup(CompilationMode.Partial(baselineProfileMode = BaselineProfileMode.Require))

    // Partial pre-compilation with some just-in-time (JIT) compilation.
    // Represents performance after some app usage.
    @Test
    fun startupPartialCompilation() = startup(
        CompilationMode.Partial(
            baselineProfileMode = BaselineProfileMode.Disable,
            warmupIteration = 3
        )
    )

    // Full pre-compilation. Generally not representative of real user
    // experience, but can yield more stable performance metrics by removing
    // noise from JIT compilation within benchmark runs.
    @Test
    fun startupFullCompilation() = startup(CompilationMode.Full())

    private fun startup(compilationMode: CompilationMode) = benchmarkRule.measureRepeated(
        packageName = "com.example.macrobenchmark.target",
        metrics = listOf(StartupTimingMetric()),
        compilationMode = compilationMode,
        iterations = 10,
        startupMode = StartupMode.COLD,
        setupBlock = {
            pressHome()
        }
    ) {
        // Waits for the first rendered frame, which represents time to initial display.
        startActivityAndWait()

        // Waits for content to be visible, which represents time to fully drawn.
        device.wait(Until.hasObject(By.res("my-content")), 5_000)
    }
}

Attenzione: esegui i benchmark su un dispositivo fisico per misurare le prestazioni reali. La misurazione delle prestazioni su un emulatore Android probabilmente fornisce risultati errati, perché le risorse sono condivise con il computer host.

Nel seguente screenshot puoi vedere i risultati direttamente in Android Studio per l'esempio di app Now in Android eseguita su Google Pixel 7. I risultati mostrano che l'avvio dell'app è più rapido quando si utilizzano i profili di riferimento (229,0 ms) rispetto a quando non viene eseguita la compilazione (324,8 ms).

Figura 1. Risultati di ColdStartupBenchmark che mostrano il tempo di visualizzazione iniziale per nessuna compilazione (324 ms), compilazione completa (315 ms), compilazione parziale (312 ms) e Profili di riferimento (229 ms).

Suggerimento: puoi anche recuperare i risultati come file JSON per analizzarli nell'ambito della pipeline CI. Per ulteriori informazioni, consulta la sezione Benchmarking in CI.

Sebbene l'esempio precedente mostri i risultati di avvio dell'app acquisiti con StartupTimingMetric, esistono altre metriche importanti da prendere in considerazione, come FrameTimingMetric. Per ulteriori informazioni su tutti i tipi di metriche, consulta Acquisire le metriche dei macrobenchmark.

Tempo alla visualizzazione completa

L'esempio precedente misura il tempo di attesa per la prima visualizzazione (TTID), ovvero il tempo impiegato dall'app per produrre il primo frame. Tuttavia, ciò non corrispondono necessariamente al tempo che deve trascorrere prima che l'utente possa iniziare a interagire con l'app. La metrica Tempo alla visualizzazione completa (TTFD) è più utile per misurare e ottimizzando i percorsi di codice necessari per avere uno stato dell'app completamente utilizzabile.

Ti consigliamo di eseguire l'ottimizzazione sia per TTID che per TTFD, in quanto entrambi sono importanti. Un valore TTID basso aiuta l'utente a capire che l'app è effettivamente in esecuzione. È importante mantenere breve il TTFD per garantire che l'utente possa interagire rapidamente con l'app.

Per strategie sui report quando l'interfaccia utente dell'app è completamente tracciata, consulta Migliora la precisione della tempistica di avvio.