KR102500395B1 - Apparatus and method for repairing bug source code for program - Google Patents

Abstract

A device for correcting bugs in a program source code includes a preprocessor that performs preprocessing on the program source code by adding a display token to each of a plurality of buggy lines included in the program source code, and converts the preprocessed program source code into a code block-based source code. A code conversion unit for converting into code, a learning unit for learning a bug correction model based on the source code based on the converted code block, and a bug correction unit for correcting bugs in the new program source code using the learned bug correction model. can include

Description

Apparatus and method for correcting bugs in program source code {APPARATUS AND METHOD FOR REPAIRING BUG SOURCE CODE FOR PROGRAM}

The present invention relates to an apparatus and method for correcting a bug in a program source code.

In the conventional case, when a bug occurs in a program, a bug report is generated, and a developer proceeds with debugging of the program based on the bug report to directly correct the bug in the program. Thereafter, the quality assurer proceeds to verify the program in which the bug has been corrected through methods such as test cases, and proceeds with the final distribution of the verified program.

Recently, many program bugs have occurred due to the increase in the size and complexity of programs. For this reason, research on program bug correction using machine learning is being actively conducted in the field of intelligent software.

Existing machine learning-based technologies related to program bug correction include DeepFix, GenProg, and jGenProg.

Here, DeepFix is a bug correction technology for compilation errors based on the Attention algorithm. Because DeepFix only corrects compilation errors, it cannot correct various program execution errors.

GenProg is a C language-based program correction technology using GP (Genetic Programming). GenProg performs a genetic operation on an object program AST (Abstract Syntax Tree) using a heuristic method, and uses a fitness function to evaluate the fitness of the generated program.

However, existing machine learning-based technologies still have a problem in that their verification performance and program bug correction performance for various projects are poor.

In this regard, FIGS. 2A and 2B are diagrams for explaining bug correction results for DeepFix.

Referring to FIG. 2A, a program bug occurs because an inappropriate variable is used in “character % 64” at line 11.

