CN116541643A

CN116541643A - Function running time calculation method and device, storage medium and electronic equipment

Info

Publication number: CN116541643A
Application number: CN202310496901.3A
Authority: CN
Inventors: 龙国润; 黄晨
Original assignee: Black Sesame Intelligent Technology Co ltd
Current assignee: Black Sesame Intelligent Technology Co ltd
Priority date: 2023-04-26
Filing date: 2023-04-26
Publication date: 2023-08-04

Abstract

The application provides a function running time calculating method, a function running time calculating device, a storage medium and electronic equipment, and relates to the technical field of computers. The method comprises the following steps: determining a plurality of first function call chains contained in a program to be tested based on a first sampling frequency; recording sampling time stamps of functions contained in the plurality of first function call chains; the run length of the function is determined based on the sampling time stamps of the functions included in the plurality of first function call chains. By the scheme, the accuracy of analyzing the function performance is improved under the condition that the running process of the program to be tested is less affected.

Description

Function running time calculation method and device, storage medium and electronic equipment

Technical Field

The present invention relates to the field of computer technologies, and in particular, to a method and apparatus for calculating function running time, a storage medium, and an electronic device.

Background

When the perf tool is used for performing performance analysis on a program to be tested, the use condition of the function is usually determined according to the calling times of the function, and the operation ratio of the function in the whole program to be tested is calculated according to the use condition.

However, this method cannot better describe the execution of all functions, and in particular, cannot calculate the correct execution time of the function and the execution time duty ratio of the function in the whole program to be tested for the function in the sleep period.

Disclosure of Invention

In view of this, the embodiments of the present application provide a method, an apparatus, a storage medium, and an electronic device for calculating a function runtime.

In a first aspect, an embodiment of the present application provides a method for calculating a function runtime, including: determining a plurality of first function call chains contained in a program to be tested based on a first sampling frequency; recording sampling time stamps of functions contained in the plurality of first function call chains; the run length of the function is determined based on the sampling time stamps of the functions included in the plurality of first function call chains.

With reference to the first aspect, in certain implementation manners of the first aspect, the method for calculating a function runtime further includes: determining a plurality of second function call chains contained in the program to be tested based on a second sampling frequency, wherein the second sampling frequency is larger than the first sampling frequency; wherein determining the running time of the function based on the sampling time stamps of the functions included in the plurality of first function call chains includes: integrating the plurality of first function call chains and the plurality of second function call chains to generate at least one third function call chain; the run length of the function is determined based on at least one third chain of function calls.

With reference to the first aspect, in certain implementation manners of the first aspect, determining the operation duration of the function based on at least one third function call chain includes: determining a first call time of the function in the third function call chain based on the sampling time stamp of the function contained in the third function call chain; determining the exit time of the function in a third function call chain; and determining the running time of the function based on the first calling time of the function and the exiting time of the function.

With reference to the first aspect, in certain implementations of the first aspect, determining an exit time of the function in the third function call chain includes: determining other functions which are in the same function call chain and the same call depth as the function from the third function call chain; the exit time of the function is determined based on the sampling time stamps of the other functions.

With reference to the first aspect, in certain implementation manners of the first aspect, integrating the plurality of first function call chains and the plurality of second function call chains to generate at least one third function call chain includes: determining an entry function of each of the plurality of first function call chains; merging the plurality of first function call chains based on respective entry functions of the plurality of first function call chains to generate at least one fourth function call chain; and supplementing the functions contained in the plurality of second function call chains to at least one fourth function call chain to generate at least one third function call chain.

With reference to the first aspect, in certain implementation manners of the first aspect, based on respective entry functions of the plurality of first function call chains, merging the plurality of first function call chains to generate at least one fourth function call chain includes: acquiring an entry function related in the entry function of each of the plurality of first function call chains; constructing a main branch of the function call chain based on the entry functions involved in the entry functions of each of the plurality of first function call chains; determining a function call chain extension branch in a function call chain main branch; and supplementing functions contained in the plurality of first function call chains to function nodes in a main branch of the function call chain and an extension branch of the function call chain, and generating at least one fourth function call chain.

With reference to the first aspect, in certain implementation manners of the first aspect, supplementing a function included in the plurality of second function call chains to at least one fourth function call chain, generating at least one third function call chain includes: determining an entry function of each of the plurality of second function call chains; if the entry function of the second function call chain appears in at least one fourth function call chain, taking the function in the fourth function call chain which is the same as the entry function of the second function call chain as a starting point, and supplementing the function contained in the second function call chain to the at least one fourth function call chain; if the entry function of the second function call chain does not appear in the at least one fourth function call chain, constructing a main branch of the function call chain based on the entry function of the second function call chain; at least one third function call chain is generated based on the supplemented at least one fourth function call chain and the function call chain main branch.

With reference to the first aspect, in certain implementation manners of the first aspect, determining, based on the first sampling frequency, a plurality of first function call chains included in the program to be tested includes: setting the starting time and the interrupting time of a timer by using a perf tool based on the first sampling frequency; reading a general register value in a current processor at the interrupt time of the timer; if the current scheduling function belongs to the program to be tested based on the general register value, storing the function information of the current scheduling function into a buffer area; the data in the buffer area is read, and a plurality of first function call chains contained in the program to be tested are determined.

With reference to the first aspect, in certain implementations of the first aspect, recording sampling timestamps of functions included in the plurality of first function call chains includes: based on the start time and the interrupt time of the timer, sampling time stamps of functions included in the plurality of first function call chains are recorded.

