Multi-pattern build evaluation method and program
The multi-pattern build evaluation method addresses the challenge of predicting and analyzing build errors in large-scale software development by grouping source code changes and prioritizing builds, facilitating early defect detection and efficient integration.
Patent Information
- Application Number
- JP2023052818
- Authority / Receiving Office
- JP · JP
- Patent Type
- Patents
- Current Assignee / Owner
- Filing Date
- 2023-03-29
- Publication Date
- 2026-11-19
- Estimated Expiration
- 2043-03-29
AI Technical Summary
In large-scale software development, combining source code changes across categories can lead to build errors that are difficult to predict and time-consuming to analyze, and brute-force verification of all combinations is impractical due to the enormous time required.
A multi-pattern build evaluation method that groups source code changes based on synchronization elements, generating full and partial build patterns, and prioritizes and resources builds to identify error-prone combinations early, allowing for efficient integration into the source tree.
Enables early detection of defects during source code integration, reducing the time and resources needed to complete builds within deadlines by identifying and combining error-free code combinations.
Smart Images

Figure 0007953977000001 
Figure 0007953977000002 
Figure 0007953977000003
Abstract
Description
Technical Field
[0001] The present disclosure relates to a multi-pattern build evaluation method and program.
Background Art
[0002] Conventionally, in the source code integration step in large-scale development, after individually performing source code modification and testing for each category, the source code of each category is integrated into the main source tree. At this time, it is known that there may be cases where conflicts between modification contents across categories cause a build error to occur when the source codes are combined, even though the test results for each category are normal.
[0003] In response to this, for example, there is a technique for individually identifying a modified version leading to a defect and its content from modification information of source code for any arbitrary combination.
Prior Art Documents
Patent Documents
[0004]
Patent Document 1
Patent Document 2
Summary of the Invention
Problems to be Solved by the Invention
[0005] However, there has been a problem that it is impossible to detect in advance which combination will cause a build error, and when a build error occurs, it takes time to analyze the error. Furthermore, there is another problem that if brute-force verification is performed on all modification combinations to identify the modification combinations that result in a build error, an enormous amount of time is required, making it impossible to complete the build within a desired deadline.
[0006] This disclosure aims to facilitate the early detection of defects that may arise when combining source code changes made individually in each category during large-scale development. [Means for solving the problem]
[0007] The multi-pattern build evaluation method relating to this disclosure is: Computers Change information is obtained for each of the multiple modified source codes, including information indicating the modified source code and synchronization element information indicating the synchronization elements related between the modified source code and other modified source codes, and based on the synchronization element information between the multiple modified source codes, By grouping the relevant change information, Generate two or more packages containing one or more of the aforementioned change information, Before joining to the source tree, Generates a full build pattern that includes all of the two or more packages mentioned above, and a partial build pattern that includes some of the packages among the two or more packages mentioned above. The build results for all and partial build patterns are obtained, combinations that result in build errors are identified based on these build results, and the source code of combinations that do not result in errors is combined into the source tree. do. [Effects of the Invention]
[0008] According to this disclosure, when combining source code in large-scale development, it is possible to detect defects that occur when source code changes made individually in each category are combined at an early stage. [Brief explanation of the drawing]
[0009] [Figure 1] Figure 1 shows an example of the configuration of a multi-pattern build evaluation system according to an embodiment. [Figure 2] Figure 2 shows an example of the hardware configuration of each device in the multi-pattern build evaluation system according to the embodiment. [Figure 3] Figure 3 shows an example of the functional configuration of a source code management server according to the embodiment. [Figure 4] Figure 4 shows an example of the functional configuration of the build job management server according to the embodiment. [Figure 5]Figure 5 is a flowchart showing an example of the evaluation process flow performed by the multi-pattern build evaluation system according to the embodiment. [Figure 6] Figure 6 shows an example of a development ticket in the multi-pattern build evaluation method according to the embodiment. [Figure 7] Figure 7 shows an example of change information in the multi-pattern build evaluation method according to the embodiment. [Figure 8] Figure 8 shows an example of change information in the multi-pattern build evaluation method according to the embodiment. [Figure 9] Figure 9 is a diagram illustrating the packing in the multi-pattern build evaluation method according to the embodiment. [Figure 10] Figure 10 is a diagram illustrating the generation of all build patterns in the multi-pattern build evaluation method according to the embodiment. [Figure 11] Figure 11 is a diagram illustrating the generation of partial build patterns in the multi-pattern build evaluation method according to the embodiment. [Figure 12] Figure 12 is a diagram illustrating the generation of partial build patterns in the multi-pattern build evaluation method according to the embodiment. [Figure 13] Figure 13 is a diagram illustrating the generation of partial build patterns in the multi-pattern build evaluation method according to the embodiment. [Modes for carrying out the invention]
[0010] The embodiments of the multi-pattern build evaluation system, multi-pattern build evaluation method, program, and recording medium related to this disclosure will be described below with reference to the drawings.
[0011] Note that, in the description of the present disclosure, components having the same or substantially the same functions as those described above with reference to previously presented drawings may be designated by the same reference numerals, and descriptions thereof may be omitted as appropriate. Further, even when the same or substantially the same parts are represented, their dimensions and ratios may be represented differently in different drawings. Also, for example, from the viewpoint of ensuring the visibility of the drawings, in the description of each drawing, only main components may be assigned reference numerals, and components having the same or substantially the same functions as those described above in previously presented drawings may not be assigned reference numerals in some cases.
[0012] Note that, in the description of the present disclosure, components having the same or substantially the same functions may be described separately by adding alphanumeric characters to the end of their reference numerals. Alternatively, when a plurality of components having the same or substantially the same functions are not to be distinguished, the alphanumeric characters appended to the ends of their reference numerals may be omitted to describe them collectively.
[0013] Figure 1 is a diagram illustrating an example of the configuration of a multi-pattern build evaluation system 1 according to an embodiment. As shown in Figure 1, the multi-pattern build evaluation system 1 includes a client terminal 3, a source code management server 5, a build job management server 7, and a plurality of build machines 8. The client terminal 3, the source code management server 5, and the build job management server 7 are communicably connected via a network N which is a telecommunication line such as the Internet. Further, the build job management server 7 is communicably connected to each of the plurality of build machines 8.
[0014] The client terminal 3 receives user operation inputs. As an example, the client terminal 3 acquires a deadline to be entered in a development ticket and an input priority based on a user's operation input, and outputs them to the source code management server 5. As an example, the client terminal 3 acquires change information based on a user's operation input, and outputs the change information to the source code management server 5.
[0015] The source code management server 5 manages source code development tickets, change information, and link information. For example, the source code management server 5 obtains input of the target deadline and submission priority from client terminal 3 and enters it into the development ticket. For example, the source code management server 5 manages each version of the source code. For example, the source code management server 5 manages change information by associating development tickets, the modified source code based on the development ticket, and the synchronization elements related to the modified source code. For example, the source code management server 5 manages link information that defines the synchronization elements.
[0016] Furthermore, source code development tickets may be managed separately on a server dedicated to development ticket management. This development ticket management server may be provided within the multi-pattern build evaluation system 1 according to the embodiment, or it may be provided as an external server. This development ticket management server has a hardware configuration similar to that of the source code management server 5 and the build job management server 7, as shown in Figure 2, for example. As an example, the development ticket management server may obtain input of the target deadline and submission priority from the client terminal 3 and write it to the development ticket. The source code management server 5 may also refer to the development tickets managed by the development ticket management server.
[0017] The build job management server 7 manages multiple build machines 8 together. For example, the build job management server 7 packs synchronization elements together by collecting links of synchronization elements for changes in multiple source codes. For example, the build job management server 7 groups change information and generates build patterns based on synchronization element information that indicates the relationships between source codes included in the change information. For example, the build job management server 7 assigns full-submission build patterns and partial build patterns to multiple build machines 8 and executes the builds.
[0018] Multiple build machines 8 execute builds according to the build patterns assigned by the build job management server 7. Figure 1 illustrates N build machines 8-1, 8-2, ..., up to 8-N (where N is a natural number).
[0019] Figure 2 shows an example of the hardware configuration of each device in the multi-pattern build evaluation system 1 according to the embodiment.
[0020] The client terminal 3, source code management server 5, build job management server 7, and each build machine 8 each have a processor 91, main memory 92, auxiliary storage 93, communication interface 94, input interface 95, and display 96, respectively. The processor 91, main memory 92, auxiliary storage 93, communication interface 94, input interface 95, and display 96 are connected to each other via, for example, an internal bus.
[0021] Furthermore, the source code management server 5, the build job management server 7, and each build machine 8 do not necessarily need to have an input interface 95 and a display 96.
[0022] The processor 91 controls the overall operation of each device. Various types of processors can be used as the processor 91, such as a CPU (Central Processing Unit), GPU (Graphics Processing Unit), ASIC (Application Specific Integrated Circuit), and FPGA (Field Programmable Gate Array).
[0023] The main memory 92 temporarily stores data being worked on in each device. For example, RAM (Random Access Memory) can be used as the main memory 92.
[0024] The auxiliary storage device 93 stores various data and programs used in each device. Various storage media and devices such as ROM (Read Only Memory), HDD (Hard Disk Drive), SSD (Solid State Drive), and Flash memory can be used as the auxiliary storage device 93 as appropriate.
[0025] As an example, the auxiliary storage device 93 of the source code management server 5 stores source code information, change information, and link information. The source code information is information that shows the source code before the change, which is combined with the modified source code that has been successfully built, and consists of at least one of the following: the source code itself and information indicating the access destination of the source code information. The change information includes information indicating a development ticket that instructs the modification of the source code, information showing the modified source code, and synchronization element information indicating synchronization elements related between the modified source code and other modified source codes. The modified source code information consists of at least one of the following: the modified source code, information showing the changes to the source code, and information indicating the access destination of the source code or the information showing the changes. A synchronization element is a change number or defined link information that indicates a change made by another user on which the user's own changes depend. The link information is information that defines the synchronization element. Note that if the user registers the synchronization element, the link information does not need to be stored.
[0026] As an example, the auxiliary storage device 93 of the build job management server 7 stores build machine information and average build speed information for each of the multiple build machines 8. The build machine information is information indicating the processing capabilities related to the build, such as the processing speed and the number of parallel cores for each build machine 8. The average build speed information includes the processing speed and the speed of each step. In addition, the auxiliary storage device 93 of the build job management server 7 stores the generated packages, build patterns, and build results.
[0027] The communication interface 94 is a circuit for communication with the outside world via the network N at the client terminal 3, the source code management server 5, and the build job management server 7. The communication interface 94 also serves as a circuit for communication between the build job management server 7 and each of the multiple build machines 8. The communication interface 94 can be a wired communication circuit, a wireless communication circuit, or a combination thereof, as appropriate. For wireless communication, a communication circuit compatible with various standards such as 3G, 4G, 5G, Wi-Fi®, and Bluetooth® can be used as appropriate.
[0028] The input interface 95 acquires user input operations in each device. An input device such as a keyboard or touch panel can be used as the input interface 95 as appropriate.
[0029] The display 96 presents a display screen to the user. The display 96 can be a liquid crystal display (LCD), an electro-luminescence (OLED) display, a projector, etc., as appropriate. The display 96 may also be configured as a touch panel display. In this case, the touch panel of the display 96 is provided, for example, on the surface of the display 96 and outputs information corresponding to the touched position. This touch panel of the display 96 is an example of an input interface 95 that acquires user input.
[0030] Figure 3 shows an example of the functional configuration of the source code management server 5 according to the embodiment. In the source code management server 5, the processor 91 realizes the function of a synchronization element registration unit 51 by executing a program read from the auxiliary storage device 93 and loaded into the main memory device 92.
[0031] The synchronization element registration unit 51 accepts registration of synchronization elements based on user input from the client terminal 3. Alternatively, the synchronization element registration unit 51 accepts a specification from the user input from the client terminal 3 regarding the unit in which the synchronization elements should be linked.
[0032] Figure 4 shows an example of the functional configuration of the build job management server 7 according to the embodiment. In the build job management server 7, the processor 91 executes a program read from the auxiliary storage device 93 and loaded into the main storage device 92, thereby realizing the functions of the packing unit 71, the build pattern definition unit 72, and the build unit 73.
[0033] The packing unit 71 obtains change information for each of the multiple modified source codes. This change information includes information indicating the modified source code and synchronization element information indicating the synchronization elements related between the modified source code and other modified source codes.
[0034] Furthermore, the change information may include, for example, synchronization element information defined by the user. Alternatively, the packing unit 71 may define the synchronization element based on the references of the modified source code. Alternatively, the change information may include information indicating a development ticket that instructs the modification of the source code. In this case, the packing unit 71 may define the synchronization element based on the information indicating the development ticket.
[0035] Furthermore, the packing unit 71 generates two or more packages containing one or more change information based on synchronization element information between multiple modified source code files.
[0036] The build pattern definition unit 72 generates a full build pattern that includes all of two or more packages, and a partial build pattern that includes some of the packages among the two or more packages.
[0037] For example, if the change information includes information indicating a development ticket that instructs a change to the source code, the build pattern definition unit 72 generates a partial build pattern based on the build priority defined by the development ticket. For example, if the change information includes error information from a previous build, the build pattern definition unit 72 generates a partial build pattern that includes two or more of the aforementioned packages that caused errors in a previous build.
[0038] The build unit 73 causes the build machine 8 to execute the build of multiple source codes defined by the overall build pattern and the build of one or more source codes defined by the partial build pattern. If the build of all build patterns is successful, the build unit 73 adopts the build results of those overall build patterns. If the build of all build patterns is unsuccessful, the build unit 73 adopts the build results from one or more of the partial build patterns that were successfully built.
[0039] For example, if the change information includes information indicating a development ticket that instructs changes to the source code, the build unit 73 allocates the build destination resources in order from the overall build patterns, to the partial build patterns containing the change information with the highest build priority as defined by the development ticket. For example, if the change information includes error information from a previous build, the build unit 73 prioritizes allocating the build destination resources to the partial build patterns that resulted in errors in previous builds.
[0040] Next, we will explain the flow of the evaluation process performed by the multi-pattern build evaluation system 1 configured as described above. Figure 5 is a flowchart showing an example of the evaluation process performed by the multi-pattern build evaluation system 1 according to this embodiment.
[0041] First, the developer (user) uses client terminal 3 to enter the target deadline and submission priority for the development task in development ticket 201 (S101). Figure 6 shows an example of development ticket 201 in the multi-pattern build evaluation method according to the embodiment. As shown in Figure 6, development ticket 201 stores the development ticket name, deadline, and submission priority. Submission priority is information indicating the priority of build execution.
[0042] Then, the user uses client terminal 3 to make changes to the source code, such as implementing features or fixing bugs, according to the schedule specified by development ticket 201 (S102). Figure 5 illustrates the case where changes are made to "source code v.1" stored in source code management server 5 according to a development ticket (development task α).
[0043] Furthermore, after the developer makes one or more changes associated with development ticket 201 to the source code using client terminal 3, they register change information 203 indicating each change to the source code management server 5 that manages the source code using client terminal 3 (S103).
[0044] (Regarding cases where the user explicitly specifies the synchronization element) Figure 7 shows an example of change information 203a in the multi-pattern build evaluation method according to the embodiment.
[0045] As shown in Figure 7, change information 203a stores the change number, development ticket name, source code storage path, and synchronization element. The change number is a unique identification number assigned to each source code change, and does not overlap with other changes.
[0046] For example, a user specifies changes made by other users that their changes depend on in change information 203a. For instance, user A knows that their change A001 will not work unless user B's change B002 and user D's change D004 are incorporated. Therefore, when registering change A001, user A registers changes B002 and D004, which are related to the source code of their change A001, as synchronization elements. On the other hand, except in cases of mutual dependency, user D, who makes change D004, does not know whether user A's change A001 is necessary for their change. In this case, user D does not specify user A's change A001.
[0047] Furthermore, it is possible to know about changes made by other developers without relying on the source code. In such cases, even if the changes cannot be determined from the source code, they may be registered as synchronization elements. The synchronization element registration unit 51 of the source code management server 5 then retrieves the synchronization elements registered by the user.
[0048] (Regarding cases where the system automatically retrieves synchronization elements) Figure 8 shows an example of change information 203b in the multi-pattern build evaluation method according to the embodiment.
[0049] Change information 203b stores the change number, development ticket name, source code storage path, and synchronization element, as shown in Figure 8.
[0050] For example, the user specifies to the source code management server 5, using client terminal 3, which unit to link the synchronization elements in. The source code management server 5 maintains link information indicating the specified unit of synchronization elements. Note that the link information specified by client terminal 3 may also be described in change information 203b.
[0051] For example, a user can specify the API / source code level as the unit of synchronization elements. In this case, the source code management server 5 defines the synchronization elements based on service call relationships and reference information for common functions / files.
[0052] For example, a user can specify the source code level as the unit of synchronization elements. In this case, the source code management server 5 defines the synchronization elements based on file and data reference information, i.e., link information of functions used in the same use case.
[0053] In this way, the synchronization element registration unit 51 of the source code management server 5 links and acquires synchronization elements in units specified by the user. Specifically, the synchronization element registration unit 51 stores link information based on the specified unit in advance and automatically links changes that have been modified related to each other based on the difference information with the source code before modification.
[0054] If all changes to the target deadline have not been registered (S104: No) and the pre-set submission deadline has not yet been reached (S105: No), the build job management server 7 waits for further processing. On the other hand, if all changes to the target deadline have been registered (A104: Yes) or the pre-set submission deadline has been reached (S105: Yes), the build job management server 7 starts the packing and build processes (S106~S115).
[0055] The packing unit 71 of the build job management server 7 generates a package by packing the change information in order of highest submission priority, based on the synchronization element information indicating the synchronization elements.
[0056] First, the link section 711 establishes links between the change information according to the synchronization element.
[0057] Furthermore, if the API / source code level is specified as the unit of synchronization elements, the linking unit 711 creates links based on the dependencies used during the build process. Specifically, the linking unit 711 creates a dependency list from the API external reference information and constant reference information of the source code, and by referring to the created dependency list, it links the changes related to the source code associated with the changes and obtains the synchronization elements.
[0058] Furthermore, if the source code level is specified as the unit of synchronization elements, the linking unit 711 reverse-looks up functions that use files and data, that is, it refers to use cases from system test results and creates links to related functions. Specifically, the linking unit 711 refers to the development ticket name in the change information 203b and creates links to changes issued from the same development ticket. This is because, for example, changes associated with a certain use case are associated with the development ticket issued when the system test result is NG, and therefore changes related to the same development ticket are bundled together.
[0059] Then, the processing unit 712 packs the change information in order of input priority to generate a package.
[0060] Figure 9 is a diagram illustrating packing in the multi-pattern build evaluation method according to the embodiment. In Figure 9, development task α has priority S and is associated with changes 1 and 2. The synchronization elements of change 1 are changes 2 and 4. The synchronization element of change 2 is change 1. Development task β has priority A and is associated with change 3. Change 3 has no synchronization elements. Development task γ has priority A and is associated with change 4. Change 4 has no synchronization elements. Development task σ has priority B and is associated with change 5. Change 5 has no synchronization elements.
[0061] In this case, the processing unit 712 packs the change information in order, starting with the change information for change 1, which has a higher priority of priority S. At this time, change information linked based on the synchronization element is packed together. Therefore, in the example in Figure 9, the processing unit 712 first generates package 401 containing the change information for change 1, change 2, and change 4. Next, the processing unit 712 packs the change information for change 3, which has a priority of priority A, to generate package 402. Then, the processing unit 712 packs the change information for change 5, which has a priority of priority B, to generate package 403.
[0062] Thus, the packing unit 71 according to this embodiment selects change information with a high build priority, extracts change information on which the selected change information depends, and packs it into a single package.
[0063] Furthermore, the packing unit 71 does not follow links from the user side to the user side. Therefore, for example, in the example in Figure 9, if we consider the case where the priority of development task α is A and the priority of development task γ is S, then package 401 will be generated as a package containing the change information of change 4.
[0064] As shown in the example above, this method works in cases where changes to the system being used can be implemented without any changes to the user, such as the addition of APIs or constants. However, there may be cases where it does not work unless changes to the user, such as changes to APIs or constants, are also incorporated. In such cases, a flag indicating whether synchronization of the source is necessary may be added as an attribute when registering the change information in Change 4. The multi-pattern build evaluation method according to the embodiment may be configured to follow the reverse link as well, for example, if this necessity flag is ON.
[0065] Subsequently, once all change information for the target closing date has been registered, or once the pre-set submission deadline has been reached, the build will start automatically (S107~S111).
[0066] The build pattern definition unit 72 generates a full build pattern 411a that includes all packages (S107). Figure 10 is a diagram illustrating the generation of a full build pattern in the multi-pattern build evaluation method according to the embodiment. As shown in Figure 10, the build pattern definition unit 72 generates a full build pattern 411a that includes all packages 401, 402, and 403 packed based on the synchronization element. The build unit 73 then assigns the build of the full build pattern 411a to the build machine 8-1 as a resource and causes the assigned build machine 8-1 to execute the build of the full build pattern 411a (S108).
[0067] Furthermore, the build pattern definition unit 72 generates partial build patterns 411b, 411c, and 411d, which include some packages, in parallel with the processing in S107 to S108 (S109).
[0068] As an example, the build pattern definition unit 72 generates partial build patterns 411b and 411c in order from the highest to the lowest priority. Figures 11 and 12 are diagrams illustrating the generation of partial build patterns in the multi-pattern build evaluation method according to the embodiment. For example, in this embodiment, we illustrate a case where four priority levels are set in descending order: S / A / B / C. In this case, the build pattern definition unit 72 generates build patterns in the following order: priority S only (partial build pattern 411b in Figure 11) → up to priority A (partial build pattern 411c in Figure 12) → ... → priority S + B (excluding A) → priority S + C → priority A only → priority A + B → ...
[0069] Furthermore, the build pattern definition unit 72 may generate a past problem build pattern and perform the build with the highest priority if a package has been generated with a combination of change information that caused problems in past builds, i.e., resulted in an error. Figure 13 is a diagram illustrating the generation of a partial build pattern in the multi-pattern build evaluation method according to the embodiment. Figure 109 shows a past problem build pattern based on error information as a partial build pattern 411c. In this way, information on synchronization elements is retained in the error information during the build, and the build priority is increased for combinations that have caused errors multiple times in the past, thereby achieving early detection of defects.
[0070] Furthermore, when linking synchronization elements with past error information and prioritizing the inclusion of combinations with a high error frequency in the build pattern, it is also possible to configure the build pattern to generate one that excludes lower-priority change information from a package if the package was created using a combination that has caused problems in the past.
[0071] Furthermore, the build unit 73 allocates resources so that the partial build patterns with the highest submission priority are executed in order (S110), and then executes the build for the allocated partial build patterns (S111). At this time, the build unit 73 predicts the build time and allocates resources so that the completion time does not exceed the deadline. If the allocated resources become full, the build unit 73 terminates the allocation even if there are still build executions remaining for lower-priority build patterns. The build unit 73 then monitors the build status and updates the build completion time. If the updated completion time exceeds the deadline specified in the development ticket and cannot be completed within the deadline, the build unit 73 increases the resources allocated to high-priority builds and reduces the resources allocated to low-priority builds or temporarily suspends build execution.
[0072] The resource allocation by the build unit 73 includes the step of checking the available build machines 8. This allocation also includes the step of obtaining the amount of source code modifications included in a partial build pattern by referring to change information. Furthermore, this allocation includes the step of referring to past build history and obtaining build time from build machines 8 whose processing capacity and source code modification amount are similar. This allocation also includes the step of referring to development tickets and checking the remaining time until build completion based on the earliest deadline and the current time. Finally, this allocation includes the step of allocating resources in order of priority, starting with the highest priority partial build patterns, so that the build can be submitted by the remaining time specified in the development ticket. In this process, the build unit 73 allocates multiple partial build patterns in parallel to multiple build machines 8 to ensure completion within the deadline. Additionally, when the processing capacity of a build machine 8 is filled, the build unit 73 changes the allocation to the next build machine 8.
[0073] Then, the build unit 73 checks the build results for all build patterns (S112), and if the build results are NG (S113: No), it retrieves the results of the partial build patterns in order of input priority (S114).
[0074] On the other hand, if the build result of the entire build pattern or a partial build pattern is OK (S113: Yes), the build unit 73 combines the source code of the change information included in that build pattern into the main source tree (S115).
[0075] As described above, the multi-pattern build evaluation method according to the embodiment generates multiple build patterns, each bundling a small number of changes based on synchronization elements, and evaluates them so that they are combined in order of priority. Specifically, the multi-pattern build evaluation method according to the embodiment collects the changes individually made to the source code, identifies combinations that result in errors, and combines the combinations that do not result in errors into the source tree. Before combining into the source tree, the multi-pattern build evaluation method according to the embodiment performs a build using partial build patterns that bundle a small number of changes, and identifies combinations that result in build errors. In this case, the multi-pattern build evaluation method according to the embodiment can reduce the number of combinations to be verified by grouping the changes that should be combined into the source tree simultaneously based on synchronization elements. Furthermore, the multi-pattern build evaluation method according to the embodiment assigns priorities to the combinations and manipulates the resource allocation amount and processing start timing so that the build of the partial build pattern containing the high-priority change information is completed within the desired deadline.
[0076] This configuration allows for the early detection of cases where errors occur when individual changes made to the source code in each category are combined. In other words, it enables the early detection of bugs that arise when individual changes made to the source code in each category are combined during the integration of source code in large-scale development.
[0077] In this embodiment, the example of an error is described as a build error (build result NG), but it is not limited to this. The multi-pattern build evaluation method according to this embodiment may be configured to recognize an error not only when a build error occurs, but also when a malfunction or defect is detected during post-build operation verification (testing). Similarly, with regard to the generation of build patterns and resource allocation based on past error information, the configuration may use error information not only for past build errors, but also for errors that occurred when a malfunction or defect was detected during past post-build operation verification (testing).
[0078] In the embodiments described above, "determining whether it is A" may mean "determining that it is A," "determining that it is not A," or "determining whether or not it is A."
[0079] The programs executed by each device of the multi-pattern build evaluation system 1 of the above-described embodiment are provided as files in an installable or executable format, recorded on a computer-readable recording medium such as a CD-ROM, floppy disk, CD-R, or DVD.
[0080] Furthermore, the programs executed by each device of the multi-pattern build evaluation system 1 in the above-described embodiment may be stored on a computer connected to a network such as the Internet and provided by downloading them via the network. Alternatively, the programs executed by each device of the multi-pattern build evaluation system 1 may be provided or distributed via a network such as the Internet.
[0081] Furthermore, the program executed by each device of the multi-pattern build evaluation system 1 of the above-described embodiment may be pre-installed and provided in ROM or the like.
[0082] Furthermore, the program executed by the source code management server 5 in the above-described embodiment has a module configuration that includes the above-described functional unit (synchronization element registration unit 51). In actual hardware, the processor 91 reads the program from the auxiliary storage device 93 and executes it, thereby loading the above-described functional unit onto the main memory device 92, and generating the above-described functional unit on the main memory device 92.
[0083] Furthermore, the program executed by the build job management server 7 in the above-described embodiment has a modular configuration that includes the above-described functional units (packing unit 71 (link unit 711 and processing unit 712), build pattern definition unit 72 and build unit 73). In actual hardware, the processor 91 reads the program from the auxiliary storage device 93 and executes it, thereby loading the above-described functional units onto the main memory device 92, and generating the above-described functional units on the main memory device 92.
[0084] According to at least one embodiment described above, when it comes to combining source code in large-scale development, defects that occur when source code changes made individually in each category are combined can be detected early.
[0085] While several embodiments of the present invention have been described, these embodiments are presented as examples only and are not intended to limit the scope of the invention. These embodiments can be carried out in a variety of other forms, and various omissions, substitutions, and modifications can be made without departing from the spirit of the invention. These embodiments and their variations are included in the scope and spirit of the invention, as well as in the claims and their equivalents.
[0086] (Note) Based on the above description of embodiments, the following technologies are disclosed. (1) Change information is obtained for each of the multiple modified source codes, including information indicating the modified source code and synchronization element information indicating the synchronization elements related between the modified source code and other modified source codes. Based on the synchronization element information between the modified multiple source code files, two or more packages containing one or more of the modification information are generated. A full build pattern that includes all of the two or more packages mentioned above, and a partial build pattern that includes some of the packages mentioned above, are generated. A method for evaluating multi-pattern builds. (2) The information indicating the source code is at least one of the following: the source code, information indicating changes to the source code, and information indicating the access destination of the source code or the information indicating changes. The multi-pattern build evaluation method described in (1) above. (3) The aforementioned change information includes user-defined synchronization element information, The multi-pattern build evaluation method described in (1) or (2) above. (4) Define the synchronization element based on the references in the modified source code. A multi-pattern build evaluation method described in any one of the above items (1) to (3). (5) The aforementioned change information includes information indicating a development ticket that instructs changes to the source code, Define the synchronization element based on information indicating the development ticket. A multi-pattern build evaluation method described in any one of the above items (1) to (4). (6) The aforementioned change information includes information indicating a development ticket that instructs changes to the source code, Based on the build priority defined by the aforementioned development ticket, the partial build pattern is generated. A multi-pattern build evaluation method described in any one of the above items (1) to (5). (7) The aforementioned change information includes error information from previous builds, A partial build pattern is generated that includes two or more of the aforementioned packages that caused errors in previous builds. A multi-pattern build evaluation method described in any one of the above items (1) to (6). (8) The build of multiple source codes defined by the aforementioned full build pattern and the build of one or more source codes defined by the aforementioned partial build pattern are performed. If the build of all build patterns is successful, the build results of all build patterns will be adopted. If the build of all build patterns fails, the build result will be selected from one or more of the partial build patterns that succeeded. A multi-pattern build evaluation method described in any one of the above items (1) to (7). (9) The aforementioned change information includes information indicating a development ticket that instructs changes to the source code, Following the aforementioned all build patterns, the build destination resources are allocated in order, starting with the partial build patterns containing the change information with the highest build priority as defined by the development ticket. The multi-pattern build evaluation method described in (8) above. (10) The aforementioned change information includes error information from previous builds, Prioritize allocating build resources to the aforementioned partial build pattern that resulted in errors in previous builds. The multi-pattern build evaluation method described in (8) or (9) above. (11) Change information is obtained for each of the multiple modified source codes, including information indicating the modified source code and synchronization element information indicating the synchronization elements related between the modified source code and other modified source codes. Based on the synchronization element information between the modified multiple source code files, two or more packages containing one or more of the modification information are generated. To cause a computer to perform the following actions: generate a full build pattern that includes all of the two or more packages mentioned above, and a partial build pattern that includes some of the packages among the two or more packages mentioned above. program. (12) A program for causing a computer to execute the multi-pattern build evaluation method described in any one of the above items (2) to (10). (13) A computer program that is executed by a computer, and on which the program described in (11) or (12) above is recorded (Computer Program Product). [Explanation of Symbols]
[0087] 1. Multi-Pattern Build Evaluation System 3. Client terminals 5. Source code management server 51 Synchronization Element Registration Unit 7. Build Job Management Server 71 Packing Section 711 Link section 712 Processing Unit 72 Build Pattern Definition Section 73 Build Department 91 processors 92 Main memory 93 Auxiliary storage device 94 Communication Interface 95 Input Interfaces 96 Display N Network
Claims
1. A computer, Change information is obtained for each of the multiple modified source codes, including information indicating the modified source code and synchronization element information indicating the synchronization elements related between the modified source code and other modified source codes. Based on the synchronization element information between the multiple modified source codes, the relevant modification information is grouped to generate two or more packages containing one or more of the modification information. Before joining to the source tree, a full build pattern including all of the two or more packages and a partial build pattern including some of the packages are generated. The build results for the entire build pattern and the partial build pattern are obtained, combinations that result in build errors are identified based on the build results, and the source code of the combinations that do not result in errors is added to the source tree. A method for evaluating multi-pattern builds.
2. The information indicating the source code is at least one of the following: the source code, information indicating changes to the source code, and information indicating the access destination of the source code or the information indicating changes. The multi-pattern build evaluation method according to claim 1.
3. The aforementioned change information includes user-defined synchronization element information, The multi-pattern build evaluation method according to claim 1.
4. Define the synchronization element based on the references in the modified source code. The multi-pattern build evaluation method according to claim 1.
5. The aforementioned change information includes information indicating a development ticket that instructs changes to the source code, Define the synchronization element based on information indicating the development ticket. The multi-pattern build evaluation method according to claim 1.
6. The aforementioned change information includes information indicating a development ticket that instructs changes to the source code, Based on the build priority defined by the aforementioned development ticket, the partial build pattern is generated. The multi-pattern build evaluation method according to claim 1.
7. The aforementioned change information includes error information from previous builds, A partial build pattern is generated that includes two or more of the aforementioned packages that caused errors in previous builds. The multi-pattern build evaluation method according to claim 1.
8. The build of multiple source codes defined by the aforementioned full build pattern and the build of one or more source codes defined by the aforementioned partial build pattern are performed. If the build of all build patterns is successful, the build results of all build patterns will be adopted. If the build of all build patterns fails, the build result will be selected from one or more of the partial build patterns that succeeded. A multi-pattern build evaluation method according to any one of claims 1 to 7.
9. The aforementioned change information includes information indicating a development ticket that instructs changes to the source code, Following the aforementioned all build patterns, the build destination resources are allocated in order, starting with the partial build patterns containing the change information with the highest build priority as defined by the development ticket. The multi-pattern build evaluation method according to claim 8.
10. The aforementioned change information includes error information from previous builds, Prioritize allocating build resources to the aforementioned partial build pattern that resulted in errors in previous builds. The multi-pattern build evaluation method according to claim 8.
11. Change information is obtained for each of the multiple modified source codes, including information indicating the modified source code and synchronization element information indicating the synchronization elements related between the modified source code and other modified source codes. Based on the synchronization element information between the multiple modified source codes, the relevant modification information is grouped to generate two or more packages containing one or more of the modification information. Before joining to the source tree, a full build pattern including all of the two or more packages and a partial build pattern including some of the packages are generated. To cause a computer to perform the following actions: obtain the build results of the entire build pattern and the partial build pattern, identify combinations that result in build errors based on those build results, and combine the source code of the combinations that do not result in errors into the source tree, program.
Citation Information
Patent Citations
Debug support system, method, program, and recording medium
JP2015011372A
Analysis support program, analysis support device, and analysis support method
JP2015056120A
Software evaluation system
JP2019114043A
Task aware source checkin and build
US20060236301A1
Dependence-based software builds
US20110239195A1
