JP2003216425A - Resemblance measuring system - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To quantitatively measure the resemblance of texts (for example, source programs) in one-dimensional disposition. <P>SOLUTION: A case of the source program is explained. At first, a part giving no effect on the function of the program to be produced is excluded (Step1). Given two software systems are inputted and CCFinder is executed (Step2). If a clone pair of found as a result of the execution of the CCFinder, diff is executed to all the paired files (Step3). A correspondence relation is defined to the lines which are determined to be accorded with each other in either of the CCFinder or the diff (Step4). The resemblance is calculated by the definition of CSR (Step5). This system can also output a different part (differential). <P>COPYRIGHT: (C)2003,JPO

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to measuring the degree of similarity between texts in a one-dimensional array, and more particularly, to measuring quantitatively how different programs are.

[0002]

[Technical background] Given two software systems, it is important to know objectively how different the systems are. By examining the degree of difference between the versions of some systems, it is possible to know how the system is being maintained and the degree of evolution. If a document was created when the system was modified, it would be possible to use it as a clue to see the differences, but it was not easy to obtain a quantitative value. If the system is small and the whole structure can be easily grasped by humans, it would be possible to examine the quantitative values for the individual components of the system and use them as the values for the entire system. However, in a system having a complicated structure and made up of hundreds or thousands of files, it is essential to automatically obtain it by some mechanical processing.

Various methods have been proposed for calculating the degree of similarity between individual files and extracting the difference. Baxter
In the following paper, they proposed to parse the program text to make AST, and make the ratio of the common vertices the similarity. Baxter, ID, Yahin, A., Moura, L., Sant'Anna,
M., Bier, L .: Clone Detection Using Abstract Synta
x Trees, Proceedings; International Conferenceon S
oftware Maintenance, IEEE Computer Society Press, p
p. 368-378 (1998). In the following paper, Nagahashi proposed a method for applying a LCS algorithm to a set of COBOL programs after normalization to extract differences and calculate similarity. There is. Kenji Nagahashi, "Evaluation of Software Quality Based on Similarity", IPSJ Research Report 2000-SE-126, Vol. 2000, No. 25, pp.
65-72 (2000). However, all of these methods operate on a set of files and cannot be applied to a set of files.

[0004]

The object of the present invention is to determine how much each file is different from other files in the development and management of large-scale software, large-scale WEB system, large-scale documents and manuals. It does not mean that they are different, but it is to quantitatively know how different they are from other systems as a whole system composed of multiple files.

[0005]

In order to achieve the above object, the present invention is a similarity measuring system for measuring the similarity between two texts composed of a plurality of files. The patterns of the same shape are examined between the files forming the file, and the corresponding file extracting means for extracting the set of files having the same pattern, and the set of lines that can be taken between the set of files extracted by the corresponding file extracting means. It is characterized by comprising corresponding line detecting means for obtaining a set, and similarity degree calculating means for obtaining a ratio of the sum of the number of lines of two texts and the sum of the number of lines determined to correspond in each text. . The corresponding row detecting means can output the rows that are not matched, measure the degree of similarity, and output the difference. Furthermore, as preprocessing, a line deleting unit that deletes lines irrelevant to the similarity measurement from both texts can be provided. Also,
When the two texts are source programs,
As the corresponding file extracting means for measuring the similarity between files, it is also possible to obtain a homomorphic pattern after converting the token string according to the grammar of the program. Then, the corresponding line detecting means uses both the one that obtains a pattern of the same shape after converting into a token string according to the grammar of the program and the one that obtains a different portion without depending on the grammar of the program, Corresponding sets of rows can also be detected. How these systems work,
A program for constructing these systems and a recording medium recording the program are also the present invention.

[0006]

BEST MODE FOR CARRYING OUT THE INVENTION Embodiments of the present invention will be described below with reference to the drawings. As an embodiment, a software system composed of a plurality of source program files will be described below as an example. This system is a large-scale WEB system composed of a text file of a linear one-dimensional array. It can also be applied to large-scale documents and manuals. First, we propose a similarity metric CSR (Corresponding Source-line Ratio) between two software systems given as source programs. Many factors can be considered in the similarity metric of two software systems. For example, the number of files, the number of lines, and the difference in file names. Or later,
A formal definition of the proposed similarity metric CSR will be made, and a specific method for obtaining it will be described.

