JP7478037B2 - Continuous integration system and continuous integration method - Google Patents

Description

The present invention relates to a continuous integration system in model-based development.

Model-based development is widely adopted in embedded system development. Model-based development uses model files in software design and allows simulations to be performed from the design stage, which means design verification can be performed early on, resulting in high software reliability. Another feature is that code can be generated automatically directly from model files, reducing the amount of coding work required during development.

Continuous integration (CI) is a development method that automatically runs builds and tests whenever source files are frequently changed due to specification changes, enabling early detection and correction of errors.

CI provides a mechanism for continuous development, testing, and release cycles, making it possible to detect and address software defects early and improve quality in a short period of time.

In traditional development methods such as waterfall, building and testing are not performed until the final stages of a single long development cycle. As a result, if an error occurs during building or testing, not only does it take a lot of time to analyze the cause because development is the final stage, but it also requires a lot of rework when making corrections, increasing the amount of work required.

On the other hand, CI, which has a short development cycle due to agile software development, repeats builds and tests each time within that short cycle, making it possible to find and correct errors early.

In addition, any omissions or differences in specifications can be detected at an early development stage, allowing for quick corrections. This not only reduces lead time compared to traditional methods, but also makes it possible to maintain a certain level of quality.

In what follows, the builds and tests that make up a CI will be called jobs. A collection of jobs will be called a pipeline.

WO 2018/116460

Patent Document 1 focuses on historical information from past tests, estimates the resources required for each test, and changes the resources allocated to each test instance, thereby reducing the amount of resources allocated when the test is executed.

The method for reducing resource consumption in the testing process described in the above prior art documents requires past implementation data, making it difficult to apply to the code generation and build processes in continuous integration in model-based development.

However, resource estimation based on historical information is based on the assumption that the load of the processing performed is always the same. For this reason, in model-based development, not only does the processing load depend on the model files and generated code, but these files are updated daily during continuous integration, making it difficult to estimate resources using historical information.

The present invention has been made in consideration of the above points, and aims to estimate the processing load in advance by statically analyzing the model file and generated code before each process is processed, and to optimally allocate resources to each process based on the results, thereby optimizing the amount of resources allocated when each process is executed.

The present invention provides a continuous integration system including a version management server that performs file configuration management, a CI server that requests an execution machine of a job execution machine group to execute a CI job in response to a request from the version management server, and a job execution machine group that executes the CI job in response to a request from the CI server, wherein the CI server receives an input file from the version management server, issues a request to estimate resources required for execution for each CI job that constitutes a pipeline for which execution has been requested, and requests an execution machine of the job execution machine group to execute the CI job based on the received estimation result, and The CI job execution unit includes a resource estimation calculation unit that estimates resources to be allocated to the CI job in response to an estimation request from a job execution unit, and a resource determination calculation unit that determines resources to be allocated to the CI job in response to an estimation result from the resource estimation calculation unit, wherein the resource estimation calculation unit calculates a logical complexity from the input file of the CI job as an index of the load when processing the input file in response to a resource estimation request from the CI job execution unit, and the resource determination calculation unit determines an execution machine to execute the CI job from a predetermined logical complexity and job execution machine correspondence information based on the logical complexity received from the resource estimation calculation unit.

According to the present invention, it is possible to optimally allocate resources according to files such as model files and source files that are updated daily without relying on past history information, and to optimize the resources allocated when executing the processing of each process (CI job).

Details of at least one implementation of the subject matter disclosed herein are set forth in the accompanying drawings and the description below. Other features, aspects, and advantages of the disclosed subject matter will become apparent from the following disclosure, drawings, and claims.

FIG. 1 is a block diagram illustrating an example of a continuous integration system according to an embodiment of the present invention. FIG. 2 is a block diagram illustrating an example of the functions of a version management server according to an embodiment of the present invention. FIG. 2 is a block diagram illustrating an example of a configuration of a continuous integration server according to an embodiment of the present invention. 11 is a flowchart illustrating an example of a process that is performed by the resource estimation calculation unit when the input file is a model file according to the embodiment of the present invention. 11 is a flowchart illustrating an example of a process performed by the resource determination calculation unit according to the embodiment of the present invention. FIG. 13 is a diagram illustrating an embodiment of the present invention and shows a correspondence table between job execution machines and normalized logical complexity. FIG. 11 illustrates an example of a pipeline configuration file according to the embodiment of the present invention.

