Information processing system and information processing method

Abstract

An information processing system that assists the development of software by executing a test of a task generated on the basis of a plurality of source code components included in the software, the information processing system being provided with a control unit that integrates the plurality of source code components that serve as the basis of the task and generates a product, and a control unit configured to execute a test of the task using the product, the control unit registering the product in a memory when a registration condition is satisfied, and not registering the product in the memory when the registration condition is not satisfied. Wherein the registration condition is at least one of the following first to third registration conditions. The first registration condition is that the file size of the product is smaller than a predetermined amount. The second registration condition is that the safety standard required by the product exceeds the specified level. The third registration condition is that a difference value obtained by subtracting a total time of a registration time for registering the product in the memory and a read time for reading the product from the memory from an integration time for integrating the plurality of source code components exceeds a predetermined value.

Description

Technical Field

[0001] The present disclosure relates to an information processing system and an information processing method. This application claims priority based on Japanese application No. 2022-154982 filed on September 28, 2022, and all the contents described in the above Japanese application are cited. Background Art

[0002] In the past, methods called continuous integration (CI) and continuous delivery (CD) were sometimes used in software development. It should be noted that there are also cases where continuous deployment (CD) is implemented instead of continuous delivery. The purpose of such development methods is to suppress large-scale correction events and reduce the cost of correction by frequently and automatically verifying the software during development.

[0003] For example, at a software development site, multiple developers each create a source code component (source) and perform operation verification of the individual source code components. However, if multiple source code components are combined and operated as one software, errors may occur. In this case, it is necessary to verify which combination of source code components caused the error, so the operation test may take time.

[0004] In the development method based on CI / CD, for example, source code components created by multiple developers are stored in a repository on the cloud (pushing to the repository). In addition, source code component management tools such as GitHub (registered trademark) (also known as source code management (SCM: Source Code Management)) automatically create tasks (create tasks) based on the source code components stored in the repository each time the source code components are updated. Tasks are automatically tested by CI / CD tools such as Jenkins (registered trademark).

[0005] In this way, integration is repeated in smaller cycles and integration errors are checked frequently, thereby suppressing large-scale rework.

[0006] Patent Document 1 discloses a technique for selecting a test case to be executed based on the importance of the test and the execution time of the test. In the technique of Patent Document 1, for example, a test case with low importance is not executed, so the time required for automatic testing of CI can be reduced.

[0007] Patent document 2 discloses the following technology: when performing a test while saving the last test result in an execution result database, the execution result database is referenced, and if the last test result is OK (successful) and there is no change between the files involved in the last test and the files involved in the current test, the current test is skipped. In the technology of patent document 2, the processing involved in the test is omitted according to the result of the judgment, so the execution time of the test can be shortened.

[0008] Prior art literature

[0009] Patent Literature

[0010] Patent Document 1: Japanese Patent Application Publication No. 2010-134643

[0011] Patent Document 2: International Publication No. 2020 / 166345 Summary of the invention

[0012] The information processing system of the present disclosure assists in the development of software by executing tests on tasks generated based on multiple source code components included in the software. The information processing system includes a control unit that integrates the multiple source code components that serve as the basis of the task to generate a product and uses the product to execute the test of the task. The control unit registers the product in a memory when a registration condition is met, and does not register the product in the memory when the registration condition is not met.

[0013] The registration condition is at least one of the following first to third registration conditions. The first registration condition: the file size of the product is less than a specified amount. The second registration condition: the security standard required for the product exceeds a specified level. The third registration condition: the difference obtained by subtracting the total time of registering the product in the memory and the time of reading the product from the memory from the integration time of integrating the plurality of source code components exceeds a specified value.

[0014] The information processing system of the present disclosure assists in the development of software by executing tests on tasks generated based on multiple source code components included in the software. The information processing system includes a control unit that integrates multiple source code components that serve as the basis of the task to generate a product, registers the product in a memory, and uses the product to execute the test of the task. When the task is input to the control unit, the control unit reads from the memory the product that was generated when the task was input to the control unit in the past if a read condition is satisfied, and regenerates the product based on the task input to the control unit this time if the read condition is not satisfied.

[0015] The read condition is at least one of the following first to third read conditions. The first read condition: the file size of the generated product is less than a specified amount. The second read condition: the security standard required for the generated product exceeds a specified level. The third read condition: the difference obtained by subtracting the read time of reading the generated product from the memory from the integration time of integrating the plurality of source code components exceeds a specified value.

[0016] The information processing method disclosed herein assists in the development of software by executing tests on tasks generated based on a plurality of source code components included in the software, and the information processing method comprises: a first step of integrating a plurality of the source code components that are the basis of the task to generate a product; a second step of using the product to execute the test of the task; and a third step of registering the product in a memory if a registration condition is satisfied, and not registering the product in the memory if the registration condition is not satisfied.

[0017] The registration condition is at least one of the following first to third registration conditions. The first registration condition: the file size of the product is less than a specified amount. The second registration condition: the security standard required for the product exceeds a specified level. The third registration condition: the difference obtained by subtracting the total time of registering the product in the memory and the time of reading the product from the memory from the integration time of integrating the plurality of source code components exceeds a specified value. BRIEF DESCRIPTION OF THE DRAWINGS

[0018] [ Figure 1 ] Figure 1 It is a diagram showing an example of an information processing system according to an embodiment.

[0019] [ Figure 2 ] Figure 2 It is a diagram showing an example of software of an implementation mode.

[0020] [ Figure 3 ] Figure 3 This is a diagram showing an example of the internal structure of the information processing device according to the embodiment.

[0021] [ Figure 4 ] Figure 4 This is a table showing an example of version information of the implementation scheme.

[0022] [ Figure 5 ] Figure 5 This is a table showing an example of test result information according to the embodiment.

[0023] [ Figure 6 ] Figure 6 This is a table showing an example of file size information according to the implementation mode.

[0024] [ Figure 7 ] Figure 7 This is a table showing an example of safety standard information according to the implementation mode.

[0025] [ Figure 8 ] Figure 8 This is a flowchart showing an example of an information processing method according to an embodiment.

[0026] [ Fig. 9 ] Fig. 9 This is a subroutine that shows the details of the task input process in the embodiment. DETAILED DESCRIPTION

[0027] [Problems to be Solved by the Invention]

[0028] Software development tends to become larger year by year, and with this, the time required for testing is also increasing. Therefore, when adopting a development method based on CI / CD, it is required to perform testing more efficiently.

[0029] Here, when adopting a method of storing the last test result and the like in an execution result database as in Patent Document 2 and referring to the last test result and the like when executing a new test to determine whether to skip the new test, it is necessary to create the execution result database.

[0030] However, as software development becomes larger, the types of tests performed increase, or the file size of the source code component used for a test increases. Therefore, if an execution result database such as the one described above is created, it will be more time-consuming than directly executing the test without performing the steps, and sometimes it is impossible to achieve efficient test execution.

[0031] In view of this problem, an object of the present disclosure is to provide an information processing system and an information processing method that can execute a test more efficiently.

[0032] [Effects of the invention]

[0033] According to the present disclosure, testing can be performed more efficiently.

[0034] [Description of Embodiments of the Present Disclosure]

[0035] The embodiments of the present disclosure include the following structures as the gist thereof.