With reference to the first aspect, in certain implementation manners of the first aspect, the method for calculating a function runtime further includes: determining the running time length of the program to be tested when the program to be tested is sampled at a first sampling frequency; and determining the proportion of the function to the running time of the program to be tested based on the running time of the function and the running time of the program to be tested.

With reference to the first aspect, in certain implementation manners of the first aspect, the method for calculating a function runtime further includes: determining the running time of the sub-function corresponding to the function; and determining the operation time length of the function when the subfunction is not called based on the operation time length of the subfunction corresponding to the function and the operation time length of the function.

In a second aspect, an embodiment of the present application provides a function runtime computing device, including: the first determining module is used for determining a plurality of first function call chains contained in the program to be tested based on the first sampling frequency; a recording module for recording sampling time stamps of functions contained in the plurality of first function call chains; and the second determining module is used for determining the running time of the function based on the sampling time stamps of the functions contained in the plurality of first function call chains.

In a third aspect, an embodiment of the present application provides a computer readable storage medium storing a computer program for executing the method mentioned in the first aspect.

In a fourth aspect, an embodiment of the present application provides an electronic device, including: a processor; a memory for storing processor-executable instructions; the processor is adapted to perform the method mentioned in the first aspect.

In this embodiment, by reasonably setting the first sampling frequency, it may be ensured that a relatively complete first function call chain is collected. When the program to be tested is sampled by utilizing the first sampling frequency, the sampling time stamp of the function in the first function call chain is recorded, the running time of the function can be further determined, the running process of the program to be tested is not influenced, and the technician can conveniently analyze the performance of the function and perform optimization analysis on the function.

Drawings

The foregoing and other objects, features and advantages of the present application will become more apparent from the following more particular description of embodiments of the present application, as illustrated in the accompanying drawings. The accompanying drawings are included to provide a further understanding of embodiments of the application and are incorporated in and constitute a part of this specification, illustrate the application and not constitute a limitation to the application. In the drawings, like reference numerals generally refer to like parts or steps.

Fig. 1 is a flowchart of a method for calculating a function runtime according to an exemplary embodiment of the present application.

Fig. 2 is a schematic flow chart of determining the operation duration of a function according to an exemplary embodiment of the present application.

Fig. 3 is a schematic flow chart of determining the operation time length of a function according to another exemplary embodiment of the present application.

Fig. 4 is a flowchart illustrating a method for determining an exit time of a function according to an exemplary embodiment of the present application.

Fig. 5 is a schematic flow chart of generating a third function call chain according to an exemplary embodiment of the present application.

Fig. 6 is a flowchart of a method for calculating a function runtime according to another exemplary embodiment of the present application.

Fig. 7 is a flowchart of a method for calculating a function runtime according to another exemplary embodiment of the present application.

FIG. 8 is a schematic diagram of a function runtime computing device according to an exemplary embodiment of the present application.

Fig. 9 is a schematic structural diagram of an electronic device according to an embodiment of the present application.

Detailed Description

The following description of the technical solutions in the embodiments of the present application will be made clearly and completely with reference to the drawings in the embodiments of the present application, and it is apparent that the described embodiments are only some embodiments of the present application, not all embodiments. All other embodiments, which can be made by one of ordinary skill in the art without undue burden from the present disclosure, are within the scope of the present disclosure.

Summary of the application

linux: a set of operating systems is freely available and freely disseminated.

Thread: the minimum unit of operation scheduling that the operating system can perform includes specific execution threads and data. The memory address that it can access is called a virtual address, which is allocated in units of a process, and may include multiple threads in the same process.

The process comprises the following steps: can be thought of as a container of threads that contains a separate address space that is visible to all threads within a process. The process has no own execution thread, and its function is realized by the thread contained in the process, i.e. each process comprises at least one thread.

Performance analysis: non-standard application performance can create software or network problems, and to ensure that software meets or exceeds the expected value of the design, it is necessary to analyze the performance of the application to find potential problems, a process known as performance analysis.

perf: a Linux self-contained set of performance analysis tools that support multiple functions such as hardware performance counters, software performance counters, etc.

valgrind: a software development tool kit for memory debugging, memory leak detection, performance analysis and thread error detection on Linux.

Compiling: a process of generating a target program from a source program written in a source language using a compiler, and an action of generating the target program using the compiler.

Sampling: refers to the process of withdrawing an individual or sample from a population. In perf, it is generally understood that the current running function is collected at a fixed frequency.

Function call path: the method consists of functions and the calling relationship between the functions in the running process of the program.

Function call chain: and in the running process of the program, the functions form a chain relation after being called mutually.

Function in-out time: the time the function was called and the function exited.

IDE (Integrated Development Environment ): application programs for providing a program development environment include tools such as code editors, compilers, debuggers, performance analyzers, and graphical interfaces. And integrating code writing functions, analysis, compiling, debugging and other integrated software development services.

Annular buffer: also referred to as circular queues, circular buffers, is a data structure representing a fixed size, end-to-end buffer suitable for buffering data streams.

Binary: in mathematical or digital circuits, a counting system based on 2 is referred to, and a system based on 2 represents a binary system.

API (Application Programming Interface ): defining interactions between multiple software intermediaries, the kind of calls or requests that can be made, how calls or requests are made, the data format that should be used, the conventions that should be followed, etc.

Key value pairs: a data representation in a computer system and application program, all or part of a data model may be represented as < attribute name value >, which is a key-value pair.

Linked list: one common underlying data structure is a linear table, but rather than storing data in a linear order, a pointer to the next node is maintained in each node.

Traversing: refers to sequentially accessing each node in the data structure along a search path.