On the other hand, if the test case ("O Brother Where Art Thou?) is applied to DeepFix as shown in Fig. 2b, "Check sum is F" should be output. However, due to a program bug that occurred in line 11 in Fig. 2a, an inappropriate The result ("Check sum is ") is printed.

Korean Patent Publication No. 10-2019-0089615 (published on July 31, 2019)

The present invention is to solve the above-described problems of the prior art, by converting a program source code into a code block-based source code, and using a bug correction model learned based on the converted code block-based source code to create a new program. I'd like to fix a bug in the source code.

However, the technical problem to be achieved by the present embodiment is not limited to the technical problems described above, and other technical problems may exist.

As a technical means for achieving the above technical problem, an apparatus for correcting a bug in a program source code according to a first aspect of the present invention adds a display token to each of a plurality of buggy lines included in the program source code, thereby a pre-processing unit that performs pre-processing on code; a code conversion unit that converts the preprocessed program source code into a code block-based source code; a learning unit for learning a bug correction model based on the converted code block-based source code; and a bug correction unit correcting bugs of the new program source code using the learned bug correction model.

A method for correcting a bug in a program source code according to a second aspect of the present invention includes performing preprocessing on the program source code by adding a display token to each of a plurality of buggy lines included in the program source code; converting the preprocessed program source code into code block-based source code; learning a bug correction model based on the source code based on the converted code block; and correcting bugs of the new program source code using the learned bug correction model.

The above-described means for solving the problems is only illustrative and should not be construed as limiting the present invention. In addition to the exemplary embodiments described above, there may be additional embodiments described in the drawings and detailed description.

According to any one of the problem solving means of the present invention described above, the present invention converts the program source code into a code block-based source code, and uses a bug correction model learned based on the converted code block-based source code. Bugs can be corrected for new program source code.

Through this, development productivity of developers can be improved and software quality can be improved by utilizing the automated bug correction technology of the present invention.

In addition, if the bug correction technology of the present invention is used, since the bug correction activity is performed with a small amount of manpower and effort, flexible software manpower management such as additionally deploying software development manpower can be performed.

1 is a block diagram of an apparatus for correcting program bugs according to an embodiment of the present invention.
2A and 2B are diagrams for explaining a conventional method of automatically correcting program bugs.
3A to 3C are diagrams for explaining a code block processing method according to an embodiment of the present invention.
4a to 4c are views for explaining a method of correcting a bug in a new program source code according to an embodiment of the present invention.
5A to 5B are diagrams for explaining and comparing a conventional baseline model and a bug correction model of the present invention.
6 is a flowchart illustrating a method of correcting a bug in a program source code according to an embodiment of the present invention.

Hereinafter, embodiments of the present invention will be described in detail so that those skilled in the art can easily practice the present invention with reference to the accompanying drawings. However, the present invention may be embodied in many different forms and is not limited to the embodiments described herein. And in order to clearly explain the present invention in the drawings, parts irrelevant to the description are omitted, and similar reference numerals are attached to similar parts throughout the specification.

Throughout the specification, when a part is said to be "connected" to another part, this includes not only the case where it is "directly connected" but also the case where it is "electrically connected" with another element interposed therebetween. . In addition, when a certain component is said to "include", this means that it may further include other components without excluding other components unless otherwise stated.

In this specification, a "unit" includes a unit realized by hardware, a unit realized by software, and a unit realized using both. Further, one unit may be realized using two or more hardware, and two or more units may be realized by one hardware.

In this specification, some of the operations or functions described as being performed by a terminal or device may be performed instead by a server connected to the terminal or device. Likewise, some of the operations or functions described as being performed by the server may also be performed in a terminal or device connected to the corresponding server.

Hereinafter, specific details for the implementation of the present invention will be described with reference to the accompanying configuration diagram or process flow chart.

1 is a block diagram of a program bug correction device 10 according to an embodiment of the present invention.

Referring to FIG. 1 , the program bug correction device 10 may include a pre-processing unit 100, a code conversion unit 110, a learning unit 120, and a bug correction unit 130. Here, the bug correction unit 130 may include a candidate correction code derivation unit 132 and a final correction code derivation unit 134 . However, the program bug correction device 10 in FIG. 1 is only one implementation example of the present invention, and various modifications are possible based on the components shown in FIG. 1 .

The preprocessing unit 100 may perform preprocessing on the program source code by adding a display token to each of a plurality of buggy lines included in the program source code. The pre-processing unit 100 may add display tokens before and after each of the plurality of buggy lines included in the program source code.

For example, the pre-processor 100 displays a <START> token indicating the start of a buggy line including 'private static final double DEFAULT_EPSILON = 10e-p;', and displays <END' indicating an end before the buggy line. > by adding 'private static final double DEFAULT_EPSILON = 10e-p;' to '<START> private static final double DEFAULT_EPSILON = 10e-p; <END>' can preprocess it. By pre-processing the program source code in this way, the bug correction model can easily recognize bugs in the program source code and reduce the time to search for the bug.

In addition, since the program source code is composed of natural language, it is possible to omit natural language processing by the encoder and decoder of the bug correction model to be described later by adding a display token to the program source code.

The code conversion unit 110 may convert the preprocessed program source code into code block-based source code. Here, the code block-based source code is a code expression technique processed from preprocessed program source code, and each method constitutes one code block together with at least one member variable.

The code conversion unit 110 may extract member variables and methods included in the preprocessed program source code.

For example, FIG. 3A is an exemplary diagram in which program source codes are processed into code blocks. The program source code shown in FIG. 3A is code having a function of copying all Java files in a target directory to a set path. Referring to Figure 3a, the program source code has two member variables (fromPath member variable in line 5 and toPath member variable in line 6) and three methods (main function in line 7, filter function in line 10, and copyFile in line 13). function) is included. The code conversion unit 110 may extract two member variables and three methods from the program source code.

The code conversion unit 110 may generate a plurality of code blocks by combining the extracted member variables and methods, and convert the preprocessed program source code into a code block-based source code based on the generated plurality of code blocks. .

For example, referring to FIGS. 3A and 3B together, the code conversion unit 110 may generate a first code block by combining the fromPath member variable, the toPath member variable, and the copyFile function extracted from the program source code. Also, the code conversion unit 110 may generate a second code block by combining the extracted fromPath member variable, toPath member variable, and main function. Also, the code conversion unit 110 may generate a third code block by combining the extracted fromPath member variable, toPath member variable, and filter function.

Subsequently, the code conversion unit 110 may convert the preprocessed program source code into a code block-based source code based on the generated first code block, second code block, and third code block.

3C describes a process of converting a program source code into a code block-based source code.

Referring to FIG. 3C, the code conversion unit 110 converts member variables (member variables 1, .., member variables N) and methods (method 1, method 2), method M included in the program source code (Frequency.java). ) can be identified.

Subsequently, the code conversion unit 110 is configured by combining the identified member variables and methods, but may be configured with one code block per method. That is, the number of code blocks may be configured equal to the number of methods.

In this case, member variables may be included in two or more code blocks. For example, the code conversion unit 110 generates a first code block including member variable 1, member variable N, and method 1, and generates a second code block including member variable 1, member variable N, and method 2. and create an Mth code block including member variable 1, member variable N, and method M. The code block-based source code generated based on the first code block, the second code block, and the M-th code block is input as an input value of the bug correction model 30 and used for learning the bug correction model 30. can

The learning unit 120 may train a bug correction model based on the converted code block-based source code. Here, the bug correction model may be, for example, a long short-term memory (LSTM) based model. Here, LSTM is a special recurrent neural network (RNN) to solve the gradient vanishing problem in the learning process of a long sequence.

