CN108459965B

CN108459965B - Software traceable generation method combining user feedback and code dependence

Info

Publication number: CN108459965B
Application number: CN201810184034.9A
Authority: CN
Inventors: 匡宏宇; 胡昊; 吕建; 张宗飞
Original assignee: Nanjing University
Current assignee: Nanjing University
Priority date: 2018-03-06
Filing date: 2018-03-06
Publication date: 2021-11-02
Anticipated expiration: 2038-03-06
Also published as: CN108459965A

Abstract

The invention discloses a software traceable generation method combining user feedback and code dependence, which comprises the following steps: step 1, obtaining code dependence existing in target software; step 2, calculating the code dependence compactness, and setting a compactness threshold to generate a code dependence domain; step 3, generating an initial candidate list of the required codes based on an information retrieval method; and 4, optimizing the candidate list according to the user feedback and the code dependence. The invention makes up the problem of word mismatch in the information retrieval method by combining the user feedback and the code dependence information. The invention only needs the user to judge the relevance of a small number of candidate clues. Compared with the traditional information retrieval method, the accuracy and the recall rate of the candidate list generated by the method are greatly improved.

Description

Software traceable generation method combining user feedback and code dependence

Technical Field

The invention relates to a software traceable generation method combining user feedback and code dependence, belongs to the technical field of computer software maintenance, and can efficiently, automatically and accurately find out the tracing relation between software entities.

Background

Trace cues between software entities are a valuable resource in the maintenance of software. Trace threads between software entities can provide a tracing relationship between higher level software entities, e.g., use cases, and underlying software entities, e.g., source code. But acquiring trace cues between software entities requires a great deal of time and effort. Software engineers need to read and understand different software entities to determine whether a tracking relationship exists between the different software entities. Thus, semi-automated tools have been developed to improve the efficiency of obtaining trace cues.

At present, a software traceability generation method based on information retrieval ranks two required entities according to text similarity from large to small by calculating the text similarity between the two required entities. However, the method of information retrieval has the problem of vocabulary mismatching, and the method is seriously dependent on the text corpus quality of a software entity; in order to solve the problem of vocabulary mismatching, there is currently a method of using code-dependent information in a code entity based on an information retrieval method, but the method relies heavily on the effect of the information retrieval method itself.

Disclosure of Invention

The purpose of the invention is as follows: in view of the deficiencies of the prior art methods, it is an object of the present invention to provide a software traceable generation method that combines user feedback and code dependence. Compared with the traditional information retrieval method, the candidate thread sorting table generated by the invention has the advantages that the accuracy and the recall rate are obviously improved; compared with the common user feedback method, the method and the system not only reduce the user participation, but also improve the accuracy and the recall rate.

The technical scheme is as follows: since the implementation of a particular requirement is cooperatively performed by a plurality of code elements distributed in the source program, the related code elements form a code domain. When the user judges that a certain code element in the code domain is related to the requirement, the correlation between other elements and the requirement can be further obtained. The software traceable generation method combining the user feedback and the code dependence reduces the user participation by utilizing the code domain and improves the precision. Which comprises the following steps:

step 1, a code dependence capturing tool is inserted into a target system, the target system is operated, and code dependence existing in the target system is obtained, wherein the code dependence comprises calling dependence and data dependence.

And 2, calculating the code dependence compactness, setting a compactness threshold, and only reserving the code dependence with the compactness larger than the threshold to obtain a call dependence domain and a data dependence domain.

And 3, calculating the text similarity between the requirements and the code elements based on the information retrieval method and sequencing from large to small.

And 4, optimizing the initial candidate clue sorting table according to the feedback result of the user to the specific undetermined code domain and the code dependence information of the software.

Further, the step 1 comprises the following steps:

step 1.1, constructing a code dependence capture tool, monitoring 4 JVM events generated in a Java virtual machine by using a JVM interface provided by a standard JDK, and respectively reading the events for class members, modifying the events for the class members, entering the functions into the events and returning the functions to the events; registering callback functions of the 4 events, and storing function entry, return records and data access records caused by the events in the callback functions into a local database;

step 1.2, establishing a call dependency and a data dependency relationship between functions according to the record data acquired in the step 1.1;

and 1.3, aggregating the code dependencies among the functions into code dependencies among the classes, wherein the code dependency corresponding to one class is formed by combining the code dependencies corresponding to all the functions in the class. The code dependency graph is composed of V and E, wherein V is a vertex set, and an element V in V represents a class; and E is a set of edges, an element E in the E is < source, target >, source and target are equal to V, the calling dependency graph shows that calling to the target occurs in the source, and the source and the target access the same data.

Further, the step 2 comprises the following steps:

step 2.1, for the calling dependence compactness, the formula is as follows:

wherein N represents the number of different method calls existing between the class Sink and Source. WeightedInDegree_SinkRepresenting the number of times the class Sink is called, WeightendOutDegree_SourceRepresenting the number of times the class Source calls other class methods. Closensess_DCThe value range of (a) is a closed interval of 0 to 1.

Step 2.2, for the data dependency graph, the compactness calculation formula is as follows:

where N represents the total number of data dependencies captured, N_dtRepresenting the number of times a given data type appears in all data dependencies. If a data type is ubiquitous in a large number of data dependencies, the idtf value of the data type is small. idtf (x) represents the idtf value of data type x, DT_i∩DT_jRepresenting a set of data types shared between two classes, DT_i∪DT_jRepresenting the set of all data types accessed by both classes.

And 2.3, respectively setting compactness threshold values for the calling dependency graph and the data dependency graph, and deleting the edges with the compactness smaller than the threshold values to form a code dependency domain.

Further, in step 3, the text preprocessing is performed on the required text, including removing stop words, morphological restoration and stem extraction. For a code text, firstly, performing word segmentation according to a naming rule, and then performing the same text preprocessing as the required text; and calculating the similarity between the requirement text and the code text set based on the information retrieval technology. Taking a vector space model as an example, expressing a demand text and a code text by high-dimensional vectors q and r, wherein each dimension w in the vector corresponds to the weight of a word, and the weight w can be calculated by using a TF-IDF formula. For q and r high-dimensional vectors, cosine similarity between vectors can be calculated by utilizing cosine distance.

Further, the step 4 comprises the following steps:

and 4.1, reordering the undetermined code domains according to the sequence of similarity values from large to small according to the maximum similarity value of the classes and the requirements in each domain for the undetermined code domains. And for the code domain with the first rank, taking the class with the largest similarity to the requirement in the domain to be judged by the user. If there is a correlation with the demand step 4.2 is performed, otherwise step 4.4 is performed.

Step 4.2, the similarity value of the candidate clues corresponding to the intra-domain classes is improved, and the formula is as follows:

interpretation of formula parameters: maxralue is the maximum similarity of all candidate threads corresponding to the requirement, and countinsteisregion is the number of classes in the domain.

IR_now＝Min(maxIRValue，IR_origin+bonus)

Wherein IR_originFor candidate thread current similarity values, IR_nowThe similarity value after updating for the corresponding candidate thread does not exceed maxIRValue, which is the global maximum of similarity to the demand. The similarity value of the candidate clues corresponding to the out-of-domain class is then increased (i.e., step 4.3).

And 4.3, improving the similarity value of the candidate clue corresponding to the class outside the domain. And according to whether the related domain is a call dependent domain or a data dependent domain, adopting different methods to improve the similarity value of the candidate clues corresponding to the classes outside the domain. If the code domain is a calling dependent domain, finding a path from the class outside the domain to the class in the judged relevant code domain, wherein the path is required to follow the following rules:

1. from the class outside the domain to the class inside the domain, the calling relationship is always realized; or from an out-of-domain class to an in-domain class, is always the called relationship.