<Definition of Similarity> In order to define the relationship between one file or a software system composed of a plurality of files, a “product” that abstractly represents the file or software system is used. Here, for simplification, the product is considered as a set of its elements, and is written as P = {p ₁ , ..., P _m }. Here, when P is a file, each p _i is each line of the file, and when P is a software system, each p _i is each file that constitutes the software system. Two products P = {p ₁ ; ... _Pm }, Q =
It is assumed that the corresponding R⊆P × Q is obtained for {q ₁ ; ...; q _n }. Now P and Q
The similarity S (0 ≦ S ≦ 1) with respect to R is defined as follows.

[Equation 1] This is the number of elements of P and Q included in the correspondence R divided by the total number of elements of P and Q as shown in FIG. S decreases due to the increase in P and Q elements that are not related to R. R
= In the empty set, S = 0. When P and Q are the same, ∀i (p _i , q _i ) εR and S = 1.

<Similarity Applying Method and CSR> Consider a method of applying the defined similarity to an actual software system or file. 1. Let P and Q be files and p _i and q _{i be} lines in the file. R is a file difference extraction tool di
If the relation is given by ff, S can be defined as the similarity between files and calculated. 2. Let P and Q be software systems, and p _i and q _i
Be the files that make up the software system. Let R be the correspondence of files with the same file name.
In this case, the similarity between the systems can be easily calculated,
When the name is changed or the name is the same but the file contents are changed, the similarity is different from the intuitive value. Further, since the similarity is calculated with an equal weight regardless of the size of the file, it may not be intuitive. For example, if only a small number of large files correspond and a small number of large files do not, a high degree of similarity will result. 3. Let P and Q be software systems, and p _i and q _i
Be the files that make up the software system. Let R be the correspondence to the file with the highest similarity between the files. In such cases, it is possible to deal with changes in the file name and contents. However, the size of the file is not reflected. In addition, it is necessary to find the similarity between files for all combinations, which takes a lot of time and effort. 4. Let P and Q be software systems, and p _i and q _i
Be each line of each file of P and Q. Intuitively, consider each line in a file that is a concatenation of the files. It is assumed that the correspondence R of each row is given in some way. It is expected that the degree of similarity will be intuitively similar and will not be affected by the file name or file size. In the present invention,
The similarity metric between software and systems using this method can be calculated using CSR (Corresponding Source-line Ratio).
Call. After that, how to decide R and CSR
To ask in detail.

<How to Obtain CSR> Here, a specific method of obtaining the correspondence R for obtaining the previously defined similarity metric CSR will be described. Furthermore, we describe an algorithm to calculate the similarity from two given software systems. (Approach) In order to find the correspondence for all lines in all files, it is necessary to check for each line whether or not the same line exists. There are already some methods for obtaining such code duplication. CCFinder, a clone detection tool, can
It is a tool that inputs a code and outputs a code clone. CCFinder converts a source code into a token string according to the grammar of a programming language. At this time, a plurality of sources are also linked to one token string. Also, whitespace and comments in the source code do not affect the functionality of the generated program and are ignored. Furthermore, in order to detect only clones that have practical meaning, the token string is converted. This is parameter substitution (even if the names are different, they are equivalent). And
Compare the token strings to see if the source code matches. The matched partial token string is called a code clone. The UNIX diff command is
Finding algorithm LCS for each line of two files
To obtain the line-wise difference between the files.
This difference is a file that can generate the other file from the one file. The feature of the diff command is that the difference can be calculated without requiring syntax analysis. Here, the correspondence is obtained using CCFinder and diff. First, a code clone is detected using CCfinder. Execute diff between files with detected clones. CCfind
It is assumed that there is a correspondence between the lines determined to be the same line by er and diff. The accuracy of the similarity is improved by combining two types of tools.

