Information processing system, information processing method, and computer program

Abstract

An information processing system that assists the development of software to be executed in a vehicle-mounted device is provided with a control unit that adds a task provided from a repository in which a plurality of source code components included in the software are stored to a queue in which the task is to be tested. The control unit reads priority information including information relating to the task from a memory in which priority information is stored, calculates the priority of the task on the basis of the priority information, and controls the priority of the task on the basis of the priority information. The control unit compares the priorities of the tasks accumulated in the queue with the priorities of the tasks to be newly added to the queue, and adds the tasks to the queue in a state in which the execution order of the tasks having higher priorities is in the front.

Description

Technical Field

[0001] The present disclosure relates to an information processing system, an information processing method, and a computer program. This application claims priority based on Japanese application No. 2022-155082 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 operated in an integrated state as a single software, errors may occur. In this case, it is necessary to verify which combination of source code components has caused the error, so operation testing 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 preventing 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 a technique for changing the order of execution target information in an automatic execution queue based on a priority attribute or the like included in attribute information of a ticket corresponding to a source code.

[0008] Prior art literature

[0009] Patent Literature

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

[0011] Patent Document 2: Japanese Patent Application Publication No. 2021-105866 Summary of the invention

[0012] The information processing system disclosed herein is an information processing system for assisting the development of software executed in a vehicle-mounted device, and includes a control unit that adds a task to a queue in which the task is waiting for execution testing, the task being provided from a repository storing a plurality of source code components included in the software, the control unit reading priority information from a memory storing priority information, the priority information including information related to the task, the control unit calculating the priority of the task based on the priority information, the control unit comparing the priority of the tasks already accumulated in the queue with the priority of the task to be newly added to the queue, and adding the task to the queue in a state in which the execution order of the task with the higher priority is brought forward.

[0013] The information processing method disclosed herein is an information processing method for assisting the development of software executed in a vehicle-mounted device, including the step of adding a task to a queue in which the task is waiting to be tested, the task being provided from a repository storing a plurality of source code components included in the software, the step of adding the task including: a first step of reading the priority information from a memory storing the priority information, the priority information including information related to the task; a second step of calculating the priority of the task based on the priority information; and a third step of comparing the priority of the tasks already accumulated in the queue with the priority of the task to be newly added to the queue, and adding the task to the queue in a state in which the execution order of the task with the higher priority is brought forward.

[0014] The computer program disclosed herein is a computer program for assisting the development of software executed in a vehicle-mounted device, the computer program causing a computer to execute a step of adding a task to a queue in which the task is waiting to be tested, the task being provided from a repository storing a plurality of source code components included in the software, the step of performing the adding comprising: a first step of reading the priority information from a memory storing the priority information, the priority information including information related to the task; a second step of calculating the priority of the task based on the priority information; and a third step of comparing the priority of the tasks already accumulated in the queue with the priority of the task to be newly added to the queue, and adding the task to the queue in a state in which the execution order of the task with the higher priority is brought forward. BRIEF DESCRIPTION OF THE DRAWINGS

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

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

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

[0018] [ Figure 4 ] Figure 4 This is a diagram showing an example of a test environment according to an embodiment.

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

[0020] [ Figure 6 ] Figure 6 This is a table showing an example of execution time information of the implementation mode.

[0021] [ Figure 7 ] Figure 7 This is a table showing an example of required time information in the implementation mode.

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

[0023] [ Fig. 9 ] Fig. 9 This is a table showing an example of safety standard information according to the implementation mode.

[0024] [ Fig.10 ] Fig.10 This is a table showing an example of environmental information according to the embodiment.

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

[0026] [ Fig.12 ] Fig.12 This is a flowchart showing an information processing method according to a modified example.

[0027] [ Fig.13 ] Fig.13 This is a diagram for explaining the priority of each task in a modified example.

[0028] [ Fig.14 ] Fig.14 This is a table showing test result information of the modified example. DETAILED DESCRIPTION

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

[0030] The scale of software executed by devices installed in vehicles such as automobiles (on-board devices) has increased year by year, and the development method based on CI / CD has also been adopted for software used in on-board devices.

[0031] Here, in the case of software for vehicle-mounted devices, in order to perform an action test of a task, hardware resources such as a circuit board for development and a measuring tool are required. If a plurality of such hardware resources are provided, the construction of a test environment is expensive, and therefore the number of hardware resources is limited. Therefore, in software for vehicle-mounted devices, it is difficult to perform a plurality of action tests in parallel, and it is required to find the correction point of the software more quickly by performing a test from a task with a higher priority.

[0032] In view of such a problem, an object of the present disclosure is to provide an information processing system, an information processing method, and a computer program capable of executing a test from a task with a higher priority.

[0033] [Effects of the invention]

[0034] According to the present disclosure, it is possible to execute tests from a higher priority task.

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

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

[0037] (1) The information processing system disclosed herein is an information processing system for assisting the development of software executed in an in-vehicle device, comprising a control unit, the control unit adding a task to a queue in which the task is waiting for execution testing, the task being provided from a repository storing a plurality of source code components included in the software, the control unit reading priority information from a memory storing priority information, the priority information including information related to the task, the control unit calculating the priority of the task based on the priority information, the control unit comparing the priorities of the tasks already accumulated in the queue with the priorities of the tasks to be newly added to the queue, and adding the task to the queue in a state in which the execution order of the task with the higher priority is placed first.

[0038] With this configuration, it is possible to preferentially execute tests starting with tasks with higher priorities.

[0039] (2) In the information processing system of (1) above, the vehicle-mounted device may include a vehicle-mounted ECU.

[0040] Software development for automotive ECUs tends to be large-scale, so it is particularly useful to prioritize testing from higher priority tasks.

[0041] (3) In the information processing system of (1) or (2) above, the priority information may include information related to at least one of a test environment, a result of a past test of the task, an execution time of a past test of the task, and a time required for a past test of the task.

[0042] Since the test environment and the like are included in the priority information, it is possible to determine an appropriate priority corresponding to the task.