[0036] (1) The information processing system of the present disclosure assists in the development of software by executing a test of a task generated based on a plurality of source code components included in the software. The information processing system includes a control unit that integrates the plurality of source code components that are the basis of the task to generate a product and executes the test of the task using the product. The control unit registers the product in a memory when a registration condition is satisfied, and does not register the product in the memory when the registration condition is not satisfied.

[0037] The registration condition is at least one of the following first to third registration conditions. The first registration condition: the file size of the product is less than a specified amount. The second registration condition: the security standard required for the product exceeds a specified level. The third registration condition: the difference obtained by subtracting the total time of registering the product in the memory and the time of reading the product from the memory from the integration time of integrating the plurality of source code components exceeds a specified value.

[0038] With this configuration, rather than uniformly registering generated products, generated products are registered based on whether or not the registration conditions are satisfied, thereby making it possible to make the time required to execute the test more efficient.

[0039] (2) In the information processing system of (1) above, the information processing system further includes a determination unit that determines whether the registration condition is satisfied, and the control unit determines whether to register the product in the memory based on a determination result of the determination unit.

[0040] (3) In the information processing system of (2) above, the determination unit sets the prescribed amount of the first registration condition to a first prescribed amount, sets the level of the second registration condition to a first level, or sets the prescribed value of the third registration condition to a first prescribed value to determine whether the registration condition is satisfied when the free capacity of the memory is a first capacity, and the determination unit sets the prescribed amount of the first registration condition to a second prescribed amount smaller than the first prescribed amount, sets the level of the second registration condition to a second level higher than the first level, or sets the prescribed value of the third registration condition to a second prescribed value larger than the first prescribed value to determine whether the registration condition is satisfied when the free capacity of the memory is a second capacity smaller than the first capacity.

[0041] The smaller the free capacity of the memory is, the stricter the registration conditions are, and the products to be registered are limited to products with higher priority. This makes it possible to more effectively use the remaining less memory capacity.

[0042] (4) In the information processing system described in any one of (1) to (3) above, when the registration condition is satisfied, the control unit deletes the generated product of the first level that has been registered in the memory, and newly registers the generated product of the second level that is higher than the first level in the memory.

[0043] With this configuration, a product with a higher priority can be registered in the memory.

[0044] (5) In the information processing system described in any one of (1) to (4), the software is software executed by an onboard device installed in a vehicle, and the safety standard is ASIL (Automotive Safety Integrity Level) of ISO26262.

[0045] (6) In the information processing system described in any one of (1) to (5) above, when the task is input to the control unit, the control unit reads from the memory the product generated when the task was previously input to the control unit if a read condition is satisfied, and regenerates the product based on the task input to the control unit this time if the read condition is not satisfied.

[0046] The read condition is at least one of the following first to third read conditions. The first read condition: the file size of the generated product is less than a specified amount. The second read condition: the security standard required for the generated product exceeds a specified level. The third read condition: the difference obtained by subtracting the read time of reading the generated product from the memory from the integration time of integrating the plurality of source code components exceeds a specified value.

[0047] With this configuration, the time required to execute the test can be made more efficient by reading the product based on whether the reading condition is satisfied rather than reading the product uniformly.

[0048] (7) The information processing system of the present disclosure assists in the development of software by executing tests on tasks generated based on a plurality of source code components included in the software. The information processing system includes a control unit that integrates a plurality of the source code components that form the basis of the task to generate a product, registers the product in a memory, and executes the test of the task using the product. When the task is input to the control unit, the control unit reads from the memory the product that was generated when the task was input to the control unit in the past if a read condition is satisfied, and regenerates the product based on the task input to the control unit this time if the read condition is not satisfied.

[0049] The read condition is at least one of the following first to third read conditions. The first read condition: the file size of the generated product is less than a specified amount. The second read condition: the security standard required for the generated product exceeds a specified level. The third read condition: the difference obtained by subtracting the read time of reading the generated product from the memory from the integration time of integrating the plurality of source code components exceeds a specified value.

[0050] With this configuration, the time required to execute the test can be made more efficient by reading the product based on whether the reading condition is satisfied rather than reading the product uniformly.

[0051] (8) The information processing method of the present invention assists in the development of software by executing a test of a task generated based on a plurality of source code components included in the software, and the information processing method comprises: a first step of integrating a plurality of the source code components that are the basis of the task to generate a product; a second step of using the product to execute the test of the task; and a third step of registering the product in a memory when a registration condition is satisfied, and not registering the product in the memory when the registration condition is not satisfied.

[0052] The registration condition is at least one of the following first to third registration conditions. The first registration condition: the file size of the product is less than a specified amount. The second registration condition: the security standard required for the product exceeds a specified level. The third registration condition: the difference obtained by subtracting the total time of registering the product in the memory and the time of reading the product from the memory from the integration time of integrating the plurality of source code components exceeds a specified value.

[0053] With this configuration, rather than uniformly registering generated products, generated products are registered based on whether or not the registration conditions are satisfied, thereby making it possible to make the time required to execute the test more efficient.

[0054] [1. Details of embodiments of the present disclosure]

[0055] Hereinafter, details of the embodiments of the present disclosure will be described with reference to the drawings.

[0056] [1.1 Overall structure of the information processing system]

[0057] Figure 1 It is a diagram showing a configuration example of an information processing system 1 according to an embodiment.

[0058] The information processing system 1 is a system that assists the development of software SW1.

[0059] The software SW1 is executed by a device mounted on a vehicle such as an automobile (hereinafter referred to as an "on-vehicle device"). More specifically, the software SW1 is used for an on-vehicle ECU (Electronic Control Unit). For example, the software SW1 is used for a central ECU or an integrated ECU having a function of managing a plurality of ECUs. Such software SW1 tends to be developed on a large scale, and therefore development assistance based on the information processing system 1 is more useful.

[0060] The information processing system 1 includes an information processing device 10, a storage library 20, a test tool 30, a test environment 40, and a memory 50. The information processing system 1 may be implemented by a single device (e.g., a server device) concentrated in one place, or may be implemented by a plurality of devices dispersed in a plurality of places in a state where the respective parts 10, 20, 30, 40, 50 are connected to each other via a network such as the Internet so as to be able to communicate with each other.

[0061] [1.2 Software and Tasks]

[0062] Figure 2 FIG. 1 is a diagram showing an example of software SW1 according to the embodiment. Figure 2 , the software SW1 and the task Tx are described. The software SW1 includes a plurality of components X1, X2, X3. The component X1 includes a plurality of modules a1, a2, a3, and the component X2 includes a plurality of modules b1, b2.

[0063] These components X1, X2, X3 and modules a1, a2, a3, b1, b2 are collectively referred to as "source code components". That is, the software SW1 includes a plurality of source code components. These source code components may be data recorded in a predetermined programming language called source code, or may be data recorded in binary code after the source code is converted into a machine language.

[0064] These source code components are individually produced, for example, in a plurality of terminals (referred to as a terminal group 60) operated by a plurality of developers (suppliers). In the information processing system 1, operation tests of individual source code components and operation tests of a product Px generated by integrating (integrating) a plurality of source code components are performed. Integrating a plurality of source code components is sometimes referred to as "merging" or "building".

[0065] For example, a product Px generated by integrating modules a1, a2, and a3 is “assembly X1.” Other examples of product Px include a product Px generated by integrating modules a1 and a2, and a product Px generated by integrating components X1 and X2.

[0066] Here, an item of a test executed in the information processing system 1 is referred to as a task Tx. The task Tx is also referred to as a “work task”.