2. Only one intra-domain class can appear on the path.

And accumulating and multiplying the tight density values of all edges on each path for all paths meeting the requirements, and finally increasing the similarity value of the candidate clues corresponding to the class outside the domain by using the path with the maximum accumulated value.

The formula is as follows:

interpretation of formula parameters: IR_nowSimilarity value after update for the candidate thread, IR_maxInRegionFor the invocation dependency domain, all the intra-domain classes correspond to the maximum similarity of the candidate threads. There may be multiple PATHs from the out-of-domain class to the in-domain class, PATH is the PATH with the maximum compactness multiplication value of all edges in the PATH, and x is the edge on the PATH, closensess_DC(x) Call dependency tightness for edge xAnd (4) degree.

If the code domain is a data dependent domain, finding a path from the class outside the domain to the class in the determined relevant code domain, wherein the path is subject to the following rules:

1. classes outside the domain must have a direct data dependency with the class inside the domain.

2. Only one class in a domain can appear on the path.

And for all paths meeting the requirements, increasing the similarity value of the candidate clues corresponding to the class outside the domain by using the path with the maximum data dependence compactness.

The formula is as follows:

IR_now＝IR_origin+IR_maxInRegion*Closeness_CD(x)

interpretation of formula parameters: IR_nowSimilarity value after update for the candidate thread, IR_maxInRegionFor the maximum similarity of candidate clues corresponding to all in-domain classes in the data dependency domain, multiple paths may exist from the out-of-domain class to the in-domain class, and x is the edge with the maximum data dependency compactness, closense_CD(x) The data for this edge depends on the compactness.

And 4.4, reordering all candidate clues according to the sequence of the similarity values from large to small. The user decides whether to continue judging candidate code domains (recommending three judgments for a given requirement). And if the user continues to judge, repeating the step 4.1, otherwise, ending the algorithm flow.

The invention has the following beneficial effects: the present invention, when generating demand traceability, enables the accuracy of the traceable data to be significantly improved with only a small amount of user involvement by utilizing user feedback and code dependencies.

Drawings

FIG. 1 is a schematic flowchart of a traceable generation method that combines user feedback and code dependency according to an embodiment of the present invention;

FIG. 2 is a block diagram of a code capture tool in accordance with an embodiment of the present invention;

FIG. 3 is a code dependency graph of an embodiment of the present invention, where a solid line edge represents a call dependency, a dashed line edge represents a data dependency, and a dependency edge weight represents the number of times of occurrence of different call dependencies or the number of types of shared data;

FIG. 4 is a code dependency graph of an embodiment of the present invention, wherein the edge weights represent code dependency closeness;

FIG. 5 is a diagram of three code domains formed by setting the call dependency compactness and the data dependency compactness to both 0.6 according to an embodiment of the present invention.

Detailed Description

The present invention is further illustrated by the following examples, which are intended to be purely exemplary and are not intended to limit the scope of the invention, as various equivalent modifications of the invention will occur to those skilled in the art upon reading the present disclosure and fall within the scope of the appended claims.

As shown in fig. 1, the software traceable generation method, in combination with user feedback and code dependence, explains how the method performs by way of a specific example. Taking the iTrust system as an example, the iTrust is medical software and adopts java language. The system comprises a uc directory and an src directory, wherein the uc directory is a group of text files for describing requirements, the src directory is a code file of the project, and when code traceability is achieved for the iTrust system by requirements, the execution method can enable a user to more quickly see candidate clues with relevance.

Step 1, using JVMTI interface provided by standard JDK, construct code dependency capture tool as shown in FIG. 2. And operating the iTrust system, inserting the code dependence capturing tool shown in the figure 2 into the virtual machine operating the iTrust project through an agentpath parameter, monitoring events such as function entering and exiting, domain variable access and modification and the like in the virtual machine by the code dependence capturing tool, and storing data access records in a corresponding callback function into a local database when the events are triggered. And finally, analyzing database data to obtain code dependence among functions, and further obtaining code dependence among classes. Table 1 is the data dependency table involved in this embodiment, and fig. 3 is a subset of code dependencies. Where the solid lines are call dependencies and the dashed lines are data dependencies.

