System and method for evaluating software architecture

Abstract

To make it possible to evaluate software architecture.SOLUTION: A system for evaluating comprises a storage unit that stores dependence data indicative of dependence relationship between components included in software architecture, a matrix generating unit that generates a matrix indicative of the dependence relationship between the components, and an evaluating unit that evaluates the software architecture by analyzing the matrix using a previously-learnt image recognition model.SELECTED DRAWING: Figure 6

Description

[Technical field]

[0001] The present invention relates to a software architecture evaluation system and a software architecture evaluation method. [Background technology]

[0002] Software architecture plays an important role in the development of complex software. Software architecture defines the structure and configuration of software and provides a high-level view of software components and interactions. Software architecture is essential to ensure that software meets functional and non-functional requirements and operates optimally. Patent Document 1 discloses a program analysis device that analyzes a target program written in an object-oriented language, characterized in that it includes a step execution unit that executes the target program step by step, and an abstract interpretation unit that acquires a change history of an object's field and information on the object's field that caused the change for each step based on the execution result of the target program by the step execution unit, and extracts a causal relationship for each state of each object. [Prior art documents] [Patent documents]

[0003] [Patent Document 1] US Patent Application Publication No. 2006 / 0143596 Summary of the Invention [Problem to be solved by the invention]

[0004] The invention described in Patent Document 1 does not allow evaluation of software architecture. [Means for solving the problem]

[0005] A software architecture evaluation system according to a first aspect of the present invention comprises a storage unit that stores dependency data indicating dependencies between components included in a software architecture, a matrix generation unit that generates a matrix indicating the dependencies between the components, and an evaluation unit that evaluates the software architecture by analyzing the matrix using a pre-trained image recognition model. A software architecture evaluation method according to a second aspect of the present invention is an evaluation method executed by an evaluation device having a storage unit that stores dependency data indicating dependencies between components included in the software architecture, and includes generating a matrix indicating the dependencies between the components, and evaluating the software architecture by analyzing the matrix using a pre-trained image recognition model. Effect of the Invention

[0006] According to the present invention, software architecture can be evaluated. [Brief description of the drawings]

[0007] [Figure 1] Hardware configuration of the execution device [Diagram 2] A diagram showing an example of dependent data [Diagram 3] A diagram showing an example of an evaluation index [Figure 4] Hardware configuration diagram of an evaluation device for implementing the present invention [Diagram 5] Diagram explaining the overview of the image recognition model [Figure 6] Functional block diagram of evaluation software according to the first embodiment [Figure 7] FIG. 13 is a diagram showing an example of a data amount matrix. [Figure 8] A diagram showing an example of an IF number matrix [Figure 9] A diagram showing an example of a CNN model [Figure 10] FIG. 1 is a diagram showing an example of a CNN model in Modification 1. [Figure 11] Functional block diagram of evaluation software in Modification 2 [Figure 12] FIG. 13 is a diagram showing an example of a multi-channel CNN model in Modification 2. [Figure 13] FIG. 23 is a diagram showing an example of an IF number matrix in Modification 6. [Figure 14] Functional block diagram of evaluation software according to the second embodiment [Figure 15] A diagram showing an example of a template collection [Figure 16] FIG. 11 is a diagram showing a first example of processing by the standardization matrix generation unit. [Figure 17] FIG. 11 is a diagram showing a second example of processing by the standardization matrix generation unit. [Figure 18] Functional block diagram of evaluation software in the third embodiment [Figure 19] FIG. 13 is a diagram showing an example of an evaluation graph. [Figure 20] An example of a GNN model [Figure 21] FIG. 23 is a diagram showing an example of an evaluation graph in a first modified example of the third embodiment; [Figure 22] Functional block diagram of evaluation software in the fourth embodiment [Figure 23] Diagram explaining the regression model [Figure 24] A functional block diagram of evaluation software in a second modification of the fourth embodiment. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0008] --First embodiment-- Hereinafter, a first embodiment of a software architecture evaluation system and a software architecture evaluation method will be described with reference to FIGS. 1 to 9. FIG.

[0009] 1 is a hardware configuration diagram of an execution device 70 in which generated software 72V generated based on a software architecture to be evaluated is implemented. The execution device 70 includes a CPU 71 which is a central processing unit, a ROM 72 which is a read-only storage device, and a RAM 73 which is a readable and writable storage device. The CPU 71 includes a core C1 and a core C2 which are multiple computing cores. The cores C1 and C2 included in the CPU 71 expand the generated software 72V stored in the ROM 72 into the RAM 73 and execute it. However, the CPU 71 may include three or more cores. The CPU 71 may be multiple physical CPUs with one core, or a single physical CPU with multiple cores.

[0010] Each of the cores C1 and C2 executes one or more tasks that constitute the generated software 72V. Each task is composed of one or more jobs. In the following, the cores, tasks, and jobs are collectively referred to as "components." For convenience, the differences between the cores, tasks, and jobs are also referred to as differences in the "hierarchy" or "level" of the components. This hierarchy or level is such that the core is at the top and the job is at the bottom. In this embodiment, the tasks to be executed by each core are predetermined, and the jobs included in each task are also predetermined.

