CN102214142A - Instrumentation method for traceless manageable source code manually-defined mark - Google Patents

Abstract

A traceless and manageable source code manual definition flag insertion method, including steps: 10: open a project; 11: define the insertion point in the entire project by defining the insertion flag on the source code editor; 12 : Review the definitions of all insertion points: if any insertion points with errors are found, proceed to step 13 to modify them; if no insertion points with errors are found, proceed directly to step 14; 13: Modify the insertion points The definition is correct; 14: Merge the instrumentation point with the original source file to generate a new source file; 15: Compile the new source file to generate a bytecode file. The main features of this method are visualization of the instrumentation code, centralized management of the insertion code, traceless instrumentation process, automatic positioning of instrumentation points, automatic instrumentation scalability, and automatic instrumentation efficiency.

Description

Untraceable and manageable source code Manual definition of flag instrumentation method

technical field

The invention relates to dynamic analysis of computer programs, and mainly relates to a traceless and manageable source code manual definition flag insertion method.

Background technique

Program analysis usually uses static program analysis and dynamic program analysis to automatically analyze program behavior, thereby improving software quality. Dynamic program analysis often collects the dynamic running behavior of programs by means of instrumentation. Some program behaviors related to the operating environment can only be collected through instrumentation, but static program analysis cannot be analyzed. During the software development process, the code reviewer uses the source code instrumentation method to review the code after the code writing stage is completed. Usually, the reviewer has the right to read the source code but is inconvenient to modify the code. By analyzing the running behavior of the program, the errors in the code can be found as early as possible, so as to improve the software quality. Source code instrumentation can make full use of program semantics, visually display instrumented code, and will not increase the complexity of code logic.

The program instrumentation technology is to insert some probes into the program on the basis of ensuring the original logical integrity of the program under test, and throw out the characteristic data of the program operation through the execution of the probes. Through the analysis of these data, we can obtain The control flow and data flow information of the program, and then obtain dynamic information such as logic coverage, so as to achieve the method of testing. The program instrumentation technology inserts probes into the program under test, and then obtains the control flow and data flow information of the program through the execution of the probes, so as to achieve the purpose of testing. Therefore, according to the time of probe insertion, it can be divided into object code instrumentation and source code instrumentation.

Existing instrumentation methods mainly include three types of methods: assertion mechanism, bytecode instrumentation, and aspect-oriented instrumentation. The assertion mechanism directly adds instrumentation code to the source file, which will reduce the readability of the code. Bytecode instrumentation directly modifies the bytecode file, the source code of the inserted bytecode cannot be visualized, and the correctness of the code insertion process cannot be guaranteed. Aspect-oriented stubbing increases the horizontal aspect relationship on the basis of the vertical inheritance relationship of the program, which increases the logical complexity of the program.

At present, the instrumentation technology mainly has the problems of the visualization of the instrumentation point and its code, the management of the inserted code, the automatic positioning of the instrumentation point, and the low performance of the automatic instrumentation.

Contents of the invention

In view of the above problems, the present invention aims to provide a source code insertion method, which not only supports manual insertion, but also supports batch automatic insertion. Its main features include visualization of the instrumentation code, centralized management of the insertion code, and traceless process of instrumentation.

The present invention is achieved through the following technical solutions:

A traceless and manageable source code manual definition flag insertion method for source code, the steps include:

Step 10: Open a project;

Step 11: Define the insertion point in the whole project by defining the insertion flag on the source code editor;

Step 12: Review the definitions of all insertion points: if any insertion points with errors are found, proceed to step 13 to modify them; if no insertion points with errors are found, proceed directly to step 14;

Step 13: Modify the definition of stub until it is correct;

Step 14: Merge the insertion point with the original source file to generate a new source file;

Step 15: Compile the new source file to generate a bytecode file.

In said step 11), the steps of stake point definition include:

Step 20: Open a project;

Step 21: Determine whether it is necessary to define a stub point on the source file in the project, if yes, go to step 22, if not, go to step 25;

Step 22: Select the source file to be inserted, and open the source file with a source code editor;

Step 23: Locate the line of code where the insertion point is located first, and define a symbol for timely identification, and then define the corresponding insertion code on the symbol;

