Special topic of APP performance design and Optimization - poor implementation affecting performance

This article will focus on bad implementations that affect performance , It mainly includes Binder Shared memory exhausted 、Binder Thread pool exhausted 、 Create a large number of BpBinder or Binder Objects, etc .

In order to better understand the following , Let's give you a brief introduction Binder：

【 notes 】 because Binder The complexity of the mechanism , I won't go into that , Simply summarize , To better understand the content of this article .

Binder Belong to a kind of IPC Communication mechanism , It is used to realize the communication between different processes , Mainly by ServiceManager、Server（ Server side ）、Binder drive 、Client（ client ）4 Part of the form , among Client、Server、Service Manager Run in user space ,Binder The driver runs in kernel space . Once complete Binder IPC The communication process is usually as follows ：

1）Binder The driver creates a data receiving buffer in kernel space ;

2） Open up a kernel cache in kernel space , Establish the mapping relationship between the kernel cache and the data receiving cache in the kernel , And the mapping relationship between the data receiving buffer and the user space address of the receiving process in the kernel ;

3） Sender process through system call copy_from_user() Put the data copy To the kernel cache in the kernel , Due to the memory mapping between the kernel cache and the user space of the receiving process , Therefore, it is equivalent to sending data to the user space of the receiving process , Complete an inter process communication .

because Binder It plays an extremely important role in the process of cross process communication , Any process or exception will have a negative impact .

01 Binder Shared memory exhausted

Binder Performance of （ One less time copy_to_user） And safety are the biggest advantages , But because of Binder There are restrictions on the amount of data transferred in the kernel and user mode , So avoid passing Binder Transfer a lot of data . A process is used to receive Binder The shared memory of data is 1M-8K, about oneway Halve it . meanwhile ,Binder driver Also have 4M Upper limit , When multiple threads share this shared memory , once driver It is found that the shared memory of the data receiver is insufficient , It will return an error .

Binder Impact of shared memory exhaustion ：

Binder The call takes a long time , Even fail ;

If it is the key process of user operation , It will lead to Caton .

Optimization Suggestions ：

Timely release data(Server End ) or reply(Client End ), Suggest using AIDL frame ;

Binder Avoid parameter transmission of big data during interface design , Available if needed Ashmem Pass on ;

Avoid a large number of threads calling a certain in parallel at the same time in a short time Server, If there is need to , Peak shaving is required .

02 Binder Thread pool exhausted

Server There are a certain number of Binder Thread pool to respond Client Call to , A process of Binder The default maximum number of threads is 16（1 Main threads and 15 Non main threads ）, Requests that exceed will be blocked waiting for idle Binder Threads , namely Binder Thread pool exhaustion will cause subsequent calls to be blocked .

Binder The impact of thread pool exhaustion ：

Synchronously called Client End blocked , If it is in the key process of user operation , Then Caton phenomenon occurs ;

system_server And other key service processes of the system Binder Thread pool exhausted , Cause the whole machine to jam .

Optimization Suggestions ：

Avoid a large number of threads calling a certain in parallel at the same time in a short time Server, Peak shaving is required if necessary ;

promote Binder Implementation efficiency of interface implementation .

03 Create a large number of BpBinder or Binder object

BpBinder It is in the client Binder quote , Save the target service handle Information , That is, on the server side Binder Reference information of entity , Used to query Binder node , Same with Binder Physical communication .
The system doesn't limit Server Terminal Binder objects creating , Theoretically speaking, it can be created in large quantities , But a Service You should only create one Binder object ,BpBinder Object has upper limit 6000/2500 individual , More will be killed , So I suggest the same Service Of BpBinder Realize in-process sharing .

Create a large number of BpBinder or Binder The influence of the object ：

Memory footprint , frequent GC, Even because OOM And dodge back ;

The whole machine is stuck .

Optimization Suggestions ：

One Service Only one Binder Object instances , Merge by usage scenario and lifecycle Service;

Timely release those that are no longer in use BpBinder.

04 The use of multiple ServiceConnection object Bind The same Service

ServiceConnection It's actually a Service, Provide to AMS maintain , Used to manage objectives Service The callback . The same ServiceConnection Objects can manage multiple Service,Client The end has achieved different Service Reuse of ,AMS Maintain only one IServiceConnection; But it's different ServiceConnection Objects are not reused , Even if it's the same Service.

The use of multiple ServiceConnection object Bind The same Service Influence ：

increase AMS The burden of maintenance ,Service Start of / Exit will hold AMS Traverse after lock SC;

Long term holding AMS lock , Cause the whole machine to jam .

Optimization Suggestions ：

Reuse the same ServiceConnection object , Especially the same Service;

monitor Service The death callback of , If necessary, you can immediately re Bind;

In time unbind No longer used Service.

05 Get system services as you use them

System services are provided by ServiceManager maintain , Get system services IBinder The process of is also a cross process Binder call . The system services commonly used by applications have been started by ATMS Take it with you , Other system service systems are used for general applications hiden Interface to limit . When there are frequent adjustments checkService Interface , Mainly system services or system applications .

Get system services as you go ：

Unnecessary cross process synchronous calls take time 1ms about , Some even reach s level （logcat -b events -s service_manager_slow）;
Increase the system load .

Optimization Suggestions ：

After a successful acquisition, the local cache ;

adopt IBinder Of linkToDeath The mechanism senses the exit of the service , Clear local after service exit IBinder cache , Ask again when you need it next time Servicemanager obtain .

In addition to the above bad implementation , There are also component object leaks （ Native removeContextRegistrations Yes SC、Receiver and Window Leakage inspection ）、 The system core process calls non ONEWAY Of IPC Interface （ There is a risk that the core process will get stuck ） as well as HIDL Only for cross process calls （ about Client and Server Co process scenario , Do not use HIDL） etc. .

Come here ,APP The performance design and optimization topic comes to an end , Welcome to leave messages backstage , Express your opinions on the article , Or feedback what you want to see , I hope we can make progress together ~

Last ： Get one by yourself 216 Page software testing engineer interview guide document information 【 Free of charge 】. And the corresponding video learning tutorial is free to share ！, It includes basic knowledge 、Linux necessary 、Shell、 The principles of the Internet 、Mysql database 、 Special topic of bag capturing tools 、 Interface testing tool 、 Test advanced -Python Programming 、Web automated testing 、APP automated testing 、 Interface automation testing 、 Testing advanced continuous integration 、 Test architecture development test framework 、 Performance testing 、 Safety test, etc. .