The following describes an embodiment of the present invention.

Figure 1 is a block diagram showing an example of the configuration of a continuous integration (hereafter referred to as CI) system. The CI system is composed of a version management server 40 that manages the configuration of files, a CI server 70 that estimates and determines the computer resources required to execute CI jobs 73-1 to 73-N that make up a pipeline 72 and requests the job execution machine group 200 to execute the CI jobs 73-1 to 73-N, and a job execution machine group 200 consisting of multiple execution machines (computers) 211-1 to 211-M that process the CI jobs 73-1 to 73-N.

When not specifying an individual CI job, the symbol "73" is used with the "-" and everything after it omitted. The same applies to the symbols for the other components.

The version management server 40 has a function for managing the configuration of a group of files, and is composed of a branch 42 that manages the group of files, and a repository 41 that manages multiple branches 42. Figure 2 is a block diagram showing an example of the functions of the version management server 40.

In this embodiment, the branch 42 manages the following file groups: a source file group 43 consisting of program source files, a model file group 44 describing models, a CI script 45, and a pipeline configuration file group 48 describing CI jobs 73 that make up a pipeline.

The CI script 45 also consists of a group of CI job scripts 46 that describe the processing of the CI job 73, and a normalized logical complexity-job execution machine correspondence table 47 for assigning an appropriate execution machine 211 to the CI job 73.

The CI server 70 comprises a CI job execution unit 71 that manages the execution of CI jobs 73 according to the configuration of the pipeline 72, a resource estimation calculation unit 80 that estimates the resources required for the CI jobs 73 that constitute the pipeline 72, and a resource determination calculation unit 90 that determines the resources required to execute the CI jobs 73 from the estimated resources.

In this embodiment, the pipeline 72 shows an example of sequentially executing CI jobs 73-1 to 73-N.

User 1 sends a set of input files 20 to the version management server 40 via the user terminal 2. The version management server 40 stores the received set of input files 20 in a branch 42 on the repository 41.

If there is a difference between the received input file group 20 and the file group stored in the branch 42, the version management server 40 sends the file update information 50 and the pipeline input file 51 to the CI server 70.

The pipeline input files 51 consist of a set of source files 43, which are all files in the branch 42, a set of model files 44, a set of CI scripts 45, and a set of pipeline configuration files 48.

The file update information 50 includes information about files that have been updated in the source file group 43 and the model file group 44 among the input file group 20.

Below, we will explain an example of model file group 44 as an input file group.

When the CI server 70 receives file update information 50 and pipeline input file 51 from the version management server 40, the CI job execution unit 71 sends a resource estimation request 81 to the resource estimation calculation unit 80 for each CI job 73 described in the pipeline configuration file group 48, receives a resource determination result 91 from the resource determination calculation unit 90, and requests the job execution machine group 200 to execute the CI job 73.

Then, when the CI server 70 receives the job execution result 100 from the job execution machine group 200, it sends the pipeline execution result 60 to the version management server 40.

Figure 7 is a diagram showing an example of a pipeline configuration file 500. In this embodiment, the pipeline configuration file 500 describes a job 501 that generates code from a model file group 44.

The CI job execution unit 71 sends a resource estimation request 81 for this code generation job 501 to the resource estimation calculation unit 80, receives a resource determination result 91 from the resource determination calculation unit 90, and requests the execution machine 211 of the job execution machine group 200 to execute the CI job 73.

When the resource estimation calculation unit 80 receives a resource estimation request 81 from the CI job execution unit 71, it estimates computer resources using the model file group 44 present in the pipeline input file 51, calculates the normalized logical complexity 82, and sends it to the resource determination calculation unit 90.

When the resource determination calculation unit 90 receives the normalized logical complexity 82 from the resource estimation calculation unit 80, it refers to the normalized logical complexity - job execution machine correspondence table 47 contained in the pipeline input file 51 to determine the resources to be allocated.

Normalized logical complexity 82 is a real value between 0 and 1, and normalized logical complexity - job execution machine correspondence table 47 contains information for linking the value of normalized logical complexity with an execution machine suitable for job execution.

The resource determination calculation unit 90 uses the normalized logical complexity 82 and the normalized logical complexity-job execution machine correspondence table 47 to uniquely select the execution machine 211 that will execute the CI job 73, determines the resources, and sends the resource determination result 91 to the CI job execution unit 71.

