WO2019071535A1

WO2019071535A1 - Computer storage medium, and program running monitoring method and device

Info

Publication number: WO2019071535A1
Application number: PCT/CN2017/105899
Authority: WO
Inventors: 曹岚健; 刘金涛
Original assignee: 深圳市汇顶科技股份有限公司
Priority date: 2017-10-12
Filing date: 2017-10-12
Publication date: 2019-04-18
Also published as: CN109923526A

Abstract

The present application discloses a computer storage medium, and a program running monitoring method and device, said method comprising: inserting a statistic code into a function to be monitored, the statistic code being configured to store, when the statistic code is run, running data thereof into a corresponding storage address; and running, after the statistic code is inserted, the function to be monitored, the running data of the function, to be monitored, being the running data stored in the storage address corresponding to the statistic code. According to the technical solution provided by the present invention, when program monitoring needs to be performed on a function to be monitored, it only needs to run the function to be monitored, which has a statistic code inserted therein, without the need of providing a special tracking device or hardware support, simplifying the operation, providing an accurate result and having low cost.

Description

Computer storage medium, program operation monitoring method and device

Technical field

The present invention relates to the field of computer software, and in particular, to a computer storage medium, a program running monitoring method and device.

Background technique

A program is a sequence of coded instructions that can be executed by a device having information processing capabilities, such as a computer, in order to obtain a certain result, or a sequence of symbolized instructions or symbolic statements that can be automatically converted into a sequence of coded instructions. Typically, a program may contain one or more source files. Further, each source file may also contain one or more functions. In practical applications, in order to accurately calculate the running state of the program, for example, in order to track the running state of the program on the tracking target machine, it is usually necessary to track and monitor the running data of some functions in the program, for example, counting certain functions. Number of runs, run time, etc.

In the prior art, in order to statistically run data, some Microcontroller Units (MCUs) need to provide hardware support, for example, provide a tracking port for program tracking alone to provide program tracking function, and an external dedicated program tracking device. The program running process of the MCU is monitored in real time through the port, and the running data of the to-be-monitored function is tracked during the monitoring process.

The program tracking of the function to be monitored provided with the hardware port can be realized by the above prior art, but the program monitoring cannot be performed for the product without the hardware port support, and providing the corresponding hardware port for the product to be monitored may result in the product. The cost is increased, and the above-described prior art operation process is also cumbersome.

Summary of the invention

The invention provides a computer storage medium, a program operation monitoring method and a device, which are used for solving the technical problem that the existing program monitoring and prevention relies on hardware support and the process is cumbersome.

A first aspect of the present invention is to provide a program operation monitoring method comprising: inserting a statistical code in a function to be monitored, wherein the statistical code is configured to store its operational data to a corresponding one when it is itself a storage address; the function to be monitored after the insertion of the statistical code, wherein the operation data of the function to be monitored is the operation data stored in a storage address corresponding to the statistical code.

A second aspect of the present invention is to provide a program operation monitoring apparatus, comprising: a compiling module for inserting a statistical code in a function to be monitored, wherein the statistical code is used to run a statistical code when it is itself The data is stored to the corresponding storage address; the execution module is configured to run the to-be-monitored function after inserting the statistical code, wherein the running data of the function to be monitored is a running stored in a storage address corresponding to the statistical code data.

A third aspect of the present invention is to provide a program operation monitoring apparatus including: at least one processor and a memory; the memory storage computer executing an instruction; the at least one processor executing the memory execution computer execution instruction to Perform the method as described above.

A fourth aspect of the present invention is to provide a computer storage medium having program instructions stored therein, the program instructions being executed by a processor to implement the method as described above.

The computer storage medium and the program operation monitoring method and device provided by the invention, after inserting the statistical code in the function to be monitored, run the function to be monitored inserted with the statistical code, wherein when the statistical code is executed, the running of the data can be performed in real time. Data and store the run data to the corresponding storage address. Since the statistical code is set in the function to be monitored, the running data of the statistical code can accurately and truly reflect the running data of the function to be monitored. When the program needs to be monitored by the monitoring function, it only needs to run the function to be monitored inserted with the statistical code, without providing a special tracking device and no hardware support, the operation is simple, the result is accurate, and the cost is low.

DRAWINGS

In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings used in the description of the embodiments will be briefly described below. It is obvious that the drawings in the following description are only some embodiments of the present invention. Other figures may also be obtained from those of ordinary skill in the art in view of these figures.

1A-1C are schematic flowcharts of a method for monitoring program running according to Embodiment 1 of the present invention;

1D is a diagram showing an example of code of a statistical code in an embodiment of the present invention;

2A-2C are schematic flowcharts of a program operation monitoring method according to Embodiment 2 of the present invention;

3A is a schematic flowchart of a method for monitoring program running according to Embodiment 3 of the present invention;

FIG. 3B is a comparison diagram of the initial part of the function to be statistically and the function to be non-statistic;

3C is a comparison diagram of the end portion of the function to be statistically and the function to be non-statistic;

3D is a code example diagram of a function to be monitored inserted with a first statistical code and a second statistical code;

3E is a schematic flowchart of another method for monitoring program running according to Embodiment 3 of the present invention;

4A-4D are schematic structural diagrams of a program operation monitoring apparatus according to Embodiment 4 of the present invention;

5A-5C are schematic structural diagrams of a program operation monitoring apparatus according to Embodiment 5 of the present invention;

6A-6B are schematic diagrams showing the structure of a program operation monitoring apparatus according to Embodiment 6 of the present invention.

Detailed ways

The technical solutions in the embodiments of the present invention will be clearly and completely described in conjunction with the drawings in the embodiments of the present invention. It is a partial embodiment of the invention, and not all of the embodiments. All other embodiments obtained by those of ordinary skill in the art based on the embodiments of the present invention are within the scope of the present invention.

All technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention belongs, unless otherwise defined. The terminology used in the description of the present invention is for the purpose of describing particular embodiments and is not intended to limit the invention. The term "and/or" used herein includes any and all combinations of one or more of the associated listed items.

Some embodiments of the present invention are described in detail below with reference to the accompanying drawings. The features of the embodiments and examples described below can be combined with each other without conflict.

1A is a schematic flowchart of a method for monitoring a program operation according to a first embodiment of the present invention. Referring to FIG. 1A, the embodiment provides a program operation monitoring method, which is convenient, accurate, and low-cost. The program tracking of the function to be monitored is implemented. Specifically, the monitoring method of the program operation includes:

101: Insert a statistical code in the function to be monitored, wherein the statistical code is used to store its running data to a corresponding storage address when it is run by itself.

Specifically, the execution body of the program running monitoring method may be a program running monitoring device. In In practical applications, the program running monitoring device may be a medium storing related execution code, for example, a USB flash drive, etc.; or the program running monitoring device may also be a physical device integrated or installed with related execution code, for example, a chip, Intelligent terminals, computers, etc.

In practical applications, the function to be monitored can be a function in a source file under a certain program. By counting the statistical data of the function, the program monitoring of the program in which it is located can be realized. The statistical code in the solution can be pre-written by the program personnel. When the statistical code is run, a series of processes are executed correspondingly, and the running data of the statistical code itself can be stored to correspond to the statistical code based on the executed process. Stored in the address. Further, the position where the statistical code is inserted can be any position in the function as long as it does not affect the operation of the function itself. The running data of the inserted statistical code can reflect the running data of the function it is in. The operational data includes, but is not limited to, the number of operations, and the like.

Specifically, for each function to be monitored, each statistical code inserted in the function to be monitored corresponds to a storage address, which may be pre-specified by the programmer, or may be performed during the first run of the statistical code. Automatically specified in . After the storage address of a certain statistical code is specified, the statistical code can update the data stored in the corresponding storage address according to the current statistical data during the running process. For example, in the actual scenario, when it is necessary to perform program monitoring on a program, it may first determine which functions under the program need to run statistics on the running data, and correspondingly, insert statistical codes into these functions. Specifically, the process of inserting a statistical code in a function can be implemented by compiling the program in which the function is located.

Further, when performing program monitoring on a certain program, only statistical data of some functions may be selected for statistics. Correspondingly, as shown in FIG. 1B, FIG. 1B is a schematic flowchart of another method for monitoring program running according to Embodiment 1 of the present invention. On the basis of

Embodiment

1, 101 may specifically include:

1011: Set trace compile options for source files that need to be monitored in the program.

In the present embodiment, the unit for performing the statistical code insertion processing is a single source file. Specifically, set the trace compilation option for the source file where the function to be monitored is located. For example, suppose a certain program A includes source files A1, A2, and A3, wherein the source file A1 includes functions A11, A12, and A13, the source file A2 includes functions A21, A22, and A23, and the source file A3 includes functions A31 and A32. A33, currently need to run the statistics of the function A11 and A23, you can set the trace compile options for the source files A1 and A2, respectively.

Optionally, the tracking compilation option is set in various manners, for example, the tracking compilation option. It can be explicit, for example, adding a checkbox "□" corresponding to the trace compile option under the compile options for each source file. When the checkbox corresponding to the trace compile option of a source file is selected by the user, the trace compile option of the source file is set. The user selects the trace compile option to be implemented by clicking and other operations. Alternatively, you can directly add the identifier corresponding to the trace compile option to the source file to be monitored. Correspondingly, the source file to which the identifier is added is the source file with the trace compile option set.

1012: All functions in the source file set with the tracking compile option are set as the function to be monitored.

Depending on whether each source file is set with a trace compile option, you can determine which of the source files have statistics on the running data. Specifically, after setting the trace tracking compile option for some specific source files, the setting state of the trace compile option is passed to the module for compiling the program to determine the function that needs to insert the statistical code when compiling the program. . In practice, the user can select the trace compilation option for the source file where the function to be traced is located to determine the range of functions that need to be counted.

In this embodiment, all functions under the source file corresponding to the tracking compilation option are set as functions to be monitored, and then the running data of the functions to be monitored are counted. Still exemplified in connection with the foregoing examples, it is assumed that the source file A1 includes functions A11, A12, A13, the source file A2 includes functions A21, A22, A23, and the source file A3 includes functions A31, A32, A33, and current statistical functions A12 and A22 are required. The running data can set the tracking compile option for the source file A1 and the source file A2. Correspondingly, the functions A11, A12, A13, A21, A22 and A23 are the functions to be monitored.

1013: Insert a statistical code in each of the functions to be monitored by compiling the program.

Specifically, after setting the trace compile option for the source file to be monitored, the entire program is compiled. Specifically, in the process of compiling the program, a statistical code is inserted into all the functions of the source file for the source file provided with the tracking compile option.

In this embodiment, the function range of the running data statistics is determined by setting the tracking compile option, and the statistical code is inserted in the function that sets the tracking compiling option when the program is compiled, so that the function that needs to insert the statistical code is quickly and conveniently determined, and the processing is improved. s efficiency.

The operation function of the to-be-monitored function is the operation data stored in the storage address corresponding to the statistical code.

In practical applications, the function to be monitored can be run by running the program where the function to be monitored is located. Take For example, the actual scenario is as follows: After the statistical code is inserted into the function to be monitored, the function to be monitored can be run, and the running data of the function to be monitored is the running data of the statistical code. It can be understood that in the compiling stage of the program, statistical code is inserted into each function that needs to be statistically calculated. Corresponding to the running of each function, the statistical code inserted in the function is also run, so the running data of the statistical code can be Accurately reflect the operational data of the function. Subsequently, when the user needs to query the running data of the function, the running data of the statistical code can be directly output to the user. Correspondingly, the program running monitoring method may further include: acquiring a storage address corresponding to the statistical code inserted in the function to be monitored; and outputting the running data stored in the storage address as the running data of the function to be monitored.

