WO2022262472A1

WO2022262472A1 - Frame rate processing method and apparatus, storage medium, and terminal

Info

Publication number: WO2022262472A1
Application number: PCT/CN2022/091673
Authority: WO
Inventors: 陈鑫
Original assignee: Oppo广东移动通信有限公司
Priority date: 2021-06-18
Filing date: 2022-05-09
Publication date: 2022-12-22
Also published as: CN115495303A

Abstract

The present application discloses a frame rate processing method and apparatus, a storage medium, and a terminal, which relate to the technical field of device display. The method comprises: first, counting the number of times that a target application executes an interface-drawing interface, and according to a preset time interval and the number of times, calculating the frame loss rate of the target application in the preset time interval; then, acquiring the execution time of each code execution stack corresponding to the target application in the preset time interval, and according to the execution time of each code execution stack, determining a target code execution stack causing the target application to lose frames; finally, printing a target code function comprised in the target code execution stack and runtime corresponding to each target code function. As frame loss rate is determined by purely software means, the cost of frame rate processing may be reduced. In addition, a target code execution stack causing frame loss of a target application may be positioned and analyzed in real time, which may help developers to quickly and accurately analyze the cause of the frame loss.

Description

Frame rate processing method, device, storage medium and terminal

This application claims the priority of the Chinese patent application with the application number 202110683368.2 and the title of the invention "frame rate processing method, device, storage medium and terminal" filed on June 18, 2021, the entire contents of which are incorporated herein by reference. Applying.

technical field

The present application relates to the technical field of device display, and in particular to a frame rate processing method, device, storage medium and terminal.

Background technique

With the development of science and technology, more and more terminals appear in people's lives. The terminal can transmit information to the user by displaying relevant pictures. one of the focuses of the research.

In related technologies, the method of counting the frame rate of a certain application when it is running requires the terminal to be connected to special peripheral equipment, and to be connected to a computer and a server to assist in analyzing the frame loss rate. Due to the need to purchase additional peripheral equipment, such as a frame rate collector, the cost of frame rate processing is relatively high.

Contents of the invention

The present application provides a frame rate processing method, device, storage medium and terminal, which can solve the problem of high frame rate detection due to the need to purchase additional peripheral equipment in related technologies, and the inability to locate and analyze in real time the cause of frame loss The cause is a technical problem.

In the first aspect, the embodiment of the present application provides a frame rate processing method, the method including:

Counting the number of times the target application program executes the interface drawing interface within the preset time interval, and calculating the frame loss rate of the target application program within the preset time interval according to the preset time interval and the number of times;

Obtain the execution time of each code execution stack corresponding to the target application program within the preset time interval, and determine the target code execution stack that causes the target application program to drop frames according to the execution time of each code execution stack;

Print the target code functions included in the target code execution stack and the running time corresponding to each target code function.

In a second aspect, an embodiment of the present application provides a frame rate processing device, which includes:

A frame loss calculation module, configured to count the number of times the target application program executes the interface drawing interface within a preset time interval, and calculate the number of times the target application program executes the interface drawing interface in the preset time interval according to the preset time interval and the number of times frame loss rate;

An execution stack determining module, configured to obtain the execution time of each code execution stack corresponding to the target application within the preset time interval, and determine the execution time of the target application program according to the execution time of each code execution stack The object code execution stack of the frame;

The code printing module is used to print the target code functions included in the target code execution stack and the running time corresponding to each target code function.

In a third aspect, an embodiment of the present application provides a computer storage medium, where a plurality of instructions are stored in the computer storage medium, and the instructions are suitable for being loaded by a processor and executing the steps of the above method.

In a fourth aspect, an embodiment of the present application provides a terminal, including a memory, a processor, and a computer program stored in the memory and operable on the processor, the computer program being suitable for being loaded by the processor and executing the above method step.

The beneficial effects brought by the technical solutions provided by some embodiments of the present application at least include:

The present application provides a frame rate processing method. First, count the number of times the target application program executes the interface drawing interface within a preset time interval, and calculate the frame loss rate of the target application program within the preset time interval according to the preset time interval and times; Then obtain the execution time of each code execution stack corresponding to the target application within the preset time interval, and determine the target code execution stack that causes the target application to lose frames according to the execution time of each code execution stack; finally print the target code execution stack including The target code functions and the running time corresponding to each target code function. Because the frame loss rate is determined by counting the number of times the target application executes the interface drawing interface within the preset time interval, that is, the frame loss rate is determined by pure software, which can reduce the cost of frame rate processing. In addition, through the code execution stack It can locate and analyze the target code execution stack that causes the frame loss of the target application program in real time, and print the target code functions included in the target code execution stack and the running time corresponding to each target code function, which can help developers quickly and accurately analyze to find out the cause of the dropped frame.

Description of drawings

In order to more clearly illustrate the technical solutions in the embodiments of the present application or the prior art, the following will briefly introduce the drawings that need to be used in the description of the embodiments or the prior art. Obviously, the accompanying drawings in the following description are only These are some embodiments of the present application. For those skilled in the art, other drawings can also be obtained based on these drawings without creative work.

FIG. 1 is an exemplary system architecture diagram of a frame rate processing method provided in an embodiment of the present application;

FIG. 2 is a system interaction diagram of a frame rate processing method provided by an embodiment of the present application;

FIG. 3 is a schematic flowchart of a frame rate processing method provided in an embodiment of the present application;

FIG. 4 is a schematic diagram of an interface drawing principle provided in an embodiment of the present application;

FIG. 5 is a schematic diagram of calculating a frame loss rate provided by an embodiment of the present application;

FIG. 6 is a schematic diagram of an application program interface display provided by the embodiment of the present application;

FIG. 7 is a schematic structural diagram of a code execution stack provided by an embodiment of the present application;

FIG. 8 is a schematic flowchart of a frame rate processing method provided by another embodiment of the present application;

FIG. 9 is a schematic diagram of an aggregate structure provided by an embodiment of the present application;

FIG. 10 is a structural block diagram of a frame rate processing device provided by an embodiment of the present application;

FIG. 11 is a structural block diagram of a frame rate processing device provided by another embodiment of the present application;

FIG. 12 is a schematic structural diagram of a terminal provided by an embodiment of the present application.

detailed description

In order to make the features and advantages of the present application more obvious and understandable, the technical solutions in the embodiments of the present application will be clearly and completely described below in conjunction with the drawings in the embodiments of the present application. Obviously, the described embodiments It is only a part of the embodiments of the present application, but not all the embodiments. Based on the embodiments in this application, all other embodiments obtained by those skilled in the art without making creative efforts belong to the scope of protection of this application.

When the following description refers to the accompanying drawings, the same numerals in different drawings refer to the same or similar elements unless otherwise indicated. The implementations described in the following exemplary embodiments do not represent all implementations consistent with this application. Rather, they are merely examples of apparatuses and methods consistent with aspects of the present application as recited in the appended claims.

FIG. 1 is an exemplary system architecture diagram of a frame rate processing method provided by an embodiment of the present application.

As shown in FIG. 1 , the system architecture may include a terminal 101 , a network 102 and a server 103 . The network 102 is a medium for providing a communication link between the terminal 101 and the server 103 . The network 102 may include various types of wired communication links or wireless communication links, for example: wired communication links include optical fiber, twisted pair or coaxial cables, wireless communication links include Bluetooth communication links, Wi-Fi ( Wireless-Fidelity, Wi-Fi) communication link or microwave communication link, etc.

The terminal 101 can interact with the server 103 through the network 102 to receive messages from the server 103 or send messages to the server 103 . Terminal 101 may be hardware or software. When the terminal 101 is hardware, it can be various electronic devices, including but not limited to smart watches, smart phones, tablet computers, laptops, desktop computers, and the like. When the terminal 101 is software, it can be installed in the electronic devices listed above, which can be implemented as multiple software or software modules (for example: for providing distributed services), or can be implemented as a single software or software module, No specific limitation is made here.