[0067] Task Tx includes any one of the following test items (1) to (4).

[0068] (1) A test item that verifies whether a module (for example, module a1) performs actions as an individual.

[0069] (2) A test item that verifies whether the product Px of multiple modules (for example, module a1 and module a2) included in a component is integrated and operates.

[0070] (3) A test item that verifies whether a component (for example, component X1) operates, that is, verifies whether a product Px that integrates all modules included in the component (for example, modules a1, a2, and a3) operates.

[0071] (4) A test item that verifies whether the product Px that integrates multiple components (for example, component X1 and component X2) operates.

[0072] That is, the "product Px" is data generated by integrating a plurality of source code components, and the "task Tx" is a test item for verifying whether the individual source code components or the product Px operate normally.

[0073] [1.3 Repository]

[0074] Reference Figure 1 The repository 20 is, for example, a database constructed on the cloud and implemented by a large-capacity storage device. The repository 20 is connected to the terminal group 60 via a network. The developer sends a plurality of source code components created in the terminal group 60 to the repository via the network. The repository 20 stores the received plurality of source code components.

[0075] The repository 20 is provided with a source code component management tool (also called source code management (SCM)) such as GitHub. The SCM automatically generates a task Tx based on a plurality of source code components stored in the repository 20. The generated task Tx is provided from the repository 20 to the test tool 30.

[0076] [1.4 Test Tools]

[0077] Reference Figure 1The test tool 30 is a CI / CD tool such as Jenkins or Circle CI (registered trademark), and is implemented by a computer device including a processor and a memory. The test tool 30 manages a queue 31 in which multiple tasks Tx are waiting to be executed. Specifically, the test tool 30 automatically outputs the tasks Tx accumulated in the queue 31 to the information processing device 10 in sequence.

[0078] The queue 31 is, for example, a memory that accumulates a plurality of tasks Tx using a first-in, first-out (FIFO: First In, First Out) method. Figure 1 In the example of , four tasks Tx (when specially distinguished, they are referred to as T1 , T2 , T3 , and T4 , respectively) are accumulated in the queue 31 .

[0079] exist Figure 1 , when tasks T1, T2, and T3 are already accumulated in the queue 31 in this order, task T4 output from the storage library 20 is stored in the last position (last) in the execution order of the queue 31. In this case, the test tool 30 outputs the tasks Tx accumulated in the queue 31 to the information processing device 10 in the order of tasks T1, T2, T3, and T4.

[0080] [1.5 Information processing device]

[0081] Figure 3 1 is a diagram showing an example of the internal structure of the information processing device 10 according to the embodiment. The information processing device 10 is, for example, a computer device (eg, a laptop PC) including a processor and a memory, and is also referred to as a “node”.

[0082] The information processing device 10 is a device for executing, when a task Tx is input from the queue 31, a first process of integrating multiple source code components that serve as the basis of the task Tx to generate a product Px, a second process of testing the task Tx using the product Px, a third process of storing the product Px in the memory 50, and a fourth process of reading the product Px from the memory 50.

[0083] The information processing device 10 includes a control unit 11, a determination unit 12, a storage unit 13, a communication unit 14, and a reading unit 15. These units 11 to 15 are electrically connected to each other via a bus.

[0084] The control unit 11 includes, for example, a circuit structure such as a processor. Specifically, the control unit 11 includes one or more CPUs (Central Processing Units). The control unit 11 reads a computer program stored in the storage unit 13 and executes various calculations and controls.

[0085] In addition, the control unit 11 may also include a processor in which a predetermined program is pre-written. For example, the control unit 11 may also be an integrated circuit such as a CPLD (Complex Programmable Logic Device), an FPGA (Field-Programmable Gate Array), or an ASIC (Application Specific Integrated Circuit). In this case, the control unit 11 performs various operations and controls based on the pre-written program.

[0086] The determination unit 12 includes a circuit structure such as a processor, similarly to the control unit 11. The determination unit 12 reads a computer program stored in the storage unit 13 and performs various operations and controls. In addition, the determination unit 12 may also be an integrated circuit, similarly to the control unit 11. In this case, the determination unit 12 performs various operations and controls based on a pre-written program.

[0087] exist Figure 3 In the example of , the determination unit 12 is shown as a structure separate from the control unit 11. However, the determination unit 12 may be integrated with the control unit 11. For example, the determination unit 12 may be a processor that shares an area with the control unit 11. In addition, the determination unit 12 may also be included in a computer device that is different from the information processing device 10 and is connected between the information processing device 10 and the memory 50.

[0088] The storage unit 13 has a volatile memory and a nonvolatile memory, and stores various data. The volatile memory includes, for example, a RAM (Random Access Memory). The nonvolatile memory includes, for example, a flash memory, a HDD (Hard Disk Drive), an SSD (Solid State Drive), or a ROM (Read Only Memory). The storage unit 13 stores, for example, a computer program and various parameters in the nonvolatile memory.

[0089] The communication unit 14 is a communication interface for performing communication with the storage 20, the test tool 30, and the memory 50. The communication unit 14 can perform wireless communication with these units 20, 30, and 50 via a network or perform wired communication via a communication line. When performing wireless communication, the communication unit 14 has an antenna.

[0090] The reading unit 15 reads information from a computer-readable recording medium 16. The recording medium 16 is, for example, an optical disk such as a CD or a DVD or a USB flash memory. The reading unit 15 is, for example, an optical drive or a USB terminal. The recording medium 16 records a computer program and various parameters, and by causing the reading unit 15 to read the recording medium 16, the computer program and various parameters are stored in the nonvolatile memory of the storage unit 13.

[0091] [1.6 Test environment]

[0092] Reference Figure 1 The test environment 40 has the above-mentioned information processing device 10 and a test group 42. The information processing device 10 controls the test group 42 based on the task Tx output from the queue 31, thereby executing the test of the task Tx. In addition, the information processing device 10 collects information such as the results of the test of the task Tx executed in the test group 42 (for example, the execution time of the test, the history indicating whether the test succeeded or failed), and outputs it to the memory 50.

[0093] The test group 42 is a hardware resource that simulates the formal environment of the software SW1. The software SW1 is so-called "embedded software" executed by the vehicle-mounted device, so in order to perform its operation test, it is necessary to use a hardware resource that simulates the formal environment such as the test group 42. Specifically, the test group 42 includes a circuit board 43 and a measuring unit 44.

[0094] The circuit board 43 (also referred to as a development board) is a board that simulates a circuit board assembled in a vehicle-mounted device (for example, a board mounted in an ECU). The circuit board 43 may be the circuit board assembled in the vehicle-mounted device itself, or a prototype of the circuit board assembled in the vehicle-mounted device. The measuring unit 44 is a tool for measuring the operation of the circuit board 43. The measuring unit 44 is, for example, a software tool for communication such as CANoe (registered trademark).

[0095] [1.7 Memory]

[0096] The memory 50 is an auxiliary storage device such as a HDD or an SSD. The memory 50 stores result information 51 and determination information 52. The result information 51 is information obtained as a result of executing the test of the task Tx. The result information 51 includes, for example, a product Px used in executing the test of the task Tx, version information D1, and test result information D2.

[0097] Figure 4Table TB1 is an example of version information D1 of the implementation mode. Version information D1 is information related to the version of the source code component at the time of executing the test of task Tx. For example, every time the information processing device 10 (specifically, the control unit 11) executes the test of task Tx, version information D1 is provided from the information processing device 10 to the memory 50. Version information D1 is represented, for example, as a hash value (i.e., a value uniquely determined for the source code component) assigned by the SCM to the source code component.