The statistical code in this scenario can count its own running data and store it to the corresponding address. The process performed by the stats code runtime can be implemented in a variety of ways. Optionally, as shown in FIG. 1C, FIG. 1C is a schematic flowchart of still another program running monitoring method according to Embodiment 1 of the present invention. On the basis of Embodiment 1, the running data includes a running number; correspondingly, 102 specifically may include:

1011. Obtain a running number of times currently stored in a storage address corresponding to the statistical code.

1022: Add 1 to the current stored running times to obtain a calculation result;

1023. Update the currently stored running times in the storage address to the calculation result.

1024: Run the to-be-monitored function except the statistical code.

It should be noted that the sequence between the steps shown in the figure is only an exemplary implementation manner. In practical applications, based on the difference in the insertion position of the statistical code in the function, the execution order of the above steps is also May be different. For example, assuming that the statistical code is set before the function to be monitored, steps 1021 through 1023 are performed prior to 1024; assuming that the statistical code is set within the function to be monitored, steps 1021 through 1023 are performed during the execution of step 1024.

Specifically, after the statistics code runs to obtain the running times in the corresponding storage address, the running operation is calculated into the running times. Specifically, the result of adding the running number stored in the storage address is calculated, and the storage address is The data is updated to the calculation result, that is, the effect of adding 1 to the running times stored in the storage address is realized, thereby conveniently counting and updating the running times. In practical applications, before the program is monitored, the data in the storage address can be initialized, and the data in the storage address can be initialized to 0.

For example, FIG. 1D is a diagram showing an example of code of a statistical code in an embodiment of the present invention. Referring to the drawings, 0x914 is the storage address corresponding to the statistical code, and the steps performed by each line of code are as follows: a. Read 0x914 The data stored in the address, ie t0 (assuming the value of t0 is 2); b. Load the data t0 to the register, the current data in the register is t1 (at this time t0=t1=2); c. in the register The operation of t1=t1+1 (the value of t1 after the operation is 3); d. The data t1 in the register is written back to the address 0x914 (the value stored in the address of 0x914 is updated to 3). It should be noted that the program code in the figure is merely an exemplary implementation manner, and the specific implementation manner of the statistical code is not limited.

Through the above implementation manner, the statistics and storage of the running data can be automatically completed in the process of running the function, and no need to add any hardware, and the running data can be counted simply by running the program.

It should be noted that the solution of this embodiment is applicable to the field of embedded software, and is particularly applicable to the field of embedded software of a low-cost MCU. In addition, it can be applied to any target machine and can count the program running data running on any target machine. And this solution realizes low-cost program running tracking method without the need to provide any tracking unit by the CPU, without any hardware support, can count the function running track in the program, and can customize the statistical range. In addition, based on the solution of the embodiment, the statistical running data can be obtained in real time when the program is running, and the statistical running data can be obtained when the program runs paused, thereby improving the reliability of the program monitoring.

The program running monitoring method provided in this embodiment, after inserting the statistical code in the function to be monitored, running the function to be monitored inserted with the statistical code, wherein when the statistical code is executed, the running data of the self can be counted in real time, and the Run the data store to the corresponding storage address. Since the statistical code is set in the function to be monitored, the running data of the statistical code can accurately and truly reflect the running data of the function to be monitored. The solution provided by this embodiment can be implemented by simply running a function to be monitored inserted with a statistical code when the program needs to be monitored. There is no need to provide a special tracking device and no hardware support, and the operation is simple, the result is accurate, and the cost is low. .

In order to record the running data during the running of the program, you need to specify the storage address for the statistical code. Correspondingly, as shown in FIG. 2A, FIG. 2A is a schematic flowchart of a program operation monitoring method according to Embodiment 2 of the present invention. Referring to FIG. 2A, the program running monitoring method further includes:

201: Specify a corresponding storage address for the statistical code in the to-be-monitored function.

Specifically, the storage address specified for the statistical code is used to store the operational data of the statistical code. It should be noted that the figure is only an exemplary implementation manner, and the order of execution of each step is not limited. For example, 201 may also be executed in the process of inserting the statistical code in 101.

As an implementable manner, the storage address can be located in a code segment of the program. As shown in FIG. 2B, FIG. 2B is a schematic flowchart of another method for monitoring program running according to Embodiment 2 of the present invention. On the basis of the embodiment shown in FIG. 2A, 201 may specifically include:

2011: According to a preset offset, in the code segment of the program where the function to be monitored is located, a corresponding storage address is specified for the statistical code, and the storage address is offset to an entry address of the function to be monitored. The amount is the preset offset.

Specifically, the storage address corresponding to the statistical code can be specified from the code segment of the program. The code segment usually refers to a memory area used to store the program execution code. The address in the code segment can be characterized and determined by defining the start address and the offset from the start address, so in order to save storage space, it can be pre- Set a uniform starting address to determine the storage address of the statistical code in each function by setting a uniform offset. Specifically, when the storage address is located in the code segment of the program, for each function in the program, the entry address of the function can be used as the start address, and after the uniform offset is set, the statistical code in each function The offset between the corresponding storage address and the entry address of the function is fixed, so that when the program is compiled, for the function to be monitored, the statistical code needs to be inserted in the function to be monitored, and the statistical code can be inserted at the same time. Automatically addressing the entry address of the function to be monitored, the address obtained by offsetting the entry address by a fixed offset, that is, the storage address corresponding to the statistical code inserted in the function to be monitored.