[0011] FIG. 2 is a diagram showing an example of dependency data 301 indicating dependencies between components. Specifically, the dependency data 301 is data indicating dependencies between all components in the software architecture to be evaluated. The dependency in this embodiment includes both the number of interfaces (hereinafter, also referred to as the "IF number") and the data size. FIG. 2 shows that three pieces of data are transmitted from the first component 101 to the second component 102. The three pieces of data are 64-bit INT type data, 8-bit unsigned INT type data, and 32-bit floating point type data. In this case, the number of interfaces between the first component 101 and the second component 102 is "3", and the data size is "104" bits, which is the sum of 64, 8, and 32.

[0012] 2 also shows that two pieces of 64-bit INT type data are sent from the first component 101 to the third component 103. Dependent data 301 is data related to all dependencies between components that make up one software architecture. Furthermore, FIG. 2 shows that 8-bit unsigned INT type data is sent to the first component 101 itself. Note that the sending of data to the first component 101 itself occurs, for example, by a recursive call.

[0013] The dependency data 301 may explicitly include dependencies between components in each hierarchy of cores, tasks, and jobs. Alternatively, the dependency data 301 may explicitly include only dependencies between jobs, which are the lowest hierarchy. In this case, the dependency relationships between tasks and the dependency relationships between cores are calculated using the relationships between jobs and tasks and the relationships between tasks and cores. The relationships between jobs and tasks and the relationships between tasks and cores may be included in the dependency data 301 or may be determined in advance.

[0014] FIG. 3 is a diagram showing an example of evaluation indexes 303 of a software architecture. FIG. 3 shows an example in which KPIs (Key Performance Indicators) are used as the evaluation indexes 303. In FIG. 3, the KPIs include CPU load, memory load, person-hours, and number of bugs. The CPU load and memory load are values ​​expressed as percentages of the usage of the CPU 71 and RAM 73 when the execution unit 70 executes software implemented based on the software architecture to be evaluated. The person-hours are the time required to implement software based on the software architecture to be evaluated. The number of bugs is the number of bugs expected in the software implemented based on the software architecture to be evaluated.

[0015] 4 is a hardware configuration diagram of an evaluation device 80 embodying the present invention. The evaluation device 80 is, so to speak, a general-purpose computer. The evaluation device 80 includes a CPU 81 which is a central processing unit, a storage unit 82 which is a non-volatile storage device, a RAM 83 which is a volatile storage device, an output device 84 which outputs the results of the calculation, and a communication device 85. The storage unit 82 is, for example, a hard disk drive, and the RAM 83 is, for example, a DIMM. The evaluation software 20 and dependent data 301 are stored in the storage unit 82.

[0016] The CPU 81 may have only a single core or multiple cores. The CPU 81 deploys the evaluation software 20 stored in the storage unit 82 in the RAM 83 and executes it. The output device 84 is hardware that notifies humans of information, such as an LCD display or a speaker. The communication device 85 is, for example, a network interface card. The evaluation software 20 may be stored in a read-only storage device. In this embodiment, the evaluation device 80 is shown as one device, but the functions of the evaluation device 80 may be realized by multiple devices. In that case, it can be called an "evaluation system" that has functions equivalent to those of the evaluation device 80.

[0017] 5 is a diagram for explaining an overview of the image recognition model 302 included in the evaluation software 20. The image recognition model 302 is a machine learning model that receives dependent data 301 as input and outputs evaluation index 303. However, the evaluation index 303 output by the image recognition model 302 may be all or some of the items shown in FIG. 3. The image recognition model 302 is, for example, a neural network for image analysis. The image recognition model 302 is pre-trained by a known method using the pre-created dependent data 301 and evaluation index 303, i.e., the parameters included in the image recognition model 302 are calculated.

[0018] FIG. 6 is a functional block diagram for explaining the function of the evaluation software 20 for evaluating a software architecture. The evaluation software 20 includes a matrix generating unit 21, an image generating unit 22, an evaluation unit 23, and an output unit 24. The matrix generating unit 21 includes an IF number matrix generating unit 211. The evaluation unit 23 includes a CNN model 231. The output unit 24 outputs an evaluation index 303 generated by the evaluation unit 23. For example, the output unit 24 may notify a person of the evaluation index 303 by video or audio using the output device 84, or may output the evaluation index 303 to another device using the communication device 85. The output unit 24 may also output the evaluation index 303 to the RAM 83 for the purpose of use by another program stored in the evaluation device 80.

[0019] The IF number matrix generation unit 211 receives dependent data 301 as input, and outputs an IF number matrix 501. The image generation unit 22 receives IF number matrix 501 as input, and outputs converted IF number matrix 501A. The evaluation unit 23 receives converted IF number matrix 501A as input, and outputs evaluation index 303. In order to explain the operation of the matrix generation unit 21, the IF number matrix 501 and the data amount matrix 601, which is a concept similar to the IF number matrix 501, will first be explained.