Step 24: If you need to continue to define a new insertion point in this source file, go to step 21, if not, go to step 25;

Step 25: End this instrumentation definition.

In step 13, the modifiable information includes: the instrumentation code included in the instrumentation point and whether the instrumentation point needs to be compiled into a bytecode file.

In the step 14, the steps of merging the original source file and the insertion point in the manual insertion to generate a new source file include:

Step 30: the start of merging the original source file and the insertion point, at this time the insertion point in each source file has been defined;

Step 31: Find out all the source files in the project first, and select a source file from them;

Step 32: Check whether the selected source file contains an insertion point, if yes, go to step 33, if not, go to step 36;

Step 33: first back up the original source file, and then find out all the insertion points in the source file;

Step 34: Sort all the found insertion points according to the row number;

Step 35: read the original source file line by line and write a new source file to generate a new source file;

Step 36: Check whether there are still source files that need to be merged with insertion points, if yes, return to step 31, if not, then go to step 37;

Step 37: All source files have been merged with the insertion point, and the end.

In the step 34, the sorting is performed according to the row number from small to large; for the same insertion point with the same row number, the insertion point of the first type of line is arranged before the insertion point of the end type.

In the step 35, the original source file is read line by line, and all insertion points are traversed from front to back; when the source file is read line by line:

a) If the line number is different from the line number of the insertion point, write it directly into the new source file;

b) If the line number is the same as the line number of the insertion point, then:

b.1) If the instrumentation type is the line header type, first write the instrumentation code to the new source file, and then write the original source file code,

b.2) If the stub type is the end-of-line type, first write the code of the original source file to the new source file, and then write the stub code;

When the source file is read line by line, the next insertion point is taken out until all the insertion points are merged into the original source file.

The insertion point manager displays the information of all insertion points in the project by querying, modifying the information of the insertion points, classifying and filtering the insertion points, locating the insertion points to a specific line in the source file and deleting the insertion points .

The instrumentation mark is displayed on the left vertical scale of the source code editor, and different icons are used to indicate that the line has been implanted with instrumentation code and instrumentation type; the code of the instrumentation point can be customized by the user.

All instrumentation flags are carried out with the project: the instrumentation flags are automatically saved after the project is closed, and the instrumentation flags can still be restored on the ruler of the source code editor when the project is opened next time.

This method is completed with the help of the centralized manager of the insertion points. The functions of the centralized manager of the insertion points include: querying and displaying the information of all the insertion points in the project, modifying the information of the insertion points, classifying and filtering the insertion points, and displaying the insertion points. Locate to a specific line in the file and delete the insertion point.

The instrumentation scheme of manually defining flags is instrumented by line, and each line contains at most two types of instrumentation flags, one is to insert instrumentation code at the beginning of the line, and the other is to insert instrumentation code at the end of the line. On the source code editor, the line that defines the instrumentation point will display a flag on the left vertical ruler, indicating that the line has been implanted with instrumentation code and indicating the instrumentation type. Each instrumentation point code can be customized by the user, and all instrumentation flags are persisted with the project.

The persistence of the instrumentation flag means that the instrumentation flag is automatically saved after the project is closed, and the instrumentation flag can still be restored on the ruler of the source code editor when the project is opened next time.

All insertion points can be managed centrally after definition. The centralized management of insertion points includes: query and display all insertion point information in the project, modify insertion point information, classification and filter display of insertion points, insertion point Locate to a specific line in the file and delete the insertion point.

Further, the query displays information about all insertion points in the project, including all insertion points at the beginning and end of the line in the query file. The displayed information includes: the name of the project to which the insertion point belongs, the path of the file to which it belongs, the line number where it is located, the required The implanted code and whether it needs to be merged into the bytecode file.

In step 13, modify the instrumentation point information, including editing the instrumentation code in the instrumentation point and whether it needs to be merged into the bytecode file. The instrumentation classification can be sorted by project name, file name, instrumentation type, and merge selection. After sorting, the instrumentation points of the same category are displayed together. When sorting by project name, the insertion points with the same project name will be displayed together, and the other classification methods are similar.