[0043] (4) In the information processing system described in any one of (1) to (3) above, the priority information may include information on a safety standard of the vehicle required for the mission.

[0044] Since the priority information includes information on the safety standard of the vehicle, it is possible to determine an appropriate priority according to the type of vehicle and the vehicle-mounted device mounted on the vehicle.

[0045] (5) In the information processing system of (3) above, the task may include a first task and a second task, and the most recent execution time of the second task may be earlier than the most recent execution time of the first task. In this case, the control unit may calculate the priority of the second task to be higher than the priority of the first task.

[0046] By executing the test earlier on the task that has not been tested yet, it is possible to suppress the scale of source code component correction from increasing.

[0047] (6) In the information processing system of (3) or (5), the task may include a first task and a second task, and the time required for the second task is shorter than the time required for the first task. In this case, the control unit may calculate the priority of the second task to be higher than the priority of the first task.

[0048] By executing the tests preferentially starting with tasks that can be executed in a short time, the number of tests executed per unit time can be increased, and the number of tasks waiting to be executed can be reduced.

[0049] (7) In the information processing system of (3), (5) or (6), the tasks may include a first task whose most recent result is success and a second task whose most recent result is failure. In this case, the control unit may calculate the priority of the second task to be higher than the priority of the first task.

[0050] By prioritizing the execution of tests starting with the failed tasks, it is possible to confirm earlier whether the errors have been eliminated.

[0051] (8) In the information processing system of (3), (5), (6) or (7), the test environment may include: a test group including a measuring unit that measures the operation of a circuit board and a measurement circuit board; and an execution unit that executes the test of the task by controlling the test group based on the task output from the queue. In this case, the priority information may include environment information that associates the task with the test group used in the test of the task, and the control unit calculates the priority of the task based on the environment information.

[0052] The circuit board and the measuring unit are both hardware resources. If multiple test groups including such hardware resources are set, the construction of the test environment is expensive, so it is required to perform the action test of the software with a limited number of test groups. As a result, it is difficult to execute multiple tasks in parallel when developing software for vehicle-mounted devices. As a result, it is particularly useful to find the correction point of the software more quickly by preferentially executing the test from the task with higher priority.

[0053] (9) In the information processing system of (8) above, the test group may include a second test group and a plurality of first test groups, and the number of the second test groups may be less than the number of the plurality of first test groups. In this case, in the environment information, the task may include a first task associated with the first test group and a second task associated with the second test group, and the control unit may calculate the priority of the second task to be higher than the priority of the first task.

[0054] By preferentially executing the test from the test group with a small number of items, the idle time of the test group with a small number of items can be further reduced.

[0055] (10) In the information processing system of (4) above, the task may include a first task and a second task, and the security standard required for the second task may be stricter than the security standard required for the first task. In this case, the control unit may calculate the priority of the second task to be higher than the priority of the first task.

[0056] Tasks with stricter safety standards have a narrow range of values ​​allowed during testing, which makes them more prone to errors. By prioritizing testing of such tasks, errors in source code components can be discovered more quickly.

[0057] (11) In the information processing system of (10) above, the safety standard is ASIL (Automotive Safety Integrity Level) of ISO26262.

[0058] (12) In the information processing system of any one of (1) to (11) above, the control unit may calculate the priority of the tasks already accumulated in the queue based on the priority information, and sort the accumulation order in the queue in such a way that a fourth task with a higher priority than the third task among the tasks already accumulated in the queue is executed before the third task.

[0059] With this configuration, the order of accumulation of the plurality of tasks already accumulated in the queue can be reconsidered, and therefore the test can be executed more reliably, starting with the task with the highest priority.

[0060] (13) In the information processing system of any one of (1) to (12) above, the control unit may divide the task into a plurality of split tasks based on the test environment, the safety standard, the result, the execution time and at least one of the required time, and the control unit may calculate the priorities of the plurality of split tasks based on the priority information, and the control unit may accumulate a second split task having a higher priority than the first split task among the plurality of split tasks in the queue in an execution order earlier than the first split task.

[0061] By configuring in this way, the test results can be confirmed in more detail, thereby making it easier to narrow down the part of the task where the error occurred, so the error can be dealt with more quickly.

[0062] (14) The information processing method disclosed in the present invention is an information processing method for assisting the development of software executed in a vehicle-mounted device, comprising the step of adding a task to a queue in which the task is waiting for execution of a test, the task being provided from a repository storing a plurality of source code components included in the software, the step of adding the task comprising: a first step of reading the priority information from a memory storing the priority information, the priority information including information related to the task; a second step of calculating the priority of the task based on the priority information; and a third step of comparing the priority of the tasks already accumulated in the queue with the priority of the task to be newly added to the queue, and adding the task to the queue in a state in which the execution order of the task with the higher priority is placed first.

[0063] With this configuration, it is possible to preferentially execute tests starting with tasks having higher priorities.

[0064] (15) The computer program disclosed in the present invention is a computer program for assisting in the development of software executed in a vehicle-mounted device, the computer program causing a computer to execute a step of adding a task to a queue in which the task is waiting to be tested, the task being provided from a repository storing a plurality of source code components included in the software, the step of performing the adding step comprising: a first step of reading priority information from a memory storing priority information, the priority information including information related to the task; a second step of calculating the priority of the task based on the priority information; and a third step of comparing the priority of the tasks already accumulated in the queue with the priority of the task to be newly added to the queue, and adding the task to the queue in a state in which the execution order of the task with the higher priority is placed first.

[0065] With this configuration, it is possible to preferentially execute tests starting with tasks with higher priorities.

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

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

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

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

[0070] The information processing system 1 is a system that assists in the development of software SW1 to be executed by a device mounted on a vehicle such as an automobile (hereinafter referred to as an “in-vehicle device”).

[0071] The software SW1 is, for example, software for an onboard ECU (Electronic Control Unit) in an onboard device. More specifically, 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.

[0072] 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.

[0073] [1.2 Software and Tasks]

