iQIYI Android client startup optimization and analysis

1 Introduction

There is an eight-second rule in the Internet field. If the webpage opening time exceeds 8 seconds, more than 70% of users will give up waiting. For Android APP, the requirements are more stringent. If the system is unresponsive for more than 5 seconds, ANR will appear and the APP may be forced to close. Therefore, startup time, as an important performance indicator, is related to the user's *** experience.

iQIYI Android APP attaches great importance to the optimization of startup speed. This article will share our experience in startup optimization from the aspects of startup process, startup time measurement, startup optimization, and subsequent monitoring.

2 Startup Mode

To accurately measure the startup time of an app, we first need to understand the entire startup process of the app. The startup process can generally be divided into the following three categories:

As can be seen from the above figure, during the startup process, in the Cold mode, the most things are done in the life cycle and the startup time is the longest. Therefore, we use cold start to measure the APP startup time. During the startup process, how to determine which life cycles affect the startup speed?

3 Boot process

We know that the startup and running of an APP is the process in which the Linux system creates process and component objects and processes component messages in the UI thread.

Startup process diagram:

The app startup process can be divided into three stages:

3.1 Creating a process

When the app is started, if the current app process does not exist, a new process will be created; after the app main process is started, if a component is started and the component has the android:process attribute set, a new process will also be created if the process running the component does not exist.

It should be noted that if multiple processes are included in the components initialized during the startup phase, multiple processes will be created and the BindApplication operation will be repeated multiple times.

3.2 Create UI thread and Handler

After the process is created, the ActivityThread entry function is executed through reflection, a Handler is created, and MainLooper is prepared in the current thread. Component messages are received in the Handler. Let's take a look at the messages processed in the Handler:

• LAUNCH_ACTIVITY, start and execute Activity
• RESUME_ACTIVITY, resume Activity
• BIND_APPLICATION, start the app
• BIND_SERVICE, Service creation, onBind
• LOW_MEMORY, insufficient memory, recycle background program

There are many messages processed in sMainThreadHandler. Here we only list the operations that may be performed during the startup phase. These operations are all run in the Main Thread and are blocking for startup.

The Activity life cycle naturally needs to be executed in the startup phase, but for operations such as Service creation, Trim_memory callback, and broadcast reception, it is necessary to focus on the time-consuming nature of the operations.

3.3 Activity running and drawing

The first two processes, creating the process and UI thread and Handler, are all determined by the system. App developers cannot control their execution time. In this stage, the execution of BindApplication and the Acitivity life cycle can be customized by the developer.

After Activity executes to onResume, it will execute to ViewRootImpl and execute performTraversals twice. In the second traversal operation, performDraw operation will be executed, and RenderThread thread will be notified to perform drawing.

From the three stages of startup, we can see that the length of startup time is determined by the time consumed by the main thread. Therefore, our optimization work is mainly focused on troubleshooting time-consuming tasks in the main thread and optimizing them reasonably. Android phones have limited system resources. Too many asynchronous threads will occupy the CPU, resulting in an increase in the main thread execution time interval. Similarly, memory consumption status and GC frequency will also affect the startup time.

4 Analysis and measurement

Through the interpretation of the above source code, we have understood the startup process and the possible reasons for slow startup. Next, we will introduce some common analysis methods and time measurement methods.

Start the analysis tool , mainly using SysTrace. For specific usage, please refer to the official website document https://developer.android.com/studio/command-line/systrace.

4.1 SysTrace Analysis Techniques

4.1.1 UI Thread Color Display

• Green: Running
• White: Sleeping
• Brown: Uninterruptible Sleep
• Orange: Uninterruptible Sleep - Block I/O

The shorter Sleeping state within 10ms does not need to be paid attention to, as it may be caused by the time slice allocation interval of the CPU scheduling. The longer Block I/O and Sleep states indicate that the blocking startup logic is running at this stage, and further analysis and positioning of the code is required.

4.1.2 Check CPU status and thread running time

Check the CPU usage status:

Thread execution:

The density of this stage reflects the CPU occupancy rate and, to a certain extent, the blocking of the execution time of this stage. The thread execution statistics can be used to view the thread execution time ranking and optimize the sub-threads with longer execution time.

4.2 SysTrace startup time

In the SysTrace diagram, UI Thread includes operations such as bindApplication, activityStart, traversal, and RenderThread includes operations such as DrawFrame. These TAG nodes have been added to the source code, and can be referred to in #3.2.

Startup time on Trace: From bindApplication to the completion of the second traversal, it can be considered that the UI is drawn for the first time and the startup is completed. Select the start point and end point to view the time consumed by the process.

4.3 adb shell am start -W

When counting the app startup time, the system provides us with an adb command that can output the startup time

TotalTime: indicates the time it takes to start a new application, including the start of a new process and the start of an Activity, but excluding the time it takes to pause the previous application's Activity

After the system completes drawing, ActivityManagerService will call back this method. The statistical time is not as accurate as SysTrace, but it is convenient for us to start the script multiple times to measure TotalTime and compare the startup time differences between versions.

4.4 Buried Points

By adding time point records at key locations during the APP startup life cycle, measurement purposes can be achieved.

4.5 Screen Recording

The time collected by screen recording is closer to the user's actual physical sensation.

5 Optimization

In order to allow users to use services faster and more smoothly after entering the APP, some basic libraries and components will be initialized in advance during the startup process, which means that the limited system resources will be preempted, affecting the startup time. Optimizing the startup time is a process of balancing performance and experience.

Through the analysis of the Systrace tool, we found some problems in the startup process of iQiyi Android APP. Next, we will optimize the startup problems based on specific business practices.

5.1 Distinguishing between process initialization and application