The server 103 may be a service server that provides various services. It should be noted that the server 103 may be hardware or software. When the server 103 is hardware, it can be implemented as a distributed server cluster composed of multiple servers, or as a single server. When the server 103 is software, it can be implemented as multiple software or software modules (for example, for providing distributed services), or as a single software or software module, which is not specifically limited here.

It should be understood that the numbers of terminals, networks, and servers in FIG. 1 are only illustrative, and may be any number of terminals, networks, and servers according to implementation requirements.

Please refer to FIG. 2. FIG. 2 is a system interaction diagram of a frame rate processing method provided by the embodiment of the present application. It can be understood that in the embodiment of the present application, the execution subject may be a terminal or a processor in the terminal, or may be For the convenience of describing the services related to the execution of the frame rate processing method in the terminal, the processor in the terminal is used as the execution subject as an example, and a system interaction process in a frame rate processing method is introduced with reference to FIG. 1 and FIG. 2 .

S201. A user runs a target application program.

Any application program in the terminal can be determined as the target application program as required.

S202. The processor counts the number of times the target application program executes the interface drawing interface within the preset time interval, and calculates the frame loss rate of the target application program within the preset time interval according to the preset time interval and times.

Optionally, before counting the number of times the target application program executes the interface drawing interface within the preset time interval, it also includes: determining the system interface drawing cycle corresponding to the target application program, and determining the preset number of system interface drawing cycles as the preset time interval.

Optionally, calculating the frame loss rate of the target application in the preset time interval according to the preset time interval and the number of times includes: obtaining the ratio of the target difference to the preset number, and using the ratio as the target application in the preset time interval The frame loss rate within ; wherein, the target difference is the difference between the number of times the target application program executes the interface drawing interface and the preset number.

S203. The processor acquires the execution time of each code execution stack corresponding to the target application program within a preset time interval, and determines the target code execution stack that causes the target application program to drop a frame according to the execution time of each code execution stack.

Optionally, before counting the number of times the target application program executes the interface drawing interface within the preset time interval, it also includes: based on the first code inserted at the start position of each code function in the target application program, when each code function starts to run Record the identity, start time, and start flag of each code function respectively, and save them in the preset collection in chronological order; based on the second code inserted at the end position of each code function in the target application program, in each code function When the execution ends, the identity, end time, and end flag of each code function are recorded respectively, and are saved in the preset collection in chronological order.

Optionally, obtaining the execution time of each code execution stack corresponding to the target application within the preset time interval includes: if the frame loss rate is greater than the preset frame loss rate threshold, determining that the target application corresponds to the The first identity of the initial code function of each code execution stack of each code execution stack, the first start flag matching the first identity of each initial code function is searched in the preset set, and the first start flag corresponding to the first start flag Time: determine the second identity mark of the end code function of each code execution stack corresponding to the target application program within the preset time interval, and search for the second end mark matching the second identity mark of each end code function in the preset set bit, and the second end time corresponding to the second end flag bit; the difference between the first start time of the initial code function of each code execution stack and the second end time of the end code function of each code execution stack is used as each code Execution time of the execution stack.

Optionally, according to the execution time of each code execution stack, determining the target code execution stack that causes the frame loss of the target application program includes: determining the type of each code execution stack, and the type of code execution stack includes interface drawing execution stack and non-interface drawing execution Stack; the type of the code execution stack is the interface drawing execution stack, and the code execution stack whose execution time is longer than the system interface drawing cycle is determined as the target code execution stack; and/or the type of the code execution stack is non-interface drawing execution stack, and the code execution stack whose execution time of the code execution stack is greater than the execution time of the preset execution stack is determined as the target code execution stack.

S204. The processor prints the target code functions included in the target code execution stack and the running time corresponding to each target code function.

Optionally, printing the target code functions included in the target code execution stack and the running time corresponding to each target code function includes: determining the third identity between the initial code function and the end code function in the target code execution stack based on a preset set logo, the third start flag, the third end flag, the third start time and the third end time; obtain the corresponding target code functions according to each third identity, and obtain the corresponding target code functions according to the third start flag of each target code function The third start time, the difference between the third end time corresponding to the third end flag bit of each object code function determines the running time corresponding to each object code function; print each object code function and the running time corresponding to each object code function .

Optionally, after calculating the frame loss rate of the target application in the preset time interval according to the preset time interval and times, it also includes: calculating the current interface frame rate of the target application, and displaying the current frame rate in the interface of the target application interface frame rate; and/or display the frame loss rate within a preset time interval in the interface of the target application.

Optionally, before counting the number of times the target application program executes the interface drawing interface within the preset time interval, it also includes: assigning unique identities to each code function in the target application program, and linking each code function with the corresponding identities Establishing a mapping relationship; generating a mapping file based on all the mapping relationships, and packaging the mapping file into the target application, so that the target application loads the mapping file and resolves all the mapping relationships after installation.

In the embodiment of the present application, first count the number of times the target application program executes the interface drawing interface within the preset time interval, and calculate the frame loss rate of the target application program within the preset time interval according to the preset time interval and times; then obtain the The execution time of each code execution stack corresponding to the target application within the preset time interval, and determine the target code execution stack that causes the target application to lose frames according to the execution time of each code execution stack; finally print the target code included in the target code execution stack Functions and the running time corresponding to each object code function. Because the frame loss rate is determined by counting the number of times the target application executes the interface drawing interface within the preset time interval, that is, the frame loss rate is determined by pure software, which can reduce the cost of frame rate processing. In addition, through the code execution stack It can locate and analyze the target code execution stack that causes the frame loss of the target application program in real time, and print the target code functions included in the target code execution stack and the running time corresponding to each target code function, which can help developers quickly and accurately analyze to find out the cause of the dropped frame.

Please refer to FIG. 3 . FIG. 3 is a schematic flowchart of a frame rate processing method provided by an embodiment of the present application.

As shown in Figure 3, the frame rate processing method includes:

S301. Count the number of times the target application program executes the interface drawing interface within the preset time interval, and calculate the frame loss rate of the target application program within the preset time interval according to the preset time interval and times.

It can be understood that the frame rate processing method in the embodiment of the present application can be applied to the development and testing phase of the target application program by the developer, and can also be applied to the actual use process of the user. For the convenience of description, the following is applied to the developer Taking the development and testing stages of the target application program as an example, the specific implementation process of the frame rate processing method is introduced.

In this embodiment of the application, the target application program can be any application program that requires frame rate testing or detection, for example, the target application program can be an audio-visual application program or a game application program that requires a high interface frame rate Program, where the frame rate (Frame rate) is the frequency (rate) at which the bitmap image in units of frames continuously appears on the display. After the developer completes the development of the target application program, it needs to perform frame rate detection and analysis on the target application program, then the target application program can be installed in the terminal first, and the terminal specifically uses the preset system to check the target application program. The installation package is decompressed and installed, so that the target application can be run in the preset system after the installation of the target application is completed. Optionally, the preset system may be a terminal operating system such as an Android system and an Apple system. For the convenience of description, this embodiment of the present application uses the Android system as an example for introduction.

After the developer starts and runs the target application program in the preset system, in order to display the screen on the interface of the target application target, the target application program can execute the preset program provided by the software development kit (Software Development Kit, SDK) in the preset system first. Set the interface to obtain the interface drawing signal sent by the preset system. The interface drawing signal can be considered as a vertical synchronization signal or a time pulse signal, and then the target application program can execute a complete interface drawing program based on the interface drawing signal to form a frame picture. Ideally, after the target application continuously obtains the interface drawing signals sent by the preset system, it will execute multiple complete interface drawing programs based on each interface drawing signal to form a continuous multi-frame picture, then the user can observe Display a smooth interface composed of multiple frames in the interface of the target application program.

