Simulation task scheduling and processing methods, devices, computer equipment and storage media

Abstract

This application relates to a simulation task scheduling and processing method, apparatus, computer device, and storage medium. The method relates to the field of autonomous driving and specifically includes: receiving a simulation task processing request; acquiring and storing task information carried in the simulation task processing request; performing task parsing processing based on the stored task information to generate corresponding task data to be processed and scene information, and storing these. Based on the scene information, determining each scene subtask corresponding to the task data to be processed; and asynchronously invoking a matching scheduling thread based on the stored task data to be processed and the corresponding scene information to simultaneously request container resource servers corresponding to each scene subtask from a container resource cluster, so as to synchronously execute each scene subtask according to each container resource server and generate corresponding scene simulation test results. This achieves asynchronous processing of simulation tasks and synchronous execution of multiple scene subtasks, reducing task execution waiting time and resource consumption.

Description

Technical Field

[0001] This application relates to the field of computer technology, and in particular to a simulation task scheduling processing method, apparatus, computer equipment, and storage medium. Background Technology

[0002] With the development of computer technology and the gradual improvement of autonomous driving technology, autonomous vehicles are gaining popularity due to their convenience. However, before autonomous vehicles are put into use, to ensure user safety, the stability and safety of the autonomous driving control system need to be tested multiple times and continuously improved until it meets the corresponding deployment standards.

[0003] Currently, simulation verification is often used to conduct safety tests on the control systems of autonomous vehicles. For example, different test scenarios are set up for different models of autonomous vehicles and corresponding application scenarios, and multiple simulation tasks are executed in each test scenario. Based on the test results of the simulation tasks, it is determined whether the simulation test results of the autonomous vehicle in that test scenario meet the deployment standards.

[0004] Traditionally, during the execution of simulation tasks, when a simulation task request is detected, the system responds to the request, simultaneously receives and stores task data, executes the corresponding simulation task, and generates execution results for display. However, for the same model of autonomous vehicle, different test scenarios are typically set up, and multiple simulation tasks are set up in different test scenarios. When a simulation task request is detected, task data needs to be received and processed in real time. This can lead to a backlog of tasks that cannot be processed in a timely manner due to the large number of simulation tasks to be executed, resulting in problems such as excessive task execution waiting time and wasted resources. Summary of the Invention

[0005] Therefore, it is necessary to provide a simulation task scheduling and processing method, apparatus, computer equipment, and storage medium that can reduce the task execution waiting time during simulation task execution, improve resource utilization, and reduce resource waste, in order to address the above-mentioned technical problems.

[0006] Firstly, this application provides a simulation task scheduling method. The method includes:

[0007] Receive simulation task processing request, obtain and store the task information carried in the simulation task processing request;

[0008] Based on the stored task information, the task is parsed and processed to generate corresponding task data to be processed and scenario information, which are then stored.

[0009] Based on the scenario information, determine the scenario subtasks corresponding to the task data to be processed;

[0010] Based on the stored data of each task to be processed and the corresponding scenario information, the matching scheduling thread is asynchronously invoked to simultaneously request the container resource server corresponding to each scenario subtask from the container resource cluster; each container resource server is used to synchronously execute each scenario subtask and generate the corresponding scenario simulation test results.

[0011] In one embodiment, the step of performing task parsing processing based on the stored task information to generate and store corresponding task data to be processed and scenario information includes:

[0012] The preset scene processing thread is invoked to perform task parsing and processing based on the stored task information, and generate corresponding internal task structure data.

[0013] Based on the internal task structure data, determine the scenario information carried by the task information;

[0014] Each of the internal task structure data is used as task data to be processed, and the task data to be processed and the corresponding scene information are associated and stored in the storage queue set by the scheduling thread pool.

[0015] In one embodiment, the step of asynchronously invoking a matching scheduling thread based on the stored data of each task to be processed and the corresponding scene information, and simultaneously requesting container resource servers corresponding to each scene subtask from the container resource cluster, includes:

[0016] Based on the data of each task to be processed stored in the storage queue, a task scheduling instruction is triggered;

[0017] In response to the task scheduling instruction, a matching scheduling thread is determined from the scheduling thread pool;

[0018] The matching scheduling thread is invoked to simultaneously request the container resource server corresponding to each scenario subtask from the container resource cluster, based on the scenario information.

[0019] In one embodiment, the step of invoking the matching scheduling thread to simultaneously request container resource servers corresponding to each scenario subtask from the container resource cluster, based on the scenario information, includes:

[0020] Based on the scenario information described above, determine the maximum number of container resource servers required for the data of the task to be processed;

[0021] The matching scheduling thread is invoked to send a resource request to the container allocation resource server corresponding to the container resource cluster; the resource request is used to instruct the container allocation resource server to request multiple container resource servers from the container resource cluster simultaneously, based on the maximum number of container resource servers.

[0022] Receive multiple container resource servers corresponding to the resource request from the container resource allocation server.

[0023] In one embodiment, after receiving the plurality of container resource servers corresponding to the resource request from the container resource allocation server, the method further includes:

[0024] Each of the aforementioned scenario subtasks is sent to its corresponding container resource server.

[0025] Receive and display the scenario simulation test results corresponding to different scenario subtasks from the container resource servers.

[0026] In one embodiment, the method further includes:

[0027] When the number of idle container resource servers in the container resource cluster is detected to be less than the maximum number of container resource servers, the task execution status of each container resource server in use is obtained.

[0028] When it is determined that there is a container resource server whose task execution status is completed, the completed container resource server will be adjusted to an idle container resource server.

[0029] Obtain the storage time of each of the task data to be processed in the storage queue;

[0030] Request each of the idle container resource servers in sequence according to the storage time.

[0031] Secondly, this application also provides a simulation task scheduling and processing apparatus. The apparatus includes:

[0032] The task information acquisition module is used to receive simulation task processing requests, acquire and store the task information carried by the simulation task processing requests;

[0033] The task parsing and processing module is used to perform task parsing and processing based on the stored task information, generate corresponding task data to be processed and scenario information, and store them.

[0034] The scene subtask determination module is used to determine each scene subtask corresponding to the task data to be processed based on the scene information.

[0035] The container resource server request module is used to asynchronously call the matching scheduling thread based on the stored data of each task to be processed and the corresponding scenario information, and simultaneously request the container resource server corresponding to each scenario sub-task from the container resource cluster; each container resource server is used to synchronously execute each scenario sub-task and generate the corresponding scenario simulation test results.

[0036] Thirdly, this application also provides a computer device. The computer device includes a memory and a processor, the memory storing a computer program, and the processor executing the computer program to perform the following steps:

[0037] Receive simulation task processing request, obtain and store the task information carried in the simulation task processing request;

[0038] Based on the stored task information, the task is parsed and processed to generate corresponding task data to be processed and scenario information, which are then stored.

[0039] Based on the scenario information, determine the scenario subtasks corresponding to the task data to be processed;

[0040] Based on the stored data of each task to be processed and the corresponding scenario information, the matching scheduling thread is asynchronously invoked to simultaneously request the container resource server corresponding to each scenario subtask from the container resource cluster; each container resource server is used to synchronously execute each scenario subtask and generate the corresponding scenario simulation test results.