From #3, we know that for an app, the components in the app can run in different processes. For example: an app has three processes: the main process, the plug-in process, and the download process. The corresponding components will be created at the startup stage, but there is only one QYApplication that inherits from the system Application and creates three processes. The attach() and onCreate() methods in QYApplication will be executed three times.

Each process must have different content to be initialized, so in order to prevent waste of resources, we need to distinguish processes and initialize Appcation.

Results: For multi-process applications, by sorting out the initialization content and properly distinguishing initialization, memory and CPU usage can be greatly reduced.

5.2 Asynchronous processing of time-consuming tasks

The child thread handles time-consuming tasks. The less the main thread does, the sooner it enters the Acitivity drawing phase and the sooner the interface is displayed.

Notice:

• Do not perform time-consuming tasks in the main thread, such as files, network, etc.
• Initialization tasks in the startup phase should be processed in asynchronous threads as much as possible
• Main thread, no need to wait or depend on child thread tasks

Further optimization: You can build your own thread pool, maintain a certain number of threads, and manage task queues.

5.3 Preventing Multiple Threads from Seizing the CPU

Android system resources are limited, especially CPU resources. Theoretically, the tasks executed by the UI thread cannot be guaranteed to be scheduled all the time. When the number of concurrent threads is too large, the UI thread time slice will be shorter, resulting in a slower startup time.

Here are some common scenarios that can easily cause CPU preemption:

Results: By optimizing the tasks with longer execution time and higher execution frequency and maintaining the CPU usage at a reasonable level, the startup time can be significantly reduced by more than 300ms.

5.4 System API Usage

Some system APIs are blocking, which may not be noticeable when the file is small, but may cause blocking when the file is too large or used frequently. For example:

SharedPreference.Editor submit operation:

• The commit method is a blocking API, and it is recommended to use apply.

In addition, we know that the storage of SP files is an XML file, which is stored in the form of key-value. When there are too many businesses, it needs to be split into multiple files for storage to prevent the file from being too large, resulting in time-consuming reading and ANR.

For further optimization, frequent SP operations can be submitted uniformly in memory during the startup phase.

AssetManager.open operation: In Android development, we sometimes put resource files in the assets directory and then use the open operation to read the file. If the file is too large, it needs to be executed in an asynchronous thread.

Results: As business volume increases, normal use of system APIs may also cause problems. By eliminating them, 50-100ms can be reduced.

5.5 Simplified layout

The complexity of the layout directly affects the drawing time.

For example, during the startup process, a large background image will be needed, which is only used during the first installation. The subsequent attributes are set to android:visibility="gone". However, although the gone attribute is set, it will not be displayed, but it will still be parsed.

suggestion:

Reduce layout levels

Use ViewStub for useless resources, load them when you use them

1. Results: The layout of the startup phase is relatively simple, and the loading time of background images is reduced by 50-100ms.

5.6 Delayed Service Initialization

During the App startup process, Service initialization operations are often performed. Since the use of Service generally does not involve the interface, you may think that the initialization life cycle is not in the main thread. In fact, this is not the case. As mentioned in the 3.2 startup process source code introduction, the Service life cycle is also one of the Messages received by the main thread Handler.

1. Recommendation: During the Service lifecycle, pay attention to optimizing the performance of logic execution time and delay initialization as much as possible.
2. Results: Depending on the execution time of the initialization Service lifecycle, it can be reduced by more than 200ms.

5.7 Delay the task until the home page is drawn

For initialization logic that is not required for the APP home page display, it can be postponed until the home page is drawn.

Notice:

Posting twice is required to ensure that it is displayed after the first drawing, because the system drawing will execute Performtraversal twice.

Further optimization: The initialization of business logic can be divided into three stages: 5s, 10s, and 20s after the home page is drawn, to prevent frame drops caused by too many home page drawing tasks.

Result: Freeing up the CPU in the drawing phase, complex drawing can be advanced by more than 200ms.

6 Monitoring

A stable user experience depends on continuous monitoring. iQIYI has established a monitoring system to monitor startup performance. Several teams, including testing, tools, and development, have built different monitoring solutions from different perspectives.

1. Test: Record the screen to get the most accurate startup time based on the user's real experience.
2. Real-time monitoring: Obtain real online environment data through tracking and big data sampling and delivery, and monitor the startup time from various dimensions such as region, time, model, app version, and system version.
3. Script testing: Collect multiple startup data of the same script, and monitor the changes in startup time by comparing different versions.

7 SysTrace Extensions

SysTrace can clearly display the startup process and method execution time through the TAG node. However, it is a very tedious task to find the problem and then locate it through the node. If your project compilation is slow, it will be frustrating.

7.1 Automatic TAG injection

During the compilation of an Android project, specify a class, automatically insert Trace nodes before and after the method, and count the method execution time.

process:

• During the compilation process, insert a custom Task task.
• Read the configuration file, which contains the Java file name, path name and method to be injected
• Find the class file that needs to be injected, and then change the bytecode through ASM, before and after the method, and insert the custom method

Through the operation of the tool, it is possible to automatically inject TAG nodes and logic codes during packaging without modifying the original project files. The configuration files can be recycled to improve analysis efficiency and save energy and protect the environment.

8 Optimization results

Startup time: Due to the different performance of different models and different Android system versions, the startup time of the same APP version varies greatly, so statistics are generally compared on the same phone but different versions to ensure that the phone status is consistent as much as possible.

SysTrace mobile phone optimization time comparison:

Comparison of script startup time collection multiple times:

After continuous optimization of multiple versions, the startup time in two different scenarios, with and without advertisements, was reduced by 40% and 35% respectively, and the startup speed was greatly improved.

9 Conclusion

Optimizing and monitoring startup time is a long-term task that requires analyzing abnormal situations and optimizing the code logic that may cause blocking. We are very grateful for the support and cooperation of various business teams.