android_sdk: Host JVM test runner for PerfettoTraceTest

Companion to tools/run_android_test (which runs the SDK test under ART on
a device or emulator). tools/run_android_sdk_host_test compiles the
upstream perfetto Java SDK against a small set of host-only stubs for the
android.* classes the SDK references, links against the standard
libperfetto_jni.so the gn+ninja pipeline produces, and runs the JUnit
suite under whatever host JVM is on PATH.

Mechanics
---------
* Stubs at src/android_sdk/java/host_stubs/ cover the only Android
  symbols the SDK + test touch: dalvik.annotation.optimization.{Critical,
  Fast}Native (no-op annotations), android.system.SystemCleaner (delegates
  to java.lang.ref.Cleaner), android.util.{ArraySet,Log},
  android.os.Process, and androidx.test.ext.junit.runners.AndroidJUnit4
  (delegates to BlockJUnit4ClassRunner). Same .java sources compile and
  run on both Android and host -- no codegen, no patched SDK file.
* libperfetto_jni's source set gains a conditional include path
  (jdk_include_path, opt-in via tools/gn args) that wires up the host
  JDK's jni.h and a small android/log.h shim under host_shims/. AOSP /
  device builds are untouched because the conditional only fires when
  jdk_include_path is set, which the runner does itself when the user
  invokes it.
* tools/install-build-deps --java-sdk lands JUnit 4, Hamcrest, Truth,
  Guava + failureaccess, protobuf-java 4.31.1 (matches protoc 31.x),
  error_prone_annotations, checker-qual and j2objc-annotations in
  buildtools/java_sdk_host_test/. All SHA256-pinned from Maven Central.
  The flag is opt-in -- a plain tools/install-build-deps doesn't pull
  Java deps, so the standard build is unaffected.
* The runner generates the Java proto codegen for the transitive
  closure of imports starting from the protos PerfettoTraceTest
  references, javac-compiles SDK + stubs + protos to
  out/release/perfetto_sdk_host.jar, compiles the test to
  perfetto_sdk_host_test.jar, and invokes JUnitCore with java.library.path
  + LD_LIBRARY_PATH pointing at out/release.

Why the macro + this runner together
------------------------------------
Running the upstream SDK natives under HotSpot requires the standard
JNIEnv*/jclass prefix on the C side; PERFETTO_JNI_HOST_PARAMS handles
that. This change adds the surrounding glue (host stubs + native build
wiring + JUnit driver) so contributors can iterate on the Java SDK on
their dev machine without a connected device or emulator. C++ tests and
benchmarks (perfetto_unittests / perfetto_benchmarks) already run on
host; this closes the same loop for the Java side.

Usage
-----
  tools/install-build-deps
  tools/install-build-deps --java-sdk
  tools/run_android_sdk_host_test
  # -> "OK (20 tests)" on HotSpot 21

Verification
------------
PerfettoTraceTest -> 20/20 PASS on host OpenJDK 21 (3.08s).
AOSP / device build path unaffected: jdk_include_path defaults to "" so
the new include_dirs and cflags blocks in libperfetto_jni_src are inert
unless the runner is in use.