[0041] Fourthly, this application also provides a computer-readable storage medium. The computer-readable storage medium stores a computer program thereon, which, when executed by a processor, performs the following steps:

[0042] Receive simulation task processing request, obtain and store the task information carried in the simulation task processing request;

[0043] Based on the stored task information, the task is parsed and processed to generate corresponding task data to be processed and scenario information, which are then stored.

[0044] Based on the scenario information, determine the scenario subtasks corresponding to the task data to be processed;

[0045] Based on the stored data of each task to be processed and the corresponding scenario information, the matching scheduling thread is asynchronously invoked to simultaneously request the container resource server corresponding to each scenario subtask from the container resource cluster; each container resource server is used to synchronously execute each scenario subtask and generate the corresponding scenario simulation test results.

[0046] Fifthly, this application also provides a computer program product. The computer program product includes a computer program that, when executed by a processor, performs the following steps:

[0047] Receive simulation task processing request, obtain and store the task information carried in the simulation task processing request;

[0048] Based on the stored task information, the task is parsed and processed to generate corresponding task data to be processed and scenario information, which are then stored.

[0049] Based on the scenario information, determine the scenario subtasks corresponding to the task data to be processed;

[0050] Based on the stored data of each task to be processed and the corresponding scenario information, the matching scheduling thread is asynchronously invoked to simultaneously request the container resource server corresponding to each scenario subtask from the container resource cluster; each container resource server is used to synchronously execute each scenario subtask and generate the corresponding scenario simulation test results.

[0051] In the aforementioned simulation task scheduling and processing method, apparatus, computer equipment, and storage medium, simulation task processing requests are received, task information carried in the requests is acquired and stored, and task parsing is performed based on the stored task information to generate and store corresponding task data to be processed and scenario information. Then, based on the scenario information, sub-tasks corresponding to the task data to be processed are determined, and based on the stored task data and corresponding scenario information, a matching scheduling thread is asynchronously invoked to simultaneously request container resource servers corresponding to each scenario sub-task from the container resource cluster. Finally, each scenario sub-task is synchronously executed through each container resource server to generate corresponding scenario simulation test results. This achieves asynchronous execution of simulation tasks, realizing the goal of storing task data first and then asynchronously invoking the scheduling thread to request container resources, without requiring real-time simulation testing of the received task data. Furthermore, by simultaneously requesting container resource servers corresponding to multiple scenario sub-tasks included in the task data to be processed from the container resource cluster, synchronous execution of multiple scenario sub-tasks can be achieved based on the requested container resource servers, reducing execution waiting time when multiple tasks are received simultaneously, improving container resource utilization, and reducing resource consumption. Attached Figure Description

[0052] Figure 1 This is an application environment diagram of a simulation task scheduling and processing method in one embodiment;

[0053] Figure 2 This is a flowchart illustrating a simulation task scheduling method in one embodiment;

[0054] Figure 3 This is a flowchart illustrating the process of acquiring and storing simulation tasks in one embodiment;

[0055] Figure 4 This is a flowchart illustrating the process of detecting and reporting task execution results in one embodiment;

[0056] Figure 5 This is a schematic diagram of the process of simultaneously requesting container resource servers corresponding to each scenario subtask from the container resource cluster in one embodiment.

[0057] Figure 6 This is a schematic diagram of the simulation task execution process based on a Kubernetes cluster in one embodiment;

[0058] Figure 7 This is a flowchart illustrating the simulation task scheduling method in another embodiment;

[0059] Figure 8 This is a schematic diagram of the overall process of a simulation task scheduling method in one embodiment;

[0060] Figure 9 This is a schematic diagram illustrating the actual application process of a simulated task scheduling method in one embodiment.

[0061] Figure 10 This is a structural block diagram of a simulated task scheduling and processing device in one embodiment;

[0062] Figure 11 This is a schematic diagram of the architecture of a simulated task scheduling and processing system in one embodiment;

[0063] Figure 12 This is an internal structural diagram of a computer device in one embodiment. Detailed Implementation

[0064] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.

[0065] The simulation task scheduling and processing method provided in this application relates to the field of transportation. Intelligent Traffic System (ITS), also known as Intelligent Transportation System, effectively integrates advanced science and technology (information technology, computer technology, data communication technology, sensor technology, electronic control technology, automatic control theory, operations research, artificial intelligence, etc.) into transportation, driving service control, and vehicle manufacturing. This strengthens the connection between vehicles, roads, and users, thereby forming a comprehensive transportation system that ensures safety, improves efficiency, enhances the environment, and conserves energy.

[0066] The simulation task scheduling and processing method provided in this application specifically relates to autonomous driving technology in the transportation field, and can be applied to, for example... Figure 1 In the application environment shown, terminal 102 communicates with server 104 via a network. A data storage system can store the data that server 104 needs to process. The data storage system can be integrated onto server 104 or placed in the cloud or on other network servers. Server 104 receives simulation task processing requests triggered by the user based on terminal 102, obtains and stores the task information carried in the simulation task processing request, and then performs task parsing processing based on the stored task information to generate corresponding pending task data and scene information, which is then stored. Based on the scene information, each scene subtask corresponding to the pending task data can be determined. Server 104 can then asynchronously call the matching scheduling thread based on the stored pending task data and corresponding scene information to simultaneously request container resource servers corresponding to each scene subtask from the container resource cluster. Each container resource server is used to synchronously execute each scene subtask, generate corresponding scene simulation test results, and feed the scene simulation test results back to terminal 102 for display. The terminal 102 can be, but is not limited to, various personal computers, laptops, smartphones, tablets, and IoT devices, such as smart speakers, smart TVs, smart air conditioners, and smart in-vehicle devices. The server 104 can be implemented using a standalone server or a server cluster composed of multiple servers.

[0067] In one embodiment, such as Figure 2 As shown, a simulation task scheduling processing method is provided, which can be applied to... Figure 1 Taking the server in the example, the following steps are included:

[0068] Step S202: Receive simulation task processing request, obtain and store the task information carried in the simulation task processing request.

[0069] Specifically, by receiving a simulation task processing request and obtaining the task information carried in the simulation task processing request, the test scenario of the simulation task and the corresponding multiple scenario sub-tasks can be determined based on the task information.

[0070] For example, in the field of autonomous driving, test scenarios can correspond to different test areas. For instance, certain areas on a map can be further divided into multiple test areas, each containing multiple roads. Within the same test area, the road scenario information, such as road conditions and obstacles, may differ for each road. It's understandable that the road scenario information for each road in different test areas will also differ. Therefore, it's necessary to execute corresponding scenario sub-tasks for each road to obtain the corresponding scenario simulation test results.

[0071] Furthermore, the acquired task information can be stored in a task storage component, which can be a Redis database or a NoSQL database, or any other storage database with data storage capabilities. Then, by invoking a preset scene processing thread, the task storage component can be interacted with in real time to retrieve task information.