Insertion point filtering supports displaying a small number of necessary insertion points on the insertion point management interface, which avoids increasing the difficulty of user editing due to the huge number of insertion points and improves the user experience index. Insertion point filtering utilizes regular expressions to filter project names and file names, so that the insertion points in the filtered project (or file) are retained and displayed on the insertion management interface. When filtering, first find which project (or file) names match the regular expression, and save the matched projects (or files). Then find out the insertion points in the preserved project (or file) and display them on the insertion management interface.

The location of the insertion point can easily locate the file where the insertion point is located, so that the user can check the environment of the insertion point in time, and then analyze the function of this part of the program.

The insertion point deletion function supports the unified deletion of specified (or all) insertion points in the insertion point management part, avoiding the problem that the file where the insertion point must be located before deleting the insertion point, and thus improving the usability of the software.

The process of merging the defined insertion point and the original source file into a new source file is to operate each source file in the project independently. For a specific source file, first copy and back up the file, and then obtain all the insertion points in the file, and sort them from small to large line numbers. Then read the file by line and write it into a new file. When the line number is equal to the line number of a certain insertion point, write the insertion point code and the original file code into the new file according to the insertion type and then read the next line. . The code writing order is determined by the instrumentation type. If the instrumentation type is at the beginning of the line, write the instrumentation code first and then write the original file code. If it is the end-of-line instrumentation type, write the original file code first and then write the instrumentation code. Operate source file by source file by the above method, merge all instrumentation points into the corresponding source file and generate a new source file.

In the process of compiling a new source file to generate a new bytecode and running it, use the previous backup to restore the source file, from merging instrumentation points to compiling and running the bytecode file is a complete automatic process. For the outside, the original source file has not been changed and the result is the execution result of the instrumented code, and the whole process is a traceless process.

The invention saves the post-inserting code by using the mark, distinguishes the post-inserting code from the original code, and improves the visualization ability of the post-inserting code. The flag can display the corresponding instrumentation code at the instrumentation position without interfering with the editing work of the original file. At the same time, all instrumentation flags can be managed centrally, thereby improving the management ability of instrumentation codes. In order to improve the efficiency of automatic pile insertion, the present invention also designs a framework for file filtering and meta-instrumentation type reuse. All the above operations are completed in the background without modifying the user's original files, and the whole process is a traceless process.

Attached content

Figure 1 is a complete flow chart of manual stake insertion.

Fig. 2 is a flow chart of manual stake insertion point definition.

Fig. 3 is a flow chart of merging original source files and insertion points in manual insertion.

Detailed ways

The technical scheme of the present invention will be described in further detail below with reference to the accompanying drawings.

The present invention mainly includes two types of stake insertion schemes: one is manual definition of sign insertion type, and the other is automatic insertion of different application types.

The manual insertion scheme supports analysts to flexibly define and manage insertion points throughout the project according to analysis needs. The implanted instrumentation code will not destroy the original code, and finally several instrumentation points can be selected to run together with the original file according to the needs. The complete flow chart of manual pile insertion is shown in Figure 1, including the following steps:

Step 10: The start of the entire manual instrumentation process. At this time, open a project and prepare to analyze it through instrumentation;

Step 11: Define the instrumentation point throughout the project by defining the flag on the source code editor;

Step 12: After defining the insertion point, review the definitions of all insertion points. If you find an incorrect insertion point, go to step 13 to modify it, otherwise go to step 14;

Step 13: Modify the definition of the instrumentation. There are two main types of modifiable information: one is the instrumentation code contained in the instrumentation point, and the other is whether the instrumentation point needs to be compiled into a bytecode file;

Step 14: When the insertion definition is completed and no insertion point needs to be modified, merge the insertion point with the original source file and generate a new file;

Step 15: Compile the generated new source file to generate a bytecode file;

The above-mentioned manual insertion point definition process uses flags to save resource information, and the logo must be persisted with the project for future use. The flow chart of the entire manual insertion point definition is shown in Figure 2, including the following steps:

Step 20: The start of the definition of the entire manual insertion point. At this time, a project needs to be opened and ready to define the insertion point;

Step 21: Determine whether an insertion point needs to be defined on the file, if so, go to step 22, otherwise go to step 25;