[0020] 7 is a diagram showing an example of a data amount matrix 601, which will be described later. As described above, the CPU 71 has two cores, C1 and C2. In this embodiment, when the CPU 71 executes the generated software 72V, the core C1 executes tasks T1 to T3, and the core C2 executes tasks T4 to T5. Furthermore, task T1 includes jobs J1 to J2, task T2 includes jobs J3 to J4, . . . , task T5 includes jobs J9 to J10. The data amount matrix 601 includes a data amount core matrix 602, a data amount task matrix 603, and a data amount job matrix 604.

[0021] The data amount job matrix 604 shows the dependency of the data amount of jobs J1 to J10. The horizontal axis shows the job name indicating the data sender, and the vertical axis shows the job name indicating the data destination. The numbers in each cell of the data amount job matrix 604 indicate the size of the transmitted data, i.e., the number of bits. However, for convenience of drawing, zeros are left blank.

[0022] For example, the first column has "8," "16," and "64" written from top to bottom. This means that 8-bit, 16-bit, and 64-bit data are sent from job J1 to job J1, job J2, and job J3. Meanwhile, the second column is mostly blank, with numbers written only for J9 and J10. This means that job J2 does not send data to jobs J1 to J8, but sends 96 bits of data to J9 and 32 bits of data to J10.

[0023] The data amount task matrix 603 shows the data amount dependency of tasks T1 to T5. The difference between the data amount task matrix 603 and the data amount job matrix 604 is the hierarchical depth. As described above, each task includes two jobs, so in the example shown in Fig. 7, one cell in the data amount task matrix 603 is the sum of the values ​​of the corresponding four cells in the data amount job matrix 604. For example, "100" in the right corner of the data amount task matrix 603 is the sum of "72", "4", "8", and "16", which are the values ​​of the four cells in the right corner hatched with diagonal lines in the data amount job matrix 604.

[0024] The data amount core matrix 602 shows the dependency of the data amounts of cores C1 to C2. The difference between the data amount core matrix 602 and the data amount task matrix 603 is the depth of the hierarchy. As described above, core C1 includes tasks T1 to T3, and core C2 includes tasks T4 to T5. For example, "256", which is the amount of transmission from core C1 to core C1 hatched with dots in the data amount core matrix 602, is the sum of the values ​​of the cells of tasks T1 to T3 corresponding to core C1 in the data amount task matrix 603. Specifically, it is the sum of "24", "104", "32", "32", and "64", which are hatched with dots in the data amount task matrix 603.

[0025] In Fig. 7, the item names of each cell are given for ease of understanding, but if the order of the items is known, the item names are not necessary. Specifically, the data amount core matrix 602 is shown as a 3x3 matrix in Fig. 7, but it can be expressed as a 2x2 matrix. Similarly, the data amount task matrix 603 can be expressed as a 5x5 matrix, and the data amount job matrix 604 can be expressed as a 10x10 matrix.

[0026] Fig. 8 is a diagram showing an example of an IF number matrix 501. The IF number matrix 501 includes an IF number core matrix 502, an IF number task matrix 503, and an IF number job matrix 504. The IF number matrix 501 has many similarities to the data amount matrix 601 shown in Fig. 7, so differences will be mainly described here. The relationship between cores and tasks, and the relationship between tasks and jobs are the same as in Fig. 7.

[0027] An IF number core matrix 502 shows the dependency of the IF numbers of cores C1 to C2. An IF number task matrix 503 shows the dependency of the IF numbers of tasks T1 to T5. An IF number job matrix 504 shows the dependency of the IF numbers of jobs J1 to J10. "11" indicated by dotted hatching in the IF number core matrix 502 is the sum of the values ​​of the area indicated by dotted hatching in the IF number task matrix 503. "6" indicated by diagonal hatching in the IF number task matrix 503 is the sum of the values ​​of the area indicated by diagonal hatching in the IF number job matrix 504. Returning to FIG. 6, the explanation will be continued.

[0028] The IF number matrix generation unit 211 included in the matrix generation unit 21 generates an IF number matrix 501, that is, an IF number core matrix 502, an IF number task matrix 503, and an IF number job matrix 504, based on the dependent data 301. For example, the IF number matrix generation unit 211 generates the IF number job matrix 504 using the number of data transmissions between jobs included in the dependent data 301 and a predetermined sorting order of jobs, for example, ascending order of job numbers as shown in FIG.

[0029] The image generating unit 22 converts the IF number matrix 501 into a converted IF number matrix 501A. Specifically, the image generating unit 22 performs a predetermined scale conversion on the values ​​of each cell of the IF number core matrix 502, the IF number task matrix 503, and the IF number job matrix 504 to generate the IF number core matrix 502A, the IF number task matrix 503A, and the IF number job matrix 504A. For example, assume that the design maximum values ​​of each cell are 1000, 250, and 25 in the IF number core matrix 502, the IF number task matrix 503, and the IF number job matrix 504, respectively. In this case, if it is assumed that the pixel values ​​of the image to be generated are 0 to 255, the value of each cell of the IF number core matrix 502 is divided by 4, the value of each cell of the IF number task matrix 503 is used as is, and the value of each cell of the IF number job matrix 504 is multiplied by 10.