(Algorithm) An algorithm for obtaining CSR will be described below with reference to the flowchart of FIG. Input: Two software systems P and Q Output: P and Q similarity CSR (0 ≤ S ≤ 1) ・ Step 1: Preprocessing Remove the part that does not affect the function of the generated program. This process depends on the programming language used. For example, in the case of a file written in C language, all comment parts and blank lines are removed. This improves the accuracy of the similarity when executing diff. Step2: Execution of CCFinder The CCFinder is executed by using two given software systems as inputs. As an option when executing, the minimum number of matching tokens is set to 20. The minimum matching token number represents the minimum length of the matching token string to be output. -Step3: Execution of diff As a result of execution of CCFinder, dif is performed for all files of the pair in which at least one clone pair is found.
execute f. Step 4: Corresponding lines of the actual file are found from the token string of the clone detected by the corresponding extraction CCFinder. Further, the lines that match each other are calculated from the difference information obtained by diff. A relationship is defined between rows that are determined to match in either CCFinder or diff. -Step 5: Calculation of CSR Calculated from the definition of CSR. However, the total number of lines of the two software systems is the number of lines after preprocessing. Not only CCFinder but also d
The reason for using if is to improve the accuracy of correspondence. Preprocessor instructions in C language (#include line, etc.) are excluded in CCFinder. Therefore, diff
By adding the difference information using, the number of lines that can be determined to be the same line increases. Therefore, the similarity is considered to be a value that more accurately represents the similarity. As a result of the application experiment described in the next section, the number of lines with correspondence increases by about 10%. Also, dif
In the case of corresponding extraction using only f, inputting two software systems while keeping the directory structure, and combining all lines of all files of one software system into one huge file There are two possible ways of inputting. In the former case, it is necessary to have the same structure between the two software systems, which causes a problem that it cannot follow changes in file names and changes in directory structure. In the latter case, there is a problem in the order of files to be combined. This is because the algorithm used in diff cannot handle the replacement of character strings. That is, when files A and B exist, A and B
When diff is executed for the file combined with and the file combined with B and A, these two files cannot be judged to be the same. Therefore, the method of combining CC finder and diff to find the correspondence is adopted.

<Execution example> Here, the similarity metric C
Apply SR to the actual software system. Recent UNIX as an applied software system
(R) type OS was used. (Applicable system) The applicable software system is BSD UNIX (R) 4.4-BSD L
ITE, 4.4-BSD Lite2 and OS derived from these FreeBSD, NetBSD, Op
It is enBSD. FreeBSD, NetBSD, O
PenBSD is still being developed as open source. From these three OS, 4.4-BS
We have selected the major version from the version released after D Lite to the version up to the present. As a result, FreeBSD has 6 versions, N
We chose 6 versions for etBSD and 9 versions for OpenBSD. The total number of applied OS is 23.
The similarity CSR was measured for each of these OSs, considering all combinations. The processing of the language-dependent part of Step1 in the above-described algorithm for measuring the degree of similarity is as follows. -The measurement target is only the kernel part of the OS, and only the files necessary to generate the kernel are taken out. -The target language is C language only, and only files with extensions c and h are measured. -Delete all comments and blank lines.

(Application Result) FIG. 3 shows a table of the total number of files and the number of lines of each OS. The values in this table are the values measured with respect to the results after the pretreatment of Step1. FIG. 4 shows a table of a part of the measured values of the degree of similarity. Fre in the table of FIG.
Focusing only on eBSD, it is either before or after that version that the value with the highest degree of similarity is in each version. Depending on when it was released, it will be either the previous version or the later version. For example, Free
A graph comparing the CSR of BSD 2.2 with other versions is shown in FIG. If you exclude yourself from this graph, the version with the highest similarity is Fre of 0.706.
It can be seen that it is eBSD 2.1. The similarity with the next version, FreeBSD 3.0, is 0.603, which is the third closest value. The second similarity is 0.665 of FreeBSD 2.0.5. F
It can be seen that reeBSD 3.0 has undergone significant changes.

Looking at the changes in the number of files and the number of lines in the table of FIG. 3, the number of files increased by about 1.8 times, and the number of lines increased by about 1.7 times. What is the amount of change before that? You can see that it is different. Figure 6 shows the CSR between FreeBSD and NetBSD.
Shown in. FreeBSD 2.0 to FreeBSD 2.
Up to 2, the similarity is highest with NetBSD 1.0, and N
The similarity decreases as the version of etBSD increases. However, FreeBSD3.0, Fre
Regarding eBSD 4.0, the similarity with NetBSD 1.3 is higher than that of other NetBSD versions. Considering a certain version as a reference, and increasing the version to be compared, the change in similarity decreases. FreeB
When SD and NetBSD are fundamentally different development (developer or development policy), the reason why the similarity increases is that the source code is copied to add the function in the other OS. Alternatively, the same file may be imported into both OSs.

FIG. 7 shows a derivative tree of the BSD UNIX (R). This Figure 7 is FreeBSD, NetBS
How were OSs such as D and OpenBSD derived?
It shows when it was released. FreeBS
D3.0 and NetBSD1.3 are both 4.4 BSDL
This indicates that this is the first version that incorporates ite2. That is, the lines of the source code of 4.4BSDLite2 incorporated in FreeBSD and NetBSD correspond to each other, and the degree of similarity increases. From these things, CS
It can be said that R correctly represents the similarity of software systems.

<Analysis> Here, based on the similarity CSR obtained by applying as described above, the versions are classified by using the cluster analysis, and a dendrogram of the versions is created. We will compare the created dendrogram and the genealogy diagram of OS to discuss similarities and differences. (Denogram) Cluster analysis is performed using the similarity CSR as the distance between individuals. The average distance is used for the distance between clusters. A dendrogram obtained from the result of the cluster analysis is shown in FIG. The horizontal axis represents the bond distance. From Figure 8, FreeBSD, NetBSD, OpenBS
Consider how D can be classified. The largest classification is the part where the final cluster integration is performed,
It is classified into FreeBSD and NetBSD + OpenBSD. The classification by the cluster analysis using the similarity CSR correctly reflects the classification of the OS type. next,
Let's look at the classification of NetBSD and OpenBSD. Op
All OpenBSD versions except enBSD 2.0 have been integrated and integrated with NetBSD 1.1. For OpenBSD 2.0, NetBSD
After being integrated with 1.2, it has been integrated with NetBSD 1.1. As can be seen from the derivative diagram of FIG. 7, OpenBS
D is an OS derived from NetBSD 1.1. Even in the dendrogram of FIG. 8, OpenBSD is NetBSD.
It is shown that it is derived from 1.1. Also, FIG.
NetBSD1.2 and OpenBSD2.0 are the versions released at the same time, and OpenBSD
It can also be seen that BSD 2.0 is the first version.
From these causes NetBSD1.2 and OpenBSD
Showed a high degree of similarity.

<Other Similarity> In order to investigate the effectiveness of the similarity by CSR, cluster analysis was performed on the distance between individuals using similarity other than CSR. The degree of similarity used is the ratio of the number of files in which a clone is detected by the CCFinder to the total number of files, and the ratio of the number of files in which the file names including the directory name match to the total number of files. A dendrogram created using these two similarities is shown in FIGS. 9 and 10, respectively. It can be seen that the same results as in FIG. 8 are obtained. It is considered that this is because all of these OSs have a file structure and a file name derived from the BSD system. It can be said that if the development is carried out according to a policy in which the file name naming rule and the hierarchical structure of files are determined, it is possible to simply analyze using the file name. In addition, two OSes with different origins, FreeBSD 4.0 and Linux released at the same time
A similarity of 2.2.15 was calculated. The calculated similarity is
It is the ratio of the number of files in which the file name including the directory name of the CSR and the total number of files matches. The results are shown in Table 1.

[Table 1] Similarity between FreeBSD 4.0 and Linux 2.2.15 The ratio of the number of files was 0, and it was difficult to find the same file name. However, the value of CSR is 0.031
Became. In different development modes, the ratio of the number of files alone does not always represent the degree of similarity.

CSR is a value indicating the degree of similarity.
The correspondence of each line is sought in the process of calculating. Using this line-to-line correspondence, it is possible to know which line in the file is actually the same as the line in another file. Not only the value of the CSR but also the information of these corresponding rows can be obtained, which is useful when referring to or modifying the software system using the similarity. Whether or not there is a correlation between the release time and the similarity shown in the derivative diagram of FIG. 7 was calculated.
Table 2 shows the result of calculating the release interval of FreeBSD.

[Table 2] Release interval between versions (month) The correlation between CSR and release interval was -0.973. The correlation between the simple increase / decrease in the number of rows and the release interval in the table of FIG. 3 was 0.528. It can be seen that there is a strong negative correlation between CSR and the release interval. Further, the correlation between the CSR and the release interval is higher than the increase / decrease in the number of rows. From this, it is possible to know the release interval by measuring the similarity between two versions. In other words, the CSR indicates the ratio of the unmodified portion of the source code. Therefore, the high correlation means that the development is being carried out constantly. Until now, there has been no way to objectively know how much difference there is between large-scale systems, but by using the present invention, the difference between two systems can be objectively shown. For example, when a certain system A is improved to a system B, the difference between the files corresponding to A and B, the files that have been partially changed, the files newly added by B, the deleted files, etc. The information can be efficiently known together with the ratio (similarity) of the number of changed lines.

[0018]

Up to now, there has been no method for objectively obtaining the similarity between two large-scale text file systems, but the present invention enables comparison of various systems. It was For example, UNIX (R)
There were many versions of the system, but it was difficult to know the difference quantitatively. Free this system
When applied to each version of BSD UNIX (R) such as BSD and NetBSD, and calculating the difference, it became possible to obtain a genealogy that almost followed the development flow. Further, by applying the present invention and storing only the difference of the other system with reference to one system, an efficient compression saving method can be obtained. For example, when there are many systems in which only some of the files are different, if one system is compressed and stored in another system based on one reference system, the storage capacity is reduced and the system is easily managed.

[Brief description of drawings]

FIG. 1 is a diagram for explaining a similarity (CSR) according to the present invention.

FIG. 2 is a flowchart showing a process of obtaining a similarity (CSR).

FIG. 3 is a table showing the number of files and the number of lines of each OS.

FIG. 4 is a table showing a part of the similarity (CSR) between versions.

FIG. 5 is a graph showing the similarity (CSR) between FreeBSD 2.2 and other versions.

FIG. 6 is a graph showing the similarity (CSR) between FreeBSD and NetBSD.

FIG. 7 is a BSD UNIX (R) derivative diagram.

FIG. 8 is a dendrogram using similarity (CSR).

FIG. 9 is a dendrogram using the number of matched files.

FIG. 10 is a dendrogram using the same file name.

Claims (8)

[Claims] 1. A similarity measurement system for measuring the similarity between two texts composed of a plurality of files, wherein patterns of the same shape are examined by examining patterns of the same shape between files composing the two texts. Corresponding file extracting means for extracting a set of files, corresponding line detecting means for finding a set of lines that can be corresponded between the pairs of files extracted by the corresponding file extracting means, and the sum of the numbers of lines of two texts. And a similarity calculation means for calculating a ratio between the sum of the number of lines determined to correspond to each text and a sum of the numbers of lines. 2. The similarity degree measuring system according to claim 1, wherein the corresponding row detecting means outputs the rows that have not been matched, and can measure the similarity and also output the difference. 3. The similarity measurement system according to claim 1, further comprising, as preprocessing, a line deletion unit that deletes lines unrelated to similarity measurement from both texts. 4. The two texts are a source program, and the corresponding file extracting means converts the token string according to the grammar of the program and then obtains the isomorphic pattern. The similarity measurement system according to any one of 1 to 3. 5. The corresponding line detecting means converts both a token string according to the grammar of a program and then obtains a pattern of the same shape, and a method of finding a different portion without depending on the grammar of the program. The similarity measurement system according to claim 4, wherein a set of rows that can be associated with each other is detected using the similarity measurement system. 6. A similarity measuring method for measuring the similarity between two texts composed of a plurality of files, wherein patterns of the same shape are examined by checking patterns of the same shape between files composing the two texts. Extract a set of files, find the set of lines that can be matched between the extracted sets of files, and then add the sum of the number of lines of two texts and the number of lines that can be matched in each text. A method of measuring the degree of similarity, which is characterized by obtaining a ratio of 7. A recording medium for recording a program for causing a computer system to construct the similarity measurement system according to claim 1, which measures the similarity between two texts composed of a plurality of files. . 8. A program for causing a computer system to build the similarity measurement system according to claim 1, which measures the similarity between two texts composed of a plurality of files.