The program development firstly meets the functional requirements, and different development languages, different development environments and different algorithm implementations can have certain influence on the program, so that no matter what stage the development is, the performance influence of the program needs to be considered. When analyzing the program performance, on the one hand, the judgment is based on the running time of the program under the condition that the input and the output are unchanged. Similarly, the performance of the function can be determined according to the proportion of the execution time length of the function to the total operation time length of the program.

In windows platform, IDE for program development generally contains performance analysis tool, and the analyzed program runs in IDE constructed environment or virtual environment to collect data such as total running time of program, proportion of executing time of function to total running time of program, etc. so as to facilitate developer to analyze program performance.

Unlike windows, linux has various tools corresponding to it in the stages of development, debugging, performance analysis, etc. For example, in performance analysis processes, tools such as valgrind, perf are included, but not limited to. When collecting a function call chain, a function execution time length and a proportion of the function execution time length to the total program operation time length, the valgrind can operate the analyzed program in a virtual environment, and record the in-out and function call chains of each function so as to calculate the execution time length of the function. And the perf acquires a function call chain by using a sampling mode, judges the relation between the current execution function and the tested program in each sampling period, and records the current execution function and the corresponding function call chain if the current execution function belongs to the tested program.

When the tested program is operated in the virtual environment, the operation process is known to valgrind, so that a complete function call chain can be obtained, but more information needs to be recorded in the process, additional CPU (Central Processing Unit ) consumption can be generated, and the operation of the tested program is affected. The perf tests the tested program through a sampling mode, and partial functions may not be acquired due to fewer call times, so that the collected function call chain is incomplete. However, by flexibly adjusting the sampling frequency, the influence on the running process of the tested program during sampling can be reduced. In addition, in the optimization analysis process, functions to be optimized are usually used frequently, the possibility of acquisition is low, and the disadvantage of incomplete collection of a function call chain can be avoided to a certain extent.

Exemplary method

Fig. 1 is a flowchart of a method for calculating a function runtime according to an exemplary embodiment of the present application. Illustratively, the method is applied to a linux system. As shown in fig. 1, the method for calculating the function runtime provided in the embodiment of the present application includes the following steps.

Step S110, determining a plurality of first function call chains included in the program to be tested based on the first sampling frequency.

The first sampling frequency is preset by a technician in advance, and when the first sampling frequency is set, the first function call chain is ensured to be acquired, so that the program to be tested is not greatly influenced. The first sampling frequency is, for example, 200HZ. And when the sampling time comes, the performance analysis tool samples the program to be tested to obtain sampling data. Illustratively, the sample data includes register values in the CPU, identifiers of processes running in the host, process names, and the like.

Analyzing the sampling data at each sampling moment to determine a first function call chain contained in the program to be tested. Illustratively, according to a register value in the CPU, a user stack of the current process is analyzed, so that a first function call chain of the current process at the acquisition time is obtained, wherein the first function call chain represents a current function being executed by the CPU, and a function set which is gradually called up to the current function is obtained.

The data of the first function call chain is stored in the form of key-value pairs in a file, which may be named in time. Illustratively, the keys described below may be used. time: absolute time of sampling; tid: sampling the unique number of the attribution thread; samples: the sampled functions are expressed by an array; name: a function name; mem_address: the memory address where the function is located; call_stack: the calling sequence numbers of the functions in the first function calling chain.

Step S120, recording sampling time stamps of functions included in the plurality of first function call chains.

A timestamp is complete and verifiable data that can represent the presence of a piece of data at a particular point in time. The absolute time at which the function is executed at the time of sampling can be determined by the sampling timestamp of the function contained in the first function call chain.

Step S130, determining the running duration of the function based on the sampling time stamps of the functions included in the plurality of first function call chains.

Illustratively, the time at which the function first appears is taken as the start execution time of the function, and the exit time of the function in the program to be tested, i.e., the end execution time, is determined. And determining the running time of the function by utilizing the ending execution time and the starting execution time of the function.

In this embodiment, by reasonably setting the first sampling frequency, it may be ensured that a relatively complete first function call chain is collected. When the program to be tested is sampled by utilizing the first sampling frequency, the sampling time stamp of the function in the first function call chain is recorded, the running time of the function can be further determined, the running process of the program to be tested is not influenced, and technicians can conveniently analyze the performance of the function and perform optimization analysis on the function.

In some embodiments, the start time and the interrupt time of the timer may be set using the perf tool according to the first sampling frequency; reading a general register value in a current processor at the interrupt time of the timer; if the current scheduling function belongs to the program to be tested based on the general register value, storing the function information of the current scheduling function into a buffer area; the data in the buffer area is read, and a plurality of first function call chains contained in the program to be tested are determined. Further, the sampling time stamps of the functions included in the plurality of first function call chains may be recorded based on the start time and the interrupt time of the timer.

Illustratively, a new thread is created using the record command for executing the program to be tested. Before the program to be tested is executed, the perf tool creates a timer for sampling according to the set first sampling frequency in the kernel state and waits to be started. Meanwhile, a ring buffer is set for receiving data generated in a kernel mode and mapped to a user mode by using a mmap mechanism so as to read the data. Then, the timer is started while the program under test is started. The timer generates a software interrupt at the sampling time. The interrupt processing function reads a general register value on the current CPU, can analyze the register value to obtain a current scheduling function and an execution process corresponding to the current scheduling function, and compares the process with a tested process (namely a program to be tested). If the function information of the current scheduling function belongs to a part of the process to be tested, the sampled function information is put into a ring buffer area to wait for the user state program to read. The user state program is in an infinite loop state, and can continuously poll whether the ring buffer area is filled with data, and after the ring buffer area is determined to be filled with data from the kernel state, the user state program reads out the data and outputs the data to the perf.data intermediate file in a binary form. After the running of the program to be tested is finished, converting the data in the perf.data intermediate file into a readable form by utilizing a report command, and determining a first function call chain. Further, a sampling timestamp of the function in the first function call chain is determined according to the starting time and the interrupting time of the timer.