[0030] The evaluation unit 23 includes a CNN model 231. The evaluation unit 23 corresponds to the image recognition model 302 in Fig. 5. The CNN model 231 is a Convolutional Neural Network. Parameters of the CNN model 231 are trained in advance.

[0031] 9 is a diagram showing an example of the CNN model 231. The CNN model 231 includes a first convolutional neural network 2311, a second convolutional neural network 2312, a third convolutional neural network 2313, and a fully connected neural network 2314. The IF number job matrix 504A is input to the first convolutional neural network 2311. The IF number task matrix 503A is input to the second convolutional neural network 2312. The IF number core matrix 502A is input to the third convolutional neural network 2313. The fully connected neural network 2314 is a neural network with a fully connected layer, and receives the outputs of the first convolutional neural network 2311, the second convolutional neural network 2312, and the third convolutional neural network 2313.

[0032] (1) The evaluation device 80 includes a storage unit 82 that stores dependency data 301 indicating dependencies between components included in the software architecture, a matrix generation unit 21 that generates a matrix indicating dependencies between the components, and an evaluation unit 23 that evaluates the software architecture by analyzing the matrix using a pre-trained image recognition model. This allows the software architecture to be evaluated efficiently. The evaluation device 80 expresses the dependencies between the components in a matrix and analyzes them using an image recognition model 302 for image analysis. The evaluation device 80 can grasp the dependencies and interactions between the components of the software architecture, which can be useful for more effective design and optimization.

[0033] (2) The IF number matrix generator 211 of the matrix generator 21 converts the dependencies between components into a matrix in a predetermined order. Therefore, if there is no increase or decrease in components, the same position indicates the correlation between the same components.

[0034] (3) The dependencies include at least the number of interfaces between components, so that the architecture can be evaluated based on the number of interfaces.

[0035] (4) The matrix generating unit 21 generates a plurality of matrices having components with different hierarchical depths, i.e., an IF number core matrix 502, an IF number task matrix 503, and an IF number job matrix 504. Therefore, the evaluation device 80 can evaluate dependencies between components across a plurality of hierarchical levels.

[0036] (5) The evaluation unit 23 inputs the value of each element of the matrix as the brightness value of each pixel in the image data to the CNN model 231, which is an image recognition model. Since the evaluation device 80 includes the image generation unit 22 that performs a predetermined scale conversion on the value of each cell of each matrix, the CNN model 231 can use the brightness value of the image as an input value.

[0037] (Variation 1) In the first embodiment described above, the evaluation unit 23 evaluates three hierarchical levels: core, task, and job. At least one hierarchical level may be evaluated. For example, only jobs may be evaluated. In this case, the IF number matrix generation unit 211 may create at least the IF number job matrix 504.

[0038] Fig. 10 is a diagram showing an example of the CNN model 231 in the first modified example. The IF number matrix 501 shown in Fig. 10 includes only the IF number job matrix 504. The CNN model 231 may include a first convolutional neural network 2311 and a fully connected neural network 2314A. The fully connected neural network 2314A differs from the fully connected neural network 2314 in the first embodiment in that the output of the first convolutional neural network 2311 may be input to the fully connected neural network 2314A.

[0039] (Variation 2) 11 is a functional block diagram of the evaluation software 20 in the second modification. This modification is different from the first embodiment in that the evaluation unit 23 evaluates not only the number of interfaces between components but also the amount of data. The matrix generation unit 21 further includes a data amount matrix generation unit 212. The data amount matrix generation unit 212 generates the data amount matrix 601 shown in FIG. 7 using the dependent data 301. The matrix generation unit 21 outputs the IF number matrix 501 and the data amount matrix 601 to the image generation unit 22.

[0040] In addition to the processing of the first embodiment, the image generating unit 22 in this modification converts the data amount matrix 601 into a converted data amount matrix 601A. The method of generating the converted data amount matrix 601A is substantially the same as the method of generating the converted IF number matrix 501A. However, the coefficient of the scale conversion that is determined in advance is different. The evaluating unit 23 includes a multi-channel CNN model 232 that evaluates not only the converted IF number matrix 501A but also the converted data amount matrix 601A. The multi-channel CNN model 232 has completed learning processing in advance.

[0041] 12 is a diagram showing an example of the multi-channel CNN model 232 in the second modification. The multi-channel CNN model 232 includes a first convolutional neural network 2321, a second convolutional neural network 2322, a third convolutional neural network 2323, and a fully connected neural network 2324. The first convolutional neural network 2321 receives an IF number job matrix 504A and a data amount job matrix 604A. The second convolutional neural network 2322 receives an IF number task matrix 503A and a data amount task matrix 603A. The third convolutional neural network 2323 receives an IF number core matrix 502A and a data amount core matrix 602A. The fully connected neural network 2324 is a neural network equipped with a fully connected layer, and receives the outputs of the first convolutional neural network 2321, the second convolutional neural network 2322, and the third convolutional neural network 2323.

