Classes from Google apps Half 3

• Resident Set Dimension (RSS): The variety of shared and non-shared pages utilized by the app
• Proportional Set Dimension (PSS): The variety of non-shared pages utilized by the app and an excellent distribution of the shared pages (for instance, if three processes are sharing 3MB, every course of will get 1MB in PSS)
• Be aware: Non-public Set Dimension (PSS) = Non-public reminiscence + (shared reminiscence / the variety of processes sharing).
• Distinctive Set Dimension (USS): The variety of non-shared pages utilized by the app (shared pages will not be included)

PSS is helpful for the working system when it needs to understand how a lot reminiscence is utilized by all processes since pages don’t get counted a number of occasions. PSS takes a very long time to calculate as a result of the system wants to find out which pages are shared and by what number of processes. RSS does not distinguish between shared and non-shared pages (making it sooner to calculate) and is best for monitoring adjustments in reminiscence allocation.

So, which methodology must you select? The selection is determined by the utilization of shared reminiscence.

For instance, if the shared reminiscence is being utilized by the appliance solely then we should always use the RSS method. Whereas, if the shared reminiscence is taken by the Google Play Providers then we should always use the USS method. For extra understanding, please learn right here. 

2.    Take a heap dump and analyze how a lot reminiscence is utilized by the operating processes. Comply with

adb logcat | grep hprof

adb pull <output-file-name> 

This may pull the generated file to your machine for evaluation.

To get data on native heap, learn right here :

To find out about Java heap, learn right here :

3.    Perceive low-memory killer

In Android, we have now a course of referred to as low reminiscence killer, and this can decide a course of from the system and can kill that course of when the system is underneath low RAM, the thresholds may be tuned by OEMs. By doing so, you’ll get again all of the reminiscence that the method was utilizing.
However what if the low reminiscence killer kills the method that the person cares about?

 

In Android, we have now a precedence listing of functions and based mostly on that precedence listing we take away the app when the low reminiscence killer comes into play. Learn extra right here.

You may run this command and know :

adb shell dumpsys exercise oom

To test stats on low reminiscence killer :

adb shell dumpsys exercise lmk

 

Instruments 

 1.    Debug Reminiscence utilization utilizing Perfetto

That is one the perfect instruments to search out the place all of your app reminiscence is consumed. Use Perfetto to get details about reminiscence administration occasions from the kernel. Deep dive and perceive the way to profile native and Java heap right here. 

 

2.    Examine your reminiscence utilization utilizing Reminiscence Profiler

The Reminiscence Profiler is a part within the Android Profiler that helps you establish reminiscence leaks and reminiscence churn that may result in stutter, freezes, and even app crashes. It reveals an actual time graph of your app’s reminiscence use and allows you to seize a heap dump, power rubbish collections, and observe reminiscence allocations. To study extra about inspecting efficiency, please test MAD expertise movies right here. 

 

3.    Make the most of meminfo

You might need to observe how your app’s reminiscence is split between various kinds of RAM allocation with the next adb command: 

adb shell dumpsys meminfo <package_name|pid> [-d]

You may view the next seven reminiscence classes with Meminfo:

• Java heap – reminiscence allotted by Java code
• Native heap – reminiscence allotted by native code. These are finest understood utilizing debug malloc. Allocations made by the appliance from C or C++ code utilizing malloc or new.
• Code – reminiscence used for Java, native code and a few assets, together with dex bytecode, shared libraries and fonts
• Stack – reminiscence used for each native and Java stacks. This often has to do with what number of threads your utility is operating.
• Graphics – Reminiscence used for graphics buffer queues to show pixels to the display screen, GL surfaces and textures and such.
• Non-public Different – uncategorized personal reminiscence
• System – reminiscence shared with the system or in any other case underneath the management of the system.

• Non-public – Reminiscence used solely by the method.
• Shared – System reminiscence shared with different processes.
• Clear – Reminiscence-mapped pages that may be reclaimed when underneath reminiscence strain.
• Soiled – Reminiscence-mapped web page modified by a course of. These pages could also be written to file/swap after which reclaimed when underneath reminiscence strain.

• Debug class is tremendous helpful and supplies completely different strategies for Android functions, together with tracing and allocation counts. You may examine utilization right here.
• For deeper understanding and monitoring allocations for every web page, examine web page proprietor right here.

4.    Detailed evaluation utilizing showmap