In another implementation, after the user mode program reads the data, the data is not directly output to the perf.data intermediate file, but an API in the perf is utilized to obtain a first function call chain, and a sampling time stamp of a function in the first function call chain is determined according to the starting time and the interrupt time of the timer.

In this embodiment, according to the first sampling frequency, the starting time and the interrupt time of the timer are set, and at the interrupt time of the timer, it is first determined whether the current scheduling function sampled at the interrupt time belongs to the program to be tested, so that the possibility of a first function call chain validation error is avoided. Under the condition that the current scheduling function belongs to the program to be tested, the first function call chain and the sampling time stamp of the function are completely collected, so that the execution time of the function in the first function call chain can be more accurately determined, and the execution duty ratio of the function in the whole program to be tested can be further accurately calculated.

Fig. 2 is a schematic flow chart of determining the operation duration of a function according to an exemplary embodiment of the present application. The embodiment shown in fig. 2 is extended from the embodiment shown in fig. 1, and differences between the embodiment shown in fig. 2 and the embodiment shown in fig. 1 are described with emphasis, and the details of the differences are not repeated.

As shown in fig. 2, in the embodiment of the present application, the running duration of the function is determined based on the sampling time stamps of the functions included in the plurality of first function call chains, including the following steps.

Step S210, a plurality of second function call chains contained in the program to be tested are determined based on the second sampling frequency.

The second sampling frequency is also set by the technician, the second sampling frequency being greater than the first sampling frequency, and the second sampling frequency being 2000HZ, for example. And under the second sampling frequency, when the sampling time comes, the performance analysis tool samples the program to be tested to obtain sampling data. By analyzing the sampled data, a second chain of function calls contained in the program to be tested can be determined.

Step S220, integrating the plurality of first function call chains and the plurality of second function call chains, and generating at least one third function call chain.

The first function call chain and the second function call chain are respectively obtained by sampling the same program to be tested at different sampling frequencies, so that repeated function call chains exist in the first function call chain and the second function call chain, and repeated or missing functions exist in the function call chains, and then the functions belonging to the same function call chain are integrated with the first function call chains and the second function call chains, so that a more complete function call chain (namely a third function call chain) containing sampling data of the first sampling frequency and the second sampling frequency is obtained, and the third function call chain contains sampling time stamps of the functions in the first function call chain.

Step S230, determining the running duration of the function based on at least one third function call chain.

Specifically, based on a more complete third function call chain, the time of entering and exiting the function in the whole program to be tested is determined so as to determine the running time of the function.

In this embodiment, a mode of combining two samplings is adopted, when the program to be tested is sampled at a larger second sampling frequency, the influence generated by the program to be tested is ignored, and only a relatively complete second function call chain is collected. And combining the first function call chain with the second function call chain by combining the first function call chain acquired at the first sampling frequency and the sampling time stamp of the function to obtain a more complete third function call chain. And through the third function call chain, the operation time of the function is analyzed, so that the operation condition of the function under the real condition can be reflected more truly.

Fig. 3 is a schematic flow chart of determining the operation time length of a function according to another exemplary embodiment of the present application. The embodiment shown in fig. 3 is extended from the embodiment shown in fig. 2, and differences between the embodiment shown in fig. 3 and the embodiment shown in fig. 2 are described with emphasis, and the details of the differences are not repeated.

As shown in fig. 3, in the embodiment of the present application, the operation duration of the function is determined based on at least one third function call chain, which includes the following steps.

Step S310, determining a first call time of the function in the third function call chain based on the sampling time stamp of the function included in the third function call chain.

In practical cases, the first time of the function is taken as the first call time of the function. Illustratively, the third function call chain includes function call chain 1: function a, function B, function C, function D. Function A is a root node function, function B can be directly called, function B and function C are child node functions, function B can be directly called function C, function D is a leaf node function, and function C can be directly called function D. Assume ten function call chains 1 are collected: function a, function B, function C, function D, the timestamp of function D in the first function call chain 1 may be used as the first call time of function D. If the sampling time stamp of function D is not recorded in function call chain 1, the sampling time stamp of function D may be approximately determined based on other functions in the same function call chain. For example, if the function B records a sampling time stamp, the sampling time stamp of the function B is approximated as the sampling time stamp of the function D.

Step S320, determining the exit time of the function in the third function call chain.

The exit time of the function is the time when the execution of the function is finished, and can be determined according to the sampling time stamp of the function recorded in the third function call chain.

Step S330, determining the running duration of the function based on the first call time of the function and the exit time of the function.

Illustratively, the first call time of the function is 10:00.00, the exit time of the function is 10:01.21, the run length of the function is 1 minute 21 seconds.

Through the methods in steps S310 to S330, all function nodes in each first function call chain acquired at the first sampling frequency are traversed, and the running time of the functions of all function nodes in the first function call chain is determined.

In this embodiment, the same function call chain is determined in the third function call chain, and the first call time and the exit time of the function are determined through the sampling time stamp of the function in the same function call chain, so that the operation duration of the function can be accurately calculated. Compared with the method of determining the execution condition of the function by the number of times of the function call, the method of the embodiment has higher reliability, and after the program to be tested is partially optimized, a specific optimization result can be determined by the method of the embodiment, for example, the running time of the function is reduced by 200ms, etc.