Step 22: Select the file to be inserted, and open the file with a source code editor;

Step 23: For manual insertion, you must first locate the line of code where the insertion point is located, and define a sign so that it can be recognized in time in the future, and define the corresponding insertion code on the sign;

Step 24: Determine whether a new insertion point needs to be defined in this document. If a new insertion point needs to be defined, go to step 21; otherwise, go to step 25;

Step 25: The definitions of all the insertion points have been completed, and the definition of this insertion is ended;

After the insertion point is defined, in order to further improve the accuracy of the insertion point, this solution provides an insertion point manager. By querying and displaying the information of all the insertion points in the project, modifying the information of the insertion points, classifying and filtering the insertion points, locating the insertion points to a specific line in the file, and deleting the insertion points to improve the insertion point centralized management capabilities.

The process of merging the original source file with the insertion point is performed after the insertion point is defined. This operation merges the insertion point to be compiled in the file with the original file to generate a new file. The flow chart of merging the original source file and the insertion point in manual insertion is shown in Figure 3, including the following steps:

Step 30: The initial part of merging the original file with the insertion point. At this time, the insertion point in each file has been defined. Next, the insertion point will be merged for each file;

Step 31: Find out all the source files in the whole project first, and select a file from them;

Step 32: Check whether the selected file contains an insertion point, if so, go to step 33, otherwise go to step 36;

Step 33: If the file contains an insertion point, first back up the original file and then find out all the insertion points in the file;

Step 34: Sort all the found insertion points, and sort them according to the line number from small to large. For the insertion points with the same line number, the insertion points of the first type of line are arranged before the insertion points of the end type;

Step 35: Read the original file line by line and write a new file, while traversing all the insertion points from front to back. When reading a file line by line, if the line number is different from the insertion point, it will be directly written into the new file; The instrumentation code is written into the file and then the original file code. If the instrumentation type is the end-of-line type, the original file code is first written to the new file and then the instrumentation code is written. At the same time, the next instrumentation point will be fetched until all instrumentation points are merged into the original file.

Step 36: Check whether there are still files that need to be merged with the insertion point;

Step 37: All files have been merged with instrumentation points.

In this solution, after the instrumentation points are merged one by one, the new file will be compiled and a new bytecode will be generated. Run the new bytecode, and the result is the joint execution result of the instrumentation point and the original code.

The automatic insertion scheme is carried out for a specific application type, using the structure matching of the abstract syntax tree to automatically locate the insertion point, and the insertion point automatically locates the focus of the automatic insertion part. After positioning, add the syntax tree structure of the code fragment to the corresponding position in the syntax tree structure of the original file, convert the generated new syntax tree into source code and compile it into bytecode, and the resulting bytecode can be run directly. The complete flowchart of automatic pile insertion is shown in Figure 4, including the following steps:

Step 40: the start of the entire automatic pile insertion process, at this time open a project and prepare to analyze it through pile insertion;

Step 41: Define a file filter. The file filter uses regular expressions to match the required instrumentation projects (packages, files, methods), and the matched ones will be retained;

Step 42: Then use the filter defined above to filter the inserted files, and use the analyst's existing knowledge of the project files to improve the automatic insertion performance;

Step 43: Select the type of stub required, and define the code of the stub required for the relevant type;

Step 44: Then use syntax tree structure matching to locate the position of the insertion point according to different insertion types, and insert the code at the corresponding position to finally generate a new file;

Step 45: Compile the above-mentioned new files to generate new executable bytecode files, and save these files;

Step 46: Finally, an executable file is generated, and the original file information will not be modified in the whole process, and the whole process is a traceless process.

Finally, it should be noted that the above steps are only used to illustrate the technical solution of the present invention rather than limit it. Although the above steps have described the present invention in detail, those skilled in the art should understand that the specific technologies of the present invention can still be modified or some technologies can be equivalently replaced; without departing from the spirit of the technical solutions of the present invention, they should cover exist

Claims (9)

1. seamless manageable source code manual definition sign pile pitching method is characterized in that comprising step:

Step 10: open an engineering;