Change-Id: If4b9451acc9d3381a597ef9661f245e7bcdb342b
11 files changed
tree: 4bb9f873fda938c5c48b46c90c13ba56966eab04
  1. .github/
  2. ai/
  3. bazel/
  4. build_overrides/
  5. buildtools/
  6. contrib/
  7. docs/
  8. examples/
  9. gn/
  10. include/
  11. infra/
  12. protos/
  13. python/
  14. sdk/
  15. src/
  16. test/
  17. third_party/
  18. tools/
  19. ui/
  20. .bazelignore
  21. .bazelrc
  22. .bazelversion
  23. .clang-format
  24. .clang-tidy
  25. .git-blame-ignore-revs
  26. .gitallowed
  27. .gitattributes
  28. .gitignore
  29. .gn
  30. .style.yapf
  31. Android.bp
  32. Android.bp.extras
  33. BUILD
  34. BUILD.extras
  35. BUILD.gn
  36. CHANGELOG
  37. CONTRIBUTORS.txt
  38. DIR_METADATA
  39. heapprofd.rc
  40. LICENSE
  41. meson.build
  42. METADATA
  43. MODULE.bazel
  44. MODULE.bazel.lock
  45. MODULE_LICENSE_APACHE2
  46. OWNERS
  47. OWNERS.github
  48. perfetto.rc
  49. perfetto_flags.aconfig
  50. PerfettoIntegrationTests.xml
  51. persistent_cfg.pbtxt
  52. README.chromium
  53. README.md
  54. TEST_MAPPING
  55. traced_perf.rc
  56. WORKSPACE
README.md

Perfetto - System profiling, app tracing and trace analysis

Perfetto is an open-source suite of SDKs, daemons and tools which use tracing to help developers understand the behaviour of complex systems and root-cause functional and performance issues on client and embedded systems.

It is a production-grade tool that is the default tracing system for the Android operating system and the Chromium browser.

Core Components

Perfetto is not a single tool, but a collection of components that work together:

  • High-performance tracing daemons: For capturing tracing information from many processes on a single machine into a unified trace file.
  • Low-overhead tracing SDK: A C++17 library for direct userspace-to-userspace tracing of timings and state changes in your application.
  • Extensive OS-level probes: For capturing system-wide context on Android and Linux (e.g. scheduling states, CPU frequencies, memory profiling, callstack sampling).
  • Browser-based UI: A powerful, fully local UI for visualizing and exploring large, multi-GB traces on a timeline. It works in all major browsers, requires no installation, and can open traces from other tools.
  • SQL-based analysis library: A powerful engine that allows you to programmatically query traces using SQL to automate analysis and extract custom metrics.

Why Use Perfetto?

Perfetto was designed to be a versatile and powerful tracing system for a wide range of use cases.

  • For Android App & Platform Developers: Debug and root-cause functional and performance issues like slow startups, dropped frames (jank), animation glitches, low memory kills, and ANRs. Profile both Java/Kotlin and native C++ memory usage with heap dumps and profiles.
  • For C/C++ Developers (Linux, macOS, Windows): Use the Tracing SDK to instrument your application with custom trace points to understand its execution flow, find performance bottlenecks, and debug complex behavior. On Linux, you can also perform detailed CPU and native heap profiling.
  • For Linux Kernel & System Developers: Get deep insights into kernel behavior. Perfetto acts as an efficient userspace daemon for ftrace, allowing you to visualize scheduling, syscalls, interrupts, and custom kernel tracepoints on a timeline.
  • For Chromium Developers: Perfetto is the tracing backend for chrome://tracing. Use it to debug and root-cause issues in the browser, V8, and Blink.
  • For Performance Engineers & SREs: Analyze and visualize a wide range of profiling and tracing formats, not just Perfetto's. Use the powerful SQL interface to programmatically analyze traces from tools like Linux perf, macOS Instruments, Chrome JSON traces, and more.

Getting Started

We‘ve designed our documentation to guide you to the right information as quickly as possible, whether you’re a newcomer to performance analysis or an experienced developer.

  1. New to tracing? If you're unfamiliar with concepts like tracing and profiling, start here:

  2. Ready to dive in? Our “Getting Started” guide is the main entry point for all users. It will help you find the right tutorials and documentation for your specific needs:

  3. Want the full overview? For a comprehensive look at what Perfetto is, why it's useful, and who uses it, see our main documentation page:

Debian Distribution

For users interested in the Debian distribution of Perfetto, the official source of truth and packaging efforts are maintained at Debian Perfetto Salsa Repository

Community & Support

Have questions? Need help?

We follow Google's Open Source Community Guidelines.