TABLE 1

Source	Data Type	Target
			NDCodesDAO	NDCode	UpdateCodesListAction
UpdateCodesListAction	LOINCBean	DrugCodesBeanValidator
			UpdateCodeListAction	LOINCBean	DrugCodesDAO
DrugCodesBeanValidator	LOINCBean	DrugCodesDAO

Step 2, table 2 is an idtf value table of each data type involved in data dependency in this embodiment, and according to the above-mentioned code dependency compactness formula, calculating the code dependency compactness between classes as shown in fig. 4, setting a calling dependency compactness threshold of 0.6 and a data dependency compactness threshold of 0.6, and forming a code dependency domain when the compactness between classes is higher than the threshold. FIG. 5 is a diagram of a code dependent field and a data dependent field generated after setting a threshold, in which the area shown by the solid line represents the code dependent field and the area shown by the dotted line represents the data dependent field.

TABLE 2

N＝4844

#	Data Type	occurrences	Idtf Value
					1	LOINCBean	9	2.7310
2	NDCode	147	1.5179
				3	Java.lang.String	1118	0.6368

And 3, performing text preprocessing on the text in the requirement uc and the code src. The process includes removal of stop words, word shape reduction and stem extraction. In particular, for text extracted from codes, word segmentation is required first according to variable rules such as camel nomenclature. For example, for a function name initializeDrugCodes, firstly, the function name initializeDrugCodes is divided into initialize, drug and codes according to a hump rule, and then, the shape reduction and the stem extraction are carried out to respectively obtain the init, the drug and the code. For the preprocessed requirement text and code text, the similarity between the texts is calculated by using a vector space model, and table 3 is a list in which the calculated similarity is arranged from large to small according to the similarity value. The last column, isTrace, indicates whether there is a correlation between the code element and the requirement. X indicates that there is a correlation between the two.

TABLE 3

class	req	score	isTrace
				EditDrugCodes_jsp	UC15	0.3524	X
UpdateCodesListAction	UC15	0.3124	X
				DrugCodesDAO	UC15	0.2418	X
UpdateDrugListAction	UC15	0.2112	X
				DrugCodesBeanValidator	UC15	0.1045	X
editNDCInteractions_jsp	UC15	0.1816
				editNDCodes_jsp	UC15	0.1238	X
DrugInteractionAction	UC15	0.0953
				AuthDAO	UC15	0.0682
NDCodesDAO	UC15	0.0487	X
				viewResult_jsp	UC15	0.0031

And 4, sequencing the code domains, and sequencing the code domains in the graph 5 according to the similarity value obtained in the step 3 from the maximum value in each domain. The first domain is first submitted to the user to determine the correlation between editdugcodes _ jsp and UC 15. It is known from table 3 that the code domain of editdugcodes _ jsp is a call dependent domain, and thus for the intra-domain class updatecodelistaction, the code domain of editdugcodes _ jsp is a call dependent domain (the correlation between the representative class and UC15 is determined by the user in practical use), and it is known from fig. 5 that,

DrugCodesBeanValidator and out-of-domain classes that exist calls or called paths to in-domain classes