Furthermore, the interface drawing signal sent by the preset system has a certain cycle, which is also the system interface drawing cycle. The system interface drawing cycle is related to the refresh rate of the system interface corresponding to the preset system. For example, when the preset system corresponds to The refresh rate of the interface is 60 Hz, that is, the system interface needs to be refreshed 60 times in one second, so the preset system will send 60 interface drawing signals within 1 second (1000 milliseconds), so that the target application can draw based on the interface If the signal executes 60 complete interface drawing programs within 1 second, then the system interface drawing cycle can be obtained to be about 16.6 milliseconds (1000 milliseconds/60 times). Optionally, in this embodiment of the present application, there is no limitation on the interface refresh rate corresponding to the preset system, and the interface refresh rate corresponding to the preset system may be 60 Hz, 90 Hz, or 144 Hz. The principle of interface drawing is described in detail below in combination with FIG. 4 .

Please refer to FIG. 4 . FIG. 4 is a schematic diagram of an interface drawing principle provided by an embodiment of the present application. As shown in Figure 4, taking the interface refresh rate corresponding to the preset system as 60 Hz as an example, the preset system sends an interface drawing signal to the target application through the preset interface every 16.6 milliseconds, if there is a drawing event in the target application , then the target application program executes the preset interface to obtain the interface drawing signal, and executes the interface drawing program once to draw a frame of picture in the interface of the target application program. In an ideal situation, the target application will complete the drawing of the interface before obtaining the next interface drawing signal, as shown in Figure 4 for the first drawing, and the interface drawing program is executed within 16.6 milliseconds of the interface drawing cycle. At this time The display interface of the target application does not experience dropped frames.

However, in Figure 4, the second drawing took up about 3 interface drawing cycles. If there should have been planned drawing events in the last two interface drawing cycles of the 3 interface drawing cycles, but the second drawing has not ended It will cause the target application to fail to execute the preset interface to obtain the interface drawing signal and execute the interface drawing program, which means that the drawing events of the next two drawing cycles will not be executed. At this time, the display interface of the target application will drop frames. Case. A special case is that when there is no drawing event in the target application program, the target application program can execute the preset interface, that is, obtain the interface drawing signal, but the interface drawing signal will not call and execute the interface drawing program. At this time, the target application program is considered The display interface does not drop frames.

According to the above interface drawing principle, in general, as long as the target application program executes the preset interface once, it can obtain the interface drawing signal sent by the preset system through the preset interface and execute the interface drawing program once. The number of times the program executes the interface drawing interface within a certain period of time can determine the frame rate and frame loss rate of the target application program. However, in related technologies, such as in the Android system, the preset interface may only allow the source code of the target application to be executed, and the code in the processor or the code written by the developer cannot directly access the preset interface, so a feasible implementation The method is that the developer can write the preset interface so that on the basis of the preset interface, the preset interface provides another interface, which can be named interface drawing interface, and the interface drawing interface can be used in the target application The source code receives the interface drawing signal sent by the preset system, and the interface drawing program in the target application program can implement the interface drawing interface, and uses the interface drawing interface as the only entry to drive the operation of the interface drawing program in the target application program.

Furthermore, the code written by the developer can also implement the interface drawing interface, so that the interface drawing interface can also be accessed by the code written by the developer, and the interface drawing interface can also be used for the code written by the developer to receive the interface drawing sent by the preset system signal, and the code written by the developer to implement the interface drawing interface is consistent with the interface drawing program in the target application program, that is, the source code of the target application program can execute the preset interface in the system interface drawing cycle and the interface drawing interface in the system interface There is no difference in the execution of the interface drawing interface in the drawing cycle. It can be understood that if in some preset systems, the preset interface can be executed by the source code of the target application program, or by the code in the processor or the code written by the developer, then in the preset system, The default interface is also the interface drawing interface.

Since the interface drawing interface can also be accessed by the code written by the developer, and the source code of the target application program can execute the preset interface in the system interface drawing cycle and execute the interface drawing interface in the system interface drawing cycle, there is no difference, then the target application can be obtained As long as the program executes the interface drawing interface once, it can obtain an interface drawing signal sent by the preset system through the interface drawing interface, and execute the interface drawing program once.

Therefore, in order to calculate the frame loss rate when the display interface of the target application program loses frames, the preset code written by the developer can be used to count the number of times the target application program executes the interface drawing interface within the preset time interval. In this case, in a system interface drawing cycle, the interface drawing interface will be executed once, then the preset time interval can be set to include the preset number of system interface drawing cycles, then the preset number and the target within the preset time interval can be used The number of times the application program executes the interface drawing interface calculates the frame loss rate of the target application program within the preset time interval. In addition, the number of times the target application program executes the interface drawing interface within the preset time interval can also be calculated. The current interface frame rate of the target application.

Specifically, the ratio of the target difference to the preset number can be obtained, and the ratio can be used as the frame loss rate of the target application within the preset time interval, wherein the target difference is the number of times the target application executes the interface drawing interface and the preset The difference between the quantities. That is, the difference between the preset number and the number of times may be determined first, and the ratio of the difference to the preset number may be calculated, and the ratio may be used as the frame loss rate of the target application within the preset time interval. It is also possible to calculate all preset time intervals included in the last unit time, and use the number of times the target application executes the interface drawing interface in all preset time intervals as the current interface frame rate of the target application.

The specific process of calculating the frame loss rate of the target application program within the preset time interval will be introduced below with reference to FIG. 5 .

Please refer to Figure 5. Figure 5 is a schematic diagram of a frame loss rate calculation provided by the embodiment of the present application. As shown in Figure 5, taking the interface refresh rate corresponding to the preset system as 60 Hz as an example, the default system every 16.6 milliseconds Send an interface drawing signal to the target application program through the interface drawing interface, if there is a drawing event in the target application program, then the target application program executes the interface drawing interface to obtain the interface drawing signal, and executes the interface drawing program once, so as to be in the target application program Draw a frame in the interface.

As shown in Figure 5 for the first drawing, the target application program executes the interface drawing interface once, and the interface drawing program is executed within 16.6 milliseconds of the interface drawing cycle. At this time, the display interface of the target application program does not drop frames.

However, when drawing for the second time in Figure 5, the target application executes the interface drawing interface once, but executes the interface drawing program within 3 interface drawing cycles, that is, the second drawing takes up 3 interface drawing cycles. If a drawing event should have been planned in the two interface drawing cycles of the three interface drawing cycles, but because the second drawing has not ended, the target application cannot execute the preset interface to obtain the interface drawing signal and execute the interface drawing program , that is, the drawing events of the next two drawing cycles will not be executed, and at this time, the display interface of the target application program drops frames. From the third drawing to the eighth drawing later on, the target application program will execute the interface drawing interface once respectively, and execute the interface drawing program in one drawing cycle respectively, that is, the third drawing to the eighth drawing are equal to each other. No frame drops occurred.

If the 10 interface drawing cycles in Figure 5 are used as the preset time interval, then within the preset time interval, it can be counted that the number of times the target application executes the interface drawing interface is 8 times, and the preset time interval includes the system interface drawing cycle The preset number of is 10, so the difference between the preset number and the number of times is 2, and the ratio of the difference to the preset number is 0.2, then the frame loss rate of the target application within the preset time interval is 20%. Furthermore, it is also possible to calculate all the preset time intervals included in the last unit time. For example, when the unit time is 1 second, and the preset number of drawing cycles of the system interface included in the preset time interval is 10, then within 1 second 6 preset time intervals are included, and the number of times the target application program executes the interface drawing interface within the 6 preset time intervals is used as the current interface frame rate of the target application program.