Fig. 4 is a flowchart illustrating a method for determining an exit time of a function according to an exemplary embodiment of the present application. The embodiment shown in fig. 4 is extended from the embodiment shown in fig. 3, and differences between the embodiment shown in fig. 4 and the embodiment shown in fig. 3 are described with emphasis, and the details of the differences are not repeated.

As shown in fig. 4, in the embodiment of the present application, the exit time of the function is determined in the third function call chain, which includes the following steps.

In step S410, other functions in the same function call chain and the same call depth as the function are determined from the third function call chain.

For the example in fig. 3, ten third function call chains are: the eleventh third function call chain is that: the function A, the function B, the function C and the function F illustrate that after the function D is executed, the function D jumps to the executed function F, and the leaf node function is changed. The function F is a function in the same function call chain and the same call depth as the function D.

Step S420, determining the exit time of the function based on the sampling time stamps of the other functions.

Illustratively, the sampling timestamp corresponding to function F is determined as the exit time of function D. If the function F in the eleventh third function call chain does not record the sampling timestamp, the exit time of the function D can be approximately determined by any one of the function a, the function B, and the function C in the eleventh third function call chain.

In this embodiment, the exit time of the function can be further accurately determined by using other functions with the same function call chain and the same call depth as the function, so as to improve the calculation accuracy of the operation duration of the function.

Fig. 5 is a schematic flow chart of generating a third function call chain according to an exemplary embodiment of the present application. The embodiment shown in fig. 5 is extended from the embodiment shown in fig. 2, and differences between the embodiment shown in fig. 5 and the embodiment shown in fig. 2 are described with emphasis, and the details of the differences are not repeated.

As shown in fig. 5, in the embodiment of the present application, the integration of the plurality of first function call chains and the plurality of second function call chains generates at least one third function call chain, which includes the following steps.

Step S510, determining an entry function of each of the plurality of first function call chains.

And circularly traversing all the first function call chains based on sampling data obtained by sampling the program to be tested at the first sampling frequency, and taking the first function in each first function call chain as an entry function of the first function call chain. Illustratively, the first function call chain is: function a, function B, function C, function D, function E, function a is the entry function of the first function call chain.

Step S520, merging the plurality of first function call chains based on the respective entry functions of the plurality of first function call chains, and generating at least one fourth function call chain.

Specifically, based on non-repeated entry functions related in respective entry functions of the plurality of first function call chains, a function call chain main branch is constructed, and further, a function call chain extension branch in the function call chain main branch is determined, functions contained in the plurality of first function call chains are supplemented to function nodes in the function call chain main branch and the function call chain extension branch, and at least one fourth function call chain is generated.

Illustratively, at the first sampling frequency, the function call chain information collected at each moment is saved to a separate sample data, each sample data corresponding to a first function call chain. The plurality of first function call chains may be identical or different. Starting all collected sample data with an entry function of the whole program to be tested, expressing the relation between function calls and called functions of all function nodes in a linked list form, and finally storing the relation in a data structure. For example, based on the sample data collected at the first sampling frequency, all sample data are circularly traversed, a first function in each sample data is used as an entry function of a first function call chain in the sample data, on the basis of each entry function, the called sub-functions are saved in a linked list mode, and the called parent functions are saved in the sub-functions, so that a main branch of the function call chain is constructed. When a partial function overlap from the entry function occurs, a chain extension branch is then called for the function in the main branch of the chain of function calls. When a new entry function appears, namely, a non-repeated entry function, the non-repeated entry function is taken as a root node function again, a main branch of a function call chain is constructed, and the function is correspondingly supplemented to a function node in the main branch of the function call chain. Repeating the above operation until all the sample data are traversed, generating at least one fourth function call chain, wherein the at least one fourth function call chain is a tree structure containing all function nodes and the relation between function calls and called.

Step S530, supplementing the functions included in the plurality of second function call chains to at least one fourth function call chain, generating at least one third function call chain.

Specifically, the entry function of each of the plurality of second function call chains is determined, and whether the entry function of the second function call chain appears in at least one fourth function call chain is judged. If so, supplementing the function contained in the second function call chain to at least one fourth function call chain with the function in the fourth function call chain which is the same as the entry function of the second function call chain as a starting point. Otherwise, based on the entry function of the second function call chain, constructing a main branch of the function call chain, and based on the at least one supplemented fourth function call chain and the main branch of the function call chain, generating at least one third function call chain.

For example, at the second sampling frequency, the function call chain information collected at each sampling time is saved to a single sample data, where each sample data corresponds to a second function call chain, and the second function call chains may be the same or different. All sample data at this stage is looped through, and the first function in each sample data is taken as an entry function of the second function call chain. Based on the fourth function call chain, if the entry function in the second function call chain appears in the fourth function call chain, finding the position where the function appears, continuing to extend and judging whether the function of the subsequent node is repeated, if the function is overlapped, and if the function with higher call level exists in the fourth function call chain, supplementing the function into the fourth function call chain. If the entry function in the second function call chain does not appear in the fourth function call chain, the second function call chain is a function branch with a brand new entry, the entry function in the second function call chain is taken as a root node, a main branch of the function call chain is constructed, and function nodes in the main branch of the function call chain are further supplemented. Repeating the steps until all the functions in the second function call chain sampled at the stage are traversed, and generating a third function call chain containing all the first function call chains and all the second function call chains. A third function call chain organizes all data in the same data structure in the form of a tree, with parent and child node functions used to represent the relationship of function calls to called.