[0072] In one embodiment, such as Figure 3 As shown, a flowchart for acquiring and storing simulation tasks is provided. (Refer to...) Figure 3 Specifically, this is achieved by setting up an externally accessible HTTP interface to receive simulation task processing requests and task information. The HTTP interface includes a task submission interface (HTTP submit job) and a task cancellation interface (HTTP cancel job). The task submission interface receives simulation tasks submitted by users that need processing. If the user waits too long for the task to execute or if the submitted simulation task needs adjustment, they can request to cancel the submitted simulation task through the task cancellation interface.

[0073] Furthermore, referring to Figure 3 As can be seen, after obtaining task information, it is stored in the task storage component. Both the task submission and cancellation interfaces are connected to this component. Therefore, after receiving the simulation task processing request and task information at the task submission interface, the task information can be directly sent to the task storage component for storage. Similarly, after receiving a task cancellation request at the task cancellation interface, the task information also needs to be deleted from the task storage component.

[0074] Step S204: Based on the stored task information, perform task parsing and processing to generate corresponding task data to be processed and scenario information, and store them.

[0075] Specifically, by invoking a preset scene processing thread, the system interacts with the task storage component in real time to retrieve task information. This task information is then parsed to generate corresponding internal task structure data. Based on this internal task structure data, the scene information carried by the task information can be determined. In other words, since the task information itself carries scene information, extracting information from the internal task structure data allows the identification of each scene element carried by the task information.

[0076] Furthermore, by treating the internal task structure data as pending task data, and associating the pending data with the corresponding scene information, the task data is stored in a storage queue set by the scheduling thread pool. The storage queue in the scheduling thread pool is used to store pending task data, and whenever pending task data is detected in the storage queue, a task scheduling instruction is triggered to request the container resource servers corresponding to each scene information. This allows for the parallel execution of scene subtasks corresponding to each scene information based on the requested container resource servers.

[0077] In one embodiment, such as Figure 4 As shown, a process for detecting and reporting task execution results is provided, referencing... Figure 4 It is understood that the scene task thread can obtain task information from the storage component and associate the data to be processed with the corresponding scene information to the storage queue set by the scheduling thread pool. Specifically, when associating the data to be processed with the corresponding scene information to the storage queue set by the scheduling thread pool, each data item to be processed is assigned a corresponding task future (used to represent the return value of the task execution result). The scene processing thread continuously detects the task futures of different data items to be processed, obtains the corresponding task execution results, and reports the task execution results, pushing them to the caller, i.e., to the user who initiated the simulation task processing request, for the user to view.

[0078] Based on the pending task data and scenario information stored in the storage queue, a matching scheduling thread can be invoked, and the scheduling thread can simultaneously request the container resource server corresponding to each scenario subtask, so that each scenario subtask can be assigned to the corresponding container resource server for processing.

[0079] Step S206: Based on the information of each scenario, determine the sub-tasks of each scenario that correspond to the data of the task to be processed.

[0080] Specifically, based on the information from each scenario, multiple scenario subtasks can be identified within the task data to be processed. There is a one-to-one correspondence between the scenario information and the scenario subtasks, meaning that the specific scenario subtask data to be executed can be determined based on the scenario information, thereby generating scenario simulation test results corresponding to each scenario subtask.

[0081] Step S208: Based on the stored data of each task to be processed and the corresponding scenario information, asynchronously call the matching scheduling thread to simultaneously request the container resource server corresponding to each scenario sub-task from the container resource cluster. Each container resource server is used to synchronously execute each scenario sub-task and generate the corresponding scenario simulation test results.

[0082] Specifically, based on the data of each task to be processed stored in the storage queue, a task scheduling instruction is triggered. By responding to the task scheduling instruction, a matching scheduling thread is determined from the scheduling thread pool. Then, by asynchronously calling the matching scheduling thread, the container resource server corresponding to each scenario subtask is simultaneously requested from the container resource cluster according to the scenario information.

[0083] Since one piece of data to be processed usually corresponds to multiple sub-tasks in the scenario, it is necessary to trigger task scheduling instructions based on the data of each task to be processed stored in the storage queue. That is, for each simulation task processing request, a task scheduling instruction is triggered based on the data of the task to be processed. Each task scheduling instruction is used to match a scheduling thread, and the matching scheduling thread requests the container resource server corresponding to the multiple sub-scenario tasks respectively.

[0084] In one embodiment, the container resource cluster can be a Kubernetes cluster (i.e., a cluster of node servers used to run containerized applications and manage containerization on multiple hosts in a cloud platform). By invoking a scheduling thread that matches the data of tasks to be processed, a resource request is initiated to the container resource allocation server corresponding to the Kubernetes cluster. Based on the resource request, the container resource allocation server can be instructed to simultaneously request multiple container resource servers from the container resource cluster, according to the maximum number of container resource servers.

[0085] Furthermore, by responding to task scheduling instructions and determining the matching scheduling thread from the scheduling thread pool according to each instruction, resource requests are initiated to the container resource allocation server corresponding to the Kubernetes cluster via asynchronous calls to the scheduling thread. Upon receiving the resource request, the container resource allocation server simultaneously requests multiple container resource servers from the Kubernetes cluster, and then feeds back the requested container resource servers to the main server. By sending each scenario subtask to its corresponding container resource server, each scenario subtask can be executed synchronously on each container resource server to generate the corresponding scenario simulation test results.

[0086] In this Kubernetes cluster, each container resource server corresponds to a different task POD (Task POD is the basic unit of task scheduling in the Kubernetes cluster). During the process of requesting a container resource server from the Kubernetes cluster, a corresponding task POD is created based on the requested container resource server. Then, the corresponding scenario subtasks are executed through the task POD to obtain the corresponding scenario simulation test results. Using a container resource service cluster approach, different simulation tasks can be executed in parallel on multiple task POD nodes. Since a simulation task can be divided into multiple steps or scenarios, the subtasks corresponding to different steps or scenarios can also be assigned to different task POD nodes for parallel execution.

[0087] In the aforementioned simulation task scheduling method, a simulation task processing request is received, the task information carried in the request is acquired and stored, and task parsing is performed based on the stored task information to generate and store corresponding task data to be processed and scenario information. Then, based on the scenario information, sub-tasks corresponding to the task data to be processed are determined. Based on the stored task data to be processed and the corresponding scenario information, a matching scheduling thread is asynchronously invoked to simultaneously request container resource servers corresponding to each scenario sub-task from the container resource cluster. Finally, each scenario sub-task is synchronously executed through each container resource server to generate corresponding scenario simulation test results. This achieves asynchronous execution of simulation tasks, realizing the goal of storing task data first and then asynchronously invoking the scheduling thread to request container resources, without needing to perform real-time simulation testing on the received task data. Furthermore, by simultaneously requesting container resource servers corresponding to multiple scenario sub-tasks included in the task data to be processed from the container resource cluster, synchronous execution of multiple scenario sub-tasks can be achieved based on the requested container resource servers, reducing execution waiting time when multiple tasks are received simultaneously, improving container resource utilization, and reducing resource consumption.