[0074] Figure 2 This is a diagram showing an example of software SW1 according to the embodiment. Figure 2 The software SW1 and the task Tx are described. As described above, the software SW1 is software executed by the vehicle-mounted device. The software SW1 includes a plurality of components X1, X2, and X3. The component X1 includes a plurality of modules a1, a2, and a3, and the component X2 includes a plurality of modules b1 and b2.

[0075] 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.

[0076] 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) respectively. In the information processing system 1, operation tests of individual source code components and operation tests in a state where a plurality of source code components are integrated (integrated) are performed. Here, the test items performed in the information processing system 1 are referred to as tasks Tx. Tasks Tx are also referred to as "work tasks".

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

[0078] (1) A test item that verifies whether a module (such as module a1) acts as an individual.

[0079] (2) A test item that verifies whether a plurality of modules (for example, module a1 and module a2) included in one component operate in an integrated state.

[0080] (3) A test item that verifies whether a component (for example, component X1) operates, that is, verifies whether all modules included in the component (for example, modules a1, a2, and a3) operate in an integrated state.

[0081] (4) A test item that verifies whether multiple components (for example, component X1 and component X2) operate in an integrated state.

[0082] [1.3 Repository]

[0083] 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.

[0084] 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 information processing device 10.

[0085] [1.4 Information processing device]

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

[0087] The information processing device 10 is a device for executing a process of adding a task Tx to a queue 31 managed by a test tool 30. The information processing device 10 includes a control unit 11, a storage unit 12, a communication unit 13, and a reading unit 14. These units 11 to 14 are electrically connected via a bus.

[0088] 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 12 and executes various calculations and controls.

[0089] 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 information processing based on the pre-written program.

[0090] The storage unit 12 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 12 stores, for example, a computer program and various parameters in the nonvolatile memory.

[0091] The communication unit 13 is a communication interface for performing communication with the storage 20, the test tool 30, and the memory 50. The communication unit 13 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 13 has an antenna.

[0092] The reading unit 14 reads information from a computer-readable recording medium 15. The recording medium 15 is, for example, an optical disk such as a CD or a DVD or a USB flash memory. The reading unit 14 is, for example, an optical drive or a USB terminal. The recording medium 15 records a computer program and various parameters. By making the reading unit 14 read the recording medium 15, the computer program and various parameters are stored in the non-volatile memory of the storage unit 12.

[0093] The task Tx provided from the storage memory 20 is received by the communication unit 13 and input to the control unit 11 via the bus. In addition, the priority information 51 described later read from the memory 50 is also received in the communication unit 13, and is input to the control unit 11 via the bus. The control unit 11 calculates the priority of the task Tx based on the priority information 51 according to the computer program read from the storage unit 12. Then, the control unit 11 adds the task Tx to a predetermined position of the queue 31 based on the calculated priority.

[0094] [1.5 Testing Tools]

[0095] Reference Figure 1 The 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 execution unit 41 of the test environment 40 in sequence.

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

[0097] exist Figure 1 , when tasks T1, T2, and T3 are already accumulated in the queue 31 in this order, a task T4 output from the information processing device 10 (specifically, the control unit 11) is added not in FIFO but in the execution order between tasks T1 and T2. In this case, the test tool 30 outputs the tasks Tx accumulated in the queue 31 to the execution unit 41 in the order of tasks T1, T4, T2, and T3.

[0098] [1.6 Test environment]

[0099] Reference Figure 1. The test environment 40 has an execution unit 41 and a test group 42. The execution unit 41 is a computer device (e.g., a laptop PC) including a processor and a memory, and is also called a "node". The execution unit 41 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 execution unit 41 collects information such as the results of the test of the task Tx executed in the test group 42 (e.g., the execution time of the test, the time required for the execution, and the history indicating whether the test succeeded or failed), and outputs it to the memory 50.

[0100] 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.

[0101] 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).