Optionally, after the frame loss rate of the target application is calculated within a preset time interval, the frame loss rate within a plurality of subsequent preset time intervals can also be calculated sequentially, and can also be displayed on the interface of the target application The frame loss rate in each preset time interval is displayed in . Specifically, a window may be added at any position of the application interface of the target application, and the calculated frame loss rate of the target application within each preset time interval is displayed in real time through the window.

Please refer to FIG. 6 . FIG. 6 is a schematic diagram of an application program interface display provided by an embodiment of the present application.

As shown in FIG. 6 , a target application program is running in the terminal 600 , and a window 620 may be set in the display interface 610 of the target application program, and the window 620 displays the calculated frame loss rate within each preset time interval. In order to make it easier for developers to judge the frame loss rate in each preset time interval, the frame loss rate in different intervals can be represented by different graphics, colors or filling patterns. For example, when using a histogram to indicate the frame loss rate in each preset time interval, you can use a green column to indicate no frame loss (frame loss 0%), use a blue column to indicate frame loss below 30%, and use a red column to indicate frame loss More than 30%; the height of the column can also be used to correspond to the size of the frame loss rate. For example, in Figure 6, the higher the height of the column, the greater the frame loss rate in the corresponding time interval.

Optionally, since the current interface frame rate of the target application program can also be obtained, the current interface frame rate of the target application program can also be displayed in window 620 as required.

Since the above-mentioned method of calculating the frame loss rate of the target application program within the preset time interval and the current interface frame rate of the target application program is implemented by means of software, it is necessary to purchase additional peripherals compared to the related technology Equipped to analyze the method of frame loss rate, which can effectively reduce the cost of frame rate processing.

S302. Obtain the execution time of each code execution stack corresponding to the target application program within a preset time interval, and determine the target code execution stack that causes the target application program to drop a frame according to the execution time of each code execution stack.

After obtaining the frame loss rate of the target application within the preset time interval, you can determine whether to locate the cause of the frame loss of the target application according to your needs. One feasible way is, regardless of the specific value of the frame loss rate, After determining the frame loss rate of the target application program within the preset time interval, the cause of the frame loss of the target application program can be located. More severe errors in the target application; as an alternative, the frame loss rate can be compared to a frame loss rate threshold, which can be set as desired, for example, the frame loss rate threshold can be unaffected The minimum frame loss rate at which the user normally watches the display of the target application. Then when the frame loss rate is greater than the frame loss rate threshold, it will affect the user's normal viewing of the display screen of the target application. At this time, it is necessary to determine the cause of the frame loss of the target application. The advantage of this implementation is that it can reduce the target application. Power consumption due to frame loss of the target application due to positioning. For the sake of description, the following takes locating the cause of the frame loss of the target application when the frame loss rate is greater than the frame loss rate threshold as an example, and specifically introduces the method of locating the cause of the frame loss of the target application.

It can be understood that during the running of the target application, the execution process of each running event is executed in the corresponding specific thread, so when the target application executes the interface drawing program, it will also be executed in a specific main thread. A thread can include multiple code execution stacks arranged in the order of execution. The code execution stack can be considered as a collection of code functions, and the execution process of the interface drawing program is also the execution process of the code functions in the code execution stack.

Please refer to FIG. 7 . FIG. 7 is a schematic structural diagram of a code execution stack provided by an embodiment of the present application.

As shown in Figure 7, in an ideal situation, only the interface drawing code execution stack is included in the main thread code execution sequence corresponding to the interface drawing process, and one interface drawing code execution stack corresponds to one system interface drawing cycle, then if the target application If the program loses frames within the preset time interval, it may be that there is a problem with one or more interface drawing code execution stacks, causing the interface drawing code execution stack to time out during one or more system interface drawing cycles. For example, there is a problem with the interface drawing code execution stack 1 in Figure 7, which causes the execution of the interface drawing code execution stack 1 to time out in a corresponding system interface drawing cycle, and the interface drawing code execution stack 1 may occupy the subsequent system interface drawing cycle , the interface drawing code execution stack cannot be executed in the subsequent system interface drawing cycle, which leads to frame loss on the display interface of the target application program.

Another situation is that during the running of the target application, in addition to executing interface drawing events, other business events (for example, collecting voice information, etc.) may also be executed, then these business events will also be executed in the corresponding code in the thread Stack, since these code execution stacks do not involve interface drawing, these code execution stacks are named non-interface drawing code execution stacks here. Then, if the target application loses frames within the preset time interval, there may be a problem with one or more non-interface drawing code execution stacks, and the execution process of non-interface drawing code execution stacks takes up more thread execution The time is likely to occupy the subsequent system interface drawing cycle, which will cause the interface drawing code execution stack to fail to execute normally. For example, there is a problem with the non-interface drawing code execution stack 1 in Figure 7. The execution process of the non-interface drawing code execution stack 1 takes up more thread execution time, which in turn causes the interface drawing code execution stack 2 to fail to draw on the corresponding system interface. The cycle is executed normally, resulting in frame loss on the display interface of the target application.

From the execution process of the above code execution stack, it can be seen that the length of the execution process of the code execution stack may cause the frame loss of the target application program, so a feasible implementation method for determining the cause of the frame loss of the target application program is, if If the frame loss rate within the preset time interval is greater than the frame loss rate threshold, first obtain the execution time of each code execution stack corresponding to the target application within the preset time interval, so as to determine whether the corresponding code execution stack is executed according to the execution time A problem arises, wherein the manner of determining the execution time of each code execution stack corresponding to the target application program within the preset time interval may not be limited.

Further, after obtaining the execution time of each code execution stack corresponding to the target application in the preset time interval, the execution time corresponding to each code execution stack during normal execution can also be determined according to the type of each code execution stack, and each code The execution time of the execution stack is compared with its corresponding execution time during normal execution. If the execution time of the code execution stack is greater than its corresponding execution time during normal execution, the code execution stack can be determined as the one that causes the target application to drop frames. Object code execution stack.

When the frame loss rate is less than or equal to the frame loss rate threshold, it will not affect the user's normal viewing of the display screen of the target application program. At this time, there is no need to determine the cause of the frame loss of the target application program, and the process can return to step S301.

S303. Print the target code functions included in the target code execution stack and the running time corresponding to each target code function.

It can be understood that the code execution stack can be considered as a collection of code functions, so the code execution stack can include at least one code function, then after determining the target code execution stack that causes the target application to drop frames, in order to facilitate the analysis of the developer The code functions that cause the target application to drop frames can also be obtained from the target code functions included in the target code execution stack and the running time corresponding to each target code function, and the target code functions and the running time corresponding to each target code function are calculated. Print, where the specific way of printing can be to print logs or upload print logs.

Since the running time of each code function in the code execution stack is also within a certain preset time range, if the running time corresponding to one or some target code functions exceeds the preset time range, then the target code can be determined The function is the cause of the problem in the execution of the target code execution stack. Developers can optimize the target code function so that the target code function and the corresponding target code execution stack can run normally, so that the target application can draw the interface normally. Addresses frame dropping issues with target applications.

Please refer to FIG. 8 . FIG. 8 is a schematic flowchart of a frame rate processing method provided by another embodiment of the present application.

As shown in Figure 8, the method includes:

S801. Based on the first code inserted at the start position of each code function in the target application program, record the identity, start time, and start flag of each code function when each code function starts running, and save them in chronological order to in the preset collection.