[0088] In one embodiment, such as Figure 5 As shown, the steps for simultaneously requesting container resource servers corresponding to each scenario subtask from the container resource cluster, i.e., invoking the matching scheduling thread and, based on the scenario information, simultaneously requesting container resource servers corresponding to each scenario subtask from the container resource cluster, specifically include:

[0089] Step S502: Determine the maximum number of container resource servers required for the data of the task to be processed based on the scenario information.

[0090] Specifically, based on the information for each scenario, the sub-tasks that need to be executed are determined, and the number of these sub-tasks is counted. Then, based on the number of sub-tasks, the maximum number of container resource servers required to execute the corresponding task data is determined. The maximum number of container resource servers is typically not less than the number of sub-tasks in the scenario, ensuring that one container resource server can execute one sub-task, achieving parallel execution of all sub-tasks, reducing waiting time, and improving task processing efficiency.

[0091] Step S504: Invoke the matching scheduling thread to send a resource request to the container resource allocation server corresponding to the container resource cluster. The resource request is used to instruct the container resource allocation server to request multiple container resource servers from the container resource cluster at the same time, based on the maximum number of container resource servers.

[0092] Specifically, based on the task data to be processed stored in the storage queue set up by the thread scheduling pool, a task scheduling instruction can be triggered, and in response to the triggered task scheduling instruction, a matching scheduling thread can be determined from the scheduling thread pool. By calling the determined matching scheduling thread, a resource request can be initiated to the container resource allocation server corresponding to the container resource cluster.

[0093] Furthermore, after receiving a resource request, the container resource allocation server obtains the maximum number of container resource servers corresponding to the resource request, and requests multiple container resource servers from the container resource cluster simultaneously based on the maximum number of container resource servers, so as to send the requested multiple container resource servers back to the server.

[0094] In this embodiment, the container resource cluster can be a Kubernetes (k8s) cluster. The container resource allocation server corresponding to the k8s cluster is the ADO container allocation server. The ADO container allocation server is used to obtain multiple required container resource servers from the k8s cluster through the API call set up by the k8s cluster. For example, if there are 10 sub-scene tasks, the task information corresponding to all 10 scene tasks is uploaded to the ADO container allocation server at once, and the ADO container allocation server simultaneously requests 10 container resource servers from the k8s cluster.

[0095] Step S506: Receive multiple container resource servers corresponding to the resource request from the container resource allocation server.

[0096] Specifically, after receiving a resource request, the container resource allocation server requests multiple container resource servers from the container resource cluster simultaneously based on the maximum number of container resource servers corresponding to the resource request. Then, it can generate corresponding scenario simulation test results by receiving multiple container resource servers corresponding to the resource request from the container resource allocation server and executing multiple scenario sub-tasks in parallel based on the multiple container resource servers.

[0097] In one embodiment, after receiving feedback from the container resource allocation server regarding multiple container resource servers corresponding to the resource request, the method further includes:

[0098] Each scenario subtask is sent to its corresponding container resource server; the scenario simulation test results corresponding to different scenario subtasks are received from each container resource server and displayed.

[0099] Specifically, multiple container resource servers are identified, and each scenario subtask is sent to its corresponding container resource server. This allows the corresponding scenario subtasks to be executed in parallel on each container resource server, and the scenario simulation test results corresponding to different scenario subtasks are received from each container resource server. The received scenario simulation test results are then displayed for user viewing.

[0100] In this embodiment, the container resource cluster is a Kubernetes (k8s) cluster. The container resource servers within the k8s cluster correspond to task PODs. During the process of requesting a container resource server from the k8s cluster, a new task POD is created based on the requested server. The task POD then executes the corresponding scenario subtasks to obtain the scenario simulation test results. This embodiment uses a Docker container cluster, but it can be adjusted to other container methods that meet the task processing requirements; no specific limitation is imposed.

[0101] In one embodiment, such as Figure 6 As shown, a simulation task execution process based on a Kubernetes cluster is provided, referring to... Figure 6 It can be seen that by calling the scheduling thread in the scheduling thread pool to request container resource servers from the Kubernetes cluster, specifically by the scheduling thread initiating a resource request to the ADO container allocation server of the Kubernetes cluster, the ADO container allocation server, after receiving the resource request, requests the number of container resource servers corresponding to the number of scene subtasks from the Kubernetes cluster. The Kubernetes cluster, based on the number of container resource servers requested by the ADO container allocation server, establishes corresponding task PODs, and further executes the corresponding scene subtasks through the task PODs to obtain the corresponding scene simulation test results.

[0102] In this process, the task POD and the scheduling thread pool establish GRPC communication and feed back the scene simulation test results to the scheduling thread pool. The scene processing thread can detect the task futures of different task data to be processed in the scheduling thread pool to obtain the corresponding task execution results, thereby obtaining the scene simulation test results corresponding to different scene sub-tasks.

[0103] In this embodiment, the maximum number of container resource servers required for the task data to be processed is determined based on the scenario information. A matching scheduling thread is invoked to send resource requests to the container allocation server corresponding to the container resource cluster. The resource request instructs the container allocation server to simultaneously request multiple container resource servers from the container resource cluster according to the maximum number of container resource servers, and receives feedback from the container resource allocation server corresponding to the resource requests. This achieves simultaneous requesting of container resource servers corresponding to each scenario subtask of the task data to be processed via the scheduling thread, and parallel execution of all scenario subtasks through multiple container resource servers, thereby reducing task execution waiting time, improving task execution efficiency, and reducing resource consumption.

[0104] In one embodiment, such as Figure 7 As shown, a simulation task scheduling method is provided, which specifically includes the following steps:

[0105] Step S702: When it is detected that the number of idle container resource servers in the container resource cluster is less than the maximum number of container resource servers, obtain the task execution status of each container resource server in use.

[0106] Specifically, when the number of idle container resource servers in the container resource cluster is less than the maximum number of container resource servers, that is, when the number of idle container resource servers in the container resource cluster cannot meet the requirement of simultaneously processing all scenario subtasks of the current pending task data, it is necessary to obtain the task execution status of each container resource server in use and determine whether the container resource server in use has been completed, that is, to determine whether the container resource server can be used to execute scenario subtasks of other pending task data.

[0107] Step S704: When it is determined that there is a container resource server whose task execution status is "execution completed", the container resource server whose execution has completed is adjusted to an idle container resource server.

[0108] Specifically, when it is determined that there is a container resource server whose task execution status is completed, that is, the container resource server has completed the task execution processing of the previous pending task data and can be used to execute other scenario sub-tasks, the container resource server whose execution has completed is adjusted to an idle container resource server so as to process other pending task data.

[0109] Step S706: Obtain the storage time of each task data in the storage queue.

[0110] Specifically, by obtaining the storage time of each task data in the storage queue, the submission time of the simulation task processing request for each task data is determined, and the execution order of each simulation task can be determined based on the storage time.

[0111] Step S708: Request each available container resource server in sequence according to the storage time.

[0112] Specifically, based on the storage time of each pending task data in the storage queue, the execution order of each simulation task can be determined. Then, according to the execution order of each simulation task, each idle container resource server is requested in turn, so that the idle container resource servers are allocated to the corresponding scene sub-tasks in the order of execution. This avoids the situation where multiple pending task data cannot be allocated to the container resource server in time, thereby improving the utilization rate of container resources.

