Android Performance Samples

This sample project demonstrates how to use the Jetpack Microbenchmark library. It provides several benchmark examples to illustrate different performance measurement scenarios:

• AutoBoxingBenchmark: Measures the cost of allocating Integer() objects.
• BitmapBenchmark: Measures the cost of accessing Bitmap pixels, demonstrating JNI call overhead.
• SortingBenchmarks: Demonstrates working with random data and using runWithTimingDisabled sections to measure different sorting algorithms.
• RecyclerViewBenchmark: A complex UI benchmark measuring the cost of scrolling a RecyclerView.

To run Jetpack Macrobenchmarks on Firebase Test Lab as a post-submit action and track performance regressions, you must configure three integrated components:

1. GitHub Workflow: Responsible for building the application under test and the macrobenchmark APK, then submitting both to Firebase Test Lab.
2. Google Cloud Function: Automatically retrieves benchmark results from Firebase Test Lab and generates custom metrics within Google Cloud Monitoring.
3. Google Cloud Monitoring Dashboards: Used to visualize performance data via custom dashboards and configure alerts for regressions.

This setup allows you to track app performance over time and detect regressions automatically during your CI process.

Starting with Android Gradle Plugin (AGP) 8.0.0, Baseline Profiles can be stored in the src/main/baselineProfiles folder.

This approach allows for:

• Storing multiple profile files in one location.
• Granular updates: You can update or create specific profiles without needing to re-generate the entire Baseline Profile.
• Separate generator classes: You can define separate classes for different user journeys and a separate one for app startup (e.g., using the baselineprofile package).

To produce consistent results, Microbenchmarks require a specific module separation. The project is split into three distinct modules to ensure the benchmark runner does not interfere with the application being measured:

1. :microbenchmark: Contains only the Microbenchmark tests. This module serves as the entrypoint and has no dependencies on other modules to prevent it from being merged into the built application.
2. :benchmarkable: Contains the actual code that is intended to be called and measured by the Microbenchmarks.
3. :app: Contains general application code. Code in this module cannot be called from Microbenchmarks.

Key Rule: Ensure the code you want to benchmark resides in the :benchmarkable module, not the :app module.

For more consistent and stable results, you can lock the CPU clocks of your device. This requires a rooted device and is provided by the androidx.benchmark Gradle plugin.

• To lock clocks: Run ./gradlew lockClocks
• To unlock clocks: Run ./gradlew unlockClocks or simply reboot your device.

You can run the microbenchmarks using Android Studio or the command line.

Using Android Studio

Open the project in Android Studio Arctic Fox 2020.3.1 or later. Run the benchmarks as you would any other test using the keyboard shortcut:

• Windows/Linux: Ctrl-Shift-F10
• macOS: Ctrl-Shift-R

Using Command Line

Execute the following Gradle command to run the connected checks:

./gradlew benchmark:connectedCheck

Use the Firebase CLI to deploy only the functions component of the project. This will upload the backend logic required for the macrobenchmark samples to the cloud.

firebase deploy --only functions

To begin using the Cloud Functions for Macrobenchmarks, you must first set your local Google Cloud CLI configuration to the project ID used by these samples.

Run the following command to set the project context:

gcloud config set project macrobenchmark-samples-6670d

The baseBenchmarks library provides drop-in benchmarks that can be integrated into production applications to start macrobenchmarking quickly.

To use them:

1. Copy and paste the baseBenchmarks library into your project.
2. Adjust the package name to match the package name of the app you are testing.