[0042] According to the second modification, the following advantageous effects can be obtained. (6) The dependency includes the amount of data transmitted between components. The matrix input to the multi-channel CNN model 232 included in the evaluation unit 23 includes a channel indicating the dependency of the number of interfaces and a channel indicating the dependency of the amount of data. Therefore, not only the number of interfaces between components but also the amount of data can be evaluated.

[0043] (Variation 3) The evaluation software 20 does not need to include the image generation unit 22. In this case, the IF number matrix 501 is input to the evaluation unit 23. In this modification, since the upper limit value of the value input to the evaluation unit 23 is different from that in the first embodiment, it is necessary to re-learn the parameters of the CNN model 231.

[0044] (Variation 4) The image generating unit 22 may generate header information, etc., so that the converted IF number matrix 501A can be handled as a known image format. In this case, the IF number job matrix 504A, the IF number task matrix 503A, and the IF number core matrix 502A may be individual images. Also, a file format that can store image data of multiple pages in a single image file, such as TIFF, may be adopted to make the converted IF number matrix 501A a single image file.

[0045] (Variation 5) The dependent data 301 does not have to be stored in the storage unit 82. In this case, the evaluation device 80 reads the dependent data 301 from an external source using the communication device 85, and temporarily stores the dependent data 301 in the RAM 83.

[0046] (Variation 6) In the first embodiment, as shown in FIG. 8, the IF number matrix 501 has the same row and column arrangement and the row and column arrangement is symmetrical. Specifically, in the IF number job matrix 504, both the rows and columns are in ascending order, the rows are arranged in the order of J1, J2, J3, . . ., J9, J10 from top to bottom, and the columns are arranged in the order of J1, J2, J3, . . ., J9, J10 from left to right. However, the arrangement of the components in the IF number matrix 501 does not have to be symmetrical, and they may be arranged based on a predetermined rule. If the rule is changed after the CNN model 231 is trained, the CNN model 231 needs to be retrained using the IF number matrix 501 generated based on the changed rule.

[0047] Fig. 13 is a diagram showing an example of an IF number matrix 501 in Modification 6. As shown in Fig. 13, in the IF number matrix 501, the components may be arranged in ascending order along the rows and in descending order along the columns.

[0048] --Second embodiment-- A second embodiment of a software architecture evaluation system and a software architecture evaluation method will be described with reference to Figs. 14 to 17. In the following description, the same components as in the first embodiment are given the same reference numerals, and differences will be mainly described. Points that are not particularly described are the same as in the first embodiment. This embodiment differs from the first embodiment mainly in that the matrix is ​​standardized.

[0049] 14 is a functional block diagram of evaluation software 20A in the second embodiment. Evaluation software 20A further includes a standardization unit 25 in addition to the functions in the first embodiment. The processes of matrix generation unit 21, image generation unit 22, evaluation unit 23, and output unit 24 are similar to those in the first embodiment. IF number matrix 501 generated by matrix generation unit 21 is input to standardization unit 25. Standardization unit 25 generates standardized IF number matrix 501B by a process described later and inputs it to image generation unit 22. Standardized IF number matrix 501B includes standardized IF number core matrix 502B, standardized IF number task matrix 503B, and standardized IF number job matrix 504B.

[0050] The standardization unit 25 includes a template collection 250, a layout selection unit 251, and a standardization matrix generation unit 252. The template collection 250 stores a plurality of arrangements (hereinafter referred to as "templates") of components in a predetermined IF number matrix 501. The template collection 250 may be so-called hard-coded inside a program, may be a setting file attached to the program, or may be stored outside the evaluation device 80 and referred to as appropriate via the communication device 85.

[0051] FIG. 15 is a diagram showing an example of the template collection 250. The template collection 250 includes a plurality of templates. Each template is assigned a template number. One template includes three sub-templates, namely, a core sub-template, a task sub-template, and a job sub-template. A standardized sequence is set for each sub-template. In other words, each template indicates the correspondence between each position of rows and columns in the IF number matrix 501 and components.

[0052] In this specification, cores, tasks, and jobs are identified by a combination of a predetermined alphabet and number, so only the number portion is shown in Fig. 15. The template collection 250 is created in advance in accordance with the definitions of cores, tasks, and jobs written in the dependency data 301. In the example shown in Fig. 15, most of the standardized sequences are written in ascending order, but here, not only the range of values ​​but also the order in which they are written is important. For example, template numbers "2" and "3" have a common value range of 1 to 10 in the task subtemplate, but the order of task T2 represented by "2" is different.