[0113] In the above-described simulation task scheduling method, when the number of idle container resource servers in the container resource cluster is less than the maximum number of container resource servers, the task execution status of each in-use container resource server is obtained. If a container resource server is found to have completed its task execution, it is adjusted to an idle container resource server. By obtaining the storage time of each pending task data in the storage queue, and requesting each idle container resource server sequentially based on the storage time, the method promptly releases completed container resource servers for executing other scenario subtasks. This avoids situations where multiple pending task data cannot be allocated to container resource servers in a timely manner, thereby improving container resource utilization and task processing efficiency.

[0114] In one embodiment, such as Figure 8 The diagram illustrates the overall flow of a simulation task scheduling method, which specifically includes the following steps:

[0115] Step S801: Receive simulation task processing request, obtain task information carried in simulation task processing request, and store task information in task storage component.

[0116] Step S802: Invoke the preset scene processing thread to retrieve task information from the task storage component in real time.

[0117] Step S803: Perform task parsing processing on the acquired task information to generate corresponding internal task structure data.

[0118] Step S804: Determine the scenario information carried by the task information based on the internal task structure data.

[0119] Step S805: Treat the internal task structure data as task data to be processed, and associate the task data to be processed with the corresponding scene information and store them in the storage queue set by the scheduling thread pool.

[0120] Step S806: Based on the data of each task to be processed stored in the storage queue, trigger the task scheduling instruction.

[0121] Step S807: In response to the task scheduling instruction, determine the matching scheduling thread from the scheduling thread pool.

[0122] Step S808: Determine the maximum number of container resource servers required for the data of the task to be processed based on the scenario information.

[0123] Step S809: Invoke the matching scheduling thread to send a resource request to the container resource allocation server corresponding to the container resource cluster. The resource request is used to instruct the container resource allocation server to request multiple container resource servers from the container resource cluster at the same time, based on the maximum number of container resource servers.

[0124] Step S810: Receive multiple container resource servers corresponding to the resource request from the container resource allocation server.

[0125] Step S811: When it is detected that the number of idle container resource servers in the container resource cluster is less than the maximum number of container resource servers, obtain the task execution status of each container resource server in use.

[0126] Step S812: When it is determined that there is a container resource server whose task execution status is "execution completed", the container resource server whose execution has completed is adjusted to an idle container resource server.

[0127] Step S813: Obtain the storage time of each task data in the storage queue, and request each idle container resource server in sequence according to the storage time.

[0128] Step S814: Send each scenario subtask to the corresponding container resource server.

[0129] Step S815: Receive and display the scenario simulation test results corresponding to different scenario sub-tasks from each container resource server.

[0130] The above-described simulation task scheduling method enables asynchronous execution of simulation tasks. It achieves the goal of storing task data first and then asynchronously calling the scheduling thread to request container resources, without needing to perform real-time simulation testing on the received task data. At the same time, by simultaneously requesting container resource servers for multiple scenario sub-tasks included in the task data to be processed from the container resource cluster, the synchronous execution of multiple scenario sub-tasks can be achieved based on the requested multiple container resource servers. This reduces the execution waiting time when multiple tasks are received simultaneously, improves the utilization rate of container resources, and reduces resource consumption.

[0131] In one embodiment, such as Figure 9 As shown, a practical application flow of a simulation task scheduling and processing method is provided. In this embodiment, the simulation task scheduling and processing method relates to autonomous driving technology and is applied to scenario simulation testing of an autonomous driving control system. Specifically, it includes the following steps:

[0132] Step S901: Obtain the pre-divided test area and determine the corresponding multiple road scene information based on the pre-divided test area.

[0133] This process involves acquiring pre-defined test areas. These areas can be pre-divided by testers or developers based on existing map information, or by the server using existing map information and the control algorithms of the autonomous driving control system to determine test areas that match the control algorithms. In the field of autonomous driving, different autonomous driving algorithms for autonomous vehicles need to undergo simulation testing in different areas or on different roads. The simulation test results are then displayed for users to view.

[0134] Specifically, based on the pre-divided test area, the road scene information of multiple roads included in the test area is further determined. Based on the road scene information of each road, the corresponding scene sub-task can be triggered to generate. That is, for each pre-divided test area, the scene sub-tasks corresponding to each road in the test area need to be executed to generate the corresponding scene simulation test results.

[0135] Furthermore, to meet the market deployment standards for autonomous vehicles, the safety of their autonomous driving control systems during the autonomous driving process needs to be repeatedly tested. However, due to the ever-changing road conditions during vehicle operation, it is impossible to conduct on-site testing for different roads. Therefore, scenario simulation testing is often adopted. Specifically, by dividing different test areas and collecting road condition information for multiple roads within each test area, including road sign information, obstacle information, and communication control information at intersections, road scene information for the corresponding roads is generated. Based on the road scene information, corresponding scenario sub-tasks can be further triggered.

[0136] Step S902: Receive a simulation task processing request for the pre-divided test area, obtain the task information carried in the simulation task processing request, and store the task information in the task storage component.

[0137] Specifically, the process involves acquiring simulation task processing requests for pre-defined test areas. After identifying each pre-defined test area, the process detects simulation task processing requests for one or more of these areas and acquires the task information carried in the requests. This task information may include the test area to which the simulation task belongs, the road scene information carried by the simulation task, and the specific number of roads included in the test area.

[0138] Furthermore, the reception of simulation task processing requests and task information is achieved through the set HTTP interface. The HTTP interface includes a task submission interface (http submit job) and a task cancellation interface (http cancel job). The task submission interface is used to receive simulation tasks submitted by users that need to be processed. If the user waits too long for the task to execute or the submitted simulation task needs to be adjusted, the user can request to cancel the submitted simulation task through the task cancellation interface.

[0139] After acquiring the task information, it is further stored in a task storage component. This component can be a Redis database or a NoSQL database, or any other storage database with data storage capabilities. Both the task submission and cancellation interfaces are connected to the task storage component. Upon receiving a simulation task processing request and task information at the task submission interface, the task information can be directly sent to the task storage component for storage. Similarly, upon receiving a task cancellation request at the task cancellation interface, the task information must be deleted from the task storage component.

[0140] Step S903: Invoke the preset scene processing thread to obtain task information from the task storage component in real time, and perform task parsing processing on the task information to generate corresponding task data to be processed and scene information for each road.

[0141] Specifically, by calling a preset scene processing thread, the system interacts with the task storage component in real time to obtain task information from the task storage component, and performs task parsing processing on the obtained task information to obtain the task data to be processed corresponding to the task information, as well as the road scene information carried by the task information.

[0142] Step S904: Associate and store the data of the task to be processed and the corresponding road scene information in the storage queue set by the scheduling thread pool.

[0143] Specifically, the data of the tasks to be processed, along with the road scene information corresponding to the data of the tasks to be processed, are associated and stored in the scheduling thread pool, specifically in the storage queue set by the scheduling thread pool.