Drug codesdao, NDCodesDAO, AuthDAO, need to increase the similarity value of their corresponding candidate threads. Reordering the undetermined code domain, wherein the code domain in which the class DrugCodesBeanValidator is located becomes an undetermined code domain with the largest similarity value to UC15, the class with the largest similarity value to UC15 in the domain is DrugCodesBeanValidator, the undetermined code domain in which the class DrugCodesBeanValidator is located is known as a data dependent domain from FIG. 5, and the class is known to have the correlation with UC15 from Table 3, and then increasing the similarity values of candidate threads corresponding to the intra-domain class and the extra-domain class and reordering the undetermined code domain. Similarly, in the operation process of the above two code domains, the correlation between the undetermined code domain with the largest similarity value obtained by the calculation and UC15 is judged, and if the correlation is found, the similarity values of the candidate clues corresponding to the intra-domain class and the related out-of-domain class are increased until the user finishes judging all the code domains needing to be judged, and the obtained sorting table is table 4. As can be seen from Table 4, similarity is calculated compared to the information retrieval technique

The method for sequencing and sequencing is optimized on the basis of the method, and effective candidate threads are referred to the forefront of a sequencing list.

TABLE 4

class	req	score	isTrace
				EditDrugCodes_jsp	UC15	0.3524	X
UpdateCodesListAction	UC15	0.3524	X
				DrugCodesDAO	UC15	0.3524	X
DrugCodesBeanValidator	UC15	0.3524	X
				editNDCodes_jsp	UC15	0.3524	X
UpdateDrugListAction	UC15	0.3124	X
				NDCodesDAO	UC15	0.2954	X
DrugInteractionAction	UC15	0.2468
				AuthDAO	UC15	0.1845
editNDCInteractions_jsp	UC15	0.1816
				viewResult_jsp	UC15	0.0031

Claims

1. A software traceable generation method that combines user feedback and code dependence, comprising the steps of:

step 1, inserting a code dependence capturing tool in a target system, and operating the target system to obtain a code dependence existing in the target system, wherein the code dependence comprises a calling dependence and a data dependence;

step 2, calculating the code dependence compactness, setting a compactness threshold, and only reserving the code dependence with the compactness larger than the threshold to obtain a calling dependence domain and a data dependence domain;

step 3, calculating text similarity between the requirements and the code elements, and sequencing the text similarity from large to small according to the text similarity;

step 4, optimizing an initial candidate clue sorting table according to a feedback result of a user to an undetermined code domain and code dependence information of software;

the step 4 comprises the following steps:

4.1, reordering the undetermined code domains according to the sequence of similarity values from large to small according to the maximum value of the similarity between the classes and the requirements in each domain for the undetermined code domains; for the code domain with the first rank, the class with the maximum similarity to the requirement in the domain is selected and sent to a user for judgment; if the request has correlation with the requirement, executing a step 4.2, otherwise, executing a step 4.4;

interpretation of formula parameters: maxIRValue is the maximum value of the similarity of all candidate clues corresponding to the requirement, and countInThisRegion is the number of classes in the domain;

IR_now＝Min(maxIRValue，IR_origin+bonus)

wherein IR_originFor candidate thread current similarity values, IR_nowUpdating a similarity value for the corresponding candidate clue, wherein the similarity value does not exceed maxIRValue, namely a global maximum value of similarity with the requirement; step 4.3 is performed next;

4.3, improving the similarity value of the candidate clues corresponding to the class outside the domain; according to whether the related domain is a calling dependent domain or a data dependent domain, improving the similarity value of the candidate clues corresponding to the classes outside the domain by adopting different methods; if the code domain is a calling dependent domain, finding a path from the class outside the domain to the class in the judged relevant code domain, wherein the path is required to follow the following rules:

1) from the class outside the domain to the class inside the domain, the calling relationship is always realized; or from the class outside the domain to the class inside the domain, the called relation is always realized;

2) only one intra-domain class can appear on the path;

for all paths meeting the requirements, multiplying the tight density values of all edges on each path, and finally increasing the similarity value of the candidate clues corresponding to the classes outside the domain by using the path with the maximum multiplication value;

the formula is as follows:

interpretation of formula parameters: IR_nowSimilarity value after update for the candidate thread, IR_maxInRegionThe maximum similarity of candidate clues corresponding to all the intra-domain classes in the calling dependency domain; there may be multiple PATHs from the out-of-domain class to the in-domain class, PATH is the PATH x with the largest tightly multiplied value of all the edges in the PATH, and Closeness is the edge on the PATH_DC(x) The invocation for edge x depends on closeness;

1) classes outside the domain must have a direct data dependency with the class inside the domain;

2) only one intra-domain class can appear on the path;

for all paths meeting the requirements, improving the similarity value of candidate clues corresponding to the class outside the domain by using the path with the maximum data dependence compactness;

the formula is as follows:

IR_now＝IR_origin+IR_maxInRegion*Closeness_CD(x)

interpretation of formula parameters: IR_nowSimilarity value after update for the candidate thread, IR_maxInRegionFor the maximum similarity of candidate clues corresponding to all in-domain classes in the data dependency domain, multiple paths may exist from the out-of-domain class to the in-domain class, and x is the side with the maximum data dependency compactness_CD(x) The data for this edge depends on closeness;

4.4, reordering all candidate clues according to the sequence of similarity values from large to small; determining whether the candidate code domain needs to be continuously judged by the user; and if the user continues to judge, repeating the step 4.1, otherwise, ending the method flow.

2. The software traceable generation method of claim 1 in combination with user feedback and code dependency, wherein said step 1 comprises the steps of:

step 1.1, constructing a code dependence capture tool, and storing records of function entry and return and data access records caused by the function into a local database;

step 1.3, aggregating the code dependencies among the functions into code dependencies among classes, wherein the code dependency corresponding to one class is formed by combining the code dependencies corresponding to all the functions in the class; the code dependency graph is composed of V and E, wherein V is a vertex set, and an element V in V represents a class; and E is a set of edges, an element E in the E is less than source and target, the source and the target are equal to V, the calling dependency graph shows that calling to the target occurs in the source, and the data dependency graph shows that the source and the target access the same data.

3. The software traceable generation method of claim 1 in combination with user feedback and code dependency, wherein said step 2 comprises the steps of:

step 2.1, calculating the calling dependency compactness, and only reserving the calling dependency with the compactness larger than a threshold value by setting a compactness threshold value, thereby obtaining a calling dependency domain;

and 2.2, calculating the data dependence compactness, and only reserving the data dependence of which the compactness is greater than a threshold value by setting a compactness threshold value so as to obtain a data dependence domain.

4. The software traceable generation method of claim 3 in combination with user feedback and code dependency, wherein the closeness of call dependencies between code elements is calculated by the formula

Wherein N represents the number of different method calls between the class Sink and Source, WeiightedInDegreee_SinkRepresents the number of times Sink has been called, WeightedInDegree_SourceRepresenting the number of times that the class Source calls other class methods, Closense_DCThe value range of (a) is a closed interval of 0 to 1.

5. The method of claim 3, wherein the closeness of data dependency between code elements is calculated by combining user feedback and code dependency

Where N represents the total number of data dependencies captured, N_dtThe data dependency number idtf (x) representing the occurrence of the data type represents the idtf value, DT, of the data type x_i∩DT_jRepresenting a set of data types shared between two classes, DT_i∪DT_jSet of all data types representing access to two classes, Closense_CDThe value range of (a) is a closed interval of 0 to 1.

6. The software traceable generation method in combination with user feedback and code dependency of claim 1, wherein said step 3 comprises the steps of:

step 3.1, performing text preprocessing on the required text, including removing stop words, reducing word shapes and extracting word stems; for a code text, firstly, performing word segmentation according to a naming rule, and then performing the same text preprocessing as the required text;

step 3.2, calculating the similarity between the required text and the code text based on an information retrieval method; and expressing the demand text and the code text by using vectors q and r, wherein each dimension w in the vectors corresponds to the weight of a word, and calculating cosine similarity between the vectors by using cosine distance for the q vector and the r vector.