Meanwhile, when the bug correction model is trained using the entire program source code, it is difficult to learn the bug correction model because the input sequence is very long. Accordingly, the conventional bug correction model has difficulty in learning with a long sequence of inputs.

According to the present invention, as the bug correction model is learned through the source code of code block units shorter than the entire program source code, strong relationship information is extracted between display tokens displayed for each code block unit, thereby easily recognizing bugs and searching for bugs. can save time Accordingly, the performance of the bug correction model can be improved.

In addition, according to the present invention, when the bug correction model learns a code block-based source code, it concentrates only on the code block and does not pay attention to other source code lines that do not include the corresponding code block, so that it is possible to detect from other source code lines. noise can be minimized.

In the present invention, the bug correction model may be composed of a recurrent neural network including an encoder and a decoder. Here, the encoder of the bug correction model may be a bi-directional encoder that integrates information of a display token included in a code block-based source code. In the present invention, the encoder uses LSTM to process the input into the recurrent neural network.

The learning unit 120 may train a bug correction model to correct bugs in the code block-based source code through the bug correction model.

The bug correction unit 130 may correct bugs in the new program source code using the learned bug correction model.

The candidate correction code derivation unit 132 may derive at least one candidate correction code for a specific code block in the new program source code from the learned bug correction model.

For example, referring to FIGS. 2A, 4A, and 4B together, when the program source code of FIG. 2A is input to the learned bug correction model 30, the candidate correction code derivation unit 132 derives from the program source code of FIG. 2A. Derive a first candidate correction code (sum = sum + (int) character;) and a second candidate correction code (character = (char) (sum + (int) characer);) to be used for the bug correction of line 9, A third candidate correction code (remainder=(char) ((sum%64) + 22);) to be used for the bug correction of line 11 in the program source code of FIG. 2A can be derived.

The final correction code derivation unit 134 may input at least one or more candidate correction codes into a fitness measurement model to derive a correction fitness for each of the at least one or more candidate correction codes. Here, the fitness function used in the fitness measurement model can be expressed as [Equation 1].

[Equation 1]

Here, Passed Testcases means the number of test cases that candidate correction codes passed, All Testcases means the total number of candidate correction codes, and Value means correction suitability.

Referring to [Equation 1], as the number of passed test cases increases, the correction fitness approaches a predetermined value (eg, 1). If all test cases are passed, the corrected fit is calculated as a preset value.

The final correction code derivation unit 134 may derive a final correction code from among at least one or more candidate correction codes based on the correction suitability for each candidate correction code.

For example, referring to FIGS. 4A and 4C , the final correction code derivation unit 134 inputs the first candidate correction code, the second candidate correction code, and the third candidate correction code to the fitness measurement model 32 to determine the first A correction suitability for each of the candidate correction code, the second candidate correction code, and the third candidate correction code may be calculated.

At this time, a candidate correction code whose correction suitability is close to a predetermined value (eg, 1) may be determined as a correction code suitable for correcting a program bug. If all of the candidate correction codes do not reach the preset value, the candidate correction code derivation unit 132 may derive at least one or more candidate correction codes for a specific code block from the new program source code again.

For example, referring to FIGS. 2B and 4B together, a first candidate correction code (sum = sum + (int) character;) and a second candidate correction code (character = (char) (sum + (int) characer) ;) is input into the fitness measurement model 32, "Check sum is ㅁ" is output, and the third candidate correction code (remainder=(char) ((sum%64) + 22);) is applied to the fitness measurement model ( 32), if "Check sum is F" is output, the final correction code derivation unit 134 may derive the third candidate correction code as the final correction code.

The bug correcting unit 130 may correct bugs in the new program source code by replacing a specific code block with the final corrected code.

On the other hand, those skilled in the art, the pre-processing unit 100, the code conversion unit 110, the learning unit 120, the bug correction unit 130, the candidate correction code derivation unit 132 and the final correction code derivation unit 134, respectively It will be fully understood that they may be implemented separately or integrated with one or more of them.

5A to 5B are diagrams for comparing and explaining a conventional bug correction model and a bug correction model of the present invention.

Referring to Figure 5a, the conventional bug correction model is "Z. Chen, S. J. Kommrusch, M. Tufano, L. N. Pouchet, D. Poshyvanyk, & M. Monperrus, "Sequencer: Sequence-to-sequence learning for endto-end program repair", IEEE Transactions on Software Engineering, pp.1-19, 2019", a model that corrects program bugs by using open source commit information based on deep learning learning. The predictive accuracy of the conventional bug-correction model and the bug-correction model of the present invention were compared when correcting bugs for a specific program source code while learning the same data set. Here, the data set is "Z. Chen and M. Monperrus, "The CodRep Machine Learning on Source Code Competition," ArXiv eprints, Jul. pp.1-6, 2018. arXiv: 1807.03200 [cs.SE]" is the proposed CodRep, and certain program source code is also some were used.