[0053] The cell in column I, row J in standardized IF count matrix 501B indicates the dependency relationship between the I-th component and the J-th component. "I" and "J" are specified by the template collection 250, the template number, and the target. For example, in the case of template number "2", the cell in column 1, row 2 of standardized IF count task matrix 503B always stores a value indicating the dependency relationship between task T1 and task T3. This is the same even if no data related to task T1 or task T3 is stored in dependency data 301. Returning to FIG. 14, the explanation will be continued.

[0054] The placement selection unit 251 identifies the template number adopted by the software architecture to be evaluated. The template number is predetermined for each software architecture, and the template number does not change even if the version of the software architecture is changed. The template number may be included in the dependency data 301, or may be stored in a predetermined location accessible using the communication device 85.

[0055] The standardized matrix generation unit 252 generates a standardized IF number matrix 501B based on the IF number matrix 501 with reference to the template collection 250. A specific reference target at this time is the template with the template number specified by the arrangement selection unit 251. The processing of the standardized matrix generation unit 252 is to rearrange the elements in the matrix and add rows and columns. Combining the functions of the IF number matrix generation unit 211 and the standardized matrix generation unit 252, it can be said that they generate a standardized IF number matrix 501B in which values ​​indicating the dependency relationships of components corresponding to predetermined row and column positions are set.

[0056] Fig. 16 is a diagram showing a first example of processing by the standardized matrix generating unit 252. Fig. 16 shows generation of the standardized IF number task matrix 503B when the template number is "3". However, for convenience of drawing, Fig. 16 shows only tasks T1 to T6. Also, the columns and rows of "T2" are hatched to clearly indicate the processing described below.

[0057] In the IF number task matrix 503 generated by the matrix generation unit 21, the tasks are arranged in numerical order, so the order is "T1", "T2", "T3", .... The standardized matrix generation unit 252 refers to the task sub-template with the template number "3" in Fig. EX22, identifies "T2", which is an element different from the written order, and rearranges it to the specified position. Specifically, "T2" is moved between "T4" and "T5".

[0058] Fig. 17 is a diagram showing a second example of processing by the standardized matrix generation unit 252. Fig. 17 shows the generation of a standardized IF number job matrix 504B when the template number is "1." In addition, the column and row of "J6" are hatched to clearly indicate the processing described below.

[0059] In IF number job matrix 504 generated by matrix generation unit 21, jobs included in dependent data 301 are arranged in numerical order, so jobs not included in dependent data 301 are not listed in IF number job matrix 504. In the example shown in Fig. 17, "J6" has been deleted due to a version change, etc. Therefore, IF number job matrix 504 does not include "J6".

[0060] The standardized matrix generation unit 252 refers to the job subtemplate with template number "1" in Figure EX22, identifies "J6" that is missing from the written sequence, and inserts it at the specified position. In this case, the values ​​of the cells to be inserted are all zero, and since the zeros are omitted in Figure 17, this is expressed as inserting blank cells.

[0061] According to the above-described second embodiment, the following advantageous effects can be obtained. (7) The matrix generating unit 21 refers to the template collection 250 and sets values ​​indicating the dependency relationships of corresponding components at predetermined row and column positions. Therefore, even if the number of components increases or decreases due to reasons such as different versions of software architecture, values ​​indicating the same dependency relationships are stored at the same positions by recording the positions of the components in advance in the template collection 250. In other words, it becomes easy to compare software architectures between different versions.

[0062] (Modification 1 of the second embodiment) When IF number matrix 501 includes only one layer as in Modification 1 of the first embodiment, template collection 250 only needs to include the standardized sequence of the target included in IF number matrix 501. For example, when IF number matrix 501 does not include IF number core matrix 502, template collection 250 does not need to describe the standardized sequence for the core.

[0063] (Modification 2 of the second embodiment) As in the second modification of the first embodiment, when the evaluation software 20 includes the data amount matrix generating unit 212, the data amount matrix 601 is also generated. In this case, the standardization unit 25 may perform the same process on the data amount matrix 601 as on the IF number matrix 501, on the premise that the data amount matrix 601 and the IF number matrix 501 are in the same order. That is, in this modification, the template collection 250 may be the same as in the second embodiment.

[0064] (Modification 3 of the second embodiment) The matrix generating unit 21 and the standardizing unit 25 may be integrated into one unit.

[0065] --Third embodiment-- A third embodiment of a software architecture evaluation system and a software architecture evaluation method will be described with reference to Figs. 18 to 20. In the following description, the same components as those in the second modification of the first embodiment are given the same reference numerals, and differences will be mainly described. Points that are not particularly described are the same as those in the second modification of the first embodiment. This embodiment differs from the second modification of the first embodiment mainly in generating and evaluating a graph.

[0066] 18 is a functional block diagram of the evaluation software 20B in the third embodiment. The evaluation software 20B further includes a graph generating unit 26 in addition to the functions in the first embodiment. The evaluation unit 23 further includes a GNN model 233, which is one of the machine learning models, and an integrated evaluation unit 239 in addition to the multi-channel CNN model 232. The multi-channel CNN model 232 and the GNN model 233 each calculate an evaluation index 303. The integrated evaluation unit 239 calculates the average value of these two evaluation indexes 303. The evaluation unit 23 outputs the output result of the integrated evaluation unit 239 as the evaluation index 303.