For example, suppose that the starting address is defined as the entry address of the function, and the offset is set to 2, then the function of the function that currently inserts the statistical code is automatically addressed, for example, the function is found. The entry address is 0x904, and correspondingly, according to the preset offset, the storage address corresponding to the statistical code inserted in the function is 0x906. By analogy, the storage address corresponding to each inserted statistical code can be determined during the offset process.

Optionally, when the number of statistical codes inserted in each function to be monitored is multiple, different offsets may be set for the multiple statistical codes. For example, suppose that two statistical codes B11 and B12 are inserted in function A11, and two statistical codes B21 and B22 are inserted in function A12, then the starting address can be defined as the entry address of the function, which is inserted into each function. The offset set by the first statistic code is 3, and the offset set for the second statistic code inserted into each function is 4, then for function A11, assuming its entry address is 0x804, then The storage addresses corresponding to the statistical codes B11 and B12 are 0x807 and 0x808, respectively; for the function A12, assuming that the entry address is 0x904, the storage addresses corresponding to the statistical codes B21 and B22 are 0x907 and 0x908, respectively.

Through the above embodiment, the storage address corresponding to the statistical code is set in the code segment of the program, and the storage address corresponding to each statistical code is determined by uniformly defining the starting address and the offset. According to the above embodiment, only one storage is needed. The starting address and an offset can determine the storage address corresponding to each statistical code according to certain rules, thereby reducing data processing requirements and storage requirements.

As another implementable manner, the storage address may be located in a data segment of the program. As shown in FIG. 2C, FIG. 2C is a schematic flowchart of still another program running monitoring method according to Embodiment 2 of the present invention. On the basis of the embodiment shown in FIG. 2A, 201 may specifically include:

2012: in the data segment of the program where the function to be monitored is located, specifying a corresponding storage address for the statistical code in the function to be monitored;

2013: Store a correspondence between the storage address and the statistical code.

Specifically, the storage address corresponding to the statistical code may also be specified from the data segment of the program. The data segment usually refers to a memory area used to store the initialized global variables in the program. Setting the storage address in the data segment can improve the flexibility of the storage address setting. Correspondingly, when the storage address corresponding to the statistical code is specified in the data segment, the memory space corresponding to the mapping relationship between the statistical code in each function to be monitored and the storage address corresponding to the statistical code needs to be planned, and the specific implementation is implemented. When a relationship table is maintained, the correspondence between the statistical code and the storage address in different functions to be monitored can be recorded, so that when the statistical code is inserted into the function to be monitored during the compilation process of the program, the maintenance can be performed according to the maintenance. The mapping relationship finds the corresponding storage address.

For example, assuming that both functions A11 and A21 need to insert a statistical code, the corresponding statistical storage address is specified in the data segment of the program for the statistical code C11 inserted in the function A11 and the statistical code C12 inserted in the A21, assuming 0x501 and 0x502, respectively. . Then, the correspondence between C11 and 0x501 in A11 and the correspondence between C12 and 0x502 in A21 are stored. By analogy, after establishing the mapping relationship between each statistical code and the corresponding storage address, the storage address corresponding to any statistical code can be determined according to the mapping relationship.

Through the above implementation manner, the storage address corresponding to the statistical code is set in the data segment of the program, and the storage address corresponding to each statistical code is determined by maintaining the corresponding relationship between the statistical code inserted in each function and the storage address, based on In the above embodiment, the flexibility of address designation can be improved.

The program running monitoring method provided in this embodiment provides a plurality of implementation manners for specifying a storage address for a statistical code. Each implementation manner may be implemented separately or in combination. In actual applications, different designation manners may be determined according to different situations. Specify the corresponding storage address for the statistics code.

In this solution, for a single function to be monitored, the number of statistical codes inserted therein may be one or more. Correspondingly, each statistical code corresponds to a storage address. When there are multiple statistical codes inserted in a single function to be monitored, based on the running data of the plurality of statistical codes, other data, for example, the running time of the function to be monitored, may be further analyzed.

FIG. 3A is a schematic flowchart of a program running monitoring method according to Embodiment 3 of the present invention. As shown in FIG. 3A, based on any of the foregoing embodiments, 101 may specifically include:

301: Insert the first statistic code before the first instruction of the function to be monitored.

Specifically, when the program is running, the first statistical code inserted before the first instruction of the function to be monitored generates the running data and is saved in the storage address corresponding to the first statistical code. By accessing the data stored in the storage address, the running data can be queried in real time while the program is running, and output to the user. And when the program is suspended, the running data stored in the storage address can also be queried and output to the user. Preferably, the jump instruction may be added at the end of the first statistical code, that is, after the first statistical code is run, the first instruction of the main body of the function to be monitored is jumped to ensure the normal operation of the function to be monitored, and the program is improved. Reliability and stability of monitoring.

For example, as shown in FIG. 3B, FIG. 3B is a comparison diagram of the initial part of the function to be statistically and the non-statistical function. The function to be monitored is inserted into the function to be monitored, and the non-waiting function is a non-to-be-monitored function in which the statistical code is not inserted. It can be seen that the first statistical code in the example is inserted before the first instruction of the function to be monitored, that is, “acquiring the statistical data address” to “jump to the first instruction of the function”, and the inserted first statistical code corresponds to The storage address is located between the statistical code and the first instruction of the function to be monitored, that is, "the statistical data of this function prologue".

302: Insert the second statistic code before the last instruction of the function to be monitored.

Specifically, when the program is running, the second statistical code inserted before the last instruction of the function to be monitored also generates the running data and stores it in the storage address corresponding to the second statistical code. By accessing the data stored in the storage address, the running data can be queried in real time while the program is running, and output to the user. And when the program is suspended, the running data stored in the storage address can also be queried and output to the user.