[0144] The storage queue in the scheduling thread pool is used to store data of tasks to be processed. As long as data of tasks to be processed is detected in the storage queue, a task scheduling instruction will be triggered. That is, based on the data of tasks to be processed and the corresponding road scene information, the task scheduling instruction is triggered to request the container resource server corresponding to each road scene information. Then, based on the multiple requested container resource servers, the scene sub-tasks corresponding to each road scene information can be executed in parallel.

[0145] Step S905: Based on the information of each road scene, determine the sub-tasks of each scene corresponding to the task data to be processed.

[0146] Specifically, based on the road scene information, multiple scene subtasks included in the task data to be processed are determined. There is a one-to-one correspondence between the road scene information and the scene subtasks. That is, based on the road scene information determined by the pre-divided test area, multiple scene subtasks included in the task data to be processed corresponding to the pre-divided test area are further determined. In other words, it is specific to which roads need to execute scene subtasks in order to generate scene simulation test results corresponding to each road.

[0147] Step S906: Based on the data of each task to be processed stored in the storage queue, trigger the task scheduling instruction.

[0148] Specifically, since one piece of data to be processed usually corresponds to multiple sub-tasks in the scenario, it is necessary to trigger task scheduling instructions based on the data of each task to be processed stored in the storage queue. That is, for the data of the task to be processed corresponding to a simulation task processing request, a task scheduling instruction is triggered. A task scheduling instruction is used to match a scheduling thread, and according to the matched scheduling thread, a request is made to the container resource server corresponding to the multiple sub-scenario tasks respectively.

[0149] Step S907: In response to the task scheduling instruction, determine the matching scheduling thread from the scheduling thread pool.

[0150] Specifically, by responding to task scheduling instructions, a matching scheduling thread is determined from the scheduling thread pool according to each task scheduling instruction. The number of scheduling threads in the scheduling thread pool is generated based on the number given in the configuration file, and the specific number given in the configuration file can be adjusted and modified according to actual needs, and is not limited to certain values.

[0151] Step S908: Determine the maximum number of container resource servers required for the data of the task to be processed based on the scenario information.

[0152] Specifically, the number of corresponding scenario subtasks is determined based on the scenario information, and then the maximum number of container resource servers required to process the data of the task to be processed is determined based on the number of scenario subtasks. The maximum number of container resource servers is usually not less than the number of scenario subtasks.

[0153] Step S909: Invoke the matching scheduling thread to send a resource request to the container allocation resource server corresponding to the container resource cluster. The resource request is used to instruct the container allocation resource server to request multiple container resource servers from the container resource cluster at the same time, based on the maximum number of container resource servers.

[0154] Specifically, in this embodiment, the container resource cluster can be a Kubernetes cluster (i.e., a Kubernetes cluster, a cluster of node servers used to run containerized applications and manage containerization on multiple hosts in the cloud platform). By invoking a scheduling thread that matches the data of tasks to be processed, a resource request is initiated to the container resource allocation server corresponding to the Kubernetes cluster. Based on the resource request, the container resource allocation server can be instructed to simultaneously request multiple container resource servers from the container resource cluster, according to the maximum number of container resource servers.

[0155] The container resource allocation server corresponding to the Kubernetes cluster is the ADO container allocation server, which is used to request container resource servers from the Kubernetes cluster. The ADO container allocation server obtains container resource servers from the Kubernetes cluster through the calling interface set by the Kubernetes cluster.

[0156] Furthermore, after receiving a resource request, the container resource allocation server obtains the maximum number of container resource servers corresponding to the resource request, and requests multiple container resource servers from the Kubernetes cluster simultaneously based on the maximum number of container resource servers, so as to send the requested multiple container resource servers back to the server.

[0157] Step S910: Receive multiple container resource servers corresponding to the resource request from the container resource allocation server.

[0158] Step S911: Send each scenario subtask to the corresponding container resource server.

[0159] Specifically, the system receives feedback from the container resource allocation server, which corresponds to multiple container resource servers. It then sends multiple scenario subtasks, each corresponding to the task data to be processed, to the respective container resource servers, achieving a one-to-one correspondence between scenario subtasks and container resource servers. Each container resource server can then process the received scenario subtasks in parallel and generate corresponding scenario simulation test results.

[0160] Step S912: Receive and display the scenario simulation test results corresponding to different scenario sub-tasks from each container resource server.

[0161] Specifically, multiple scenario subtasks corresponding to the task data to be processed are sent to their respective container resource servers. Each container resource server processes the received scenario subtasks in parallel and generates corresponding scenario simulation test results. These scenario simulation test results are then displayed for users to view.

[0162] In the aforementioned simulation task scheduling method, a pre-divided test area is obtained, and multiple road scene information corresponding to the pre-divided test area is determined. A simulation task processing request for the pre-divided test area is received, and the task information carried in the simulation task processing request is obtained. Then, a preset scene processing thread is invoked to parse and process the task information, generating corresponding task data to be processed and information for each road scene. Based on the information for each road scene, sub-tasks corresponding to the task data to be processed can be determined. Then, based on each task data to be processed, a task scheduling instruction is triggered and responded to, and a matching scheduling thread is determined from the scheduling thread pool. Based on each scene information, the maximum number of container resource servers required for the task data to be processed is determined, and the matching scheduling thread is invoked to initiate a resource request to the container allocation resource server corresponding to the container resource cluster. According to the resource request instructions, the container allocation resource server simultaneously requests multiple container resource servers from the container resource cluster based on the maximum number of container resource servers, and sends each scene sub-task to the corresponding container resource server. Finally, the simulation test results corresponding to different scene sub-tasks are received from each container resource server and displayed.

[0163] It should be understood that although the steps in the flowcharts of the above embodiments are shown sequentially according to the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some steps in the flowcharts of the above embodiments may include multiple steps or multiple stages. These steps or stages are not necessarily completed at the same time, but can be executed at different times. The execution order of these steps or stages is not necessarily sequential, but can be performed alternately or in turn with other steps or at least some of the steps or stages of other steps.

[0164] Based on the same inventive concept, this application also provides a simulation task scheduling processing apparatus for implementing the simulation task scheduling processing method described above. The solution provided by this apparatus is similar to the implementation scheme described in the above method; therefore, the specific limitations in one or more embodiments of the simulation task scheduling processing apparatus provided below can be found in the limitations of the simulation task scheduling processing method described above, and will not be repeated here.

[0165] In one embodiment, such as Figure 10 As shown, a simulation task scheduling and processing device is provided, including: a task information acquisition module 1002, a task parsing and processing module 1004, a scene subtask determination module 1006, and a container resource server request module 1008, wherein:

[0166] The task information acquisition module 1002 is used to receive simulation task processing requests, acquire and store the task information carried in the simulation task processing requests;

[0167] The task parsing and processing module 1004 is used to perform task parsing and processing based on the stored task information, generate corresponding task data to be processed and information of each scenario, and store them.

[0168] The scene subtask determination module 1006 is used to determine each scene subtask corresponding to the task data to be processed based on the scene information.