As a result of comparison, as shown in the graph in FIG. 5A (X-axis means model training count, Y-axis means accuracy), the performance of the code block-based bug correction model of the present invention is about 85% compared to the conventional bug correction model. % accuracy, and it can be confirmed that program bug corrections are performed appropriately.

Referring to FIG. 5B, in the graph of FIG. 5B (the X-axis means the type of program source code, and the Y-axis means the number of corrected codes), the bug correction model of the present invention identifies 898 bugs in a specific program source code. Corrected. In contrast, the conventional bug-correction model corrected 728 bugs in a specific program source code.

Looking at these experimental results, it was confirmed that the performance of the code block-based bug correction model of the present invention is significantly higher than that of the conventional bug correction model.

6 is a flowchart illustrating a method of correcting a bug in a program source code according to an embodiment of the present invention.

Referring to FIG. 6 , in step S601, the program bug correction device 10 may perform preprocessing on the program source code by adding a display token to each of a plurality of buggy lines included in the program source code.

In step S603, the program bug correction device 10 may convert the preprocessed program source code into code block-based source code.

In step S605, the program bug correction device 10 may train a bug correction model based on the converted code block-based source code.

In step S607, the program bug correction device 10 may correct the bug of the new program source code by using the learned bug correction model.

In the foregoing description, steps S601 to S607 may be further divided into additional steps or combined into fewer steps, depending on an embodiment of the present invention. Also, some steps may be omitted if necessary, and the order of steps may be changed.

An embodiment of the present invention may be implemented in the form of a recording medium including instructions executable by a computer, such as program modules executed by a computer. Computer readable media can be any available media that can be accessed by a computer and includes both volatile and nonvolatile media, removable and non-removable media. Also, computer readable media may include all computer storage media. Computer storage media includes both volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data.

The above description of the present invention is for illustrative purposes, and those skilled in the art can understand that it can be easily modified into other specific forms without changing the technical spirit or essential features of the present invention. will be. Therefore, the embodiments described above should be understood as illustrative in all respects and not limiting. For example, each component described as a single type may be implemented in a distributed manner, and similarly, components described as distributed may be implemented in a combined form.

The scope of the present invention is indicated by the claims to be described later rather than the detailed description, and all changes or modifications derived from the meaning and scope of the claims and equivalent concepts thereof should be construed as being included in the scope of the present invention. .

10: Program bug correction device
100: pre-processing unit
110: code conversion unit
120: learning unit
130: bug corrector
132: candidate correction code derivation unit
134: final correction code derivation unit

Claims (9)

In the apparatus for correcting bugs in program source code,
a preprocessing unit which preprocesses the program source code by adding a display token to each of a plurality of buggy lines included in the program source code;
a code conversion unit that converts the preprocessed program source code into a code block-based source code;
a learning unit for learning a bug correction model based on the converted code block-based source code; and
A bug correcting unit correcting bugs in the new program source code using the learned bug correction model.
A program bug correction device comprising a.
According to claim 1,
The code converter
Extracting member variables and methods included in the preprocessed program source code;
Combining the extracted member variables and methods to generate a plurality of code blocks;
Converting the preprocessed program source code into the code block-based source code based on the generated plurality of code blocks. Program bug fixing device.
According to claim 2,
The number of the plurality of code blocks is the same as the number of the extracted methods.
According to claim 1,
The bug correction model is a long short-term memory (LSTM) based model, program bug correction device.
According to claim 1,
Wherein the learning unit learns to correct bugs in the source code based on the converted code block through the bug correction model.
According to claim 1,
The bug correction unit is a candidate correction code derivation unit for deriving at least one candidate correction code for a specific code block of the new program source code from the learned bug correction model.
A program bug correction device comprising a.
According to claim 6,
The bug correction unit inputs the at least one or more candidate correction codes into a fitness measurement model to derive a correction fitness for each of the at least one or more candidate correction codes, and based on the correction fitness for each of the at least one or more candidate correction codes, the at least one or more candidate correction codes. A final correction code derivation unit for deriving a final correction code from among candidate correction codes.
A program bug correction device comprising a.
According to claim 7,
Wherein the bug correcting unit corrects the bug of the new program source code by replacing the specific code block with the final corrected code.
In the method of correcting bugs in program source code,
performing preprocessing on the program source code by adding a display token to each of a plurality of buggy lines included in the program source code;
converting the preprocessed program source code into code block-based source code;
learning a bug correction model based on the source code based on the converted code block; and
Correcting a bug in a new program source code using the learned bug correction model
To include, program bug correction method.

Images