[0102] Figure 4 This is a diagram showing an example of a test environment 40 according to the embodiment. Figure 4 The example shows a case where the test environment 40 includes multiple test groups 42. The multiple test groups 42 include multiple (in Figure 4 The number of the second test groups 42b is less than the number of the first test groups 42a. Figure 4 In addition, the plurality of test groups 42 may include a plurality of second test groups 42 b.

[0103] The circuit substrate 43 and the measuring unit 44 included in the first test group 42a are referred to as the first circuit substrate 43a and the first measuring unit 44a. The first measuring unit 44a measures the operation of the first circuit substrate 43a. Similarly, the circuit substrate 43 and the measuring unit 44 included in the second test group 42b are referred to as the second circuit substrate 43b and the second measuring unit 44b. The second circuit substrate 43b is a substrate having a function different from that of the first circuit substrate 43a. The second measuring unit 44b measures the operation of the second circuit substrate 43b.

[0104] Reference Figure 1The circuit board 43 and the measuring unit 44 are both hardware resources and have low versatility. For example, the circuit board 43 is not a general-purpose board but a dedicated board adjusted for a vehicle-mounted device. That is, the circuit board 43 and the measuring unit 44 are only used for testing the software SW1 and are likely to become expensive. If a plurality of such test groups 42 are provided, the construction of the test environment 40 is expensive, so it is required to perform the action test of the software SW1 with a limited number of test groups 42.

[0105] As a result, when developing the software SW1 for the vehicle-mounted device, it is difficult to execute a plurality of tasks Tx in parallel, and it is required to first execute the test of the task Tx with a higher priority so as to find the correction point of the software SW1 more quickly.

[0106] Therefore, in the information processing system 1 , when adding a task Tx to the queue 31 , by adding the task Tx at a position corresponding to the priority of the task Tx, it is possible to execute the test of the task Tx with a high priority earlier.

[0107] [1.7 Memory]

[0108] Reference Figure 1 . The memory 50 is an auxiliary storage device such as a HDD or an SSD. Priority information 51 is stored in the memory 50. The priority information 51 is information used to calculate the priority of the task Tx. The priority information 51 includes, for example, version information D1, execution time information D2, required time information D3, test result information D4, safety standard information D5, and environment information D6. In addition, information that is not included in the priority information 51 may also exist in the information D1 to information D6. That is, the priority information 51 only needs to include at least one of the information D1 to information D6. In addition, the priority information 51 may also include information other than the information D1 to information D6.

[0109] Figure 5 Table 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, each time the execution unit 41 executes the test of task Tx, the version information D1 is provided from the execution unit 41 to the memory 50. The 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.

[0110] exist Figure 5In 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.

[0111] That is, at execution time TM2, the version of module a1 is updated from hash Ha1-1 to hash Ha1-2. Figure 5 In the example, source code components other than module a1 have not been updated between execution time TM1 and execution time TM2. Therefore, among multiple source code components, module a1 is the most recently updated source code component. That is, in version information D1, by observing the difference in hash values ​​between multiple execution times, it is possible to determine which source code component has been most recently updated.

[0112] Figure 6 Table TB2 is an example of execution time information D2 of the embodiment. The execution time information D2 is information that associates the task Tx with the execution time (most recent execution time) of the test that last executed the task Tx. For example, each time the execution unit 41 executes the test of the task Tx, the execution time information D2 is provided from the execution unit 41 to the memory 50. Figure 6 In the example shown in FIG. 1 , the integration test of modules a1 and a2 is last executed at the execution time TM2, and the integration test of modules a2 and a3 is last executed at the execution time TM1. That is, based on the execution time information D2, it is possible to determine which task Tx is executed most recently and which task Tx is suspended for a long time.

[0113] Figure 7 Table TB3 is an example of required time information D3 of the embodiment. The required time information D3 is information that associates the task Tx with the required time taken to execute the test of the task Tx. For example, each time the execution unit 41 executes the test of the task Tx, the required time information D3 is provided from the execution unit 41 to the memory 50. Figure 7 Table TB3 stores the time required for each execution time TM1 and TM2. For example, the integration test of modules a1 and a2 takes 1 minute and 2 seconds at execution time TM1 and 1 minute and 6 seconds at execution time TM2. In addition, it is shown that the integration test of modules a2 and a3 takes 2 minutes and 30 seconds at execution time TM1, and the integration test is not executed at execution time TM2.

[0114] The required time information D3 can be used to obtain the time required in the most recent test. For example, the most recent time required for the integration test of modules a1 and a2 is 1 minute and 6 seconds, and the most recent time required for the integration test of modules a2 and a3 is 2 minutes and 30 seconds. In addition, the required time information D3 can be used to obtain the statistical value (for example, the average value or the median value) of the time required in past tests. For example, the average value of the time required for the integration test of modules a1 and a2 in the past two times is 1 minute and 4 seconds.

[0115] Figure 8 Table TB4 is an example of test result information D4 of the embodiment. Test result information D4 is information that associates task Tx with the test result of task Tx. The test result includes 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.

[0116] exist Figure 8 The table TB4 stores the test results at each execution time TM1 and TM2. For example, each time the execution unit 41 executes the test of the task Tx, the test result information D4 is provided from the execution unit 41 to the memory 50. For example, it is shown that the integration test of the modules a1 and a2 failed at the execution time TM1 and succeeded at the execution time TM2. It is shown that the integration test of the modules a2 and a3 succeeded at the execution time TM1 and was not executed at the execution time TM2. In addition, it is shown that the integration test of the components X3 and X1 failed at both the execution times TM1 and TM2.

[0117] According to the test result information D4, 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 D4, 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.

[0118] Fig. 9Table TB5 is an example of safety standard information D5 representing an implementation method. Safety standard information D5 is information related to the safety standard required for the source code component at the time of executing the test of task Tx. For example, each time the execution unit 41 executes the test of task Tx, the safety standard information D5 is provided from the execution unit 41 to the memory 50. The safety standard is, for example, the safety standard of a vehicle, more specifically, the safety standard of an automobile. The safety standard is, for example, the ASIL (Automotive Safety Integrity Level) of ISO26262. In ASIL, for example, 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.

[0119] exist Fig. 9 In 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 5 ), the safety standard has been raised to a higher level.