In the embodiment of the present application, in order to facilitate the subsequent determination of the execution time of each code execution stack corresponding to the target application within the preset time interval, each code function in the target application can be assigned a unique identity, and establish a mapping relationship between each code function and the corresponding identity, so that each code function and its corresponding identity are mapped one by one. It is also possible to generate a mapping file based on all mapping relationships, for example, the mapping file is mapping.txt, and package the mapping file into the target application, so that after the target application is installed, the mapping file is loaded and all mapping relationships are resolved.

Further, it is also possible to insert the first code at the beginning of each code function during the writing process of each code function in the target application, wherein the first code is used to record the identity and code of the corresponding code function based on the above-mentioned mapping relationship. The start time when the function starts to run and the code function is the start identification bit to start running; and the second code is inserted at the end position of each code function, wherein the second code is used to record the identity and code of the corresponding code function based on the above-mentioned mapping relationship The end time of the function ending operation and the code function is the end identification bit of the end operation.

Then, after the target application program runs in the preset system, based on the first code inserted at the start position of each code function in the target application program, the identity and start time of each code function can be recorded respectively when each code function starts running and the start flag, and are stored in the preset collection in chronological order. In order to facilitate corresponding storage of the identity, start time and start flag of each code function, the identity, start time, and start flag of each code function can be stored in a long-type storage method, wherein a long-type data includes 64-bit storage bytes, the first 18 bits of a long integer are used to save the identity of the corresponding code function, the middle 45 bits are used to save the start time of the corresponding code function, and the last bit is used to save the start flag of the corresponding code function.

In the process of recording the identity, start time, and start flag of each code function, the recording results can also be saved in a preset collection in chronological order. For example, when the identity, start time, and start flag of each code function are stored in a long-type storage method, after determining the long-type data of a code function, the order of the start time recorded in the long-type can be followed. Each long type data is formed into a long type array, and the length of the long type array can be set according to the total number of code functions in the target application program, for example, the length of the long type array can be set to 8MB.

S802. Based on the second code inserted at the end position of each code function in the target application program, record the identity, end time, and end flag of each code function when each code function finishes running, and save them in chronological order to in the preset collection.

Similar to the above steps, after the target application program runs in the preset system, based on the second code inserted at the end position of each code function in the target application program, the identity of each code function can be recorded separately when each code function finishes running ID, end time and end flag, and save them in the preset collection in chronological order. Among them, in order to store the identity, end time and end flag of each code function conveniently, the identity, end time, and end flag of each code function can also be stored in a long-type storage method. Among them, a long data type Including 64-bit storage bytes, the first 18 bits of a long integer are used to save the identity of the corresponding code function, the middle 45 bits are used to save the end time of the corresponding code function, and the last bit is used to save the end sign of the corresponding code function bit.

On the basis of the previous step, since it may be necessary to record the identity, end time, and end flag of the code function at any time during the process of recording the identity, start time, and start flag of the code function, so when recording each code In the process of identifying the identity, end time, and end flag of the function, the recording results can also be saved in the same preset set in the above steps in chronological order, that is, the identity, end time, and end flag of the code function It is stored in the same set as the code function's identity, end time, and end flag. For example, when the identity, end time, and end flag of each code function are stored in a long-type storage method, after determining the long-type data of a code function, it can be recorded in the order of the end time in the long-type, Insert each long-type data into the above-mentioned long-type array, then the long-type array includes each long-type data arranged in chronological order.

Please refer to FIG. 9 . FIG. 9 is a schematic diagram of an aggregate structure provided by an embodiment of the present application.

As shown in Figure 9, when the identity, start time, end time, start flag, and end flag of each code function are stored in a long-type storage method, the left side of Figure 9 shows a long-type data storage method , that is, each long type data is formed into a set (long type array). For example, in the long data in Figure 9, identity 1 represents the code function whose identity is 1, time 1 represents the start time of the code function whose identity is 1, and flag 1 represents the start flag bit of the code function whose identity is 1 ; Another example, in another long data in Figure 9, identity 1 represents the code function with identity 1, time 14 represents the end time of the code function with identity 1, and mark 0 represents the code function with identity 1 The end flag, and the rest of the long data are similar to the above, that is, the identity value represents the unique identity of the corresponding code function, the time value represents the start time or end time of the corresponding code function (judged according to the flag bit), and the flag value (0 Or 1) indicates whether the corresponding code function starts or ends, wherein the long data in the long array is sorted according to the start time or end time of the records. Furthermore, according to the writing logic of the code function, different parts of the same code function can be executed separately, that is, other code functions can be nested in a code function, so the start time and end time of the same code function are different, and the same The start flag and end flag of the code function are also different.

Then through this set, it is easy to determine the running position of a certain code function and its corresponding running time. For example, for any code function with an identity, two long data can be determined through the above set, and then through The flag bits of each long-type data respectively determine the long-type data corresponding to the start of the code function and the long-type data corresponding to the end of the code function, and finally determine the start time and end time corresponding to the long-type data respectively, and calculate the start time and end time The difference can determine the running time of the code function. Similarly, the running time of any code function in the target application can be calculated.

S803. Count the number of times the target application program executes the interface drawing interface within the preset time interval, and calculate the frame loss rate of the target application program within the preset time interval according to the preset time interval and times.

For step S803, reference may be made to the detailed description in step S301, which will not be repeated here.

S804. If the frame loss rate is greater than the frame loss rate threshold, determine the first identity of the initial code function of each code execution stack corresponding to the target application within the preset time interval, and search the preset set for each initial code function The first start flag matched by the first ID of the ID and the first start time corresponding to the first start flag.

From the execution process of the above code execution stack, it can be seen that the length of the execution process of the code execution stack may cause the frame loss of the target application program, so a feasible implementation method for determining the cause of the frame loss of the target application program is, if If the frame loss rate within the preset time interval is greater than the frame loss rate threshold, first obtain the execution time of each code execution stack corresponding to the target application within the preset time interval, so as to determine whether the corresponding code execution stack is executed according to the execution time problem appear.

Since the code execution stack can be considered as including multiple code functions, and the code functions have a certain execution logic during execution, the sequence of execution logic determines the execution order of the code functions. Therefore, according to the above mapping relationship, it is possible to first determine the code execution stacks corresponding to the target application program within the preset time interval, and then determine the first identity of the initial code function of each code execution stack, wherein the code execution The initial code function of the stack refers to the code function that is executed first when the code execution stack starts to run, and finally finds the record result (for example, long data) corresponding to the first identity of each initial code function in the preset set, In the record result, if the first start flag matched with the first identity and the first start time corresponding to the first start flag are determined, then each first start time can be regarded as the time when each code execution stack starts to run.

S805. Determine the second identity of the end code function of each code execution stack corresponding to the target application within the preset time interval, and search for the second end mark matching the second identity of each end code function in the preset set bit, and the second end time corresponding to the second end flag bit.

Similarly, the second identity of the end code function of each code execution stack corresponding to the target application within the preset time interval can also be determined according to the above mapping relationship, wherein the initial code function of the code execution stack refers to the start code function of the code execution stack The first code function to execute at runtime. Understandably, due to the writing logic of the code function, the start code function and the end code function of a code execution stack are different parts of the same code function, so the identity of the start code function and the end code function of a code execution stack The identifiers can be the same (that is, the first identity identifier and the second identity identifier are the same); of course, the start code function and the end code function of a code execution stack may not be different parts of the same code function, so a code execution stack The ID of the start code function and the ID of the end code function may also be different (that is, the first ID and the second ID are different). It is also possible to search for the record results (for example, long data) corresponding to the second identity of each end code function in the preset set, and determine the second end flag bit matching the second identity in the record results, and For the second end time corresponding to the second end flag bit, each second end time can be considered as the time when each code execution stack finishes running.

S806. Use the difference between the first start time of the initial code function of each code execution stack and the second end time of the end code function of each code execution stack as the execution time of each code execution stack.