Step 11: by at source code editing machine definition pitching pile sign, and then in whole engineering definition pitching pile point;

Step 12: examine the definition of all pitching pile points:, then enter step 13 it is made amendment if find to have the pitching pile point of mistake; Do not have to find to have the pitching pile point of mistake, then directly enter step 14;

Step 13: revise the definition of pitching pile to correct;

Step 14: pitching pile point and former source file are merged the new source file of generation;

Step 15: new source file is compiled the generation byte code files.

2. seamless manageable source code manual definition sign pile pitching method according to claim 1 is characterized in that in the described step 11), and the step of pitching pile point definition comprises:

Step 20: open an engineering;

Step 21: judge whether and need define the pitching pile point on the source file in engineering, if, then jump to step 22, if not, then jump to step 25;

Step 22: choose the source file of required pitching pile, open this source file with the source code editing machine;

Step 23: navigate to earlier pitching pile point place code line, and define a sign and be convenient to and in time identify, again at the corresponding pitching pile code of this sign definition;

Step 24: if need to then jump to step 21 at the new pitching pile point of the continuous definition of this source file relaying, if do not need, then enter step 25;

Step 25: finish this pitching pile definition.

3. seamless manageable source code manual definition sign pile pitching method according to claim 1 is characterized in that in the described step 13 can modification information comprise: whether pitching pile code and pitching pile point that pitching pile point comprised need to be compiled into byte code files.

4. according to claim 1 or 2 or 3 described seamless manageable source code manual definition sign pile pitching methods, it is characterized in that in the described step 14 that manually the step of the new source file of pitching pile Central Plains source file and pitching pile point merging generation comprises:

Step 30: the beginning that former source file and pitching pile point merge, the pitching pile point in each source file defines at this moment;

Step 31: earlier all source files in the engineering are found out, and therefrom select a source file;

Step 32: check whether comprise the pitching pile point in the selected source file, then enter step 33, if then do not jump to step 36 if having;

Step 33: at first with former source file backup, find out then all pitching pile points in the source file;

Step 34: all pitching pile points that find out are sorted, sort according to line number;

Step 35: read former source file line by line and write a new source file, generate a new source file;

Step 36: check whether also have source file need merge the pitching pile point,, then to return step 31,, then to enter step 37 if do not have if having;

Step 37: all source files had all merged the pitching pile point, finished.

5. seamless manageable source code manual definition sign pile pitching method according to claim 4 is characterized in that in the described step 34 that ordering is to sort according to line number is ascending; For the identical pitching pile point of line number, the first type pitching pile point of row comes before the last type pitching pile point of row.

6. seamless manageable source code manual definition sign pile pitching method according to claim 4 is characterized in that reading former source file line by line in the described step 35, travels through all pitching pile points from front to back; When reading source file line by line:

If a) line number is different from pitching pile point line number, in the new source file that then writes direct;

B) if line number is identical with pitching pile point line number, at this moment:

B.1) if the pitching pile type is the first type of row, then earlier write the pitching pile code, write former source file code again to new source file,

B.2) if the pitching pile type is the last type of row, then earlier write former source file code, write the pitching pile code again to new source file;

When reading source file line by line, take out next pitching pile point, until all pitching pile points all merge in the former source file.

7. seamless manageable source code manual definition sign pile pitching method according to claim 1, it is characterized in that described pitching pile sign is presented on the left vertical scale of source code editing machine, show that with the different icons form this row implanted pitching pile code and pitching pile type; The code of pitching pile point can be by User Defined.

8. seamless manageable source code manual definition sign pile pitching method according to claim 7, it is characterized in that all pitching pile signs all carry out with engineering: the pitching pile sign is preserved after engineering is closed automatically, and the pitching pile sign still can reduce on the scale of source code editing machine when opening engineering next time.

9. seamless manageable source code manual definition sign pile pitching method according to claim 1, it is characterized in that this method concentrates manager to finish by pitching pile point, pitching pile point concentrates the function of manager to comprise: inquiry also shows the specifically deletion of certain delegation and pitching pile point in the file of all pitching pile dot informations in the engineering, the information of revising pitching pile point, pitching pile point classification and filtration demonstration, pitching pile point location.

Images