[0169] The container resource server request module 1008 is used to asynchronously call the matching scheduling thread based on the stored data of each task to be processed and the corresponding scenario information, and simultaneously request the container resource server corresponding to each scenario sub-task from the container resource cluster; each container resource server is used to synchronously execute each scenario sub-task and generate the corresponding scenario simulation test results.

[0170] In the aforementioned simulation task scheduling and processing device, simulation task processing requests are received, task information carried in the requests is acquired and stored, and task parsing is performed based on the stored task information to generate and store corresponding task data to be processed and scenario information. Then, based on the scenario information, sub-tasks corresponding to the task data to be processed are determined. Based on the stored task data to be processed and the corresponding scenario information, a matching scheduling thread is asynchronously invoked to simultaneously request container resource servers corresponding to each scenario sub-task from the container resource cluster. Then, each scenario sub-task is synchronously executed through each container resource server to generate corresponding scenario simulation test results. This achieves asynchronous execution of simulation tasks, realizing the goal of storing task data first and then asynchronously invoking the scheduling thread to request container resources, without needing to perform real-time simulation testing on the received task data. Furthermore, by simultaneously requesting container resource servers for multiple scenario sub-tasks included in the task data to be processed from the container resource cluster, synchronous execution of multiple scenario sub-tasks can be achieved based on the requested container resource servers, reducing execution waiting time when multiple tasks are received simultaneously, improving container resource utilization, and reducing resource consumption.

[0171] In one embodiment, the task information acquisition module is further configured to:

[0172] The preset scene processing thread is invoked to perform task parsing and processing based on the stored task information, generating corresponding internal task structure data; the scene information carried by the task information is determined based on the internal task structure data; each internal task structure data is used as task data to be processed, and the task data to be processed and the corresponding scene information are associated and stored in the storage queue set by the scheduling thread pool.

[0173] In one embodiment, the container resource server request module is further configured to:

[0174] Based on the data of each task to be processed stored in the storage queue, a task scheduling instruction is triggered; in response to the task scheduling instruction, a matching scheduling thread is determined from the scheduling thread pool; the matching scheduling thread is invoked, and based on the information of each scenario, the container resource server corresponding to each scenario subtask is requested from the container resource cluster simultaneously.

[0175] In one embodiment, the container resource server request module is further configured to:

[0176] Based on the information of each scenario, determine the maximum number of container resource servers required for the data of the task to be processed; call the matching scheduling thread to initiate a resource request to the container allocation resource server corresponding to the container resource cluster; the resource request is used to instruct the container allocation resource server to request multiple container resource servers from the container resource cluster at the same time according to the maximum number of container resource servers; receive the multiple container resource servers corresponding to the resource request from the container resource allocation server.

[0177] In one embodiment, a simulation task scheduling processing apparatus is provided, further comprising:

[0178] The scene subtask sending module is used to send each scene subtask to the corresponding container resource server.

[0179] The scenario simulation test result display module is used to receive and display the scenario simulation test results corresponding to different scenario sub-tasks from each container resource server.

[0180] In one embodiment, a simulation task scheduling processing apparatus is provided, further comprising:

[0181] The task execution status acquisition module is used to acquire the task execution status of each active container resource server when the number of idle container resource servers in the container resource cluster is less than the maximum number of container resource servers.

[0182] The adjustment module is used to adjust container resource servers that have completed execution to idle container resource servers when it is determined that there are such servers.

[0183] The storage time acquisition module is used to acquire the storage time of each task data in the storage queue;

[0184] The idle container resource server request module is used to request each idle container resource server sequentially based on the storage time.

[0185] Each module in the aforementioned simulation task scheduling and processing device can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in the processor of a computer device in hardware form or independent of it, or stored in the memory of a computer device in software form, so that the processor can call and execute the operations corresponding to each module.

[0186] In one embodiment, such as Figure 11 As shown, a simulation task scheduling and processing system is provided, referring to... Figure 11It can be seen that the simulation task scheduling and processing system specifically includes a task receiving component 1102, a task storage component 1104, a scheduling strategy component 1106, a Kubernetes cluster resource pool 1108, and a container resource server 1110, wherein:

[0187] The task receiving component 1102 is used to receive simulation task processing requests, obtain the task information carried in the simulation task processing requests, and store the task information in the task storage component 1104 connected to the task receiving component 1102.

[0188] The task storage component 1104 is used to store task information sent by the task receiving component 1102. The task storage component 1104 is also connected to the scheduling policy component 1106, which can retrieve the stored task information from the task storage component.

[0189] The scheduling strategy component 1106 interacts with the task storage component 1104 and obtains the task information stored in the task storage component 1104. Then, based on the task information, it requests the corresponding container resource server 1110 from the k8s cluster resource pool 1108.

[0190] The scheduling strategy component 1106 includes a scene processing thread and a scheduling thread pool. The scheduling thread pool has multiple scheduling threads and a task storage queue. The scene processing thread is used to parse and process tasks based on the stored task information to generate corresponding task data to be processed and scene information, and then associates and stores the task data to be processed and scene information in the task storage queue. The scheduling threads in the scheduling thread pool are used to simultaneously request container resource servers 1110 corresponding to each scene subtask from the container resource cluster according to the scene information.

[0191] The container resource server 1110 is used to receive each of the scenario sub-tasks, execute each scenario sub-task, generate corresponding scenario simulation test results, and feed back the scenario simulation test results corresponding to different scenario sub-tasks to the scheduling strategy component 1106, which further feeds back and displays the scenario simulation test results.

[0192] The aforementioned simulation task scheduling and processing system receives simulation task processing requests, acquires and stores the task information carried in the requests, and performs task parsing based on the stored information to generate and store corresponding task data to be processed and scenario information. Then, based on the scenario information, it determines the sub-tasks corresponding to the task data to be processed and asynchronously calls the matching scheduling thread to simultaneously request container resource servers corresponding to each scenario sub-task from the container resource cluster, based on the stored task data and corresponding scenario information. Finally, it synchronously executes each scenario sub-task on each container resource server, generating corresponding scenario simulation test results. This achieves asynchronous execution of simulation tasks, storing task data first and then asynchronously calling the scheduling thread to request container resources, without requiring real-time simulation testing of the received task data. Furthermore, by simultaneously requesting container resource servers for multiple scenario sub-tasks included in the task data to be processed from the container resource cluster, it enables synchronous execution of multiple scenario sub-tasks, reducing execution waiting time when multiple tasks are received simultaneously, improving container resource utilization, and reducing resource consumption.

[0193] In one embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be as follows: Figure 12 As shown, this computer device includes a processor, memory, input / output (I / O) interfaces, and a communication interface. The processor, memory, and I / O interfaces are connected via a system bus, and the communication interface is also connected to the system bus via the I / O interfaces. The processor provides computational and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system, computer programs, and a database. The internal memory provides the environment for the operating system and computer programs stored in the non-volatile storage media. The database stores task information, pending task data, scene information, scene subtasks, container resource servers, and scene simulation test results. The I / O interfaces are used for exchanging information between the processor and external devices. The communication interface is used for communication with external terminals via a network connection. When the computer program is executed by the processor, it implements a simulation task scheduling method.