As mentioned above, each first start time can be considered as the time when each code execution stack starts running, and each second end time can be considered as the time when each code execution stack ends running, so the initial code function of each code execution stack can be The difference between the first start time of the code execution stack and the second end time of the end code function of each code execution stack is used as the execution time of each code execution stack.

S807. Determine the type of each code execution stack. The type of code execution stack includes an interface rendering execution stack and a non-interface rendering execution stack.

In the above-mentioned embodiment, the types of code execution stacks include interface drawing execution stacks and non-interface drawing execution stacks, and the execution time of different types of code execution stacks is different, so when determining the target that causes the target application to drop frames When the code executes the stack, the type of each code execution stack can be determined first.

S808. Determine the type of the code execution stack as the interface drawing execution stack, and the code execution stack whose execution time is longer than the system interface drawing cycle is determined as the target code execution stack.

Since one interface drawing code execution stack corresponds to one system interface when the display interface of the target application program does not drop frames, when the type of the code execution stack is the interface drawing execution stack, the execution of the interface drawing execution stack can be executed The time is compared with the system interface drawing cycle. If the execution time of the interface drawing execution stack is longer than the system interface drawing cycle, the code execution stack can be determined as the target code execution stack, that is, the target code execution stack that causes the target application to drop frames .

S809. Determine the code execution stack whose type is the non-interface drawing execution stack and whose execution time is longer than the preset execution stack execution time as the target code execution stack.

Further, since the display interface of the target application program does not drop frames, the non-interface drawing execution stack should occupy a small amount of time in the thread, so as to avoid occupying the subsequent system interface drawing cycle and avoid subsequent interface drawing The code execution stack cannot be executed normally. The non-interface drawing execution stack takes up less time in the thread. It can be set as the default execution stack execution time. The specific value of the preset execution stack execution time can be set according to the needs. The default execution stack The execution time can be considered as the minimum time for the normal execution of the non-interface drawing execution stack without affecting the normal execution of the subsequent interface drawing code execution stack.

Therefore, when the type of the code execution stack is the non-interface drawing execution stack, the execution time of the non-interface drawing execution stack can be compared with the execution time of the preset execution stack. When the execution time of the non-interface drawing execution stack is greater than the execution time of the preset execution stack time, the code execution stack can be determined as the target code execution stack, that is, the target code execution stack that causes the target application program to drop frames.

S810. Determine a third identity, a third start flag, a third end flag, a third start time, and a third end time between the initial code function and the end code function in the target code execution stack based on a preset set.

It can be understood that the code execution stack can be considered as a collection of code functions, so the code execution stack can include at least one code function, then after determining the target code execution stack that causes the target application to drop frames, in order to facilitate the analysis of the developer The code function that causes the frame loss of the target application program can be obtained, and the target code functions included in the target code execution stack and the running time corresponding to each target code function can be obtained.

Specifically, the identity of the initial code function and the identity of the end code function in the target code execution stack can be determined first according to the above mapping relationship. Since the record data in the preset collection is arranged in chronological order, the initial code function and the end code function The code functions between the end code functions are the target code functions in the target code execution stack, so all the identities between the identities of the initial code functions and the identities of the end code functions can be determined based on the preset set, and these The identities are determined as third identities, and these third identities are the identities of the object code functions. Further, a third start flag, a third end flag, a third start time, and a third end time of the target code function may also be determined according to the third identifier.

S811. Obtain the corresponding target code functions according to each third identity, and according to the third start time corresponding to the third start flag bit of each target code function, the third end time corresponding to the third end flag bit of each target code function The difference determines the execution time corresponding to each object code function.

Since the third identity is the identity of the target code function, the corresponding target code functions can be determined based on the above-mentioned mapping relationship according to each third identity, and the target code function can be obtained from the code storage location of the target application program. specific code. Further, it is also possible to calculate the difference between the third start time corresponding to the third start flag of each object code function and the third end time corresponding to the third end flag of each object code function, and determine each difference as The running time corresponding to each object code function.

S812. Print each object code function and the running time corresponding to each object code function.

In order to facilitate developers to analyze the code functions that cause the target application to drop frames, it is also possible to obtain the target code functions included in the target code execution stack and the running time corresponding to each target code function, and compare the target code functions and each target code function It takes time to print the operation, and the specific way of printing can be to print the log or upload the print log.

In this embodiment of the application, by inserting code in the code function of the target application program in advance, the execution time of each code execution stack corresponding to the target application program can be accurately calculated through the inserted code, so that the execution time of each code execution stack can be calculated according to each code execution stack. Execution time determines the target code execution stack that causes the target application to drop frames, and the inserted code can also accurately locate the target code functions included in the target code execution stack and the corresponding running time of each target code function, which can help developers quickly , Accurately analyze the cause of frame loss.

Please refer to FIG. 10 . FIG. 10 is a structural block diagram of a frame rate processing device provided by an embodiment of the present application.

As shown in Figure 10, the frame rate processing device 1000 includes:

The frame loss calculation module 1010 is configured to count the number of times the target application program executes the interface drawing interface within the preset time interval, and calculate the frame loss rate of the target application program within the preset time interval according to the preset time interval and times.

Optionally, the frame loss calculation module 1010 is further configured to determine a system interface drawing period corresponding to the target application program, and determine a preset number of system interface drawing periods as a preset time interval.

Optionally, the frame loss calculation module 1010 is also used to calculate the current interface frame rate of the target application program, and display the current interface frame rate in the interface of the target application program; and/or display the preset time in the interface of the target application program The frame loss rate in the interval.

The execution stack determination module 1020 is configured to obtain the execution time of each code execution stack corresponding to the target application program within a preset time interval, and determine the target code execution stack that causes the target application program to drop frames according to the execution time of each code execution stack.

The code printing module 1030 is configured to print the target code functions included in the target code execution stack and the running time corresponding to each target code function.

Please refer to FIG. 11 . FIG. 11 is a structural block diagram of a frame rate processing device provided by another embodiment of the present application.

As shown in Figure 11, the frame rate processing device 1000 includes:

The first code insertion module 1110 is used to record the identity, start time and start flag of each code function when each code function starts running based on the first code inserted at the start position of each code function in the target application program, And save them in the preset collection in chronological order.

The second code insertion module 1120 is used to record the identity, end time and end flag of each code function when each code function ends running based on the second code inserted at the end position of each code function in the target application program, And save them in the preset collection in chronological order.

The frame loss calculation module 1130 is configured to count the number of times the target application program executes the interface drawing interface within the preset time interval, and calculate the frame loss rate of the target application program within the preset time interval according to the preset time interval and times.

The first information determination module 1140 is configured to determine the first identity of the initial code function of each code execution stack corresponding to the target application program within the preset time interval if the frame loss rate is greater than the frame loss rate threshold, in the preset set Search for the first start flag matching the first identity of each initial code function, and the first start time corresponding to the first start flag.

The second information determination module 1150 is configured to determine the second identity of the end code function of each code execution stack corresponding to the target application within the preset time interval, and search for the second identity of each end code function in the preset set Identify the matched second end flag bit, and the second end time corresponding to the second end flag bit.

Execution stack time determination module 1160 is used to use the difference between the first start time of the initial code function of each code execution stack and the second end time of the end code function of each code execution stack as the execution time of each code execution stack.

The execution stack type determination module 1170 is configured to determine the type of each code execution stack, and the type of the code execution stack includes an interface drawing execution stack and a non-interface drawing execution stack.

The first judging module 1180 is configured to determine the type of the code execution stack as the interface drawing execution stack, and the code execution stack whose execution time is longer than the system interface drawing cycle as the target code execution stack.