[0098] exist Figure 4 In the example, the version of module a1 at the execution time TM1 of the test (for example, the date and time when the test is executed) is represented by hash Ha1-1, and the version of module a2 at the execution time TM1 is represented by hash H2-1. Furthermore, the version of module a1 at the execution time TM2 after the execution time TM1 (the execution time closer to the current time) is represented by hash Ha1-2, and the version of module a2 at the execution time TM1 is represented by hash H2-1.

[0099] That is, at execution time TM2, the version of module a1 is updated from hash Ha1-1 to hash Ha1-2. Figure 4 In the example of , source code components other than module a1 are not updated during the period from execution time TM1 to execution time TM2. Therefore, module a1 is the most recently updated source code component among the plurality of source code components.

[0100] Figure 5 Table TB2 is an example of test result information D2 of the embodiment. Test result information D2 is information that associates task Tx with the test result of task Tx. Test results include failure (NG) and success (OK) of the test. Here, failure of the test includes, for example, a case where the expected measurement value is not satisfied in the measuring unit 44. In addition, success of the test includes, for example, a case where all the expected measurement values ​​are satisfied in the measuring unit 44.

[0101] exist Figure 5 The table TB2 stores the test results at each execution time TM1 and TM2. For example, each time the information processing device 10 executes the test of the task Tx, the test result information D2 is provided from the information processing device 10 to the memory 50. For example, it is shown that the integration test of the modules a1 and a2 fails at the execution time TM1 and succeeds at the execution time TM2. It is shown that the integration test of the modules a2 and a3 succeeds at the execution time TM1 and is not executed at the execution time TM2. In addition, it is shown that the integration test of the components X3 and X1 fails at both the execution times TM1 and TM2.

[0102] According to the test result information D2, the results of the most recent test can be obtained. For example, the most recent test result of the integration test of modules a1 and a2 is successful, and the most recent test result of the integration test of modules a2 and a3 is successful. On the other hand, the most recent test result of the integration test of components X3 and X1 is a failure. In addition, according to the test result information D2, information about the number of consecutive test failures in the past can be obtained. For example, the integration test of components X3 and X1 has failed twice in the past, counting from the most recent.

[0103] The determination information 52 is information for performing various determinations on the test execution of the task Tx, and includes, for example, file size information D3, safety standard information D4, and information on the time required for generating, registering, and reading the product Px.

[0104] Figure 6 Table TB3 shows an example of file size information D3 of the embodiment. File size information D3 is information about the file size of product Px used for testing task Tx. For example, file size information D3 is provided from information processing device 10 to memory 50 every time information processing device 10 executes the test of task Tx.

[0105] exist Figure 6 In the example, the file size of the product Px (hereinafter referred to as "product a1-a2") generated by integrating multiple modules a1 and a2 at the execution time TM1 is 10 [MB], and the file size of the product a1-a2 at the execution time TM2 is 12 [MB].

[0106] Figure 7 Table TB4 is an example of safety standard information D4 of the implementation mode. Safety standard information D4 is information related to the safety standard required for the source code component when the test of task Tx is executed. For example, every time the information processing device 10 executes the test of task Tx, the safety standard information D4 is provided from the information processing device 10 to the memory 50.

[0107] Safety standards are, for example, safety standards for vehicles, more specifically, automobiles. Safety standards are, for example, ASIL (Automotive Safety Integrity Level) of ISO26262. In ASIL, multiple levels such as QM, ASIL-A, ASIL-B, ASIL-C, and ASIL-D are set, and the required standards become stricter in this order. That is, the most relaxed conditions are required for QM, and the most stringent conditions are required for ASIL-D.

[0108] exist Figure 7In the example, the safety standard of module a1 at execution time TM1 is expressed as QM, and the safety standard of module a1 at execution time TM2 is expressed as ASIL-A. That is, it shows that module a1 is updated from execution time TM1 to execution time TM2 ( Figure 4 ), the safety standard has been raised to a higher level.

