Evaluation system for software architecture, and evaluation method for software architecture

Abstract

This evaluation system comprises: a storage unit that stores dependency data indicating the dependency relationship between components included in a software architecture; a matrix generation unit that generates a matrix indicating the dependency relationship between the components; and an evaluation unit that evaluates the software architecture through analysis of the matrix by using an image recognition model trained in advance.

Description

Software architecture evaluation system, software architecture evaluation method

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

[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 their interactions. Software architecture is essential for ensuring that software meets functional and non-functional requirements and operates optimally. Patent Document 1 discloses a program analysis device for analyzing a target program written in an object-oriented language, comprising: a step execution unit that executes the target program step by step; and an abstract interpretation unit that, based on the execution results of the target program by the step execution unit, acquires, for each step, a change history of object fields and information about the object fields that caused the changes, and extracts causal relationships at the state level of each object.

[0003] US Patent Application Publication No. 2006 / 0143596

[0004] The invention described in Patent Document 1 cannot evaluate software architecture.

[0005] A software architecture evaluation system according to a first aspect of the present invention includes 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 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 that includes a storage unit that stores dependency data indicating dependencies between the 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.

[0006] According to the present invention, software architecture can be evaluated.

[0007] FIG. 1 is a hardware configuration diagram of an execution device; FIG. 2 is a diagram showing an example of dependent data; FIG. 3 is a diagram showing an example of an evaluation index; FIG. 4 is a hardware configuration diagram of an evaluation device embodying the present invention; FIG. 5 is a diagram explaining an overview of an image recognition model; FIG. 6 is a functional block diagram of evaluation software in a first embodiment; FIG. 7 is a diagram showing an example of a data volume matrix; FIG. 8 is a diagram showing an example of an IF number matrix; FIG. 9 is a diagram showing an example of a CNN model; FIG. 10 is a functional block diagram of evaluation software in a modification 1; FIG. 11 is a functional block diagram of evaluation software in a modification 2; FIG. 12 is a diagram showing an example of a multi-channel CNN model in a modification 2; FIG. 13 is a diagram showing an example of an IF number matrix in a modification 6;

[0008] First Embodiment A first embodiment of a software architecture evaluation system and a software architecture evaluation method will be described below with reference to FIGS.

[0009] 1 is a hardware configuration diagram of an execution device 70 on which generated software 72V, which is generated based on the 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 multiple processing cores, namely, core C1 and core C2. The cores C1 and C2 included in the CPU 71 load 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 also include multiple physical CPUs each including one core, or a single physical CPU including 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. Hereinafter, the cores, tasks, and jobs are collectively referred to as "components." Hereinafter, 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. In this embodiment, the dependency includes both the number of interfaces (hereinafter also referred to as the "number of IFs") and 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 data, 8-bit Unsigned INT data, and 32-bit floating-point 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 bits.

[0012] 2 also shows that two 64-bit INT type data are sent from the first component 101 to the third component 103. Dependency data 301 is data related to all dependencies between components that make up a single 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, through a recursive call.

[0013] The dependency data 301 may explicitly include dependencies between components at each level of the core, task, and job hierarchy. Alternatively, the dependency data 301 may explicitly include only dependencies between jobs, which are the lowest level. 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 predetermined.

[0014] FIG. 3 is a diagram showing an example of evaluation indicators 303 for a software architecture. FIG. 3 shows an example in which KPIs (Key Performance Indicators) are used as the evaluation indicators 303. The KPIs in FIG. 3 include CPU load, memory load, man-hours, and the number of bugs. The CPU load and memory load are values ​​expressed as percentages of the utilization of the CPU 71 and RAM 73 when the execution device 70 executes software implemented based on the software architecture being evaluated. The man-hours are the time required to implement software based on the software architecture being evaluated. The number of bugs is the number of bugs expected in software implemented based on the software architecture being 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 calculations, 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 storage unit 82 stores evaluation software 20 and dependent data 301.

[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 into the RAM 83 and executes it. The output device 84 is hardware that notifies people 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 also be stored in a read-only storage device. In this embodiment, the evaluation device 80 is shown as a single device, but the functions of the evaluation device 80 may be realized by multiple devices. In this case, it can be called an "evaluation system" that has functions equivalent to those of the evaluation device 80.

[0017] FIG. 5 is a diagram illustrating 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 indexes 303. However, the evaluation indexes 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 trained in advance by a known method using the dependent data 301 and evaluation indexes 303 that have been created in advance, i.e., the parameters included in the image recognition model 302 are calculated.

[0018] FIG. 6 is a functional block diagram illustrating the functions of evaluation software 20 for evaluating software architecture. The evaluation software 20 includes a matrix generation unit 21, an image generation unit 22, an evaluation unit 23, and an output unit 24. The matrix generation unit 21 includes an IF number matrix generation 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 an output device 84, or may output the evaluation index 303 to another device using a communication device 85. The output unit 24 may also output the evaluation index 303 to RAM 83 for use by other programs 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 a converted IF number matrix 501A. The evaluation unit 23 receives converted IF number matrix 501A as input and outputs an 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 to-be-generated software 72V, core C1 executes tasks T1 to T3, and core C2 executes tasks T4 to T5. Task T1 includes jobs J1 to J2, task T2 includes jobs J3 to J4, ..., and 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 volume job matrix 604 shows the dependency of the data volume of jobs J1 to J10. The horizontal axis lists the job name indicating the data source, and the vertical axis lists the job name indicating the data destination. The number in each cell of the data volume job matrix 604 is 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 contains "8," "16," and "64" from top to bottom. This means that job J1 sends 8-bit, 16-bit, and 64-bit data to jobs J1, J2, and J3, respectively. On the other hand, the second column is mostly blank, with only J9 and J10 containing numerical values. This means that job J2 does not send data to jobs J1 to J8, but sends 96-bit data to J9 and 32-bit 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 mentioned above, each task includes two jobs, so in the example shown in Figure 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 diagonally hatched right corner cells 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 hierarchical depth. As mentioned above, core C1 includes tasks T1 to T3, and core C2 includes tasks T4 to T5. For example, the amount of transmission from core C1 to core C2, indicated by dotted hatching in the data amount core matrix 602, "256," is the sum of the values ​​of the cells for tasks T1 to T3 corresponding to core C1 in the data amount task matrix 603. Specifically, it is the sum of the values ​​indicated by dotted hatching in the data amount task matrix 603, "24," "104," "32," "32," and "64."

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

[0026] 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 is similar in many ways 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] The IF number core matrix 502 shows the dependency relationship of the IF numbers of cores C1 to C2. The IF number task matrix 503 shows the dependency relationship of the IF numbers of tasks T1 to T5. The IF number job matrix 504 shows the dependency relationship of the IF numbers of jobs J1 to J10. The "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. The "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, i.e., 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 job order, for example, ascending order of job numbers as shown in FIG.

[0029] The image generation unit 22 converts the IF number matrix 501 into a converted IF number matrix 501A. Specifically, the image generation 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 maximum design values ​​of each cell in the IF number core matrix 502, the IF number task matrix 503, and the IF number job matrix 504, respectively, are 1000, 250, and 25. In this case, assuming that the pixel values ​​of the image to be generated range from 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 first convolutional neural network 2311 receives an IF number job matrix 504A as input. The second convolutional neural network 2312 receives an IF number task matrix 503A as input. The third convolutional neural network 2313 receives an IF number core matrix 502A as input. The fully connected neural network 2314 is a neural network with a fully connected layer, and receives as input 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 a software architecture, a matrix generation unit 21 that generates a matrix indicating the 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 for efficient evaluation of software architectures. The evaluation device 80 expresses the dependencies between 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 components of a 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 dependency relationships between components into a matrix in a predetermined order. Therefore, if there is no increase or decrease in the number of components, the same position indicates the correlation between the same components.

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

[0035] (4) The matrix generation unit 21 generates multiple matrices with different component hierarchical depths, i.e., an IF count core matrix 502, an IF count task matrix 503, and an IF count job matrix 504. This allows the evaluation device 80 to evaluate dependencies between components across multiple 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 levels: core, task, and job. However, it is sufficient to evaluate at least one level. For example, it is also possible to evaluate only jobs. In this case, the IF number matrix generation unit 211 is required to create at least the IF number job matrix 504.

[0038] 10 is a diagram illustrating an example of the CNN model 231 in Modification 1. The IF number matrix 501 illustrated 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. Unlike the fully connected neural network 2314 in the first embodiment, the fully connected neural network 2314A may receive the output of the first convolutional neural network 2311 as input.

[0039] (Modification 2) Fig. 11 is a functional block diagram of the evaluation software 20 in Modification 2. This modification differs 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 generation unit 22 in this modification converts the data amount matrix 601 into a converted data amount matrix 601A. The method for generating the converted data amount matrix 601A is substantially the same as the method for generating the converted IF number matrix 501A. However, the predetermined scale conversion coefficients are different. The evaluation 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 a multi-channel CNN model 232 in Modification 2. 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 as input a number-of-IFs job matrix 504A and a data amount job matrix 604A. The second convolutional neural network 2322 receives as input a number-of-IFs task matrix 503A and a data amount task matrix 603A. The third convolutional neural network 2323 receives as input a number-of-IFs core matrix 502A and a data amount core matrix 602A. The fully connected neural network 2324 is a neural network 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 this 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 variation, the upper limit of the value input to the evaluation unit 23 is different from that in the first embodiment, and therefore, the parameters of the CNN model 231 need to be re-learned.

[0044] (Variation 4) The image generation unit 22 may generate header information, etc., so that the converted IF number matrix 501A can be handled in 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. Furthermore, a file format, such as TIFF, that can store image data of multiple pages in a single image file may be adopted, and the converted IF number matrix 501A may be a single image file.

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

[0046] (Variation 6) In the first embodiment, as shown in FIG. 8 , the rows and columns of the IF number matrix 501 were aligned in the same order, but the rows and columns were symmetrical. Specifically, in the IF number job matrix 504, both the rows and columns were in ascending order, with the rows arranged from top to bottom in the order of J1, J2, J3, ..., J9, J10, and the columns arranged from left to right in the order of J1, J2, J3, ..., J9, J10. However, the arrangement of components in the IF number matrix 501 does not need to be symmetrical, as long as they are arranged based on a predetermined rule. Note that if the rule is changed after the CNN model 231 has been 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 Example 6. As shown in Fig. 13, in the IF number matrix 501, 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 Figures 14 to 17. In the following description, the same components as in the first embodiment are designated by the same reference numerals, and differences will be mainly described. Points that are not specifically 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. The evaluation software 20A further includes a standardization unit 25 in addition to the functions in the first embodiment. The processes of the matrix generation unit 21, image generation unit 22, evaluation unit 23, and output unit 24 are the same as those in the first embodiment. The IF number matrix 501 generated by the matrix generation unit 21 is input to the standardization unit 25. The standardization unit 25 generates a standardized IF number matrix 501B by a process described below and inputs it to the image generation unit 22. The standardized IF number matrix 501B includes a standardized IF number core matrix 502B, a standardized IF number task matrix 503B, and a standardized IF number job matrix 504B.

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

[0051] FIG. 15 is a diagram showing an example of the template collection 250. The template collection 250 includes multiple templates. Each template is assigned a template number. One template includes three subtemplates: a core subtemplate, a task subtemplate, and a job subtemplate. A standardized sequence is set for each subtemplate. In other words, each template indicates the correspondence between each row and column position in the IF number matrix 501 and a component.

[0052] In this specification, cores, tasks, and jobs are each identified by a combination of predetermined letters and numbers, so only the numbers are shown in FIG. 15. The template collection 250 is created in advance to match 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" share the same 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 number matrix 501B indicates the dependency relationship between the Ith component and the Jth component. These "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 number task matrix 503B always stores a value indicating the dependency relationship between task T1 and task T3. This is true even if the dependency data 301 does not store data related to task T1 or task T3. Returning to FIG. 14, the explanation will continue.

[0054] The placement selection unit 251 identifies the template number used by the software architecture to be evaluated. The template number is predetermined for each software architecture and 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 references the template collection 250 and generates a standardized number of IFs matrix 501B based on the number of IFs matrix 501. The specific reference target at this time is the template with the template number identified by the placement selection unit 251. The processing of the standardized matrix generation unit 252 involves rearranging the elements in the matrix and adding rows and columns. Combining the functions of the number of IFs matrix generation unit 211 and the standardized matrix generation unit 252, it can be said that they generate a standardized number of IFs 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 generation unit 252. FIG. 16 shows the generation of a standardized number-of-IFs task matrix 503B when the template number is "3." However, for convenience of drawing, only tasks T1 to T6 are shown in FIG. 16. Furthermore, the column and row 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, tasks are arranged in numerical order, resulting in the order "T1," "T2," "T3," ... The standardization matrix generation unit 252 references the task subtemplate with template number "3" in Figure EX22, identifies "T2," an element that differs from the written order, and rearranges it to the specified position. Specifically, "T2" is moved between "T4" and "T5."

[0058] 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 the IF number job matrix 504 generated by the matrix generation unit 21, jobs included in the dependent data 301 are arranged in numerical order, and therefore jobs not included in the dependent data 301 are not listed in the IF number job matrix 504. In the example shown in Fig. 17, "J6" has been deleted due to a version change, etc. Therefore, the IF number job matrix 504 does not include "J6".

[0060] The standardization matrix generation unit 252 references 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 inserted cells are all zero, and since the zeros are omitted in Figure 17, this is expressed as inserting a blank cell.

[0061] The second embodiment described above provides the following advantageous effects: (7) The matrix generation unit 21 references 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 the template collection 250 in advance. In other words, it becomes easier to compare software architectures between different versions.

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

[0063] (Variation 2 of the Second Embodiment) As in Variation 2 of the first embodiment, when the evaluation software 20 includes the data amount matrix generation unit 212, a data amount matrix 601 is also generated. In this case, the standardization unit 25 may perform the same processing on the data amount matrix 601 as on the number of IFs matrix 501, on the premise that the data amount matrix 601 and the number of IFs matrix 501 are arranged in the same order. That is, in this variation as well, the template collection 250 may be the same as in the second embodiment.

[0064] (Third Modification 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 Figures 18 to 20. In the following description, the same components as those in Variation 2 of the first embodiment are designated by the same reference numerals, and differences will be mainly described. Points that are not particularly described are the same as in Variation 2 of the first embodiment. This embodiment differs from Variation 2 of the first embodiment mainly in the way graphs are generated and evaluated.

[0066] 18 is a functional block diagram of evaluation software 20B according to the third embodiment. The evaluation software 20B further includes a graph generation unit 26 in addition to the functions of the first embodiment. The evaluation unit 23 further includes a GNN model 233, which is one of machine learning models, and an integrated evaluation unit 239, in addition to a 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 generation unit 26 receives the converted IF number matrix 501A and the converted data amount matrix 601A. The graph generation unit 26 generates an evaluation graph 700 and inputs it to the evaluation unit 23. The evaluation unit 23 receives the converted IF number matrix 501A and the converted data amount matrix 601A from the image generation unit 22 as in the second modification of the first embodiment, and in this embodiment, further receives the evaluation graph 700 from the graph generation unit 26.

[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. Below, 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 represent 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 weights set for the links are the number of interfaces and the amount of data listed 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 listed 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 items output from core C1 to core C2, i.e., the number of interfaces, is 50 and the number of interfaces 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 as input. The second graph neural network 2332 receives an evaluation task graph 703 as input. The third graph neural network 2333 receives an evaluation core graph 702 as input. The fully connected neural network 2334 is a neural network with fully connected layers, and receives as input the outputs of the first graph neural network 2331, the second graph neural network 2332, and the third graph neural network 2333.

[0072] The third embodiment described above provides the following advantages: (8) The evaluation unit 23 in this embodiment includes a graph neural network, which is a machine learning model. Therefore, dependencies between different components in a software system can be analyzed and easily visualized. This provides valuable insight into the architecture and can help identify areas for optimization or improvement.

[0073] (Variation 1 of the Third Embodiment) Fig. 21 is a diagram showing an example of an evaluation graph 700A in Variation 1 of the third embodiment. The evaluation graph 700A in this variation is a directed graph. In this variation, the number of links between nodes is up to four.

[0074] (Modification 2 of the Third Embodiment) Unlike the first embodiment, the data amount matrix generating unit 212 does not need to be provided, in which case the number of links between nodes is reduced by half.

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

[0076] (Fourth Modification of the Third Embodiment) The evaluation unit 23 in this embodiment includes a CNN model 231 and a 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 Figures 22 and 23. In the following description, the same components as in the first embodiment are designated by the same reference numerals, and differences will be mainly described. Points that are not specifically 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 evaluation software 20C according to the fourth embodiment. The evaluation software 20C further includes an index generation unit 27 in addition to the functions of the first embodiment. The evaluation unit 23 includes a regression model 235, which is one of machine learning models, and an integrated evaluation unit 239, in addition to a CNN model 231. The index generation unit 27 generates an architecture index 800 based on dependency data 301. The index generation unit 27 is, for example, publicly 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 illustrating the regression model 235. As described above, the index generation unit 27 generates architecture indexes 800 based on the dependency data 301. The architecture indexes 800 are quantitative indexes used to evaluate the quality and effectiveness of a software architecture. The architecture indexes 800 include anti-dependencies, number of jobs, intra-core communication, inter-core communication, internal dependencies, coupling, cumulative dependencies, system stability, and the like. The regression model 235 is, for example, a nonlinear regression model that receives the architecture indexes 800 as input and outputs evaluation indexes 303. The regression model 235 is used to predict the relationship between one or more independent variables and the evaluation indexes 303, which are dependent variables.

[0080] The fourth embodiment described above provides the following advantages: (9) The evaluation unit 23 in this embodiment includes the 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 provides valuable insight into the architecture and can help identify areas for optimization or improvement.

[0081] (Variation 1 of the Fourth Embodiment) The evaluation unit 23 in this embodiment includes a CNN model 231 and a 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] (Variation 2 of the Fourth Embodiment) Fig. 24 is a functional block diagram of evaluation software in this variation. In this variation, the configurations of the other embodiments are combined, and 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 variation, the multi-channel CNN model 232, the GNN model 233, and the regression model 235 each output an evaluation index 303. The integrated evaluation unit 239 calculates the average value of these three evaluation indexes 303.

[0083] In the above-described embodiments and modifications, the functional block configurations are merely examples. Some functional configurations shown as separate functional blocks may be integrated, or a configuration shown in a single functional block diagram may be divided into two or more functions. Furthermore, 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 loaded from another device as needed via the input / output interface and a medium available to the evaluation device 80. Here, the medium refers to, for example, a storage medium detachable from the input / output interface, or a communication medium, i.e., a wired, wireless, or optical network, or a carrier wave or digital signal propagating through the network. Furthermore, some or all of the functions realized by the program may be realized by a hardware circuit or FPGA.

[0085] The above-described 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 embodiments conceivable within the scope of the technical concept of the present invention are also included within the scope of the present invention.

[0086] 20: Evaluation software 21: Matrix generation unit 22: Image generation unit 23: Evaluation unit 24: Output unit 25: Standardization unit 26: Graph generation unit 27: Index generation unit 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 model 239: Integrated evaluation unit 250: Template collection 251: Placement selection unit 252: Standardization matrix generation unit 301: Dependent data 302: Image recognition model 303: Evaluation index

Claims

1. An evaluation system comprising: 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.

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

3. An evaluation system as described in claim 1, wherein the correspondence between elements and components in the matrix is ​​predetermined, and the matrix generation unit sets values ​​indicating the dependency of corresponding components at predetermined row and column positions.

4. The evaluation system according to claim 1, wherein the dependencies include at least the number of interfaces between the components.

5. An evaluation system as described in claim 4, wherein the dependencies between the components further include an amount of data transmitted between the components, and 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. An evaluation system according to claim 1, wherein the matrix generation unit generates a plurality of matrices having components at different hierarchical depths.

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

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

9. A method for evaluating a software architecture, the method being executed by an evaluation device having a storage unit that stores dependency data indicating dependencies between components included in the software architecture, the method including: 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.

Images