The showmap command supplies a way more detailed breakdown of reminiscence than pleasant meminfo. It lists the title and sizes of reminiscence maps utilized by a course of. This can be a abstract of the data obtainable at /proc/<pid>/smaps, which is the first supply of knowledge utilized in dumpsys meminfo, apart from some graphics reminiscence.

$adb root
$ adb shell pgrep <course of>
Output – course of id
$ adb shell showmap <course of id>

 

Pattern Output : 

Malloc debug is a technique of debugging native reminiscence issues. It might assist detect reminiscence corruption, reminiscence leaks, and use after free points. You may test this documentation for extra understanding and utilization.  

Starting with Android 27, Android NDK helps Tackle Sanitizer which is a quick compiler-based software for detecting reminiscence bugs in native code. ASan detects:

ASan runs on each 32-bit and 64-bit ARM, plus x86 and x86-64. ASan’s CPU overhead is roughly 2x, code dimension overhead is between 50% and 2x, and the reminiscence overhead is massive (dependent in your allocation patterns, however on the order of 2x). To study extra, learn right here.

Digicam from the Google group used it and automatic the method that will run and get again to them within the type of alerts in case of Asan points, and located it actually handy to repair reminiscence points missed throughout code authoring/evaluation.

After you have an entire app startup hint, take a look at the hint and measure time taken for main operations like bindApplication, activitystart and so on.

Have a look at total time spent to

• Establish all time consuming operations.
• Establish any operations which aren’t presupposed to be executed throughout startup (Ideally there are a whole lot of legacy code operations which we’re not aware of and never simply seen when taking a look at our app code for efficiency)
• Establish which all operations are completely wanted OR could possibly be delayed till your first body is drawn.

3.    Examine Dwelling exercise load time

That is your app’s house web page and infrequently efficiency will rely on the loading of this web page. For many apps, there may be a whole lot of knowledge displayed on this web page, spanning a number of layouts and processes operating in background. Examine the house exercise format and particularly take a look at the Choreographer.onDraw methodology of the house exercise.

• Measure time taken for total operations of measure, draw,inflate,animate and so on.
• Have a look at body drops.
• Establish layouts taking excessive time to render or measure.
• Establish belongings taking a very long time to load.
• Establish layouts not wanted however nonetheless getting inflated.

Instruments 

 1.    Perfetto

• To know CPU utilization, thread exercise, body rendering time, Perfetto would be the finest software.
• File hint both through the use of command line or UI instruments like Perfetto. Add app package deal title with the -a tag, to filter knowledge in your app. Some methods to seize hint :
• Produces a report combining knowledge from the Android kernel, such because the CPU scheduler, disk exercise, and app threads.
• Finest when enabled with customized tracing to know which methodology or a part of code is taking how lengthy after which develop can dig deep accordingly.
• Perceive Atrace, and ftrace whereas analyzing traces by Perfetto.

2.    App Startup library

The App Startup library supplies an easy, performant approach to initialize parts at utility startup. Each library builders and app builders can use App Startup to streamline startup sequences and explicitly set the order of initialization. As an alternative of defining separate content material suppliers for every part it’s essential initialize, App Startup permits you to outline part initializers that share a single content material supplier. This may considerably enhance app startup time. To search out the way to use it in your app, refer right here. 

 

3.    Baseline Profiles

Baseline Profiles are an inventory of lessons and strategies included in an APK utilized by Android Runtime (ART) throughout set up to pre-compile vital paths to machine code. This can be a type of profile guided optimization (PGO) that lets apps optimize startup, cut back jank, and enhance efficiency for finish customers. Profile guidelines are compiled right into a binary kind within the APK, in belongings/dexopt/baseline.prof.

Throughout set up, ART performs Forward-of-time (AOT) compilation of strategies within the profile, leading to these strategies executing sooner. If the profile comprises strategies utilized in app launch or throughout body rendering, the person experiences sooner launch occasions and/or decreased jank. For extra info on utilization and benefits, refer right here.  

4.    Android CPU Profiler

You should utilize the CPU Profiler to examine your app’s CPU utilization and thread exercise in actual time whereas interacting together with your app, or you’ll be able to examine the main points in recorded methodology traces, operate traces, and system traces. The detailed info that the CPU Profiler information and reveals is set by which recording configuration you select:

• System Hint: Captures fine-grained particulars that can help you examine how your app interacts with system assets.
• Methodology and performance traces: For every thread in your app course of, you’ll find out which strategies (Java) or capabilities (C/C++) are executed over a interval, and the CPU assets every methodology or operate consumes throughout its execution.