The CI job execution unit 71 transmits the CI job information 112 and the job execution request 110 to the job execution machine group 200. The job execution request 110 includes information about the machine that will execute the CI job 73, and is uniquely selected from the job execution machine group 200.

The selected execution machine 211 executes the CI job 73 based on the CI job information 112 and then sends the job execution result 100 to the CI server 70.

The job execution machine group 200 is composed of multiple execution machines 211-1 to 211-M that process CI jobs 73.

Figure 3 is a block diagram showing an example of the configuration of a CI server 70. The CI server 70 is a computer including a processor 11, a memory 12, a storage device 13, and a network device 14.

The resource estimation calculation unit 80, the resource determination calculation unit 90, and the CI job execution unit 71 are loaded into the memory 12 and executed by the processor 11.

The processor 11 operates as a functional unit that provides a specific function by executing processing according to the program of each functional unit. For example, the processor 11 functions as a resource estimation calculation unit 80 by executing processing according to a resource estimation calculation program. The same applies to other programs. Furthermore, the processor 11 also operates as a functional unit that provides each function of the multiple processes executed by each program. A computer and a computer system are devices and systems that include these functional units.

The network device 14 is connected to a network 15. The version management server 40, the job execution machine group 200, and the user terminal 2 shown in FIG. 1 are connected to the network 15, and can communicate with each other.

Figure 4 is a flowchart showing an example of processing performed by the resource estimation calculation unit 80. This processing is executed when the CI server 70 receives file update information 50 and a pipeline input file 51 from the version management server 40.

First, the CI job execution unit 71 sends a resource estimation request 81 to the resource estimation calculation unit 80 to estimate the computer resources for executing the CI job 73.

When the resource estimation calculation unit 80 receives a resource estimation request 81 (301), it performs a logical complexity evaluation on the target file (e.g., a model file). If the target file is a model file, the resource estimation calculation unit 80 measures the input/output port size (kB) of the model to evaluate the logical complexity (302).

In the CI server 70 of this embodiment, the resource estimation calculation unit 80 calculates the input/output port size as the sum of the values obtained by multiplying the number of input ports and the number of output ports of the model file by the size of each port. As a result, the larger the number of input/output ports, the greater the processing load of the CI job 73, so the input/output port size is calculated as an index of the processing load of the model file.

The resource estimation calculation unit 80 measures the input/output port size by acquiring the latest model file information from the model file group 44 based on the file update information 50 received by the CI server 70. In addition, while the above example shows that the input/output port size is used as an indicator of the processing load of the model file, this is not limited to this, and the sum of the number of input ports and the number of output ports can be used as an indicator of the processing load of the model file.

To simplify the evaluation, the measured input/output port size is normalized using a widely known existing method and treated as logical complexity (303). The normalized logical complexity is sent to the resource determination calculation unit 90 as normalized logical complexity 82 (304).

Figure 5 is a flowchart showing an example of the processing performed by the resource determination calculation unit 90.

When the resource determination calculation unit 90 receives the normalized logical complexity 82 (401), it performs a process of determining the computer resources to be used in the job execution machine group 200. The resource determination calculation unit 90 compares the normalized logical complexity 82 with the normalized logical complexity - job execution machine correspondence table 47 (402) and uniquely determines the execution machine 211 that will execute the CI job 73 (403).

The resource determination calculation unit 90 transmits the result of the determined execution machine 211 of the CI job 73 to the CI job execution unit 71 as a resource determination result 91 (404).

By the above processing, the CI job execution unit 71 sends a job execution request 110, an input file 111, and CI job information 112 to the execution machine 211 to which the CI job 73 is assigned based on the received resource determination result 91, and executes the CI job 73.

When the CI job execution unit 71 receives the job execution results 100 from the execution machine 211 to which the CI job 73 is assigned, it compiles the job execution results 100 of the CI jobs 73 that make up the pipeline 72 and sends them to the version management server 40 as the pipeline execution results 60.

Figure 6 shows an example of the normalized logical complexity - job execution machine correspondence table 47. The normalized logical complexity - job execution machine correspondence table 47 contains the performance 470 of the execution machine and the normalized logical complexity 471-1 to 471-N for each CI job 73-1 to 73-N in one entry.

The performance index of each execution machine 211 in the job execution machine group 200 is stored in the execution machine performance 470. The normalized logical complexity 471-1 to 471-N stores the range of normalized logical complexity preset for each CI job 73.