The second judging module 1190 is configured to determine the code execution stack whose type is non-interface drawing execution stack and whose execution time is longer than the preset execution stack execution time as the target code execution stack.

The third information determination module 11100 is configured to determine the third identity, the third start flag, the third end flag, and the third start time between the initial code function and the end code function in the target code execution stack based on a preset set and the third end time.

The code time-consuming determination module 11110 is used to obtain the corresponding target code functions according to the third identities, according to the third start time corresponding to the third start flag of each target code function, and the third end flag of each target code function The difference of the corresponding third end time determines the running time corresponding to each target code function.

The printing module 11120 is used to print each object code function and the running time corresponding to each object code function.

In an embodiment of the present application, a frame rate processing device includes: a frame loss calculation module, configured to count the number of times a target application program executes an interface drawing interface within a preset time interval, and calculate the number of times the target application program executes an interface drawing interface according to the preset time interval and times The frame loss rate within the preset time interval; the execution stack determination module is used to obtain the execution time of each code execution stack corresponding to the target application program within the preset time interval, and determine the resulting target according to the execution time of each code execution stack The target code execution stack where the application program drops frames; the code printing module is used to print the target code functions included in the target code execution stack and the running time corresponding to each target code function. Because the frame loss rate is determined by counting the number of times the target application executes the interface drawing interface within the preset time interval, that is, the frame loss rate is determined by pure software, which can reduce the cost of frame rate processing. In addition, through the code execution stack It can locate and analyze the target code execution stack that causes the frame loss of the target application program in real time, and print the target code functions included in the target code execution stack and the running time corresponding to each target code function, which can help developers quickly and accurately analyze to find out the cause of the dropped frame.

An embodiment of the present application further provides a computer storage medium, where a plurality of instructions are stored in the computer storage medium, and the instructions are suitable for being loaded by a processor and executing the steps of any one of the methods in the foregoing embodiments.

Further, please refer to FIG. 12 . FIG. 12 provides a schematic structural diagram of a terminal according to an embodiment of the present application. As shown in FIG. 12 , a terminal 1200 may include: at least one central processing unit 1201 , at least one network interface 1204 , a user interface 1203 , a memory 1205 , and at least one communication bus 1202 .

Wherein, the communication bus 1202 is used to realize connection and communication between these components.

Wherein, the user interface 1203 may include a display screen (Display) and a camera (Camera), and the optional user interface 1203 may also include a standard wired interface and a wireless interface.

Wherein, the network interface 1204 may optionally include a standard wired interface and a wireless interface (such as a WI-FI interface).

Wherein, the central processing unit 1201 may include one or more processing cores. The central processing unit 1201 uses various interfaces and lines to connect various parts of the entire terminal 1200, by running or executing instructions, programs, code sets or instruction sets stored in the memory 1205, and calling data stored in the memory 1205 to execute Various functions and processing data of the terminal 1200. Optionally, the central processing unit 1201 can adopt at least one of a digital signal processing (Digital Signal Processing, DSP), a field-programmable gate array (Field-Programmable Gate Array, FPGA), and a programmable logic array (Programmable Logic Array, PLA). A form of hardware to achieve. The central processing unit 1201 may integrate one or a combination of a central processing unit (Central Processing Unit, CPU), an image central processing unit (Graphics Processing Unit, GPU) and a modem. Among them, the CPU mainly handles the operating system, user interface and application programs, etc.; the GPU is used to render and draw the content that needs to be displayed on the display screen; the modem is used to handle wireless communication. It can be understood that, the above-mentioned modem may not be integrated into the central processing unit 1201, but may be realized by a single chip.

Wherein, the memory 1205 may include a random access memory (Random Access Memory, RAM), and may also include a read-only memory (Read-Only Memory). Optionally, the memory 1205 includes a non-transitory computer-readable storage medium (non-transitory computer-readable storage medium). The memory 1205 may be used to store instructions, programs, codes, sets of codes, or sets of instructions. The memory 1205 may include a program storage area and a data storage area, wherein the program storage area may store instructions for implementing an operating system, instructions for at least one function (such as a touch function, a sound playback function, an image playback function, etc.), Instructions and the like for implementing the above method embodiments; the storage data area can store the data and the like involved in the above method embodiments. Optionally, the memory 1205 may also be at least one storage device located away from the aforementioned central processing unit 1201 . As shown in FIG. 12 , the memory 1205 as a computer storage medium may include an operating system, a network communication module, a user interface module, and a frame rate processing program.

In the terminal 1200 shown in FIG. 12 , the user interface 1203 is mainly used to provide the user with an input interface to obtain the data input by the user; and the central processing unit 1201 can be used to call the frame rate processing program stored in the memory 1205, and specifically Do the following:

Count the number of times the target application program executes the interface drawing interface in the preset time interval, and calculate the frame loss rate of the target application program in the preset time interval according to the preset time interval and times; The corresponding execution time of each code execution stack, and the execution time of each code execution stack to determine the target code execution stack that causes the target application to lose frames; print the target code functions included in the target code execution stack and the corresponding operation of each target code function time consuming.

In the several embodiments provided in this application, it should be understood that the disclosed devices and methods may be implemented in other ways. For example, the device embodiments described above are only illustrative. For example, the division of modules is only a logical function division. In actual implementation, there may be other division methods. For example, multiple modules or components can be combined or integrated. to another system, or some features may be ignored, or not implemented. In another point, the mutual coupling or direct coupling or communication connection shown or discussed may be through some interfaces, and the indirect coupling or communication connection of devices or modules may be in electrical, mechanical or other forms.

A module described as a separate component may or may not be physically separated, and a component shown as a module may or may not be a physical module, that is, it may be located in one place, or may also be distributed to multiple network modules. Part or all of the modules can be selected according to actual needs to achieve the purpose of the solution of this embodiment.

In addition, each functional module in each embodiment of the present application may be integrated into one processing module, each module may exist separately physically, or two or more modules may be integrated into one module. The above-mentioned integrated modules can be implemented in the form of hardware or in the form of software function modules.

If the integrated modules are realized in the form of software function modules and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present application is essentially or part of the contribution to the prior art or all or part of the technical solution can be embodied in the form of a software product, and the computer software product is stored in a storage medium , including several instructions to make a computer device (which may be a personal computer, a server, or a network device, etc.) execute all or part of the steps of the methods in various embodiments of the present application. The aforementioned storage media include: U disk, mobile hard disk, read-only memory (ROM, Read-Only Memory), random access memory (RAM, Random Access Memory), magnetic disk or optical disc, etc., which can store program codes. .

It should be noted that, for the sake of simplicity of description, the aforementioned method embodiments are expressed as a series of action combinations, but those skilled in the art should know that the present application is not limited by the described action sequence. Depending on the application, certain steps may be performed in other orders or simultaneously. Secondly, those skilled in the art should also know that the embodiments described in the specification are all preferred embodiments, and the actions and modules involved are not necessarily required by this application.

In the foregoing embodiments, the descriptions of each embodiment have their own emphases, and for parts not described in detail in a certain embodiment, reference may be made to relevant descriptions of other embodiments.

The above is a description of a frame rate processing method, device, storage medium and terminal provided by this application. For those skilled in the art, according to the idea of the embodiment of this application, there will be changes in the specific implementation and application scope In summary, the contents of this specification should not be construed as limiting the application.

Claims

A frame rate processing method, characterized in that the method comprises:

Counting the number of times the target application program executes the interface drawing interface within the preset time interval, and calculating the frame loss rate of the target application program within the preset time interval according to the preset time interval and the number of times;

Obtain the execution time of each code execution stack corresponding to the target application program within the preset time interval, and determine the target code execution stack that causes the target application program to drop frames according to the execution time of each code execution stack;