For example, as shown in FIG. 3C, FIG. 3C is a comparison diagram of the end portion of the function to be statistically and the non-to-be-statistic function, wherein the function to be monitored is the function to be monitored inserted with the second statistical code, and the function to be monitored is not Insert a non-to-monitor function for the statistics code. Visible, the second statistic code in the example Before inserting the last instruction of the function to be monitored, that is, “acquiring the statistical data address” to “modifying the statistical data writing back”, in combination with FIG. 3B, the storage address corresponding to the second statistical code is also located in the first statistical code and the function to be monitored. Between the first instructions, that is, "the statistics of this function epilogue" in Figure 3B.

It can be understood that the first statistical code and the second statistical code are respectively inserted before the last instruction of the function to be monitored and before the last instruction of the function to be monitored, and correspondingly, when the function to be monitored is run, the first statistical code is first Execution, the second statistical code will be executed when the function to be monitored is about to end. Specifically, as shown in FIG. 3D, FIG. 3D is a code example diagram of a function to be monitored inserted with a first statistical code and a second statistical code. Referring to the drawing, before executing the function body code instruction of the function to be monitored, the first execution is performed. A statistical code, namely "li t0, 0x914" to "jal 0x91C"; before the end of running the function to be monitored, the second statistical code, "li t0, 0x914" to "sw t1, (t0)", is executed. Therefore, the running data generated by the first statistical code and the second statistical code can accurately reflect the running times of the function to be monitored. And further, based on the running time of the first statistical code and the second statistical code, that is, the time when the data stored in the corresponding storage address changes, more abundant statistical data can be analyzed, for example, the running time of the function to be monitored .

Further, as shown in FIG. 3E, FIG. 3E is a schematic flowchart of another method for monitoring program running according to Embodiment 3 of the present invention. The method for monitoring the running of the program may further include:

303: Record the current first time when the running times of the storage addresses corresponding to the first statistical code change.

304: Record the current second time when the running times of the storage addresses corresponding to the second statistical code change.

305: Output a running time of the function to be monitored, where the running time is a difference between the first time and the second time.

When the program is running, when entering the function to be monitored, the first statistical code is executed, thereby automatically modifying the running data in the storage address corresponding to the first statistical code; before leaving the function to be monitored, the second statistical code is executed, thereby automatically Modify the running data in the storage address corresponding to the second statistical code. Based on the above principle, an observation point may be set at a storage address corresponding to the first statistical code and the second statistical code, and used to record the changed time when the data stored in the address changes. Specifically, when the data in the storage address corresponding to the first statistical code changes, that is, when the first statistical code is running, Recording the current first moment, the first moment can reflect the initial running time of the function to be monitored where the first statistical code is located. When the data in the storage address corresponding to the second statistical code changes, that is, when the second statistical code is running, the current second time is recorded, and the second time can reflect the ending running time of the to-be-monitored function where the second statistical code is located. The running time of the function to be monitored can be obtained according to the initial running time and the ending running time of the function to be monitored.

The program running monitoring method provided in this embodiment inserts a statistical code at the beginning and the end of the function to be monitored, records the time when the statistical code is running, and obtains the running time of the function to be monitored according to the time difference between the two times, and realizes the data. The statistics are further expanded to enrich the data content.

In general, based on the solutions of the above embodiments, the following solutions can be implemented:

1) When the program is running or paused, the storage address corresponding to the statistical code in all the functions to be monitored is obtained. By accessing the data in the storage address, the number of times the function to be monitored is run, and the like.

2) Insert a statistical code at the beginning and end of the function to be monitored. The observation points are set for the two statistical codes in the function to be monitored, and the time at which the data changes in the corresponding storage address is recorded, thereby estimating the running time of the function to be monitored.

It can be understood that, in order to understand the solution more clearly, the running code of the statistical code and the program to be monitored in the above embodiment are implemented by setting the insertion position of the statistical code. However, in practical applications, it may not be limited to the above manner. For example, the position of the statistical code may be flexibly set, and the execution order of the statistical code relative to the function to be monitored is determined by adding a jump instruction to the function. For example, the statistical code can be inserted at an address after the program to be monitored, and a jump instruction is inserted into the program to be monitored, and the jump instruction is used to indicate the address corresponding to the jump execution statistical code, so that the statistical code can also be implemented. The operational data is consistent with the operational data of the function to be monitored. Therefore, the specific implementation is not limited to the specific implementation manner in the foregoing embodiments.

The program running monitoring method provided by the present application, after inserting the statistical code in the function to be monitored, runs the function to be monitored inserted with the statistical code, wherein when the statistical code is executed, the running data of the self can be counted in real time, and the running is performed. The data is stored to the corresponding storage address. Since the statistical code is set in the function to be monitored, the running data of the statistical code can accurately and truly reflect the running data of the function to be monitored. The solution provided by this embodiment can be implemented by simply running a function to be monitored inserted with a statistical code when the program needs to be monitored. There is no need to provide a special tracking device and no hardware support, and the operation is simple, the result is accurate, and the cost is low. .

4A is a schematic structural diagram of a program operation monitoring apparatus according to Embodiment 4 of the present invention; as can be seen from FIG. 4A, the program operation monitoring apparatus is used to conveniently and accurately implement program tracking of a function to be monitored. Specifically, The program operation monitoring device includes:

a compiling module 41, configured to insert a statistical code in the function to be monitored, wherein the statistical code is used to store its running data to a corresponding storage address when it is run by itself;

The execution module 42 is configured to run the to-be-monitored function after inserting the statistical code, where the running data of the function to be monitored is the running data stored in the storage address corresponding to the statistical code.