In addition, the performance information of the execution machine 211 is set in advance for each execution machine 211 according to its respective configuration. Performance indicators for each execution machine 211 can be indicators based on the processor frequency or number of cores, or the installed memory capacity, etc.

The resource determination calculation unit 90 determines the optimal execution machine 211 for executing the CI job 73 according to the normalized logical complexity 82 of the CI job 73 calculated by the resource estimation calculation unit 75 and the range of the normalized logical complexity 471. For example, when assigning an execution machine for CI job 1 (73-1), if the value of the normalized logical complexity 82 is 0.1 or more and less than 0.4, CI job 1 (73-1) is assigned to execution machine M, if the value of the normalized logical complexity 82 is 0.4 or more and less than 0.8, CI job 1 (73-1) is assigned to execution machine 2, and if the value of the normalized logical complexity 82 is 0.8 or more and less than 1, CI job 1 (73-1) is assigned to execution machine 1.

Changing the machine allocation for each CI job 73 can be achieved by appropriately changing the threshold of the range of the corresponding normalized logical complexity 471. In particular, when the normalized logical complexity is 0, there is no optimal machine in the correspondence table.

A normalized logical complexity of 0 means that the file to be processed by the CI job 73 does not contain any logic, and it is possible to determine that no processing is required for the CI job 73. In this case, the resource determination calculation unit 90 receives information that the CI job execution unit 71 does not have an optimal execution machine 211.

The normalized logical complexity can be calculated by setting a value in the normalized logical complexity - job execution machine correspondence table 47 for each type of CI job 73. If the CI job 73 is a compile job, the number of lines in the source file can be calculated as the logical complexity. If the CI job 73 is a test job, the test vector can be calculated as the logical complexity.

In addition, logical complexity may be any indicator that represents the load on the execution machine 211 when processing the CI job 73, and is not limited to the above.

As described above, the CI server 70 of this embodiment can estimate the processing load in advance as normalized logical complexity by statically analyzing model files and source files before executing each CI job 73 (each process) without relying on past history information, and can optimally allocate resources (execution machine 211) to which each CI job 73 (process) is assigned based on the estimation results.

<Conclusion>
As described above, the continuous integration system of the above embodiment can be configured as follows.

(1) A continuous integration system comprising a version management server (40) that performs configuration management of a file (input file group 20), a CI server (70) that requests an execution machine (211) of a job execution machine group (200) to execute a CI job (73) in response to a request from the version management server (40), and a job execution machine group (200) that executes the CI job (73) in response to a request from the CI server (70), wherein the CI server (70) receives input files from the version management server (40), issues an estimation request (81) for resources required for execution for each CI job (73) that constitutes a pipeline (72) for which an execution request has been made, and requests an execution machine (211) of the job execution machine group (200) to execute the CI job (73) based on the received estimation result, and a CI job execution unit (71) that executes the CI job (73) based on the received estimation result. A continuous integration system comprising a resource estimation calculation unit (80) that estimates resources to be allocated to the CI job (73) in response to an estimation request (81) from a job execution unit (71), and a resource determination calculation unit (90) that determines resources to be allocated to the CI job (73) in response to an estimation result (normalized logical complexity 822) from the resource estimation calculation unit (80), wherein the resource estimation calculation unit (80) calculates logical complexity (82) from the input file of the CI job (73) in response to the resource estimation request (91) from the CI job execution unit (71), and the resource determination calculation unit (90) determines an execution machine (211) that executes the CI job (73) from a preset logical complexity and job execution machine correspondence information (47) based on the logical complexity (82) received from the resource estimation calculation unit (80).

The above configuration makes it possible to optimally allocate resources for executing CI job 73 in accordance with update information for input files such as model files and source files, which are updated daily, without relying on past history information, and to optimize the resources allocated when executing the processing of each process (CI job).

(2) The continuous integration system described in (1) above, wherein the resource estimation calculation unit (80) calculates the logical complexity as an index of the load when processing the input file.

With the above configuration, by calculating the logical complexity according to the type of input file, it is possible to optimize the allocation of resources according to the processing load between each CI job 73 that constitutes the pipeline 72.

(3) The continuous integration system described in (2) above, wherein the resource estimation calculation unit (80) calculates the logical complexity (82) based on the number of input ports and the number of output ports when the input file is a model file.