Print the target code functions included in the target code execution stack and the running time corresponding to each target code function.
The method according to claim 1, wherein the counting the number of times the target application program executes the interface drawing interface before the preset time interval further includes:

A system interface drawing period corresponding to the target application program is determined, and a preset number of system interface drawing periods is determined as a preset time interval.
The method according to claim 2, wherein the calculating the frame loss rate of the target application in the preset time interval according to the preset time interval and the number of times comprises:

Obtain the ratio of the target difference to the preset number, and use the ratio as the frame loss rate of the target application within the preset time interval;

Wherein, the target difference is a difference between the number of times the target application executes the interface drawing interface and a preset number.
The method according to claim 1, wherein the counting the number of times the target application program executes the interface drawing interface before the preset time interval further includes:

Based on the first code inserted at the start position of each code function in the target application program, record the identity, start time and start flag of each code function when each code function starts to run, and save them in chronological order to in the default collection;

Based on the second code inserted at the end position of each code function in the target application program, record the identity, end time and end flag of each code function when each code function ends, and save them in chronological order to in the preset set.
The method according to claim 4, wherein the obtaining the execution time of each code execution stack corresponding to the target application within the preset time interval comprises:

If the frame loss rate is greater than the preset frame loss rate threshold, determine the first identity of the initial code function of each code execution stack corresponding to the target application program within the preset time interval, and in the preset time interval Finding the first start flag matching the first identity of each initial code function in the set, and the first start time corresponding to the first start flag;

Determine the second identity of the end code function of each code execution stack corresponding to the target application program within the preset time interval, and search for the second identity that matches the second identity of each end code function in the preset set a second end flag, and a second end time corresponding to the second end flag;

The difference between the first start time of the initial code function of each code execution stack and the second end time of the end code function of each code execution stack is used as the execution time of each code execution stack.
The method according to claim 5, wherein the determining the target code execution stack that causes the frame loss of the target application program according to the execution time of each code execution stack includes:

Determine the type of each code execution stack, the type of the code execution stack includes an interface drawing execution stack and a non-interface drawing execution stack;

The type of the code execution stack is an interface drawing execution stack, and the code execution stack whose execution time is longer than the system interface drawing cycle is determined as the target code execution stack; and/or

The type of the code execution stack is a non-interface drawing execution stack, and the execution time of the code execution stack is greater than the execution time of the preset execution stack. The code execution stack is determined as the target code execution stack.
The method according to claim 5 or 6, wherein the printing of the target code functions included in the target code execution stack and the running time corresponding to each target code function includes:

Determine a third identity, a third start flag, a third end flag, a third start time, and a third end time between the initial code function and the end code function in the target code execution stack based on the preset set ;

Obtain the corresponding target code functions according to each third identity, and according to the third start time corresponding to the third start flag of each target code function, the difference between the third end time corresponding to the third end flag of each target code function Determine the running time corresponding to each object code function;

Print each object code function and the running time corresponding to each object code function.
The method according to claim 1, wherein after calculating the frame loss rate of the target application program in the preset time interval according to the preset time interval and the number of times, further comprising:

calculating the current interface frame rate of the target application, and displaying the current interface frame rate in the interface of the target application; and/or

Displaying the frame loss rate within the preset time interval on the interface of the target application program.
The method according to claim 4, wherein the counting the number of times the target application executes the interface drawing interface before the preset time interval further includes:

Assigning unique identities to each code function in the target application program, and establishing a mapping relationship between each code function and the corresponding identities;

A mapping file is generated based on all the mapping relationships, and the mapping file is packaged into the target application program, so that the target application program loads the mapping file and resolves all the mapping relationships after installation.
A frame rate processing device, characterized in that the device comprises:

A frame loss calculation module, configured to count the number of times the target application program executes the interface drawing interface within a preset time interval, and calculate the number of times the target application program executes the interface drawing interface in the preset time interval according to the preset time interval and the number of times frame loss rate;

An execution stack determining module, configured to obtain the execution time of each code execution stack corresponding to the target application within the preset time interval, and determine the execution time of the target application program according to the execution time of each code execution stack The object code execution stack of the frame;

The code printing module is used to print the target code functions included in the target code execution stack and the running time corresponding to each target code function.
The device according to claim 10, wherein the frame loss calculation module is further configured to determine the system interface drawing cycle corresponding to the target application program, and determine a preset number of system interface drawing cycles as a preset time interval .
The device according to claim 11, wherein the frame loss calculation module is further configured to obtain a ratio of the target difference to the preset number, and use the ratio as the target application program in the preset Set the frame loss rate in the time interval;

Wherein, the target difference is a difference between the number of times the target application executes the interface drawing interface and a preset number.
The device according to claim 10, further comprising:

The first code insertion module is used to record the identity, start time and start flag of each code function when each code function starts running based on the first code inserted at the start position of each code function in the target application program , and save them in the preset collection in chronological order;

The second code insertion module is used to record the identity, end time and end flag of each code function when each code function ends running based on the second code inserted at the end position of each code function in the target application program , and save them in the preset collection in chronological order.
The device according to claim 13, further comprising:

The first information determination module is configured to determine the first information of the initial code function of each code execution stack corresponding to the target application within the preset time interval if the frame loss rate is greater than the preset frame loss rate threshold An identity, searching in the preset set for a first start flag that matches the first identity of each initial code function, and a first start time corresponding to the first start flag;

The second information determination module is configured to determine the second identity of the end code function of each code execution stack corresponding to the target application program within the preset time interval, and search for each end code in the preset set the second end flag matched by the second identifier of the function, and the second end time corresponding to the second end flag;

The execution stack time determination module is used to use the difference between the first start time of the initial code function of each code execution stack and the second end time of the end code function of each code execution stack as the execution time of each code execution stack.
The device according to claim 14, further comprising:

The execution stack type determination module is used to determine the type of each code execution stack, and the type of the code execution stack includes an interface drawing execution stack and a non-interface drawing execution stack;

The first judging module is used to determine the type of the code execution stack as an interface drawing execution stack, and the code execution stack whose execution time is longer than the system interface drawing cycle is determined as the target code execution stack; and/ or

The second judging module is used to determine the type of the code execution stack as a non-interface drawing execution stack, and the code execution stack whose execution time is greater than the preset execution stack execution time is determined as the target code execution stack .
The device according to claim 14 or 15, wherein the device further comprises:

The third information determination module is configured to determine the third identity, the third start flag, the third end flag, the third code function between the initial code function and the end code function in the target code execution stack based on the preset set. Three start time and a third end time;

The code time-consuming determination module is used to obtain corresponding target code functions according to each third identity, and corresponds to the third end flag of each target code function according to the third start time corresponding to the third start flag of each target code function The difference of the third end time of the determination of the running time corresponding to each object code function;

The printing module is used to print each object code function and the running time corresponding to each object code function.
The device according to claim 10, wherein the frame loss calculation module is also used for:

calculating the current interface frame rate of the target application, and displaying the current interface frame rate in the interface of the target application; and/or

Displaying the frame loss rate within the preset time interval on the interface of the target application program.
The device according to claim 13, wherein the frame loss calculation module is also used for:

Assigning unique identities to each code function in the target application program, and establishing a mapping relationship between each code function and the corresponding identities;

A mapping file is generated based on all the mapping relationships, and the mapping file is packaged into the target application program, so that the target application program loads the mapping file and resolves all the mapping relationships after installation.
A computer storage medium, characterized in that the computer storage medium stores a plurality of instructions, and the instructions are suitable for being loaded by a processor and executing the steps of the method according to any one of claims 1-9.
A terminal, characterized by comprising a memory, a processor, and a computer program stored in the memory and operable on the processor, when the processor executes the program, it realizes any one of claims 1-9 method steps.