[0109] For source code components other than module a1, since there is no update from execution time TM1 to execution time TM2, the safety standard does not change. For example, the safety standard of modules a2, a3, b1, and b2 is QM, and the safety standard of component X3 is ASIL-D. In the safety standard information D4, by observing the most recent execution time (in Figure 7 The information of the safety standard at the execution time TM2 is included, and the safety standard required at the current time can be understood.

[0110] The determination information 52 includes information on the time taken to integrate the product Px integrated in the past (integration time T1). In addition, the determination information 52 includes information on the time taken to register the product Px registered in the memory 50 in the past (registration time T2). In addition, the determination information 52 includes information on the time taken to read the product Px read from the memory 50 in the past (reading time T3).

[0111] The integration time T1, the registration time T2, and the reading time T3 included in the determination information 52 may be values ​​based on actual time (measured values ​​or statistical values ​​of a plurality of measured values) or may be predicted values. In the case of predicted values, the integration time T1, the registration time T2, and the reading time T3 are predicted based on, for example, the file size of the product Px, the communication speed between the information processing device 10 and the memory 50, and the processing speed of the information processing device 10.

[0112] [1.8 Issues to be Solved by the Implementation Method]

[0113] The information processing system 1 includes a memory 50 (also referred to as a build cache server) for storing a product Px (intermediate product) generated by integrating a plurality of source code components. The memory 50 manages the product Px and the test results of the task Tx executed using the product Px by storing result information 51 in a table format, for example.

[0114] When the task Tx is tested in the information processing device 10, it is assumed that the control unit 11 generates a product Px by integrating a plurality of source code components each time the task Tx is input without the memory 50. However, since the integration of the product Px takes time in the control unit 11, the test execution of the task Tx may take time.

[0115] Therefore, the information processing system 1 includes a memory 50 for storing past products Px and test results. When a task Tx is input to the control unit 11, the control unit 11 inquires whether the memory 50 stores a product Px related to the task Tx and whether the past test result of the product Px was successful.

[0116] Furthermore, the control unit 11 shortens the time required for test execution by skipping the execution of the test based on the input task Tx when the past test result is successful. In addition, even when the past test result is unsuccessful (when the test result is a failure or there is no test result), the control unit 11 reads the product Px of the past integration from the memory 50 when the product Px is stored, thereby shortening the time required for integration.

[0117] In order to achieve the above-mentioned time reduction, the control unit 11 integrates a plurality of source code components to generate a product Px, and then stores the product Px in the memory 50. When the test is executed, the test result is stored in the memory 50.

[0118] In recent years, as software development has become larger in scale, the types of tests to be executed have increased, or the file size of the product Px used for one test has increased. Therefore, if all the products Px are stored in the memory 50, the following problems arise.

[0119] (Issue 1) When the file size of the product Px is relatively large, the time for transmitting and receiving the product Px between the information processing device 10 and the memory 50 becomes longer. As a result, the total time (T2+T3) of the communication time for registering the product Px previously generated by the control unit 11 in the memory 50 (registration time T2) and the communication time for reading the product Px registered in the memory 50 from the control unit 11 (reading time T3) may become longer than the time (integration time T1) for integrating a plurality of source code components to newly generate the product Px (T1<T2+T3). In this case, the efficiency of executing the test is deteriorated by registering and reading the product Px in the memory 50.

[0120] (Problem 2) Registering more products Px in the memory 50 or registering products Px with large file sizes in the memory 50 may cause the capacity (for example, disk capacity) of the memory 50 to be insufficient, making it impossible to re-register products Px with relatively high priority.

[0121] In order to solve the above-mentioned (problem 1) and (problem 2), in the information processing system 1 of the embodiment, the memory 50 further stores the determination information 52. In addition, the information processing device 10 further includes a determination unit 12. In addition, when the control unit 11 receives the input of the task Tx, the determination unit 12 determines whether to regenerate the product Px and whether to register the regenerated product Px in the memory 50 based on the determination information 52. Based on the determination result of the determination unit 12, the control unit 11 regenerates the product Px, reads the past product Px from the memory 50, or registers the generated product Px in the memory 50.

[0122] In this way, in the information processing system 1, instead of uniformly registering all the products Px in the memory 50, it is determined whether the product Px needs to be registered according to the situation, thereby improving the efficiency of the registration time. In addition, in the information processing system 1, even if the product Px has already been registered in the memory 50, the product Px can be newly generated according to the situation, thereby improving the efficiency of the reading time. In this way, according to the information processing system 1, when the development method based on CI / CD is adopted, by shortening the time spent on executing the test, the test can be executed more efficiently.

[0123] The following describes specific steps of the information processing method executed by the information processing system 1 .

[0124] [1.9 Information processing method]

[0125] Figure 8 1 is a flowchart showing an example of an information processing method executed by the information processing system 1. In the information processing system 1, first, a task Tx to be tested is input to the control unit 11 (task input process: step S100).

[0126] Fig. 9 It is a subroutine that shows the details of the task input process. First, the developer creates a plurality of source code components through the terminal group 60, and stores the plurality of source code components in the repository 20 via the network (step S21). The plurality of source code components are stored in the repository 20 at appropriate times.

[0127] The SCM managing the repository 20 creates a task Tx (step S22), for example, periodically (also referred to as a polling process) or when a new source code component is stored in the repository 20 (also referred to as a push process). For example, in a state where modules a1, a2, a3, b1, b2, and component X3 are already stored in the repository 20, when a new version of module a1 is stored in the repository 20, the SCM creates a task Tx associated with module a1.

[0128] For example, the SCM creates a task Tx for executing an integration test of modules a1 and a2, a task Tx for executing an integration test of modules a1 and a3, a task Tx for executing a test of component X1, and a task Tx for executing an integration test including component X1 (e.g., an integration test of components X1 and X2). In addition, the SCM automatically creates tasks Tx related to software SW1 on a regular basis even if the source code component is not updated.

[0129] Then, the produced one or more tasks Tx are provided by the SCM from the storage library 20 to the queue 31 (step S23 ).

[0130] The test tool 30 outputs the task Tx accumulated in the queue 31 to the information processing device 10 by, for example, the FIFO method (step S24). The communication unit 14 of the information processing device 10 outputs the task Tx received from the test tool 30 to the control unit 11. As described above, the task Tx is input to the control unit 11, and step S100 ends.

[0131] Reference Figure 8 When accepting input of a new task Tx, the control unit 11 reads the result information 51 from the memory 50 (step S101 ).

[0132] Next, the control unit 11 determines whether the same product Px as the product Px integrated from the source code component that is the basis of the task Tx is already registered in the memory 50 (step S102 ).

[0133] Specifically, the control unit 11 reads the version information D1 included in the result information 51. Then, it is determined whether the hash values ​​of all source code components that are the basis of the input task Tx match the hash values ​​of the corresponding source code components stored in the version information D1.

[0134] If the hash value of at least one of all the source code components that are the basis of the task Tx does not match, the product Px that is the same as the product Px integrated from the source code component that is the basis of the task Tx is not registered in the memory 50 (No in step S102). That is, the product Px predetermined for test execution is different from the product Px registered in the memory 50. Therefore, it is not appropriate to use the product Px registered in the memory 50 instead.

[0135] For example, consider the following case: As a result of updating module a1, a task Tx (hereinafter referred to as "task a1-a2") related to a test item for verifying whether the product Px of modules a1 and a2 is integrated and operated is created in the SCM. In this case, for example, module a1 has a new hash value Ha1-3. The latest hash value of module a1 registered in the memory 50 is as follows: Figure 4 In the case of "Ha1-2", the hash value of the source code component included in the newly input task a1-a2 does not match the hash value of the source code component registered in the memory 50, so the control unit 11 determines that the product Px integrated from the source code component that is the basis of the newly input task a1-a2 is not registered in the memory 50. In this case, the control unit 11 proceeds to the integration process (step S105) described later.

[0136] On the other hand, consider a case where tasks a1-a2 that are regularly created in the SCM are input to the control unit 11 without using the update of the source code component as a trigger. In this case, for example, module a1 has the same hash value Ha1-2 as that at the time of the last test execution (execution time TM2). In addition, module a2 also has the same hash value Ha2-1 as that at the execution time TM2. Therefore, since the hash values ​​of all the source code components included in the newly input tasks a1-a2 are consistent with the hash values ​​of the corresponding source code components registered in the memory 50, the control unit 11 determines that the product Px integrated by the source code components that are the basis of the newly input tasks a1-a2 is registered in the memory 50.

[0137] When the product Px related to the newly input task Tx is registered in the memory 50 (Yes in step S102 ), the control unit 11 determines whether a successful test result based on the input task Tx is registered in the memory 50 (step S103 ).

[0138] Specifically, the control unit 11 reads the test result information D2 included in the result information 51. Then, the control unit 11 confirms whether the most recent test result based on the newly input task Tx is successful based on the test result information D2. Figure 5 As shown, the most recent test result (i.e., the test result at execution time TM2) of task a1-a2 is successful. In this case (Yes in step S103), the control unit 11 enters the end determination process (step S110) described later, and reuses the past test result. In this case, the information processing system 1 omits the integration process (step S105) and the test process (step S108) described later, so the time taken to execute the test of task Tx can be shortened.

[0139] In the test result information D2 , when the latest test result based on the newly input task Tx is a failure, or when there is no past test result based on the newly input task Tx (No in step S103 ), the process proceeds to the next step S104 .

[0140] If the most recent test result based on the newly input task Tx in the test result information D2 is unsuccessful, the determination unit 12 determines whether to read the product Px from the memory 50 based on the determination information 52 (step S104 ).

[0141] Specifically, the determination unit 12 reads the determination information 52 from the memory 50. Then, the determination unit 12 determines whether the read condition is satisfied with respect to the product Px generated by integrating the plurality of source code components that are the basis of the task Tx, based on the determination information 52. Here, the read condition is at least one of the following first to third read conditions. The determination unit 12 may also determine that the read condition is satisfied when one of the first to third read conditions is satisfied. In addition, the determination unit 12 may also determine that the read condition is satisfied only when multiple conditions (for example, the first and second read conditions) among the first to third read conditions are satisfied.

[0142] The first reading condition is that the file size of the product Px stored in the memory 50, that is, the product Px used in the past test, is smaller than the specified amount M1. The second reading condition is that the safety standard required for the product Px exceeds the specified level L1. The third reading condition is that the difference (T1-T3) obtained by subtracting the reading time T3 of the product Px from the memory 50 from the integration time T1 of integrating the plurality of source code components exceeds the specified value E1 (T1-T3>E1).

[0143] The determination unit 12 determines whether the first read condition is satisfied based on the file size information D3 included in the determination information 52. For example, when the determination target is the product a1-a2, the determination unit 12 determines the file size of the most recent product a1-a2 (in Figure 6 In the example, 12 [MB]) is compared with the predetermined amount M1. Then, when the file size of the product a1-a2 is smaller than the predetermined amount M1 (12<M1 [MB]), the determination unit 12 determines that the first read condition is satisfied.

[0144] If the file size of the product Px is small, the reading time T3 for reading from the memory 50 can be kept short. Therefore, in the case of a product Px whose file size is smaller than the predetermined amount M1, it is determined that the first reading condition is satisfied, and the product Px is read from the memory 50, thereby preventing the reading time T3 from becoming longer.

[0145] Here, the prescribed amount M1 may be a fixed value or a variable value depending on the situation (for example, depending on the allowed reading time T3). For example, the prescribed amount M1 may be changed so that the prescribed amount M1 increases as the allowed reading time T3 increases. The prescribed amount M1 is stored in the storage unit 13 as a parameter, for example.

[0146] The determination unit 12 determines whether the second read condition is satisfied based on the safety standard information D4 included in the determination information 52. For example, when the determination object is the product a1-a2, the safety standard required for the most recent product a1-a2 becomes "ASIL-A" of the module a1 that requires a stricter safety standard among the modules a1 and a2. In this case, the determination unit 12 compares ASIL-A with the prescribed level L1. Furthermore, when the safety standard (ASIL-A) required for the product a1-a2 exceeds the prescribed level L1 (ASIL-A>L1), the determination unit 12 determines that the second read condition is satisfied.

[0147] A product Px with a high safety standard has a high benchmark required for testing and is prone to failure. Therefore, there is a tendency to frequently execute tests for products Px with a high safety standard. By configuring so that, in the case of a product Px whose required safety benchmark exceeds a predetermined level L1, it is determined that the second read condition is satisfied, and the product is read from the memory 50 with higher priority, the integration time T1 for integrating the source code component to generate the product Px can be shortened.

[0148] Here, the prescribed level L1 is a level such as QM, ASIL-A, etc. The prescribed level L1 may be a fixed value or a variable value according to the situation. For example, the prescribed level L1 may be changed so that the prescribed level L1 decreases as the allowed reading time T3 becomes longer. The prescribed level L1 is stored in the storage unit 13 as a parameter, for example.

[0149] The determination unit 12 determines whether the third reading condition is satisfied based on the various times T1 and T3 included in the determination information 52. For example, when the determination object is the product a1-a2, the determination unit 12 compares the difference (T1-T3) obtained by subtracting the reading time T3 of the product a1-a2 from the integration time T1 of the product a1-a2 with the prescribed value E1. Then, when the difference exceeds the prescribed value E1 (T1-T3>E1), the determination unit 12 determines that the third reading condition is satisfied.

[0150] For example, when the read time T3 is shorter than the integration time T1, the time can be shortened by reading the product Px from the memory 50 instead of integrating it from the source code component. Therefore, when the difference (T1-T3) is larger, the product Px is preferentially read from the memory 50, thereby shortening the time required for test execution.

[0151] Here, the predetermined value E1 may be a fixed value or a variable value depending on the situation. For example, the predetermined value E1 may be changed so that the predetermined value E1 decreases as the allowed reading time T3 increases. The predetermined value E1 is stored in the storage unit 13 as a parameter, for example.

[0152] Through the above, the determination unit 12 generates a determination result of whether the read condition is satisfied. Then, the determination unit 12 outputs the determination result to the control unit 11. When the determination result of the determination unit 12 is "the read condition is satisfied", the control unit 11 reads the product Px from the memory 50 (Yes in step S104). In this case, the control unit 11 then uses the read product Px to perform the test process described later (step S108).

[0153] On the other hand, if the determination result of the determination unit 12 is "the read condition is not satisfied", the control unit 11 does not read the generated product Px from the memory 50 (No in step S104). In this case, the control unit 11 integrates a plurality of source code components based on the input task Tx to regenerate the generated product Px (step S105).

[0154] After step S105, the determination unit 12 determines whether to register the newly generated product Px in the memory 50 (step S106). Specifically, the determination unit 12 determines whether the following registration conditions are satisfied based on the newly generated product Px. Here, the registration condition is at least one of the following first to third registration conditions.

[0155] The determination unit 12 may determine that the registration condition is satisfied when one of the first to third registration conditions is satisfied. Furthermore, the determination unit 12 may determine that the registration condition is satisfied only when multiple conditions (for example, the first registration condition and the second registration condition) among the first to third registration conditions are satisfied.

[0156] First registration condition: By integrating the plurality of source code components based on the input task Tx, the file size of the newly generated product Px is less than a specified amount M2. Second registration condition: The safety standard required for the product Px exceeds a specified level L2. Third registration condition: The difference (T1-(T2+T3)) obtained by subtracting the total time (T2+T3) between the registration time T2 of registering the newly generated product Px in the memory 50 and the reading time T3 of reading the product Px from the memory 50 from the integration time T1 of integrating the plurality of source code components exceeds a specified value E2 (T1-(T2+T3)>E2).

[0157] For example, when the determination target is a newly generated product a1-a2, the determination unit 12 compares the file size of the product a1-a2 with the predetermined amount M2. If the file size of the product a1-a2 is smaller than the predetermined amount M2, the determination unit 12 determines that the first registration condition is satisfied.

[0158] If the file size of the product Px is small, the registration time T2 for registering in the memory 50 can be kept short. Therefore, in the case of a product Px whose file size is smaller than the predetermined amount M2, it is determined that the first registration condition is satisfied, and the product Px is registered in the memory 50, thereby preventing the registration time T2 from being prolonged.

[0159] Here, the prescribed amount M2 may be a fixed value or a variable value depending on the situation. For example, the prescribed amount M2 may be changed so that the longer the allowed registration time T2 is, the larger the prescribed amount M2 is. The prescribed amount M2 is stored in the storage unit 13 as a parameter, for example. The prescribed amount M2 may be the same value as the prescribed amount M1 or a different value.

[0160] The determination unit 12 determines whether the second read condition is satisfied based on the safety standard required for the newly generated product Px. Specifically, the determination unit 12 compares the safety standard required for the newly generated product Px with the prescribed level L2. Then, when the safety standard required for the product Px exceeds the prescribed level L2, the determination unit 12 determines that the second read condition is satisfied.

[0161] The product Px with a high safety standard has a high benchmark required for testing and is prone to failure. Therefore, there is a tendency to frequently execute tests for the product Px with a high safety standard. By configuring so that when the required safety benchmark is a product Px exceeding the prescribed level L2, it is determined that the second registration condition is satisfied and the product Px is registered in the memory 50 with higher priority, more products Px with a high safety standard can be stored in the memory 50. As a result, in step S102, the registration rate of the product Px in the memory 50 relative to the input task Tx can be increased, and the frequency of integration processing can be reduced.

[0162] Here, the prescribed level L2 is a level such as QM, ASIL-A, etc. The prescribed level L2 may be a fixed value or a variable value depending on the situation. For example, the prescribed level L2 may be changed in such a way that the longer the allowed registration time T2 is, the lower the prescribed level L2 is. The prescribed level L2 is stored in the storage unit 13 as a parameter, for example. In addition, the prescribed level L2 may be the same value as the prescribed level L1 or a different value.

[0163] The determination unit 12 determines whether the third registration condition is satisfied based on various times T1, T2, and T3. The determination unit 12 compares the difference (T1-(T2+T3)) obtained by subtracting the total time (T2+T3) of the registration time T2 and the reading time T3 required to predict the product Px from the integration time T1 of the newly generated product Px with the prescribed value E2. Then, the determination unit 12 determines that the third registration condition is satisfied when the difference exceeds the prescribed value E2 (T1-(T2+T3)>E2).

[0164] For example, when the total time (T2+T3) is shorter than the integration time T1, the newly generated product Px is registered in the memory 50 and then read from the memory 50, which can shorten the time compared to the case where the same product Px is newly integrated from the source code component later. Therefore, by configuring so that the product Px is preferentially registered in the memory 50 when the difference (T1-(T2+T3)) is larger, the time taken to execute the test can be shortened.

[0165] Here, the prescribed value E2 may be a fixed value or a variable value depending on the situation. For example, the prescribed value E2 may be changed so that the longer the allowed registration time T2 is, the smaller the prescribed value E2 is. The prescribed value E2 is stored in the storage unit 13 as a parameter, for example.

[0166] As described above, the determination unit 12 generates a determination result of whether the registration condition is satisfied. Then, the determination unit 12 outputs the determination result to the control unit 11. When the determination result of the determination unit 12 is "the registration condition is satisfied" (Yes in step S106), the control unit 11 registers the newly generated product Px in the memory 50 (step S107).

[0167] On the other hand, when the determination result of the determination unit 12 is "registration conditions are not satisfied" (No in step S106), the control unit 11 skips step S107 and performs a test process (step S108). That is, when the determination result of the determination unit 12 is "registration conditions are not satisfied", the control unit 11 does not register the newly generated product Px in the memory 50.

[0168] Next, the control unit 11 performs a test process (step S108). Specifically, the test of the task Tx is performed using the product Px read from the memory 50 or the newly generated product Px. The control unit 11 controls the circuit board 43 based on the task Tx, and measures the operation of the circuit board 43 through the measuring unit 44. Then, based on the measurement result of the measuring unit 44, it is determined whether the test of the task Tx is successful.

[0169] After step S108, the control unit 11 registers the test result of the task Tx in the memory 50 (step S109). The test result is, for example, Figure 5 The test result information D2 shown is stored in the memory 50 in a table format.

[0170] Finally, the control unit 11 determines whether a series of information processing is completed (completion determination process: step S110 ). Specifically, the control unit 11 determines whether there is another input of a task Tx from the queue 31 .

[0171] For example, in step S100, a plurality of tasks Tx are input to the control unit 11. When the information processing of steps S101 to S109 is performed on the first task Tx, the process returns to step S101 in order to perform the information processing of steps S101 to S109 on the second task Tx (No in step S110). When no other task Tx to be processed is input to the control unit 11, a series of information processing is terminated (Yes in step S110).

[0172] Thus, a series of information processing methods in the information processing system 1 are completed. According to the information processing method, the time taken to execute the test can be made more efficient by registering or reading the product Px according to the situation instead of registering or reading the product Px uniformly.

[0173] [2. Modifications]

[0174] Hereinafter, a modification of the embodiment will be described. In the modification, the same reference numerals are given to the same components as those of the above-described embodiment, and description thereof will be omitted.

[0175] [2.1 Consider the free capacity of memory]

[0176] In step S106, the determination unit 12 may also modify various parameters M2, L2, and E2 according to the free capacity of the memory 50. For example, when the free capacity of the memory 50 is the first capacity C1, the determination unit 12 sets the prescribed amount M2 of the first registration condition to the first prescribed amount M21, sets the prescribed level L2 of the second registration condition to the first level L21, and sets the prescribed value E2 of the third registration condition to the first prescribed value E21, to determine whether the registration condition is satisfied.

[0177] On the other hand, when the free capacity of the memory 50 is a second capacity C2 which is smaller than the first capacity C1 (C2<C1), the determination unit 12 sets the prescribed amount M2 of the first registration condition to a second prescribed amount M22 which is smaller than the first prescribed amount M21, sets the prescribed level L2 of the second registration condition to a second prescribed level L22 which is higher than the first level L21, and sets the prescribed value E2 of the third registration condition to a second prescribed value E22 which is larger than the first prescribed value E21, to determine whether the registration condition is satisfied (M22<M21, L22>L21, E22>E21).

[0178] That is, the smaller the free capacity of the memory 50 is, the stricter the registration condition is, and the products Px to be registered are limited to products Px with higher priority. This makes it possible to more effectively use the remaining less capacity of the memory 50.

[0179] In the above, an example is described in which the conditions of all the first to third registration conditions are made stricter according to the free capacity of the memory 50. However, the condition of at least one of the first to third registration conditions may be made stricter according to the free capacity of the memory 50. For example, the determination unit 12 may set the prescribed amount M2 of the first registration condition to be higher according to the free capacity of the memory 50, and set the prescribed level L2 and the prescribed value E2 in the second and third registration conditions to fixed values ​​regardless of the free capacity of the memory 50.

[0180] [2.2 Deleting the generated items registered in the memory]

[0181] In step S107, the control unit 11 may delete the product Px already registered in the memory 50 when registering the newly generated product Px in the memory 50. In this case, for example, the control unit 11 leaves the product Px with a higher required safety standard in the memory 50.

[0182] Specifically, when the safety standard required for the product Px already registered in the memory 50 is the first level L21, and the safety standard required for the newly registered predetermined product Px is the second level L22 which is higher than the first level L21, the control unit 11 deletes the already registered product Px from the memory 50 and registers the newly generated product Px in the memory 50.

[0183] With such a configuration, for example, even when the remaining capacity of the memory 50 becomes low, the product Px requiring a stricter safety standard and a higher priority can be registered in the memory 50 .

[0184] [3. Notes]

[0185] The present disclosure includes the contents shown in the following supplementary notes.

[0186] [Note 1]

[0187] An information processing device assists in the development of software by executing tests on tasks generated based on multiple source code components included in the software, wherein the information processing device includes a control unit that integrates the multiple source code components that form the basis of the task to generate a product and uses the product to execute the test of the task, and the control unit registers the product in a memory when a registration condition is met, and does not register the product in the memory when the registration condition is not met.

[0188] Here, the registration condition is at least one of the following first to third registration conditions. First registration condition: the file size of the product is smaller than a prescribed amount. Second registration condition: the security standard required for the product exceeds a prescribed level. Third registration condition: the difference obtained by subtracting the total time of registering the product in the memory and the time of reading the product from the memory from the integration time of integrating the plurality of source code components exceeds a prescribed value.

[0189] [Note 2]

[0190] An information processing method assists in the development of software by executing a test of a task generated based on a plurality of source code components included in the software, the information processing method comprising: a first step of integrating a plurality of the source code components that form the basis of the task to generate a product when a read condition is not satisfied; a second step of using the product to execute the test of the task; a third step of registering the product in a memory; and a fourth step of reading from the memory the product generated in the first step executed in the past when the read condition is satisfied.

[0191] Here, the read condition is at least one of the following first to third read conditions. First read condition: the file size of the product is less than a specified amount. Second read condition: the security standard required for the product exceeds a specified level. Third read condition: the difference obtained by subtracting the read time of the product from the memory from the integration time of integrating the plurality of source code components exceeds a specified value.

[0192] [Note 3]

[0193] A computer program for assisting the development of software by executing a test of a task generated based on a plurality of source code components included in the software, wherein the computer program causes a computer to execute the following steps: a first step of integrating a plurality of source code components that are the basis of the task to generate a product when a read condition is not satisfied; a second step of executing the test of the task using the product; a third step of registering the product in a memory; and a fourth step of reading from the memory the product generated in the first step executed in the past when the read condition is satisfied.

[0194] Here, the read condition is at least one of the following first to third read conditions. First read condition: the file size of the product is less than a specified amount. Second read condition: the security standard required for the product exceeds a specified level. Third read condition: the difference obtained by subtracting the read time of the product from the memory from the integration time of integrating the plurality of source code components exceeds a specified value.

[0195] [Note 4]

[0196] A computer program for assisting the development of software by executing tests of tasks generated based on multiple source code components included in the software, wherein the computer program causes a computer to execute the following steps: a first step of integrating the multiple source code components that form the basis of the task to generate a product; a second step of using the product to execute the test of the task; and a third step of registering the product in a memory if a registration condition is met, and not registering the product in the memory if the registration condition is not met.

[0197] Here, the registration condition is at least one of the following first to third registration conditions. First registration condition: the file size of the product is smaller than a prescribed amount. Second registration condition: the security standard required for the product exceeds a prescribed level. Third registration condition: the difference obtained by subtracting the total time of registering the product in the memory and the time of reading the product from the memory from the integration time of integrating the plurality of source code components exceeds a prescribed value.

[0198] [4. Supplementary Note]

[0199] In addition, about the above-mentioned embodiment and various modification examples, at least a part of them can also be arbitrarily combined with each other. In addition, it should be considered that the embodiment and modification examples disclosed this time are illustrative and non-restrictive in all aspects. The scope of the present disclosure is represented by the claims, and it is intended to include all changes within the meaning and scope equivalent to the claims.

[0200] Description of Reference Numerals

[0201] 1 Information Processing System

[0202] 10 Information processing device

[0203] 11. Control Unit

[0204] 12. Judgment Department

[0205] 13 Storage

[0206] 14 Ministry of Communications

[0207] 15 Reading unit

[0208] 16 Recording Media

[0209] 20 Repositories

[0210] 30 Testing Tools

[0211] 31 Queue

[0212] 40 Test Environment

[0213] 42 Test Group

[0214] 43 Circuit board

[0215] 44 Measurement Department

[0216] 50 Memory

[0217] 51 Result Information

[0218] 52 Determination information

[0219] 60 terminal groups

[0220] SW1 Software

[0221] a1, a2, a3, b1, b2 modules

[0222] X1, X2, X3 components

[0223] Px products

[0224] Tx, T1, T2, T3, T4 tasks

[0225] D1 Version Information

[0226] D2 Test Result Information

[0227] D3 file size information

[0228] D4 Safety Standard Information

[0229] TB1, TB2, TB3, TB4 tables

[0230] TM1, TM2 execution time

[0231] T1 Integration time

[0232] T2 Registration Time

[0233] T3 Reading time

[0234] M1, M2 Required amount

[0235] M21 The first specified amount

[0236] M22 Second specified amount

[0237] L1, L2 regulated levels

[0238] L21 First Level

[0239] L22 Second Level

[0240] E1, E2 Specified values

[0241] E21 First specified value

[0242] E22 Second specified value

Claims

1. An information processing system for assisting the development of software by executing tests of tasks generated based on a plurality of source code components included in the software, wherein: The information processing system includes a control unit that integrates the plurality of source code components that are the basis of the task to generate a product, and executes a test of the task using the product. The control unit registers the product in the memory when a registration condition is satisfied, and does not register the product in the memory when the registration condition is not satisfied. The registration condition is at least one of the following first to third registration conditions: The first registration condition: the file size of the generated product is less than a specified amount, Second registration condition: the safety standard required for the product exceeds the prescribed level, Third registration condition: a difference obtained by subtracting a total time of registering the product in the memory and a time of reading the product from the memory from an integration time of integrating the plurality of source code components exceeds a predetermined value.

2. The information processing system according to claim 1, wherein: The information processing system further includes a determination unit configured to determine whether the registration condition is satisfied. The control unit determines whether to register the product in the memory based on a determination result of the determination unit.

3. The information processing system according to claim 2, wherein: The determination unit determines whether the registration condition is satisfied by setting the prescribed amount of the first registration condition to a first prescribed amount, setting the level of the second registration condition to a first level, or setting the prescribed value of the third registration condition to a first prescribed value when the free capacity of the memory is a first capacity. The determination unit determines whether the registration condition is satisfied by setting the prescribed amount of the first registration condition to a second prescribed amount that is smaller than the first prescribed amount, setting the level of the second registration condition to a second level that is higher than the first level, or setting the prescribed value of the third registration condition to a second prescribed value that is higher than the first prescribed value, when the free capacity of the memory is a second capacity that is smaller than the first capacity.

4. The information processing system according to claim 1, wherein: When the registration condition is satisfied, the control unit deletes the product whose rank is the first rank and has been registered in the memory, and re-registers the product whose rank is the second rank higher than the first rank in the memory.

5. The information processing system according to claim 1, wherein: The software is software executed by an onboard device installed in a vehicle, The safety standard is ASIL (Automotive Safety Integrity Level) of ISO26262.

6. The information processing system according to any one of claims 1 to 5, wherein: When the task is input to the control unit, the control unit reads the product generated when the task was input to the control unit in the past from the memory if a read condition is satisfied, and regenerates the product based on the task input to the control unit this time if the read condition is not satisfied. The read condition is at least one of the following first to third read conditions: The first reading condition: the file size of the generated object is smaller than a specified amount, Second reading condition: the safety standard required by the product exceeds the prescribed level, A third reading condition: a difference obtained by subtracting a reading time of the product from the memory from an integration time of integrating the plurality of source code components exceeds a prescribed value.

7. An information processing system for assisting the development of software by executing tests of tasks generated based on a plurality of source code components included in the software, wherein: The information processing system includes a control unit that integrates the plurality of source code components that are the basis of the task to generate a product, registers the product in a memory, and executes a test of the task using the product. When the task is input to the control unit, the control unit reads the product generated when the task was input to the control unit in the past from the memory if a read condition is satisfied, and regenerates the product based on the task input to the control unit this time if the read condition is not satisfied. The read condition is at least one of the following first to third read conditions: The first reading condition: the file size of the generated object is smaller than a specified amount, Second reading condition: the safety standard required by the product exceeds the prescribed level, A third reading condition: a difference obtained by subtracting a reading time of the product from the memory from an integration time of integrating the plurality of source code components exceeds a prescribed value.

8. An information processing method for assisting the development of software by executing a test of a task generated based on a plurality of source code components included in the software, wherein: The information processing method comprises: The first step is to integrate the plurality of source code components that are the basis of the task to generate a product; The second step is to use the generated object to perform the test of the task; and The third step is to register the generated product in the memory if the registration condition is met, and not to register the generated product in the memory if the registration condition is not met. The registration condition is at least one of the following first to third registration conditions: The first registration condition: the file size of the generated product is less than a specified amount, Second registration condition: the safety standard required for the product exceeds the prescribed level, Third registration condition: a difference obtained by subtracting a total time of registering the product in the memory and a time of reading the product from the memory from an integration time of integrating the plurality of source code components exceeds a predetermined value.

Images