5.    Debug API + CPU Profiler

To present apps the power to begin and cease recording CPU profiling after which examine in CPU profiler is what Debug API is all about. It supplies details about tracing and allocation counts the identical approach utilizing startMethodTracing() and stopMethodTracing().

 

Debug.startMethodTracing(“pattern”) – Begins recording a hint log with the title you present  Debug.stopMethodTracing() – he system begins buffering the generated hint knowledge, till the  utility calls this methodology.

• Debug API is designed for brief intervals or situations which are exhausting to begin/cease recording manually. (Used it as soon as to search out the lock rivalry occurring as a consequence of some library)

• To generate a technique hint of an app’s execution, we will instrument the app utilizing the Debug class. This fashion builders get extra management over precisely when the system begins and stops recording tracing info.

6.    MacroBenchmark

• Measures Scrolling / Animation rendering time.
• Use a UiAutomator to set off a scroll or animation. (It captures body timing / janks for regardless of the app is doing. Scroll and animations are simply the best methods to supply frames the place jank is noticeable)
• Requires Android 10 or increased to run the checks.
• Can view traces on Systrace/Perfetto Traces.
• FrameTimingMetric is the API reporting body time in ms.

This pattern can be utilized for app instrumentation. 

 

• Added in API stage 30 and supported within the newest Studio Bumblebee preview (2021.1)
• Makes use of simpleperf with custom-made construct scripts for profiling.
• Simpleperf helps profiling java code on Android >M.
• Profiling a launch construct requires one in every of following:
• System to be rooted
• Android >=O, use a script wrap.sh and make android::debuggable=“true” to allow profiling.
• Android >=Q, add profileable in manifest flag.

<profileable android:shell=[“true” | “false”] android:allow=[“true” | “false”] />

• Useful in app instrumentation with Macrobenchmark.

8.    MicroBenchmark

The Jetpack Microbenchmark library permits you to rapidly benchmark your Android native code (Kotlin or Java) from inside Android Studio. The library handles warmup, measures your code efficiency and allocation counts, and outputs benchmarking outcomes to each the Android Studio console and a JSON file with extra element. Learn extra right here.

Monitoring App dimension

No person needs to obtain a big APK which may devour most of their Community/Wifi Bandwidth, additionally most significantly, area contained in the cellular system.

The scale of your APK has an influence on how briskly your app masses, how a lot reminiscence it makes use of, and the way a lot energy it consumes. Lowering your app’s obtain dimension permits extra customers to obtain your app.

Instruments

• Use the Android Dimension Analyzer

The Android Dimension Analyzer software is a simple approach to establish and implement many methods for decreasing the scale of your app. It’s obtainable as each an Android Studio plugin in addition to a standalone JAR

• Take away unused assets utilizing Lint

The lint software, a static code analyzer included in Android Studio, detects assets in your res/ folder that your code does not reference. When the lint software discovers a probably unused useful resource in your challenge, it prints a message like the next instance.

Be aware : Libraries that you simply add to your code might embrace unused assets. Gradle can mechanically take away assets in your behalf when you allow shrinkResources in your app’s construct.gradle file.

• Native animated picture decoding

In Android 12 (API stage 31), the NDK ImageDecoder API has been expanded to decode all frames and timing knowledge from photos that use the animated GIF and animated WebP file codecs. When it was launched in Android 11, this API decoded solely the primary picture from animations in these codecs. 

 

Use ImageDecoder as an alternative of third-party libraries to additional lower APK dimension and profit from future updates associated to safety and efficiency. 

 

• Crunch PNG recordsdata utilizing aapt

The aapt software can optimize the picture assets positioned in res/drawable/ with lossless compression throughout the construct course of. For instance, the aapt software can convert a true-color PNG that doesn’t require greater than 256 colours to an 8-bit PNG with a shade palette. Doing so leads to a picture of equal high quality however a smaller reminiscence footprint. Learn extra right here.

Be aware : Please test Android developer documentation for all of the helpful instruments which can assist you establish and assist repair such efficiency points.

Recap

This a part of the weblog captures the instruments utilized by Google to establish and repair efficiency points of their apps. They noticed nice enhancements of their metrics. Most Android Go apps may gain advantage from making use of the methods described above. Optimize and make your app pleasant and quick in your customers!