[0067] The graph generating unit 26 receives the converted IF number matrix 501A and the converted data amount matrix 601A. The graph generating unit 26 generates an evaluation graph 700 and inputs it to the evaluating unit 23. The evaluating unit 23 receives the converted IF number matrix 501A and the converted data amount matrix 601A from the image generating unit 22 as in the second modified example of the first embodiment, and further receives the evaluation graph 700 from the graph generating unit 26 in this embodiment.

[0068] Fig. 19 is a diagram showing an example of an evaluation graph 700. However, for convenience of drawing, Fig. 19 shows a case where only three cores, tasks, and jobs exist. The evaluation graph 700 includes an evaluation core graph 702, an evaluation task graph 703, and an evaluation job graph 704. In the following, the configuration of the evaluation core graph 702 will be described as a representative of the evaluation core graph 702, the evaluation task graph 703, and the evaluation job graph 704.

[0069] In the evaluation core graph 702, nodes are cores to be evaluated. Links connecting nodes are the number of interfaces and the amount of data between the nodes. In FIG. 19, the number of interfaces is indicated by a solid line, and the amount of data is indicated by a dashed line. The weight set for the link is the number of interfaces and the amount of data described in the converted IF number matrix 501A and the converted data amount matrix 601A. The graph generation unit 26 generates the evaluation core graph 702 by referring to the number of interfaces and the amount of data described in the converted IF number matrix 501A and the converted data amount matrix 601A.

[0070] However, since the evaluation graph 700 is an undirected graph, the weight is the total value in both directions. For example, if the number of data output from core C1 to core C2, i.e., the number of IFs, is "50" and the number of IFs output from core C2 to core C1 is "40", the weight of the solid line connecting core C1 and core C2 is set to "90". The graph generation unit 26 performs this summation process to generate the evaluation core graph 702.

[0071] 20 is a diagram showing an example of the GNN model 233. The GNN model 233 includes a first graph neural network 2331, a second graph neural network 2332, a third graph neural network 2333, and a fully connected neural network 2334. The first graph neural network 2331 receives an evaluation job graph 704. The second graph neural network 2332 receives an evaluation task graph 703. The third graph neural network 2333 receives an evaluation core graph 702. The fully connected neural network 2334 is a neural network with a fully connected layer, and receives the outputs of the first graph neural network 2331, the second graph neural network 2332, and the third graph neural network 2333.

[0072] According to the above-described third embodiment, the following advantageous effects can be obtained. (8) In this embodiment, the evaluation unit 23 includes a graph neural network, which is a machine learning model. As a result, dependencies between different components in a software system can be analyzed and easily visualized. This can provide valuable insights into the architecture and help identify areas for optimization or improvement.

[0073] (Modification 1 of the third embodiment) 21 is a diagram showing an example of an evaluation graph 700A in the first modified example of the third embodiment. The evaluation graph 700A in this modified example is a directed graph. In this modified example, the number of links between nodes is a maximum of four.

[0074] (Modification 2 of the third embodiment) Unlike the first embodiment, the data amount matrix generating unit 212 may not be provided. In that case, the number of links between nodes is reduced by half.

[0075] (Modification 3 of the third embodiment) As in the second embodiment, the standardization unit 25 may be provided. In that case, the graph generation unit 26 receives the standardized IF number matrix 501B and the standardized converted data amount matrix 601A.

[0076] (Variation 4 of the third embodiment) The evaluation unit 23 in this embodiment includes the CNN model 231 and the GNN model 233. However, it is not essential that the evaluation unit 23 includes the CNN model 231, and the evaluation unit 23 may include only the GNN model 233. In this case, the evaluation unit 23 does not need to include the integrated evaluation unit 239.

[0077] --Fourth embodiment-- A fourth embodiment of a software architecture evaluation system and a software architecture evaluation method will be described with reference to Figs. 22 and 23. In the following description, the same components as in the first embodiment are denoted by the same reference numerals, and differences will be mainly described. Points that are not particularly described are the same as in the first embodiment. This embodiment differs from the first embodiment mainly in that regression analysis is performed.

[0078] FIG. 22 is a functional block diagram of the evaluation software 20C in the fourth embodiment. The evaluation software 20C further includes an index generating unit 27 in addition to the functions in the first embodiment. The evaluation unit 23 includes a regression model 235, which is one of the machine learning models, and an integrated evaluation unit 239 in addition to the CNN model 231. The index generating unit 27 generates an architecture index 800 based on the dependency data 301. The index generating unit 27 is, for example, known software. The architecture index 800 is input to the regression model 235. The CNN model 231 and the regression model 235 each calculate an evaluation index 303. The integrated evaluation unit 239 calculates the average value of these two evaluation indexes 303. The evaluation unit 23 outputs the output result of the integrated evaluation unit 239 as the evaluation index 303.