In practical applications, the program running monitoring device may be a medium storing an associated execution code, such as a USB flash drive, etc.; or the program running monitoring device may also be a physical device integrated or installed with related execution code, for example, a chip. , smart terminals, computers, etc. The specific implementation form and structure of each module are not limited in this embodiment, and those skilled in the art can arbitrarily set them according to the functions they implement.

For example, in the actual scenario, when it is necessary to perform program monitoring on a program, it may first determine which functions under the program need to run statistics on the running data. Accordingly, the compiling module 41 inserts statistical codes into the functions, and executes the module. 42 Run the function to be monitored after inserting the statistical code. It can be understood that the statistical code inserted in the function will also be run while running each function, so the running data of the statistical code can accurately reflect the running data of the function.

Subsequently, when the user needs to query the running data of the function, the data in the storage address can be accessed, and the running data is output to the user. Correspondingly, as shown in FIG. 4B, on the basis of the fourth embodiment, the program running monitoring apparatus may further include: an obtaining module 43, configured to acquire a storage address corresponding to the statistical code inserted in the function to be monitored; and the first output module 44. The operating data stored in the storage address is used as the running data of the function to be monitored.

Further, when performing program monitoring on a certain program, only statistical data of some functions may be selected for statistics. Correspondingly, as shown in FIG. 4C, on the basis of the fourth embodiment, the compiling module 41 may specifically include:

The interaction unit 411 sets a tracking compile option for the source files to be monitored in the program;

The processing unit 412 is configured to use all the functions in the source file set with the tracking compile option The function to be monitored;

The processing unit 412 is further configured to insert a statistical code in each of the to-be-monitored functions by compiling the program.

Specifically, the interaction unit 411 sets a tracking compilation option for the source file where the function to be monitored is located, and the setting manner is various. The processing unit 412 sets all the functions under the source file corresponding to the tracking compile option as functions to be monitored, and compiles the entire program. Specifically, in the process of compiling the program, the processing unit 412 inserts a statistical code into all the functions of the source file for the source file provided with the tracking compile option.

In addition, the flow of the statistical code runtime execution in this scenario can be implemented in a variety of ways. Optionally, as shown in FIG. 4D, on the basis of Embodiment 4, the running data includes a running number; and correspondingly, the executing module 42 includes:

The reading unit 421 is configured to acquire the currently stored running times in the storage address corresponding to the statistical code;

The calculating unit 422 is configured to add 1 to the currently stored running times to obtain a calculation result;

The updating unit 423 is configured to update the currently stored running times in the storage address to the calculation result;

The processing unit 424 is configured to run the to-be-monitored function except the statistical code.

Specifically, the reading unit 421 acquires the number of operations in the storage address, the calculating unit 422 calculates the result of adding 1 to the running number stored in the storage address, and the updating unit 423 updates the data in the storage address to the calculation result, and the processing unit 424 operates. The function to be monitored other than the statistical code.

The program running monitoring device provided by the embodiment, after inserting the statistical code in the function to be monitored, runs a function to be monitored inserted with a statistical code, wherein when the statistical code is executed, the running data of the self can be counted in real time, and the Run the data store to the corresponding storage address. Since the statistical code is set in the function to be monitored, the running data of the statistical code can accurately and truly reflect the running data of the function to be monitored. The solution provided in this embodiment needs to be performed on the function to be monitored. In the case of sequence monitoring, it is only necessary to run the function to be monitored inserted with the statistical code, without providing a special tracking device and no hardware support, the operation is simple, the result is accurate, and the cost is low.

In order to record the running data during the running of the program, you need to specify the storage address for the statistical code. Correspondingly, as shown in FIG. 5A, FIG. 5A is a schematic structural diagram of a program operation monitoring apparatus according to Embodiment 5 of the present invention. Referring to FIG. 5A, the program operation monitoring apparatus further includes:

The specifying module 51 is configured to specify a corresponding storage address for the statistical code in the function to be monitored.

Specifically, the storage address specified for the statistical code is used to store the operational data of the statistical code.

As an implementable manner, the storage address can be located in a code segment of the program. As shown in FIG. 5B, FIG. 5B is a schematic structural diagram of another program running monitoring apparatus according to Embodiment 5 of the present invention. On the basis of the embodiment shown in FIG. 5A, the specifying module 51 includes:

The offset unit 511 is configured to: in the code segment of the program where the function to be monitored is located, specify a corresponding storage address, where the storage address is to the function to be monitored, according to a preset offset The offset of the entry address is the preset offset.

Specifically, the offset unit 511 can specify a storage address corresponding to the statistical code from the code segment of the program. When the storage address is located in the code segment of the program, for each function in the program, the offset unit 511 uses the entry address of the function as the start address, and according to the offset, specifies the storage corresponding to the statistical code inserted in the function to be monitored. address. Optionally, when the number of statistical codes inserted in each function to be monitored is multiple, the offset unit 511 may set different offsets for the plurality of statistical codes.

As another implementable manner, the storage address may be located in a data segment of the program. As shown in FIG. 5C, FIG. 5C is a schematic structural diagram of still another program running monitoring apparatus according to Embodiment 5 of the present invention. On the basis of the embodiment shown in FIG. 5A, the specifying module 51 includes:

The allocating unit 512 is configured to: in the data segment of the program where the function to be monitored is located, specify a corresponding storage address for the statistical code in the to-be-monitored function;

The storage unit 513 is configured to store a correspondence between the storage address and the statistical code.

Specifically, the specifying module 51 may also specify a storage address corresponding to the statistical code from the data segment of the program. The allocating unit 512 specifies the storage address corresponding to the statistical code in the data segment, and the storage unit 513 plans a memory space corresponding to the mapping relationship between the statistical code in each function to be monitored and the storage address corresponding to the statistical code.