In the present embodiment, the integration process of the third function call chain is described in detail. The first sampling frequency is less in the number of times of adoption per unit time than the second sampling frequency, and the influence on the program to be tested is lower. The second sampling frequency is more times of sampling in unit time than the first sampling frequency, and a more complete second function call chain can be collected. The function call chains of the two-stage sampling are combined, a more complete third function call chain can be obtained, and the occupation ratio condition of the execution time of the function in the whole program to be tested can be accurately analyzed.

Fig. 6 is a flowchart of a method for calculating a function runtime according to another exemplary embodiment of the present application. The embodiment shown in fig. 6 is extended from the embodiment shown in fig. 1, and differences between the embodiment shown in fig. 6 and the embodiment shown in fig. 1 are described with emphasis, and the details of the differences are not repeated.

As shown in fig. 6, in the embodiment of the present application, the method for calculating the function runtime further includes the following steps.

In step S610, the running duration of the program to be tested is determined when the program to be tested is sampled at the first sampling frequency.

For example, the total running time of the program to be tested may be determined according to the starting running time of the program to be tested and the ending running time of the program to be tested.

Step S620, determining the proportion of the function to the running time of the program to be tested based on the running time of the function and the running time of the program to be tested.

Illustratively, the running time of the function is 1 minute and 30 seconds, and the running time of the program to be tested is 5 minutes, and the proportion of the function to the running time of the program to be tested is 30%.

In this embodiment, by calculating the proportion of the function to the running time of the program to be tested, it is convenient for a technician to analyze the execution condition of the function and optimize the function to be optimized, and at the same time, the execution result of the function after optimization can be analyzed.

Fig. 7 is a flowchart of a method for calculating a function runtime according to another exemplary embodiment of the present application. The embodiment shown in fig. 7 is extended from the embodiment shown in fig. 1, and differences between the embodiment shown in fig. 7 and the embodiment shown in fig. 1 are described with emphasis, and the details of the differences are not repeated.

As shown in fig. 7, in the embodiment of the present application, the method for calculating the function runtime further includes the following steps.

Step S710, determining the operation duration of the sub-function corresponding to the function.

Illustratively, for function call chain 2: function a, function B, function C, function D, function Q, function call chain 3: function A, function B, function C, function D, function K, function D has called function Q and function K, namely function D corresponds two sub-functions, is function Q and function K respectively, further can confirm the running time that function Q and function K correspond respectively according to the sample timestamp of the function recorded.

Step S720, determining the operation time of the function when the subfunction is not called based on the operation time of the subfunction corresponding to the function and the operation time of the function.

By way of example, the operation time of the function D when the subfunction is not called can be obtained by subtracting the operation time corresponding to each of the function Q and the function K from the operation time of the function D.

In this embodiment, the operation duration of the function when the subfunction is not called is further calculated through the operation duration of the function and the operation duration of the subfunction corresponding to the function, which is favorable for accurately analyzing the operation time of the function alone and the operation time of the function in the sleep period.

Exemplary apparatus

Embodiments of a method for calculating a function runtime of the present application are described above in detail with reference to fig. 1 to 7, and embodiments of a device for calculating a function runtime of the present application are described below in detail with reference to fig. 8. It should be understood that the description of the method embodiments of the function runtime calculation corresponds to the description of the device embodiments of the function runtime calculation, and that parts which are not described in detail can therefore be seen in the previous method embodiments.

FIG. 8 is a schematic diagram of a function runtime computing device according to an exemplary embodiment of the present application. As shown in fig. 8, a function runtime computing device 80 provided in an embodiment of the present application includes:

A first determining module 810, configured to determine a plurality of first function call chains included in the program to be tested based on the first sampling frequency;

a recording module 820 for recording sampling time stamps of functions included in the plurality of first function call chains;

a second determining module 830 is configured to determine a running duration of the function based on sampling time stamps of the functions included in the plurality of first function call chains.

In an embodiment of the present application, the second determining module 830 is further configured to determine a plurality of second function call chains included in the program to be tested based on a second sampling frequency, where the second sampling frequency is greater than the first sampling frequency; integrating the plurality of first function call chains and the plurality of second function call chains to generate at least one third function call chain; the run length of the function is determined based on at least one third chain of function calls.

In an embodiment of the present application, the second determining module 830 is further configured to determine, in the third function call chain, a first call time of the function based on a sampling timestamp of the function included in the third function call chain; determining the exit time of the function in a third function call chain; and determining the running time of the function based on the first calling time of the function and the exiting time of the function.

In an embodiment of the present application, the second determining module 830 is further configured to determine, from the third function call chain, other functions that are in the same function call chain and the same call depth as the function; the exit time of the function is determined based on the sampling time stamps of the other functions.

In an embodiment of the present application, the second determining module 830 is further configured to determine an entry function of each of the plurality of first function call chains; merging the plurality of first function call chains based on respective entry functions of the plurality of first function call chains to generate at least one fourth function call chain; and supplementing the functions contained in the plurality of second function call chains to at least one fourth function call chain to generate at least one third function call chain.

In an embodiment of the present application, the second determining module 830 is further configured to obtain an entry function involved in each entry function of the plurality of first function call chains; constructing a main branch of the function call chain based on the entry functions involved in the entry functions of each of the plurality of first function call chains; determining a function call chain extension branch in a function call chain main branch; and supplementing functions contained in the plurality of first function call chains to function nodes in a main branch of the function call chain and an extension branch of the function call chain, and generating at least one fourth function call chain.