With the above configuration, when the input file is a model file, it is possible to predict that the processing load will increase according to the sum of the number of input ports and the number of output ports, and the execution machine 211 can be determined according to the degree of logical complexity.

The present invention is not limited to the above-described embodiments, but includes various modified examples. For example, the above-described embodiments are described in detail to clearly explain the present invention, and are not necessarily limited to those having all of the configurations described. It is also possible to replace part of the configuration of one embodiment with the configuration of another embodiment, and it is also possible to add the configuration of another embodiment to the configuration of one embodiment. In addition, the addition, deletion, or replacement of part of the configuration of each embodiment with other configurations can be applied alone or in combination.

The above configurations, functions, processing units, and processing means may be realized in part or in whole in hardware, for example by designing them as integrated circuits. The above configurations and functions may be realized in software by a processor interpreting and executing a program that realizes each function. Information on the programs, tables, files, etc. that realize each function may be stored in a memory, a recording device such as a hard disk or SSD (Solid State Drive), or a recording medium such as an IC card, SD card, or DVD.

In addition, the control lines and information lines shown are those considered necessary for the explanation, and not all control lines and information lines on the product are necessarily shown. In reality, it can be assumed that almost all components are interconnected.

1 User 2 User terminal 20 Input file group 40 Version management server 41 Repository 42 Branch 43 Source file group 44 Model file group 45 CI script 46 CI job script group 47 Normalized logical complexity - job execution machine correspondence table 48 Pipeline configuration file group 50 File update information 51 Pipeline input file 60 Pipeline execution result 70 CI server 71 CI job execution unit 72 Pipeline 73-1 to 73-N CI jobs 1 to N
80 Resource estimation calculation unit 81 Resource estimation request 82 Normalized logical complexity 90 Resource determination result 100 Job execution result 110 Job execution request 111 Input file 112 CI job information 200 Job execution machine group 211-1 to 211-M Execution machines 1 to M
501 Code generation job

Claims (4)

A version control server that manages file configurations,
a CI server that requests an execution machine of a job execution machine group to execute a CI job in response to a request from the version management server;
A continuous integration system including a job execution machine group that executes the CI job in response to a request from the CI server,
The CI server includes:
a CI job execution unit that receives an input file from the version management server, issues a request to estimate resources required for execution for each CI job constituting a pipeline for which an execution request has been made, and requests an execution machine of the job execution machine group to execute the CI job based on the received estimation result;
a resource estimation calculation unit that estimates resources to be allocated to the CI job in response to an estimation request from the CI job executing unit;
a resource determination calculation unit that determines resources to be allocated to the CI job in accordance with an estimation result from the resource estimation calculation unit;
The resource estimation calculation unit,
Calculating a logical complexity from the input file of the CI job as an index of a load when processing the input file in response to a resource estimation request from the CI job execution unit;
The resource determination calculation unit is
A continuous integration system characterized by determining an execution machine to execute the CI job based on the logical complexity received from the resource estimation calculation unit, from a preset logical complexity and job execution machine correspondence information. 2. The continuous integration system of claim 1,
The resource estimation calculation unit,
A continuous integration system, characterized in that, when the input file is a model file, the logical complexity is calculated based on the number of input ports and the number of output ports. A continuous integration method in which a CI server controls a group of job execution machines that execute CI jobs by requesting the execution of the CI jobs from an execution machine of the group of job execution machines in response to a request from a version management server that performs configuration management of files, the method comprising:
a CI job execution step in which the CI server receives an input file from the version management server, issues a request to estimate resources required for execution for each CI job constituting a pipeline for which execution has been requested, and requests an execution machine of the job execution machine group to execute the CI job based on the received estimation result;
a resource estimation calculation step in which the CI server estimates resources to be allocated to the CI job in response to the estimation request;
a resource determination calculation step in which the CI server determines resources to be allocated to the CI job in accordance with the estimation result;
The resource estimation calculation step includes:
Calculating a logical complexity from the input file of the CI job as an indicator of a load when processing the input file in response to the resource estimation request;
The resource determination calculation step includes:
Based on the logical complexity, a predetermined logical complexity and job execution machine correspondence information are
The continuous integration method according to claim 1, further comprising: determining an execution machine for executing the CI job from the execution machine; 4. A continuous integration method according to claim 3, comprising:
The resource estimation calculation step includes:
A continuous integration method, comprising the steps of: when the input file is a model file, calculating the logical complexity based on the number of input ports and the number of output ports.

Images