[0120] 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 D5, by observing the most recent execution time (in Fig. 9 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.

[0121] Fig.10 Table TB6 is an example of environment information D6 of the embodiment. Environment information D6 is information that associates task Tx with test group 42 used in the test of task Tx. For example, each time the execution unit 41 executes the test of task Tx, environment information D6 is provided from the execution unit 41 to the memory 50. For example, it is shown that the integration test of modules a1 and a2 and the integration test of modules a2 and a3 are executed using the first test group 42a, and the integration test of modules a3 and a1 and the test of component X1 are executed using the second test group 42b. Based on environment information D6, the type of test group 42 used in the test of task Tx can be obtained.

[0122] [1.8 Information processing method]

[0123] Fig.111 is a flowchart showing an example of an information processing method executed by the information processing system 1. First, the developer creates a plurality of source code components using the terminal group 60, and stores the plurality of source code components in the repository 20 via the network. The plurality of source code components are stored in the repository 20 at appropriate timings.

[0124] The SCM managing the repository 20 creates a task Tx (step S11), 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 the module a1. 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 (for example, an integration test of components X1 and X2).

[0125] Then, the created one or more tasks Tx are provided from the repository 20 to the information processing device 10. With the above, step S11 ends.

[0126] The communication unit 13 of the information processing device 10 outputs the task Tx received from the storage 20 to the control unit 11. When the control unit 11 accepts the input of a new task Tx, it reads the priority information 51 from the memory 50 (step S12). The control unit 11 may read, for example, all of the information D1 to D6 included in the priority information 51, or may read only a part of the information D1 to D6 for calculating the priority of the task Tx. The read priority information 51 is input to the control unit 11 via the communication unit 13. Step S12 ends as described above.

[0127] Next, the control unit 11 calculates the priority of the task Tx based on the priority information 51 (step S13). The priority is calculated, for example, by at least one method from the first to fifth calculation examples shown below. The control unit 11 may also calculate multiple priorities based on multiple information of the information D1 to the information D6 by two or more calculation examples from the first to the fifth calculation examples. The calculation example of the priority is described below.

[0128] [1.8.1 First calculation example: giving priority to shelved tasks]

[0129] The control unit 11 reads the execution time information D2 and calculates a higher priority for a long-pending task Tx (i.e., a task Tx with a longer elapsed time from the most recent test execution time). By executing the test on the temporarily untested task Tx earlier, the scale of source code component correction can be suppressed from increasing.

[0130] For example, in Figure 6 In this case, the most recent execution time TM1 of task Tx (in this calculation example, an example of the “second task” of the present disclosure, appropriately referred to as task a2-a3) related to the integrated test of modules a2 and a3 is earlier (in the past) than the most recent execution time TM2 of task Tx (in this calculation example, an example of the “first task” of the present disclosure, appropriately referred to as task a1-a2) related to the integrated test of modules a1 and a2.

[0131] Therefore, the control unit 11 calculates the priority of task a2-a3 to be higher than the priority of task a1-a2. In the case where a higher priority gives a higher value to task Tx, the control unit 11 assigns "2" as the priority of task a2-a3 and assigns "1" as the priority of task a1-a2, for example.

[0132] The control unit 11 may also calculate the priority based on the values ​​of the execution times TM1 and TM2. For example, the time from the execution times TM1 and TM2 to the current time may be used as the priority value. In this case, since the time from the execution time TM2 to the current time is longer than the time from the execution time TM1 to the current time, a higher value is calculated as the priority of the task a2-a3.

[0133] [1.8.2 Second calculation example: giving priority to tasks that can be executed in a short time]

[0134] The control unit 11 reads the required time information D3 and calculates the priority of the task Tx that can be executed in a short time to be higher. By executing the test first from the task Tx that can be executed in a short time, the number of tests executed per unit time can be increased and the number of tasks waiting to be executed can be reduced.

[0135] For example, in Figure 7 In this case, the time required for testing task Tx related to the integration test of modules a1 and a2 (in this calculation example, it is an example of the “second task” of the present disclosure, appropriately referred to as task a1-a2) is shorter than the time required for testing task Tx related to the integration test of modules a2 and a3 (in this calculation example, it is an example of the “first task” of the present disclosure, appropriately referred to as task a2-a3).

[0136] Therefore, the control unit 11 calculates the priority of task a1-a2 to be higher than the priority of task a2-a3. In the case where a higher priority gives a higher value to task Tx, the control unit 11 assigns "2" as the priority of task a1-a2 and assigns "1" as the priority of task a2-a3, for example.

[0137] The control unit 11 may also calculate the priority based on the value of the required time. For example, the value obtained by subtracting the required time from the specified value E1 may be used as the priority value. Here, the specified value E1 is set to a value that is sufficiently larger than each required time. In this case, the value (E1-66) obtained by subtracting the most recent required time of task a1-a2 from the specified value E1 (for example, 1 minute 6 seconds = 66 seconds) is larger than the value (E1-150) obtained by subtracting the most recent required time of task a2-a3 from the specified value E1 (for example, 2 minutes 30 seconds = 150 seconds), so a higher value is calculated as the priority of task a1-a2. In addition, in calculating the priority, the control unit 11 may use the value of the most recent required time, or may use a statistical value of the required time (for example, the average value of the required time for multiple times in the past).

[0138] [1.8.3 The third calculation example: giving priority to tasks with recent failure history]

[0139] The control unit 11 reads the test result information D4 and calculates the priority of the task Tx with the most recent failure history to be higher. By preferentially executing the test starting from the failed task Tx, it is possible to confirm earlier whether the error has been eliminated.

[0140] For example, in Figure 8 In this case, the most recent test result of task Tx related to the integration test of components X1 and X2 (in this calculation example, it is an example of the “first task” of the present disclosure, appropriately referred to as task X1-X2) is successful, and the most recent test result of the task related to the integration test of components X3 and X1 (in this calculation example, it is an example of the “second task” of the present disclosure, appropriately referred to as task X3-X1) is failed.

[0141] Therefore, the control unit 11 calculates the priority of task X3-X1 to be higher than the priority of task X1-X2. In the case where a higher priority is assigned to task Tx, the control unit 11 assigns "2" as the priority of task X3-X1 and assigns "1" as the priority of task X1-X2, for example.

[0142] The control unit 11 may also calculate the priority based on the number of consecutive failures since the most recent time. For example, the value obtained by adding a constant (such as 1) to the number may be used as the priority. In this case, regarding task X1-X2, since the number of consecutive failures since the most recent time is 0 (the most recent test result is success), the control unit 11 calculates the priority of task X1-X2 as 1 (=0+1). In addition, regarding task X3-X1, since the number of consecutive failures since the most recent time is 2, the control unit 11 calculates the priority of task X3-X1 as 3 (=2+1). Thus, a higher value is calculated as the priority of task X3-X1 with more failure history.

[0143] [1.8.4 Fourth calculation example: Prioritize tasks that require more stringent safety standards]

[0144] The control unit 11 reads the safety standard information D5 and calculates a higher priority for the task Tx requiring a stricter safety standard. For example, the task Tx requiring a stricter safety standard has a narrow range of values ​​allowed in the test of the measuring unit 44 and is prone to errors. By preferentially executing the test starting from such a task Tx, errors in the source code component can be discovered earlier.

[0145] For example, in Fig. 9 In the case of , the ASIL-D required for component X3 is the strictest, followed by the ASIL-A required for module a1. In addition, the QM required for other source code components (for example, modules a2, a3, etc.) is the loosest.

[0146] Consider Figure 8 The task Tx shown is a combination of source code components. For example, when performing integration testing of modules a1 and a2, the safety standard required for task a1-a2 including modules a1 and a2 is the most stringent ASIL-A (the safety standard of module a1) among the standards required for the source code components included in task a1-a2. In addition, when performing integration testing of modules a2 and a3, the safety standard required for task a2-a3 including modules a2 and a3 becomes the most stringent QM (the safety standard of modules a2 and a3) among the standards required for the source code components included in task a2-a3.

[0147] According to the above, the safety standard required for the test of task a1-a2 (in this calculation example, an example of the "second task" of the present disclosure) is stricter than the safety standard required for the test of task a2-a3 (in this calculation example, an example of the "first task" of the present disclosure). Therefore, the control unit 11 calculates the priority of task a1-a2 to be higher than the priority of task a2-a3. In the case where a higher value is assigned to task Tx as the priority is higher, the control unit 11 assigns "2" as the priority of task a1-a2 and assigns "1" as the priority of task a2-a3.

[0148] The controller 11 may calculate the priority according to the strictness (height) of the safety standard. For example, the control unit 11 may set the priority of the task Tx of the most stringent ASIL-D to "5", ASIL-C to "4", ASIL-B to "3", ASIL-A to "2", and QM to "1", thereby assigning priorities respectively.

[0149] [1.8.5 Fifth calculation example: Prioritize tasks that use a smaller number of test groups]

[0150] The control unit 11 reads the environment information D6 and calculates a higher priority for the task Tx using the smaller number of test groups 42 in the environment information D6. By executing the test from the smaller test group 42 first, the idle time of the smaller test group 42 can be further reduced.

[0151] For example, Figure 4 As shown, consider the case where the test environment 40 includes two first test groups 42a and one second test group 42b. Fig.10 In the example, the number of second test groups 42b associated with task Tx (an example of the “second task” of the present disclosure in this calculation example, appropriately referred to as task a3-a1) related to the integrated test of modules a3 and a1 is less than the number of first test groups 42a associated with task Tx (an example of the “first task” of the present disclosure in this calculation example, appropriately referred to as task a1-a2) related to the integrated test of modules a1 and a2.

[0152] Therefore, the control unit 11 calculates the priority of task a3-a1 to be higher than the priority of task a1-a2. In the case where a higher priority gives a higher value to task Tx, the control unit 11 assigns "2" as the priority of task a3-a1 and assigns "1" as the priority of task a1-a2, for example.

[0153] The control unit 11 may also calculate the priority based on the number of test groups 42. For example, the value obtained by subtracting the number of test groups 42 from the specified value E2 may be used as the priority value. Here, the specified value E2 is set to a value that is sufficiently larger than the number of each test group 42. In this case, the value (E2-1) obtained by subtracting the number of the second test group 42b (one) from the specified value E2 is larger than the value (E2-2) obtained by subtracting the number of the first test group 42a (two) from the specified value E2, so a higher value is calculated as the priority of the task a3-a1 associated with the second test group 42b.

[0154] [1.8.6 Adding tasks to the queue]

[0155] The calculated priority is stored in, for example, the storage unit 12. As described above, step S13 ends.

[0156] Next, the control unit 11 adds the task Tx to the queue 31 based on the priority (step S14). Figure 1 As shown in FIG. 1 , it is considered that in a state where tasks T1 , T2 , and T3 are already accumulated in the queue 31 , a task T4 is newly added to the queue 31 .

[0157] When the priority of task T4 is lower than task T1 and higher than task T2 , the control unit 11 adds task T4 to the queue 31 in an execution order later than task T1 and earlier than task T2 (ie, between task T1 and task T2 ).

[0158] For example, when the priority is calculated based on the above-mentioned "first calculation example", the priority of task T1 is "3", the priorities of tasks T2 and T3 are "1" respectively, and the priority of the newly added task T4 is "2", the control unit 11 adds task T4 between task T1 and task T2 as described above. As a result, a plurality of tasks Tx are accumulated in the queue 31 in descending order of priority, so that the test can be executed preferentially starting from the task Tx with the highest priority.

[0159] Furthermore, when the priority is calculated using a plurality of calculation examples, the importance may be preset for each calculation example, and when adding the task Tx to the queue 31 , the priorities of the calculation examples with the highest importance may be evaluated in order.

[0160] Here, consider the case where two priorities are calculated by the first calculation example and the second calculation example. For example, the priority calculated by the first calculation example (hereinafter referred to as the first priority) is set to be higher in importance than the priority calculated by the second calculation example (hereinafter referred to as the second priority). This setting is set by, for example, an operator of the management information processing device 10 and is stored in advance in the storage unit 12 as one of the parameters.

[0161] In this case, the control unit 11 first compares the first priorities of the tasks T1, T2, and T3 accumulated in the queue 31 and the newly added task T4. For example, if the first priorities of the tasks T1, T2, and T3 are "2" respectively, and the first priority of the task T4 is also "2", the appropriate position for adding the task T4 to the queue 31 cannot be determined by the first priority alone.

[0162] Therefore, the control unit 11 then compares the second priorities of the tasks T1, T2, and T3 accumulated in the queue 31 and the newly added task T4. For example, when the second priority of task T1 is "3", the second priorities of tasks T2 and T3 are "1" respectively, and the second priority of the newly added task T4 is "2", the control unit 11 adds task T4 between tasks T1 and T2 as described above.

[0163] In this way, by comparing tasks Tx in order of importance among multiple priorities, tasks Tx can be added to a more appropriate position of the queue 31. In addition, when all priorities are the same, newly added tasks Tx can be added to the queue in an execution order later than previously accumulated tasks Tx according to the FIFO method.

[0164] In addition, when the priority is calculated through multiple calculation examples, the "weight" of the priority can also be pre-set for each calculation example, and the addition position of task Tx to queue 31 can be determined based on the comprehensive priority calculated by adding multiple priorities while assigning "weights" to the multiple priorities respectively.

[0165] For example, consider a case where the weight of the first priority is set to "2" and the weight of the second priority is set to "1". In this case, the combined priority is calculated as "first priority x 2 + second priority x 1". The weight of each priority is set, for example, by an operator of the management information processing device 10 and is pre-stored in the storage unit 12 as one of the parameters.

[0166] The above ends step S14. The tasks Tx accumulated in the queue 31 are output to the execution unit 41 at an appropriate timing by the test tool 30, and the test is executed. The above allows the test to be executed preferentially starting from the task Tx with a higher priority.

[0167] [2. Modifications]

[0168] 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.

[0169] [2.1 Variations of the information processing method]

[0170] Fig.12 In the above-mentioned embodiment, for example, the priority of task T4 to be newly added to queue 31 is calculated and compared with the respective priorities (calculated priorities) of tasks T1, T2, and T3 already accumulated in queue 31, thereby determining the position of adding task T4.

[0171] In contrast, in this variation, when task T4 is newly added to queue 31, the priorities of tasks T1, T2, and T3 already accumulated in queue 31 are recalculated. Then, based on the priorities, task T4 is not only added to queue 31, but the order of tasks T1 to T3 in queue 31 is also reassigned.

[0172] like Fig.12 As shown, steps S11 and S12 are executed in the same manner as in the above-described embodiment. Thereafter, the control unit 11 calculates the priority of the task T4 in the same manner as in step S13, and recalculates the priorities of the tasks T1, T2, and T3 in the queue 31 (step S15).

[0173] Fig.13 This is a diagram for explaining the priority of each task in a modified example. For example, the priorities of tasks T1, T2, and T3 already accumulated in the queue 31 are set to "3", "2", and "1", respectively, before adding task T4. Then, through step S15, the priority of task T4 is calculated to be "3", and the priorities of tasks T1, T2, and T3 are recalculated to be "4", "1", and "2", respectively.

[0174] In this case, the control unit 11 sorts the accumulation order of tasks T1 to T3 in the queue 31 based on the respective priorities after step S15. Specifically, the control unit 11 sorts tasks T1, T3, and T2 in order of priority from high to low. Then, the control unit 11 adds task T4 between task T1 and task T3. As a result, the final accumulation order of the queue 31 becomes tasks T1, T4, T3, and T2 in order of execution of the test from early to late.

[0175] In this way, not only is task T4 added to the appropriate position, but also the order of tasks T2 and T3 is swapped in the above example. Therefore, each time a task Tx is added to the queue 31, the order of accumulation of the plurality of tasks Tx already accumulated in the queue 31 can be reconsidered, so that the test can be executed more reliably starting from the task Tx with a high priority. In particular, this method is preferred when it is desired to advance the execution order of the task Tx that has been delayed (i.e., shelved) for a long time in the queue 31.

[0176] In addition, if the priorities of all the tasks Tx in the queue 31 are recalculated each time a task Tx is added to the queue 31, an excessive processing load may be imposed on the control unit 11. Therefore, the control unit 11 may, for example, execute steps S15 and S16 each time only a specified number of tasks Tx are added to the queue 31, and execute steps S13 and S14 in other cases. In addition, the priorities of the tasks Tx in the queue 31 may not be recalculated during the push process, and the priorities of the tasks Tx in the queue 31 may be recalculated only during the polling process. By configuring in this way, it is possible to reduce the processing load in the control unit 11 and to reallocate the order of the tasks Tx in the queue 31.

[0177] [2.2 Variations of tasks]

[0178] The control unit 11 may also calculate the priorities of the plurality of split tasks DTx based on the fact that the task Tx is divided into the plurality of split tasks DTx, for example, according to each test item. The control unit 11 may divide the task Tx into the plurality of split tasks DTx, for example, based on at least one of the test environment used by the task Tx, the safety standard required for the task Tx, the result of the test of the task Tx, the execution time of the test of the task Tx, and the time required for the test of the task Tx.

[0179] For example, an example of dividing a task Tx into a plurality of divided tasks DTx based on a safety standard is described. Fig. 9 As shown, for task Tx (hereinafter referred to as task X3) related to the action test of component X3, ASIL-D is required as a safety standard. However, not all test items included in task X3 require ASIL-D. For example, sometimes part of the test items included in task X3 include items that require QM as a safety standard.

[0180] Therefore, when calculating the priority, the control unit 11 divides the task X3 into divided tasks X3a and X3b based on the safety standard, for example, for each test item. For example, the divided task X3a only includes the test items requiring QM in the task X3. In addition, the divided task X3b only includes the test items requiring safety standards (ASIL-A, B, C, D) above ASIL-A in the task X3.

[0181] Fig.14Table TB4a shows the test result information D4 of the modified example. In table TB4a, task X3 is divided into a plurality of divided tasks X3a and X3b. Moreover, by subdividing the test result information D4 according to each of the plurality of divided tasks X3a and X3b, the test result can be confirmed in more detail, for example, the test of divided task X3a succeeded at the execution time TM1, and the test of divided task X3b failed. As a result, it is easy to narrow down the scope of which part of task X3 has an error, so the error can be dealt with more quickly.

[0182] Furthermore, in step S13, the control unit 11 may calculate the priorities of the plurality of divided tasks TDx respectively. Furthermore, in step S14, the control unit 11 may determine the position of the divided tasks TDx to be newly added to the queue 31 based on the priorities of the plurality of divided tasks TDx already accumulated in the queue 31. Thus, the test can be performed more finely.

[0183] [3. Notes]

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

[0185] [Note 1]

[0186] An information processing device assists in the development of software executed in a vehicle-mounted device, wherein:

[0187] The information processing device includes a control unit configured to add a task to a queue of tasks waiting for test execution, wherein the task is provided from a repository storing a plurality of source code components included in the software.

[0188] The control unit reads the priority information from a memory storing the priority information, wherein the priority information includes information related to the task.

[0189] The control unit calculates the priority of the task based on the priority information,

[0190] The control unit compares the priorities of the tasks already accumulated in the queue and the priority of the task to be newly added to the queue, and adds the task to the queue in a state where the execution order of the task with a higher priority is placed first.

[0191] [4. Supplementary Note]

[0192] In addition, with respect to the above-mentioned embodiments and various modifications, at least a part of them may be arbitrarily combined with each other. In addition, it should be considered that the embodiments and modifications disclosed this time are illustrative and non-restrictive in all aspects. The scope of the present disclosure is indicated by the claims, and it is intended to include all changes within the meaning and scope equivalent to the claims.

[0193] Description of Reference Numerals

[0194] 1 Information Processing System

[0195] 10 Information processing device

[0196] 11. Control Unit

[0197] 12 Storage

[0198] 13 Ministry of Communications

[0199] 14 Reading section

[0200] 15 Recording Media

[0201] 20 Repositories

[0202] 30 Testing Tools

[0203] 31 Queue

[0204] 40 Test Environment

[0205] 41 Executive Department

[0206] 42 Test Group

[0207] 42a First test group

[0208] 42b Second test group

[0209] 43 Circuit board

[0210] 43a First circuit substrate

[0211] 43b Second circuit substrate

[0212] 44 Measurement Department

[0213] 44a First measurement unit

[0214] 44b Second measurement unit

[0215] 50 Memory

[0216] 51 Priority Information

[0217] 60 Terminal Group

[0218] SW1 Software

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

[0220] X1, X2, X3 components

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

[0222] DTx segmentation task

[0223] D1 Version Information

[0224] D2 Execution time information

[0225] D3 Time required information

[0226] D4 Test Result Information

[0227] D5 Safety Standards Information

[0228] D6 Environmental Information

[0229] TB1, TB2, TB3, TB4, TB4a, TB5, TB6 table

[0230] TM1, TM2 execution time

[0231] E1, E2 Specified values

Claims

1. An information processing system for assisting the development of software executed in an in-vehicle device, wherein: The information processing system includes a control unit configured to add a task to a queue of tasks waiting for test execution, wherein the task is provided from a repository storing a plurality of source code components included in the software. The control unit reads the priority information from a memory storing the priority information, wherein the priority information includes information related to the task. The control unit calculates the priority of the task based on the priority information, The control unit compares the priorities of the tasks already accumulated in the queue and the priority of the task to be newly added to the queue, and adds the task to the queue in a state where the execution order of the task with a higher priority is placed first.

2. The information processing system according to claim 1, wherein: The vehicle-mounted device includes a vehicle-mounted ECU.

3. The information processing system according to claim 2, wherein: The priority information includes information on at least one of a test environment, a result of a past test of the task, an execution time of the past test of the task, and a required time of the past test of the task.

4. The information processing system according to any one of claims 1 to 3, wherein: The priority information includes information related to a safety standard of the vehicle required for the mission.

5. The information processing system according to claim 3, wherein: The tasks include a first task and a second task, the most recent execution time of the second task is earlier than the most recent execution time of the first task, The control section calculates the priority of the second task to be higher than the priority of the first task.

6. The information processing system according to claim 3, wherein: The tasks include a first task and a second task, the required time of the second task is shorter than the required time of the first task, The control section calculates the priority of the second task to be higher than the priority of the first task.

7. The information processing system according to claim 3, wherein: The tasks include a first task whose most recent result is success and a second task whose most recent result is failure, The control section calculates the priority of the second task to be higher than the priority of the first task.

8. The information processing system according to claim 3, wherein: The test environment has: A test group, including a measuring unit, the measuring unit measuring a circuit substrate and an operation of the circuit substrate; and an execution unit that executes a test of the task by controlling the test group based on the task output from the queue, The priority information includes context information associating the task with the test group used in testing the task, The control unit calculates the priority of the task based on the environmental information.

9. The information processing system according to claim 8, wherein: The test group includes a second test group and a plurality of first test groups, the number of the second test groups is less than the number of the plurality of first test groups, In the environment information, the tasks include a first task associated with the first test group and a second task associated with the second test group, The control section calculates the priority of the second task to be higher than the priority of the first task.

10. The information processing system according to claim 4, wherein: The task includes a first task and a second task, the safety standard required for the second task is stricter than the safety standard required for the first task, The control section calculates the priority of the second task to be higher than the priority of the first task.

11. The information processing system according to claim 10, wherein: The safety standard is ASIL (Automotive Safety Integrity Level) of ISO26262.

12. The information processing system according to any one of claims 5 to 9, wherein: The control unit calculates the priority of the task already accumulated in the queue based on the priority information, The control unit sorts the accumulation order in the queue so that, among the tasks accumulated in the queue, a fourth task having a higher priority than the third task is executed before the third task.

13. The information processing system according to any one of claims 5 to 9, wherein: The control unit divides the task into a plurality of divided tasks based on at least one of the test environment, the safety standard, the result, the execution time, and the required time, The control unit calculates the priorities of the plurality of divided tasks based on the priority information. The control unit accumulates, in the queue, second divided tasks having a higher priority than the first divided task among the plurality of divided tasks in an execution order prior to the first divided task.

14. An information processing method for assisting the development of software executed in a vehicle-mounted device, wherein: The information processing method comprises the steps of adding a task to a queue of tasks waiting for test execution, wherein the task is provided from a repository storing a plurality of source code components included in the software, The steps of performing the appending include: The first step is to read the priority information from a memory storing the priority information, wherein the priority information includes information related to the task; The second step is to calculate the priority of the task based on the priority information; and The third step is to compare the priorities of the tasks already accumulated in the queue and the priority of the task to be newly added to the queue, and add the task to the queue in a state where the execution order of the task with a higher priority is placed first.

15. A computer program for assisting in the development of software executed in a vehicle-mounted device, wherein: The computer program causes a computer to execute the step of adding a task to a queue of tasks waiting for test execution, wherein the task is provided from a repository storing a plurality of source code components included in the software. The steps of performing the appending include: The first step is to read the priority information from a memory storing the priority information, wherein the priority information includes information related to the task; The second step is to calculate the priority of the task based on the priority information; and The third step is to compare the priorities of the tasks already accumulated in the queue and the priority of the task to be newly added to the queue, and add the task to the queue in a state where the execution order of the task with a higher priority is placed first.

Images