In an embodiment of the present application, the second determining module 830 is further configured to determine an entry function of each of the plurality of second function call chains; if the entry function of the second function call chain appears in at least one fourth function call chain, taking the function in the fourth function call chain which is the same as the entry function of the second function call chain as a starting point, and supplementing the function contained in the second function call chain to the at least one fourth function call chain; if the entry function of the second function call chain does not appear in the at least one fourth function call chain, constructing a main branch of the function call chain based on the entry function of the second function call chain; at least one third function call chain is generated based on the supplemented at least one fourth function call chain and the function call chain main branch.

In an embodiment of the present application, the first determining module 810 is further configured to set, based on the first sampling frequency, a start time and an interrupt time of the timer using the perf tool; reading a general register value in a current processor at the interrupt time of the timer; if the current scheduling function belongs to the program to be tested based on the general register value, storing the function information of the current scheduling function into a buffer area; the data in the buffer area is read, and a plurality of first function call chains contained in the program to be tested are determined.

In an embodiment of the present application, the recording module 820 is further configured to record sampling time stamps of functions included in the plurality of first function call chains based on a start time and an interrupt time of the timer.

In an embodiment of the present application, the second determining module 830 is further configured to determine an operation duration of the program to be tested when the program to be tested is sampled at the first sampling frequency; and determining the proportion of the function to the running time of the program to be tested based on the running time of the function and the running time of the program to be tested.

In an embodiment of the present application, the second determining module 830 is further configured to determine an operation duration of a sub-function corresponding to the function; and determining the operation time length of the function when the subfunction is not called based on the operation time length of the subfunction corresponding to the function and the operation time length of the function.

Next, an electronic device according to an embodiment of the present application is described with reference to fig. 9. Fig. 9 is a schematic structural diagram of an electronic device according to an exemplary embodiment of the present application.

As shown in fig. 9, the electronic device 90 includes one or more processors 901 and memory 902.

Processor 901 may be a Central Processing Unit (CPU) or other form of processing unit having data processing and/or instruction execution capabilities and may control other components in electronic device 90 to perform desired functions.

The memory 902 may include one or more computer program products that may include various forms of computer-readable storage media, such as volatile memory and/or non-volatile memory. The volatile memory may include, for example, random Access Memory (RAM) and/or cache memory (cache), and the like. The non-volatile memory may include, for example, read Only Memory (ROM), hard disk, flash memory, and the like. One or more computer program instructions may be stored on the computer readable storage medium that can be executed by the processor 901 to perform the methods of the various embodiments of the present application described above and/or other desired functions. Various contents such as a first function call chain, a second function call chain, a third function call chain, a running time of a function, and the like may also be stored in the computer-readable storage medium.

In one example, the electronic device 90 may further include: an input device 903 and an output device 904, which are interconnected by a bus system and/or other forms of connection mechanisms (not shown).

The input device 903 may include, for example, a keyboard, a mouse, and the like.

The output device 904 may output various information to the outside, including a first function call chain, a second function call chain, a third function call chain, a running time of a function, and the like. The output means 904 may include, for example, a display, speakers, a printer, and a communication network and remote output devices connected thereto, etc.

Of course, only some of the components of the electronic device 90 that are relevant to the present application are shown in fig. 9 for simplicity, components such as buses, input/output interfaces, and the like being omitted. In addition, the electronic device 90 may include any other suitable components depending on the particular application.

In addition to the methods and apparatus described above, embodiments of the present application may also be a computer program product comprising computer program instructions which, when executed by a processor, cause the processor to perform the steps in the methods according to the various embodiments of the present application described above in the present specification.

The computer program product may write program code for performing the operations of embodiments of the present application in any combination of one or more programming languages, including an object oriented programming language such as Java, C++ or the like and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computing device, partly on the user's device, as a stand-alone software package, partly on the user's computing device, partly on a remote computing device, or entirely on the remote computing device or server.

Furthermore, embodiments of the present application may also be a computer-readable storage medium, having stored thereon computer program instructions, which when executed by a processor, cause the processor to perform the steps in the methods according to various embodiments of the present application described above in the present specification.

The computer readable storage medium may employ any combination of one or more readable media. The readable medium may be a readable signal medium or a readable storage medium. The readable storage medium may include, for example, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or a combination of any of the foregoing. More specific examples (a non-exhaustive list) of the readable storage medium would include the following: an electrical connection having one or more wires, a portable disk, a hard disk, random Access Memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

The basic principles of the present application have been described above in connection with specific embodiments, however, it should be noted that the advantages, benefits, effects, etc. mentioned in the present application are merely examples and not limiting, and these advantages, benefits, effects, etc. are not to be considered as necessarily possessed by the various embodiments of the present application. Furthermore, the specific details disclosed herein are for purposes of illustration and understanding only, and are not intended to be limiting, as the application is not intended to be limited to the details disclosed herein as such.

The block diagrams of the devices, apparatuses, devices, systems referred to in this application are only illustrative examples and are not intended to require or imply that the connections, arrangements, configurations must be made in the manner shown in the block diagrams. As will be appreciated by one of skill in the art, the devices, apparatuses, devices, systems may be connected, arranged, configured in any manner. Words such as "including," "comprising," "having," and the like are words of openness and mean "including but not limited to," and are used interchangeably therewith. The terms "or" and "as used herein refer to and are used interchangeably with the term" and/or "unless the context clearly indicates otherwise. The term "such as" as used herein refers to, and is used interchangeably with, the phrase "such as, but not limited to.