[0194] Those skilled in the art will understand that Figure 12 The structure shown is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the computer device to which the present application is applied. Specific computer devices may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.

[0195] In one embodiment, a computer device is also provided, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps in the above method embodiments.

[0196] In one embodiment, a computer-readable storage medium is provided having a computer program stored thereon that, when executed by a processor, implements the steps in the above method embodiments.

[0197] In one embodiment, a computer program product is provided, including a computer program that, when executed by a processor, implements the steps in the above method embodiments.

[0198] It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, data stored, data displayed, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties, and the collection, use and processing of the relevant data shall comply with the relevant laws, regulations and standards of the relevant countries and regions.

[0199] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. Any references to memory, databases, or other media used in the embodiments provided in this application can include at least one of non-volatile and volatile memory. Non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory, optical memory, high-density embedded non-volatile memory, resistive random access memory (ReRAM), magnetic random access memory (MRAM), ferroelectric random access memory (FRAM), phase change memory (PCM), graphene memory, etc. Volatile memory can include random access memory (RAM) or external cache memory, etc. By way of illustration and not limitation, RAM can take many forms, such as Static Random Access Memory (SRAM) or Dynamic Random Access Memory (DRAM). The databases involved in the embodiments provided in this application may include at least one type of relational database and non-relational database. Non-relational databases may include, but are not limited to, blockchain-based distributed databases. The processors involved in the embodiments provided in this application may be general-purpose processors, central processing units, graphics processing units, digital signal processors, programmable logic devices, quantum computing-based data processing logic devices, etc., and are not limited to these.

[0200] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0201] The embodiments described above are merely illustrative of several implementation methods of this application, and while the descriptions are specific and detailed, they should not be construed as limiting the scope of this patent application. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these all fall within the protection scope of this application. Therefore, the protection scope of this application should be determined by the appended claims.

Claims

1. A simulation task scheduling and processing method, characterized in that, The method includes: Receive a simulation task processing request, acquire and store the task information carried in the simulation task processing request; the task information is used to determine the test scenario of the simulation task, the test scenario includes different test areas, each test area includes multiple roads, and each road included in the same test area corresponds to different road scenario information; The preset scene processing thread is invoked to perform task parsing based on the stored task information, generate corresponding internal task structure data, and determine the scene information carried by the task information based on the internal task structure data. Each of the internal task structure data is used as the task data to be processed, and the task data to be processed and the corresponding scene information are associated and stored in the storage queue set by the scheduling thread pool; Based on the scenario information, determine the scenario subtasks corresponding to the task data to be processed; Based on the data of each task to be processed stored in the storage queue, a task scheduling instruction is triggered; In response to the task scheduling instruction, a matching scheduling thread is asynchronously invoked from the scheduling thread pool; through the matching scheduling thread, based on the scenario information, container resource servers corresponding to each scenario subtask are simultaneously requested from the container resource cluster, so that each container resource server synchronously and in parallel executes each scenario subtask and generates corresponding scenario simulation test results.

2. The method according to claim 1, characterized in that, The step of invoking the matching scheduling thread, based on the scenario information, to simultaneously request the container resource server corresponding to each scenario subtask from the container resource cluster, includes: Based on the scenario information described above, determine the maximum number of container resource servers required for the data of the task to be processed; The matching scheduling thread is invoked to send a resource request to the container allocation resource server corresponding to the container resource cluster; the resource request is used to instruct the container allocation resource server to request multiple container resource servers from the container resource cluster simultaneously, based on the maximum number of container resource servers. Receive multiple container resource servers corresponding to the resource request from the container resource allocation server.

3. The method according to claim 2, characterized in that, After receiving the multiple container resource servers corresponding to the resource request from the container resource allocation server, the method further includes: Each of the aforementioned scenario subtasks is sent to its corresponding container resource server. Receive and display the scenario simulation test results corresponding to different scenario subtasks from the container resource servers.

4. The method according to claim 2, characterized in that, The method further includes: When the number of idle container resource servers in the container resource cluster is detected to be less than the maximum number of container resource servers, the task execution status of each container resource server in use is obtained. When it is determined that there is a container resource server whose task execution status is completed, the completed container resource server will be adjusted to an idle container resource server. Obtain the storage time of each of the task data to be processed in the storage queue; Request each of the idle container resource servers in sequence according to the storage time.

5. A simulation task scheduling and processing device, characterized in that, The device includes: The task information acquisition module is used to receive simulation task processing requests, acquire and store the task information carried by the simulation task processing requests; the task information is used to determine the test scenario of the simulation task, the test scenario includes different test areas, each test area includes multiple roads, and each road included in the same test area corresponds to different road scenario information; The task parsing and processing module is used to call a preset scene processing thread, perform task parsing and processing based on the stored task information, generate corresponding internal task structure data, and determine the scene information carried by the task information according to the internal task structure data; treat each internal task structure data as task data to be processed, and associate and store the task data to be processed and the corresponding scene information in the storage queue set by the scheduling thread pool. The scene subtask determination module is used to determine each scene subtask corresponding to the task data to be processed based on the scene information. The container resource server request module is used to trigger a task scheduling instruction based on the data of each task to be processed stored in the storage queue, respond to the task scheduling instruction, asynchronously call a matching scheduling thread from the scheduling thread pool; through the matching scheduling thread, according to the scenario information, simultaneously request the container resource server corresponding to each scenario subtask from the container resource cluster, so that the container resource server synchronously and in parallel executes each scenario subtask and generates the corresponding scenario simulation test results.

6. The apparatus according to claim 5, characterized in that, The container resource server request module is also used for: Based on the scenario information, determine the maximum number of container resource servers required for the task data to be processed; invoke the matching scheduling thread to initiate a resource request to the container allocation resource server corresponding to the container resource cluster; the resource request is used to instruct the container allocation resource server to request multiple container resource servers from the container resource cluster simultaneously according to the maximum number of container resource servers; receive the multiple container resource servers corresponding to the resource request from the container resource allocation server.

7. The apparatus according to claim 6, characterized in that, The device further includes: The scene subtask sending module is used to send each of the scene subtasks to the corresponding container resource server. The scenario simulation test result display module is used to receive and display the scenario simulation test results corresponding to different scenario sub-tasks fed back by each of the container resource servers.

8. The apparatus according to claim 6, characterized in that, The device further includes: The task execution status acquisition module is used to acquire the task execution status of each of the container resource servers in use when it is detected that the number of idle container resource servers in the container resource cluster is less than the maximum number of container resource servers. The adjustment module is used to adjust the container resource server that has finished executing to an idle container resource server when it is determined that there is a container resource server whose task execution status is completed. The storage time acquisition module is used to acquire the storage time of each of the task data to be processed in the storage queue; The idle container resource server request module is used to sequentially request each of the idle container resource servers according to the storage time.

9. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, When the processor executes the computer program, it implements the steps of the method according to any one of claims 1 to 4.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the steps of the method according to any one of claims 1 to 4.

11. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by a processor, it implements the steps of the method according to any one of claims 1 to 4.

Images