Deep Dive into Android Performance: Systrace/Perfetto with Kotlin & XML

In Android development, performance is paramount. Users expect smooth, responsive apps, and even slight hiccups can lead to frustration and abandonment. Diagnosing and optimizing performance, especially in complex apps, requires sophisticated tools and techniques. This is where Systrace and Perfetto come into play. While traditionally used in Java/Kotlin Android development, they can be invaluable for understanding the performance bottlenecks in your entire Android system stack, even when developing XML-based UIs. Let’s explore how to use Systrace and Perfetto for deep performance analysis, particularly relevant when working with Kotlin and XML for Android development.

What are Systrace and Perfetto?

• Systrace: Systrace is a powerful tracing tool developed by Google to analyze the performance of the Android system. It captures kernel-level and user-space events, allowing developers to identify bottlenecks related to CPU usage, disk I/O, graphics rendering, and other system operations. Systrace provides insights into interactions between different components, offering a holistic view of the Android runtime.

• Perfetto: Perfetto is a more recent and advanced open-source tracing and profiling tool for Android, Chrome, and Linux systems. It is designed as a successor to Systrace and offers more comprehensive features, better performance, and enhanced UI capabilities. Perfetto supports both on-device and host-side analysis and allows developers to inspect various aspects of system behavior with great precision.

Why Use Systrace/Perfetto for Performance Analysis?

• Comprehensive Insights: Systrace and Perfetto offer a system-level perspective on application performance. This means you can see how your app interacts with other system services, which is especially helpful when diagnosing issues like UI jank caused by background processes.

• Bottleneck Detection: They provide tools to pinpoint the exact cause of performance problems. Whether it’s CPU contention, excessive garbage collection, or slow disk access, these tools help you quickly identify the culprits.

• Graphical Visualization: Systrace and Perfetto present trace data in an easy-to-understand graphical format. This allows you to visually inspect the timing and duration of events, making it easier to identify patterns and anomalies.

• Historical Analysis: By saving trace data, you can compare performance before and after code changes. This allows you to quantitatively measure the impact of your optimizations.

Setting Up Systrace/Perfetto

Before diving into detailed usage, let’s cover how to set up these tools. There are different methods to run Systrace, choose the approach best suited for your workflow:

1. Using Command Line Systrace (Classic Approach):

• Android SDK: Ensure that you have the Android SDK installed, and the platform-tools directory is added to your system’s PATH variable.

• Connect Device: Connect an Android device (physical or emulator) to your computer via USB. Enable USB debugging in the developer options of the device.

• Systrace Command:

  python $ANDROID_HOME/platform-tools/systrace/systrace.py --time=10 -o trace.html gfx view sched dalvik app

  • $ANDROID_HOME: Your Android SDK path.
  • --time=10: Specifies the duration of the trace in seconds (10 in this case).
  • -o trace.html: Sets the output file to ‘trace.html’.
  • gfx view sched dalvik app: These are trace categories. Commonly used ones include: gfx (graphics), view (UI elements), sched (scheduling), dalvik (Dalvik VM), and app (application specific). Adjust based on areas you want to trace. Use `python $ANDROID_HOME/platform-tools/systrace/systrace.py –list-categories` for the list of categories.

2. Using Android Studio (Integrated Method):

• Android Studio provides a GUI for running Systrace via the CPU Profiler. Open Android Studio.
• Profile or Debug app (Run > Profile ‘app’ OR Run > Debug ‘app’).
• Select CPU Profiler at the bottom. If you’ve been using sampling or tracing, stop profiling.
• In the CPU Profiler, there’s an option labelled “Record Java method traces.” There’s also a dropdown that lets you switch to record system traces. Switch to *System Trace* and select a profile configuration. Default configurations often have what’s needed to get started. Advanced setups benefit from configuring desired CPU events, System Calls, Kernel functions etc, so make those configuration adjustments to match profiling goals..
• Start a recording, interact with the App to generate the execution needing review, and then stop.

3. Perfetto Setup:

• Download Perfetto: While you might find the binaries for Perfetto on your system or the Android SDK directories, the fully self contained version (traceconv static binary for processing etc), are better downloaded from the source site itself for the proper host architecture you intend to process traces on. Head to the Android Open Source Project (AOSP) website to grab a static traceconv binary (https://android.googlesource.com/platform/system/extras/+/master/perfetto/docs/getting-started.md). If needing an SDK integration, there is still work to integrate Perfetto workflows in the newer Android Studio releases. So it can’t quite run seamlessly as you’d do with systrace yet, particularly with automatic dependency downloads etc. Keep up with release notes from Google in future SDK builds!

• ADB Access: Set up ADB correctly and know its directory. As Android requires permissions to record some aspects about traces, it remains the best approach to connect via USB debugging through ADB. The steps and command sequences below also assume that

• Record a trace. Running perfetto on devices that are running Android 9 (API level 28) or higher is the supported usage for capturing trace details and analysis . Android versions before v9, have various API version requirements as well so please consider Android v9 and onwards.

  adb shell perfetto --time 10s --out /data/misc/perfetto-traces/example.perfetto-trace --config trace_config.pbtxt

• Process.

  
  ./traceconv -i /data/misc/perfetto-traces/example.perfetto-trace -o example.pb
  

• Open Perfetto UI: Go to the Perfetto UI in your web browser: https://ui.perfetto.dev. Import the “.pb” to proceed for deep execution context analysis from various apps, including all framework, system and processes activities that occur as Android runs its system functions, or how a device interacts at all aspects. Trace_config.pbtxt lets you determine what trace capabilities, buffers, types and so forth you desire. A proper understanding of that protobuf structure improves the ability to use and gain advanced contextual insights.

Understanding Trace Output and Key Areas to Investigate (Systrace and Perfetto)

• Frames Section (gfx category): Look for rendering times of each frame. High rendering times indicate potential UI jank, slow animations, or other graphics-related issues. A frame taking longer than ~16ms leads to a perceived frame rate of below 60 FPS and a less smooth UI.

• View Section (view category): Understand how much time each view or UI component is consuming, within each phase as your users directly touch on components.

• CPU Usage (sched category): Identify CPU-intensive tasks in your app. Excessive CPU usage leads to high battery consumption and system slowdowns. Check thread states like runnable, sleeping, or waiting.

• Disk I/O: Minimize disk operations because they can be slow and may lead to noticeable lags, such as application pauses when reading resources.

• Wake Locks: Identify parts of the system stack locking certain wake behaviors. This allows determining possible issues in your processes by following locks being held and not appropriately released to drain excessive battery during usage.

• Garbage Collection (GC) and Memory Management: Garbage Collection is a necessity and happens over many types and aspects on the device in the user-level code, plus throughout framework operations, the Dalvik VM itself, kernel operations and so forth! Investigate the frequency and duration of garbage collection events, and how allocation behavior occurs from top down the running code. This analysis ensures effective usage, code structure benefits and to identify issues pertaining to resource holding where garbage collection will be running constantly causing an overhead strain. Frequent garbage collections may lead to poor performance (specifically stutters or UI unresponsiveness), as they halt the main thread.

Systrace/Perfetto and Kotlin/XML in Android Development

Systrace and Perfetto are useful whether using Kotlin or older forms involving using the old Java language alongside XML development.

1. Identifying XML Layout Issues:

   • When profiling Android systems from front to back end including activities in app functions based XML layouts (Activity/Fragments setup). Understanding how certain Android View system is inflated helps pinpoint and minimize inflated issues that cause pauses within applications.
     This involves XML layout parsing, view inflation, and UI composition, so ensure components are optimized properly such as view inflation delays and resource allocation and proper usage in theme settings or component-draw timings on your custom implementations within Android views/XML layouts to ensure smooth and fast performance rates!

2. Coroutines and Asynchronous Operations: Kotlin Coroutines enable concurrency in code by managing long processes into async functions (eg IO, disk loading etc); As it has async execution functions, using tracing assists in the exact determination if something truly running concurrently and as efficiently possible during run-times as asynchronous. A system such as the execution of Android on various services might interfere depending device’s configuration or architecture structure in runtime too! That makes them more useful versus general Profiling Tools like Simpleperf to find bottlenecks within them for application needs from ground up!!
   Ensure threads are used and performing asynchronous functions on system stack efficiently as it can during executions from each operation’s point while following through the different device aspects such like OS configurations settings.

3. Debugging Rendering Performance: Optimizations ensure user interface run smoothly across mobile phone screens by providing better experience across different displays and graphics systems.

   • Tracing through the gfx or other areas is beneficial on how UI draws as they may run with slower and problematic performances from high level all the way down low for issues requiring attention. Some may even run with errors along all kinds devices as some setups configurations settings that would slow it out when its getting processes through these device! It helps finding drawing call delays or delays during graphic component creation because how they are displayed on displays in graphics cards, or certain framework level bugs preventing from them performance-drawing properly!.
4. State changes in memory using Compose? or MutableState? : Understanding overhead from what is often re-computed helps address where various memory, GC or thread-related code areas need tuning that simple benchmarking doesn’t always highlight.

Advanced Techniques

• Custom Events: Add custom events to your trace to track specific events or metrics in your code. This allows you to correlate system events with application-specific actions, e.g., specific actions performed when a view’s layout happens on creation within system services etc, thus provides complete insights when diagnosing the specific performance and resource characteristics you define!

• Automated Analysis: To use automated data processing through continuous profiling you need save each profile taken by Perfecto during usage. Perfecto collects full detail in context from memory bandwidth use allocation activity; Disk input & output reads data usages; It has CPU scheduling thread usages etc. It makes them automated because all these context details helps improving from baseline to better states when done via code!

• Leveraging Compile Flags. Add specific Kotlin Compiler flags such as optimizing cache for types etc, ensures during execution system performance increases significantly through reduced computations since each operation that were recomputing multiple items that might reduce computations costs across your system.

Conclusion

Systrace and Perfetto are vital for Android developers who need to optimize performance and maintain smooth and responsive apps. Systrace in its simplicity still offers insights even XML system operations. As development gets sophisticated including composable designs, transitions from Java / XML UI development for some areas shifts increasingly towards modern solutions to address advanced situations through efficient methods provided especially to tune across older devices; In cases for complex areas involving detailed inspection for bottlenecks, Profiling and usage tracking benefits from system processes analysis through performance. It becomes most optimal to take detailed profiling actions to fully trace stack from ground-up (kernel < — system < — app processes), by deeply observing the system context and operational attributes on-top applications which creates efficient output when tracing systems thoroughly throughout its depths to find ways system configurations effect outputs on each service within run-time operations or service performance across the systems!. Consider incorporating the profiling through CI/CD and integrating tools can also streamline developer efficiency by generating metrics to improve development speed.