[0079] FIG. 23 is a diagram for explaining the regression model 235. As described above, the index generating unit 27 generates the architecture index 800 based on the dependency data 301. The architecture index 800 is a quantitative index used to evaluate the quality and effectiveness of a software architecture. The architecture index 800 includes anti-dependency, the number of jobs, intra-core communication, inter-core communication, internal dependency, coupling, cumulative dependency, system stability, and the like. The regression model 235 is, for example, a nonlinear regression model, which receives the architecture index 800 as input and outputs the evaluation index 303. The regression model 235 is used to predict the relationship between one or more independent variables and the evaluation index 303, which is a dependent variable.

[0080] According to the above-described fourth embodiment, the following advantageous effects can be obtained. (9) In this embodiment, the evaluation unit 23 includes a regression model 235, which is a machine learning model. Therefore, dependencies between different components in a software system can be analyzed and easily visualized. This can provide valuable insight into the architecture and help identify areas for optimization or improvement.

[0081] (Modification 1 of the fourth embodiment) The evaluation unit 23 in this embodiment includes the CNN model 231 and the regression model 235. However, it is not essential that the evaluation unit 23 includes the CNN model 231, and the evaluation unit 23 may include only the regression model 235. In this case, the evaluation unit 23 does not need to include the integrated evaluation unit 239.

[0082] (Modification 2 of the fourth embodiment) 24 is a functional block diagram of the evaluation software in this modification. In this modification, which is combined with the configuration of the other embodiments, the evaluation unit 23 includes a multi-channel CNN model 232, a GNN model 233, a regression model 235, and an integrated evaluation unit 239. In this modification, each of the multi-channel CNN model 232, the GNN model 233, and the regression model 235 outputs an evaluation index 303. The integrated evaluation unit 239 calculates the average value of these three evaluation indexes 303.

[0083] In each of the above-mentioned embodiments and modifications, the configuration of the functional blocks is merely an example. Some functional configurations shown as separate functional blocks may be integrated, or a configuration shown in one functional block diagram may be divided into two or more functions. In addition, some of the functions of each functional block may be provided by other functional blocks.

[0084] In each of the above-described embodiments and modifications, the evaluation device 80 may be provided with an input / output interface (not shown), and the evaluation software 20 may be read from another device via the input / output interface and a medium available to the evaluation device 80 when necessary. Here, the medium refers to, for example, a storage medium that is detachable from the input / output interface, or a communication medium, i.e., a wired, wireless, optical, or other network, or a carrier wave or digital signal that propagates through the network. In addition, some or all of the functions realized by the program may be realized by a hardware circuit or an FPGA.

[0085] The above-mentioned embodiments and modifications may be combined with each other. Although various embodiments and modifications have been described above, the present invention is not limited to these. Other aspects that are conceivable within the scope of the technical idea of ​​the present invention are also included in the scope of the present invention. [Explanation of symbols]

[0086] 20: Evaluation software 21: Matrix generation section 22: Image generation unit 23: Evaluation section 24: Output section 25: Standardization Department 26: Graph generation section 27:Indicator generation section 80: Evaluation device 211: IF number matrix generation unit 212: Data amount matrix generation unit 231:CNN model 232: Multi-channel CNN model 233: GNN model 235 : Regression Models 239: Integrated Evaluation Department 250: Template collection 251: Placement selection section 252: Standardization matrix generator 301 :Dependent data 302: Image recognition model 303: Evaluation index

Claims

1. A storage unit that stores dependency data indicating dependencies between components included in the software architecture; a matrix generation unit that generates a matrix indicating dependencies between the components; and an evaluation unit that evaluates the software architecture by analyzing the matrix using a pre-trained image recognition model.

2. 2. The evaluation system according to claim 1, The matrix generation unit converts the dependencies between the components into the matrix in a predetermined order.

3. 2. The evaluation system according to claim 1, The correspondence between the elements and the components in the matrix is ​​determined in advance, The matrix generation unit sets values ​​indicating dependencies between corresponding components at predetermined row and column positions, in an evaluation system.

4. 2. The evaluation system according to claim 1, The dependency relationships include at least a number of interfaces between the components.

5. 5. The evaluation system according to claim 4, The dependencies between the components further include an amount of data transmitted between the components; The matrix includes a channel indicating the dependency of the number of interfaces and a channel indicating the dependency of the amount of data.

6. 2. The evaluation system according to claim 1, The matrix generation unit generates a plurality of matrices having components at different hierarchical depths.

7. 2. The evaluation system according to claim 1, The evaluation unit inputs the value of each element of the matrix into the image recognition model as a brightness value of each pixel in image data.

8. 2. The evaluation system according to claim 1, The evaluation system, wherein the evaluation unit further includes at least one of a graph neural network and a regression model for evaluating the matrix.

9. An evaluation method executed by an evaluation device having a storage unit that stores dependency data indicating dependencies between components included in a software architecture, the evaluation method comprising: generating a matrix indicating dependencies between the components; and evaluating the software architecture by analyzing the matrix using a pre-trained image recognition model.

Images