It is also noted that in the apparatus, devices and methods of the present application, the components or steps may be disassembled and/or assembled. Such decomposition and/or recombination should be considered as equivalent to the present application.

The previous description of the disclosed aspects is provided to enable any person skilled in the art to make or use the present application. Various modifications to these aspects will be readily apparent to those skilled in the art, and the generic principles defined herein may be applied to other aspects without departing from the scope of the application. Thus, the present application is not intended to be limited to the aspects shown herein but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

The foregoing description has been presented for purposes of illustration and description. Furthermore, this description is not intended to limit the embodiments of the application to the form disclosed herein. Although a number of example aspects and embodiments have been discussed above, a person of ordinary skill in the art will recognize certain variations, modifications, alterations, additions, and subcombinations thereof.

Claims

1. A method for calculating a function runtime, comprising:

determining a plurality of first function call chains contained in a program to be tested based on a first sampling frequency;

recording sampling time stamps of functions contained in the plurality of first function call chains;

the method comprises the steps of determining the running time of a function based on sampling time stamps of the functions contained in the plurality of first function call chains.

2. The method as recited in claim 1, further comprising:

determining a plurality of second function call chains contained in the program to be tested based on a second sampling frequency, wherein the second sampling frequency is larger than the first sampling frequency;

wherein the determining the running duration of the function based on the sampling time stamps of the functions included in the plurality of first function call chains includes:

integrating the plurality of first function call chains and the plurality of second function call chains to generate at least one third function call chain;

Determining the running time of the function based on the at least one third function call chain.

3. The method of claim 2, wherein the determining the run length of the function based on the at least one third chain of function calls comprises:

determining a first call time of the function in the third function call chain based on a sampling timestamp of the function contained in the third function call chain;

determining an exit time of the function in the third function call chain;

and determining the running time of the function based on the first calling time of the function and the exiting time of the function.

4. A method according to claim 3, wherein said determining the exit time of the function in the third chain of function calls comprises:

determining other functions which are in the same function call chain and the same call depth as the function from the third function call chain;

determining the exit time of the function based on the sampling time stamps of the other functions.

5. The method of any of claims 2 to 4, wherein the integrating the plurality of first function call chains and the plurality of second function call chains generates at least one third function call chain, comprising:

Determining an entry function of each of the plurality of first function call chains;

merging the plurality of first function call chains based on respective entry functions of the plurality of first function call chains to generate at least one fourth function call chain;

and supplementing functions contained in the plurality of second function call chains to the at least one fourth function call chain to generate the at least one third function call chain.

6. The method of claim 5, wherein the merging the plurality of first function call chains based on their respective entry functions to generate at least one fourth function call chain comprises:

acquiring entry functions involved in respective entry functions of the plurality of first function call chains;

constructing a main branch of a function call chain based on the entry functions involved in the respective entry functions of the plurality of first function call chains;

determining a function call chain extension branch in the function call chain main branch;

and supplementing functions contained in the plurality of first function call chains to function nodes in the main branches and the extension branches of the function call chains, and generating at least one fourth function call chain.

7. The method of claim 5, wherein supplementing the at least one fourth chain of function calls with functions contained in the plurality of second chains of function calls, generating the at least one third chain of function calls, comprises:

determining respective entry functions of the plurality of second function call chains;

if the entry function of the second function call chain appears in the at least one fourth function call chain, taking a function in the fourth function call chain which is the same as the entry function of the second function call chain as a starting point, and supplementing the function contained in the second function call chain to the at least one fourth function call chain;

if the entry function of the second function call chain does not appear in the at least one fourth function call chain, constructing a function call chain main branch based on the entry function of the second function call chain;

generating the at least one third function call chain based on the at least one fourth function call chain after supplementation and the function call chain main branch.

8. The method according to any one of claims 1 to 4, wherein determining a plurality of first function call chains included in the program under test based on the first sampling frequency comprises:

Setting the starting time and the interrupting time of a timer by using a perf tool based on the first sampling frequency;

reading a general register value in a current processor at the interrupt time of the timer;

if the current scheduling function belongs to the program to be tested based on the general register value, storing the function information of the current scheduling function into a buffer area;

and reading the data in the buffer area, and determining the plurality of first function call chains contained in the program to be tested.

9. The method of claim 8, wherein the recording the sampling time stamps of the functions included in the plurality of first function call chains comprises:

based on the start time and the interrupt time of the timer, sampling time stamps of the functions included in the plurality of first function call chains are recorded.

10. The method according to any one of claims 1 to 4, further comprising:

determining the running time length of the program to be tested when the program to be tested is sampled at the first sampling frequency;

and determining the proportion of the function to the running time of the program to be tested based on the running time of the function and the running time of the program to be tested.

11. The method according to any one of claims 1 to 4, further comprising:

determining the operation time length of the sub-function corresponding to the function;

and determining the operation time length of the function when the sub-function is not called based on the operation time length of the sub-function corresponding to the function and the operation time length of the function.

12. A function runtime computing device, comprising:

the first determining module is used for determining a plurality of first function call chains contained in the program to be tested based on the first sampling frequency;

a recording module, configured to record sampling time stamps of functions included in the plurality of first function call chains;

and the second determining module is used for determining the running time of the function based on the sampling time stamps of the functions contained in the plurality of first function call chains.

13. A computer readable storage medium, characterized in that the storage medium stores a computer program for executing the method of any of the preceding claims 1 to 11.

14. An electronic device, comprising:

a processor;

a memory for storing the processor-executable instructions;

The processor being configured to perform the method of any of the preceding claims 1 to 11.