The program running monitoring apparatus provided in this embodiment provides a plurality of implementation manners for specifying a storage address for a statistical code. Each implementation manner may be implemented separately or in combination. In actual applications, different designation manners may be determined according to different situations. Specify the corresponding storage address for the statistics code.

In this solution, for a single function to be monitored, the number of statistical codes inserted therein may be one or more. FIG. 6A is a schematic structural diagram of a program operation monitoring apparatus according to Embodiment 6 of the present invention. As shown in FIG. 6A, on the basis of any of the foregoing embodiments, the compiling module 41 includes:

a first compiling unit 413, configured to insert the first statistic code before the first instruction of the function to be monitored;

The second compiling unit 414 is configured to insert the second statistic code before the last instruction of the function to be monitored.

Specifically, when the program is running, the first statistical code inserted by the first compiling unit 413 before the first instruction of the function to be monitored generates the running data and is saved in the storage address corresponding to the first statistical code. The second statistical code inserted by the second compiling unit 414 before the last instruction of the function to be monitored also generates the running data and stores it in the storage address corresponding to the second statistical code. By accessing the data stored in the storage address, the running data stored in the storage address can be queried and output to the user when the program is running or paused.

In the actual application, when the embodiment is implemented in combination with the solution of the foregoing embodiment, for example, when the implementation is performed on the basis of the embodiment shown in FIG. 4C, the processing unit 412 may specifically include the first compiling unit 413 and the second compiling unit 414. . That is, the process of the processing unit 412 inserting the execution code in each function to be monitored may refer to the embodiment shown in FIG. 6A, that is, the first statistical code and the second statistical code are both inserted.

Further, as shown in FIG. 6B, on the basis of the embodiment shown in FIG. 6A, the program operation monitoring device may further include:

The recording module 61 is configured to record the current first time when the running times of the storage addresses corresponding to the first statistical code change;

The recording module 61 is further configured to: when the running times of the storage addresses corresponding to the second statistical code change, record the current second time;

The second output module 62 is configured to output a running time of the function to be monitored, where the running time is a difference between the first time and the second time.

During the running of the program, when the data in the storage address corresponding to the first statistical code changes, the recording module 61 records the current first time, and the first time can reflect the initial running of the function to be monitored where the first statistical code is located. time. When the data in the storage address corresponding to the second statistical code changes, the recording module 61 records the current second time, which can reflect the end running time of the to-be-monitored function where the second statistical code is located. The second output module 62 can obtain the running time of the function to be monitored according to the initial running time and the ending running time of the function to be monitored.

The program running monitoring apparatus provided in this embodiment inserts a statistical code at the beginning and the end of the function to be monitored, records the time when the statistical code is running, and obtains the running time of the function to be monitored according to the time difference between the two times, and realizes the data. The statistics are further expanded to enrich the data content.

The specific implementation process and the implementation effect of the method steps implemented in each module in this embodiment are the same as the specific implementation process and the implementation effect in the foregoing method embodiments. For details, refer to the content of the foregoing method embodiments.

The program running monitoring device provided by the application, after inserting the statistical code in the function to be monitored, runs the function to be monitored inserted with the statistical code, wherein when the statistical code is executed, the running data of the self can be counted in real time, and the running is performed. The data is stored to the corresponding storage address. Since the statistical code is set in the function to be monitored, the running data of the statistical code can accurately and truly reflect the running data of the function to be monitored. The solution provided by this embodiment can be implemented by simply running a function to be monitored inserted with a statistical code when the program needs to be monitored. There is no need to provide a special tracking device and no hardware support, and the operation is simple, the result is accurate, and the cost is low. .

The seventh embodiment of the present invention further provides a computer storage medium, which may include: a U disk, a mobile hard disk, a read-only memory (ROM), and random access. A medium for storing a program code, such as a memory (RAM), a magnetic disk, or an optical disk. Specifically, the computer storage medium stores program instructions, and the program instructions are used in the program operation monitoring method in the above embodiment.

Embodiment 8 of the present invention provides a program operation monitoring device, which may be a terminal device installed with a program running system, such as a mobile phone, a computer, a PAD, or a smart watch, etc., the program operation monitoring device includes at least one processor And a memory for storing computer execution instructions, the number of processors may be one or more, and may work separately or in cooperation, and the processor is configured to execute the computer-executed instructions of the memory storage to implement the above embodiment. The program runs monitoring methods.

The technical solutions and the technical features in the above various embodiments may be used in the case of the present invention without departing from the scope of the present invention.

In the several embodiments provided by the present invention, it should be understood that the related apparatus and method disclosed may be implemented in other manners. For example, the device embodiments described above are merely illustrative. For example, the division of the modules or units is only a logical function division. In actual implementation, there may be another division manner, for example, multiple units or components may be used. Combinations can be integrated into another system, or some features can be ignored or not executed. In addition, the mutual coupling or direct coupling or communication connection shown or discussed may be an indirect coupling or communication connection through some interface, device or unit, and may be in an electrical, mechanical or other form.

The units described as separate components may or may not be physically separated, and the components displayed as units may or may not be physical units, that is, may be located in one place, or may be distributed to multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of the embodiment.

In addition, each functional unit in each embodiment of the present invention may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit. The above integrated unit can be implemented in the form of hardware or in the form of a software functional unit.

The integrated unit, if implemented in the form of a software functional unit and sold or used as a standalone product, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present invention contributes in essence or to the prior art or the technical solution All or part of it may be embodied in the form of a software product stored in a storage medium comprising instructions for causing a computer processor to perform all or part of the steps of the methods described in various embodiments of the present invention. The foregoing storage medium includes: a U disk, a removable hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk, and the like, which can store program codes.

The above is only the embodiment of the present invention, and is not intended to limit the scope of the invention, and the equivalent structure or equivalent process transformation of the present invention and the contents of the drawings may be directly or indirectly applied to other related technologies. The fields are all included in the scope of patent protection of the present invention.

Finally, it should be noted that the above embodiments are merely illustrative of the technical solutions of the present invention, and are not intended to be limiting; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art will understand that The technical solutions described in the foregoing embodiments may be modified, or some or all of the technical features may be equivalently replaced; and the modifications or substitutions do not deviate from the technical solutions of the embodiments of the present invention. range.

Claims

A program operation monitoring method, comprising:

Inserting a statistical code into the function to be monitored, wherein the statistical code is used to store its running data to a corresponding storage address when it is run by itself;

The function to be monitored after the insertion of the statistical code is executed, wherein the running data of the function to be monitored is the running data stored in the storage address corresponding to the statistical code.
The method according to claim 1, wherein the running data includes a running number; the running to insert the statistical code to the monitored function comprises:

Obtaining the currently stored running times in the storage address corresponding to the statistical code;

Add 1 to the current stored running times to obtain the calculation result;

Updating the currently stored running times in the storage address to the calculation result;

The function to be monitored in addition to the statistical code is run.
The method according to claim 1 or 2, wherein the method further comprises:

Specifying a corresponding storage address for the statistical code in the function to be monitored.
The method according to claim 3, wherein the specifying a corresponding storage address for the statistical code in the function to be monitored comprises:

Determining, according to a preset offset, a corresponding storage address for the statistical code in a code segment of the program where the function to be monitored is located, where the offset of the storage address to the entry address of the function to be monitored is The preset offset.
The method according to claim 3, wherein the specifying a corresponding storage address for the statistical code in the function to be monitored comprises:

Specifying, in the data segment of the program where the function to be monitored is located, a corresponding storage address for the statistical code in the function to be monitored;

And storing a correspondence between the storage address and the statistical code.
The method according to any one of claims 1 to 5, wherein the method further comprises:

Obtaining a storage address corresponding to the statistical code inserted in the function to be monitored;

The operational data stored in the storage address is output as the operational data of the function to be monitored.
Method according to any one of claims 1 to 6, wherein said to be monitored Insert statistical code into the function, including:

Inserting the first statistical code before the first instruction of the function to be monitored;

Insert the second statistic code before the last instruction of the function to be monitored.
The method of claim 7, wherein the method further comprises:

When the number of times of running in the storage address corresponding to the first statistical code changes, the current first time is recorded;

When the running times of the storage addresses corresponding to the second statistical code change, the current second time is recorded;

And outputting a running time of the function to be monitored, where the running time is a difference between the first time and the second time.
The method according to any one of claims 1-8, wherein the inserting the statistical code in the function to be monitored comprises:

Set trace compile options for source files that need to be monitored in the program;

All functions in the source file set with the trace compile option are set as the function to be monitored;

A statistical code is inserted in each of the functions to be monitored by compiling the program.
A program operation monitoring device, comprising:

a compiling module, configured to insert a statistical code in the function to be monitored, wherein the statistical code is used to store its running data to a corresponding storage address when it is run by itself;

An execution module, configured to run the to-be-monitored function after inserting the statistical code, where the running data of the function to be monitored is running data stored in a storage address corresponding to the statistical code.
The device according to claim 10, wherein the running data comprises a running number; the executing module comprises:

a reading unit, configured to acquire a running time currently stored in a storage address corresponding to the statistical code;

a calculation unit, configured to add 1 to the currently stored running times to obtain a calculation result;

An update unit, configured to update a current running number of times in the storage address to the calculation result;

a processing unit, configured to run the to-be-monitored function in addition to the statistical code.
The device according to claim 10 or 11, wherein the device further comprises:

a specifying module, configured to specify a corresponding storage location for the statistical code in the function to be monitored site.
The apparatus according to claim 12, wherein said specifying module comprises:

An offset unit, configured to specify, according to a preset offset, a corresponding storage address for the statistical code in a code segment of the program where the function to be monitored is located, where the storage address is to the entry of the function to be monitored The offset of the address is the preset offset.
The apparatus according to claim 12, wherein said specifying module comprises:

An allocating unit, configured to specify a corresponding storage address for the statistical code in the to-be-monitored function in a data segment of the program where the function to be monitored is located;

a storage unit, configured to store a correspondence between the storage address and the statistical code.
The device according to any one of claims 10 to 14, wherein the device further comprises:

An obtaining module, configured to obtain a storage address corresponding to the statistical code inserted in the function to be monitored;

The first output module is configured to output the running data stored in the storage address as the running data of the function to be monitored.
The apparatus according to any one of claims 10-15, wherein the compiling module comprises:

a first compiling unit, configured to insert the first statistical code before the first instruction of the function to be monitored;

a second compiling unit, configured to insert the second statistical code before the last instruction of the function to be monitored.
The device according to claim 16, wherein the device further comprises:

a recording module, configured to record a current first time when a running time changes in a storage address corresponding to the first statistical code;

The recording module is further configured to: when the number of times of running in the storage address corresponding to the second statistical code changes, record the current second time;

And a second output module, configured to output a running time of the function to be monitored, where the running time is a difference between the first time and the second time.
The apparatus according to any one of claims 10-17, wherein the compiling module comprises:

An interactive unit that sets trace compile options for source files that need to be monitored in the program;

a processing unit, configured to use, as the function to be monitored, all functions in a source file set with a tracking compile option;

The processing unit is further configured to insert a statistical code in each of the to-be-monitored functions by compiling the program.
A program operation monitoring device, comprising: at least one processor and a memory;

The memory storage computer executes instructions; the at least one processor executes the computer-executed instructions stored by the memory to perform the method of any of claims 1-9.
A computer storage medium, characterized in that the computer storage medium stores program instructions, the program instructions being executed by a processor to implement the method of any one of claims 1-9.