Software processing method of automatic driving application graphical developer and electronic equipment

Abstract

The embodiment of the invention provides a software processing method of an automatic driving application graphical developer and electronic equipment. The invention relates to the technical field of automatic driving, and the method comprises the steps: responding to a software development instruction, and determining a software development task corresponding to target software indicated by the software development instruction; based on a pre-constructed automatic driving graphical development environment management system, according to the software development tasks, determining target containers corresponding to the software development tasks, and determining dependency relationships among the software development tasks; the automatic driving graphical development environment management system is a pre-constructed system for managing different automatic driving development environments; and executing the software development task in a target container corresponding to the software development task according to the dependency relationship. In the technical field of automatic driving, the method is used for achieving the effect of improving the safety and real-time performance of automatic driving when software processing is carried out based on an automatic driving application graphical developer.

Description

Technical Field

[0001] The present application relates to the field of autonomous driving technology, and in particular to a software processing method and electronic device for an autonomous driving application graphical developer. Background Art

[0002] In the process of autonomous driving software development, in addition to the development of the software functions themselves, it is also necessary to integrate external tools to perform different software development tasks in the software development process. Among them, the external tools are based on different autonomous driving software development environments.

[0003] In the prior art, during the software development process, since the development environments corresponding to various software development tasks may be different, when executing each software development task, it is necessary to manually configure and call each development environment to complete the software development process.

[0004] However, the existing methods may lead to low efficiency and poor versatility in software development, which may further lead to poor safety and real-time performance of autonomous driving. Summary of the invention

[0005] The embodiments of the present application provide a software processing method and an electronic device for an autonomous driving application graphical developer, so as to achieve the effect of improving the safety and real-time performance of autonomous driving.

[0006] In a first aspect, an embodiment of the present application provides a software processing method of an autonomous driving application graphical developer, including:

[0007] In response to the software development instruction, determining a software development task corresponding to the target software indicated by the software development instruction; wherein the software development instruction is used to indicate the target software to be developed for the vehicle;

[0008] Based on a pre-built graphical development environment management system for autonomous driving, according to the software development task, a target container corresponding to the software development task is determined, and dependencies between the software development tasks are determined; wherein the graphical development environment management system for autonomous driving is a pre-built system for managing different autonomous driving development environments; the target container is an environment container for executing software development tasks;

[0009] The software development task is executed in a target container corresponding to the software development task according to the dependency relationship.

[0010] In one possible implementation, based on a pre-built graphical development environment management system for autonomous driving, a target container corresponding to the software development task is determined according to the software development task, and the dependency relationship between the software development tasks is determined, including: based on the pre-built graphical development environment management system for autonomous driving, an environment instance corresponding to the software development task is determined; wherein the environment instance is a pre-built instance for executing the software development task; based on the environment instance corresponding to the software development task, a target container corresponding to the software development task is determined; based on the environment instance corresponding to the software development task, the dependency relationship between the software development tasks is determined.

[0011] In one possible implementation, the environment instance indicates an environment container for executing a software development task; and according to the environment instance corresponding to the software development task, determining a target container corresponding to the software development task includes: determining the environment container for executing the software development task indicated by the environment instance as the target container of the software development task corresponding to the environment instance.

[0012] In one possible implementation, the environment instance indication is based on an environment template; wherein the environment template is a template that defines task flows in different autonomous driving development environments; according to the environment instance corresponding to the software development task, the dependency relationship between the software development tasks is determined, including: according to the environment instance corresponding to the software development task, the environment template corresponding to the software development task is determined; the environment template indicates the tools and artifacts of the software development task, and the dependency relationship between the tools and artifacts; the tool is used to execute the software development task; the artifact is obtained after executing the software development task; according to the tools and artifacts of the software development task indicated by the environment template corresponding to the software development task, and the dependency relationship between the tools and artifacts, the dependency relationship between the software development tasks is determined.

[0013] In a possible implementation, the software development task is executed in a target container corresponding to the software development task according to the dependency relationship, including: according to the dependency relationship, if it is determined that the software development task has no dependent software development task, then executing the tool of the software development task in the target container corresponding to the software development task to execute the corresponding software development task; according to the dependency relationship, if it is determined that the software development task has a dependent software development task, then after the dependent software development task is executed, executing the tool of the software development task in the target container corresponding to the software development task to execute the corresponding software development task.

[0014] In a possible implementation, the environment instance also indicates a tool instance corresponding to a tool for a software development task; wherein the tool instance includes instructions for executing the tool; executing the tool for the software development task in a target container corresponding to the software development task to execute the corresponding software development task includes: in the target container corresponding to the software development task, executing the tool instructions included in the tool instance corresponding to the tool for executing the software development task to execute the corresponding software development task.

[0015] In a possible implementation, the method further includes: determining whether a tool for the software development task is installed in a target container corresponding to the software development task; if it is determined that the tool is installed, executing the tool for executing the software development task in the target container corresponding to the software development task to execute the corresponding software development task; otherwise, generating and presenting prompt information; wherein the prompt information indicates a failure in executing the software development task.

[0016] In one possible implementation, the construction process of the pre-built graphical development environment management system for autonomous driving includes: obtaining the software package and configuration information of each autonomous driving software in each autonomous driving development environment, and constructing an environment template corresponding to each autonomous driving development environment based on the software package and configuration information of each autonomous driving software in each autonomous driving development environment; and constructing an environment instance corresponding to each environment template based on the environment template corresponding to each autonomous driving development environment.

[0017] In a second aspect, an embodiment of the present application provides a software processing device of an autonomous driving application graphical developer, comprising:

[0018] A first determination module is used to determine, in response to a software development instruction, a software development task corresponding to the target software indicated by the software development instruction; wherein the software development instruction is used to indicate the target software to be developed for the vehicle;

[0019] A second determination module is used to determine, based on a pre-built graphical development environment management system for autonomous driving, a target container corresponding to the software development task according to the software development task, and to determine dependencies between the software development tasks; wherein the graphical development environment management system for autonomous driving is a pre-built system for managing different autonomous driving development environments; and the target container is an environment container for executing software development tasks;

[0020] A processing module is used to execute the software development task in a target container corresponding to the software development task according to the dependency relationship.

[0021] In a possible implementation, the second determination module includes a first determination unit, which is used to determine the environment instance corresponding to the software development task based on the pre-built graphical development environment management system for autonomous driving; wherein the environment instance is a pre-built instance for executing the software development task; a second determination unit, which is used to determine the target container corresponding to the software development task according to the environment instance corresponding to the software development task; and a third determination unit, which is used to determine the dependency relationship between the software development tasks according to the environment instance corresponding to the software development task.

[0022] In a possible implementation, the environment instance indicates an environment container for executing a software development task; and the second determination unit is specifically used to determine the environment container for executing the software development task indicated by the environment instance as a target container for the software development task corresponding to the environment instance.

[0023] In one possible implementation, the environment instance indication is based on an environment template; wherein the environment template is a template that defines task flows in different autonomous driving development environments; the third determination unit is specifically used to determine the environment template corresponding to the software development task according to the environment instance corresponding to the software development task; the environment template indicates the tools and artifacts of the software development task, and the dependencies between the tools and artifacts; the tool is used to execute the software development task; the artifact is obtained after executing the software development task; the dependencies between the software development tasks are determined according to the tools and artifacts of the software development task indicated by the environment template corresponding to the software development task, and the dependencies between the tools and artifacts.

[0024] In a possible implementation, the processing module is specifically used to, based on the dependency relationship, if it is determined that the software development task has no independent software development task, execute the tool of the software development task in the target container corresponding to the software development task to execute the corresponding software development task; based on the dependency relationship, if it is determined that the software development task has a dependent software development task, after the dependent software development task is executed, execute the tool of the software development task in the target container corresponding to the software development task to execute the corresponding software development task.

[0025] In a possible implementation, the environment instance also indicates a tool instance corresponding to a tool for a software development task; wherein the tool instance includes instructions for executing the tool; and the processing module is further specifically used to execute the instructions for executing the tool included in the tool instance corresponding to the tool for the software development task in a target container corresponding to the software development task, so as to execute the corresponding software development task.

[0026] In a possible implementation, the processing module is further used to determine whether the tool for the software development task is installed in the target container corresponding to the software development task; if it is determined to be installed, the tool for executing the software development task in the target container corresponding to the software development task is executed to execute the corresponding software development task; otherwise, prompt information is generated and presented; wherein the prompt information indicates a failure in executing the software development task.

[0027] In a possible implementation, the processing module is further used to obtain the software package and configuration information of each autonomous driving software in each autonomous driving development environment, and to construct an environment template corresponding to each autonomous driving development environment based on the software package and configuration information of each autonomous driving software in each autonomous driving development environment; and to construct an environment instance corresponding to each environment template based on the environment template corresponding to each autonomous driving development environment.

[0028] In a third aspect, an embodiment of the present application provides an electronic device, including: a memory, a processor;

[0029] The memory stores computer-executable instructions;

[0030] The processor executes the computer-executable instructions stored in the memory, so that the processor executes the above first aspect and / or various possible implementations of the first aspect.

[0031] In a fourth aspect, an embodiment of the present application provides a computer-readable storage medium, in which computer-executable instructions are stored. When the computer-executable instructions are executed by a processor, they are used to implement the first aspect above and / or various possible implementations of the first aspect.

[0032] In a fifth aspect, an embodiment of the present application provides a computer program product, including a computer program, which, when executed by a processor, implements the above first aspect and / or various possible implementation methods of the first aspect.

[0033] The software processing method and electronic device of the graphical developer of an autonomous driving application provided in the embodiment of the present application determine, in response to a software development instruction, the software development task corresponding to the target software indicated by the software development instruction, and based on a pre-built graphical development environment management system for autonomous driving, determine the target container corresponding to the software development task according to the software development task, and determine the dependency relationship between the software development tasks, and execute the software development task in the target container corresponding to the software development task according to the dependency relationship. The target container corresponding to the software development task and the dependency relationship between the software development tasks can be automatically determined based on the pre-built graphical development environment management system for autonomous driving, thereby improving the versatility and efficiency of software processing of the graphical developer of autonomous driving applications, thereby improving the development effect of autonomous driving applications, and further improving the safety and real-time performance of autonomous driving. BRIEF DESCRIPTION OF THE DRAWINGS

[0034] The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the present application and, together with the description, serve to explain the principles of the present application.

[0035] Figure 1 Schematic diagram of the software processing method of the autonomous driving application graphical developer provided in this application Figure 1 ;

[0036] Figure 2 Schematic diagram of the software processing method of the autonomous driving application graphical developer provided in this application Figure 2 ;

[0037] Figure 3 Schematic diagram of the software processing method of the autonomous driving application graphical developer provided in this application Figure 3 ;

[0038] Figure 4 A schematic diagram of the structure of the software processing device of the autonomous driving application graphical developer provided in this application;

[0039] Figure 5 A schematic diagram of the structure of the electronic device provided in this application.

[0040] The above drawings have shown clear embodiments of the present application, which will be described in more detail later. These drawings and text descriptions are not intended to limit the scope of the present application in any way, but to illustrate the concept of the present application to those skilled in the art by referring to specific embodiments. DETAILED DESCRIPTION

[0041] Exemplary embodiments will be described in detail herein, examples of which are shown in the accompanying drawings. When the following description refers to the drawings, the same numbers in different drawings represent the same or similar elements unless otherwise indicated. The implementations described in the following exemplary embodiments do not represent all implementations consistent with the present application. Instead, they are merely examples of devices and methods consistent with some aspects of the present application as detailed in the appended claims.

[0042] In the prior art, during the software development process, since the development environments corresponding to various software development tasks may be different, it is necessary to manually configure and call each development environment to complete the software development process when executing each software development task. However, the methods in the prior art will lead to low efficiency and poor versatility in software development, which will further lead to poor safety and real-time performance of autonomous driving.

[0043] With the development of autonomous driving technology, the process of autonomous driving software development no longer relies on manual programming, but is instead implemented using a graphical development platform, such as an autonomous driving application graphical developer. However, when developing autonomous driving software based on an autonomous driving application graphical developer, it is necessary to determine whether the existing autonomous driving application graphical developer has integrated all the tools or environments that the target autonomous driving software relies on. In this process, if it is found that some of the tools or environments are not integrated into the existing autonomous driving application graphical developer, the overall architecture of the autonomous driving application graphical developer needs to be adjusted, which will also affect the efficiency and versatility of software development.

[0044] Therefore, there is an urgent need for a software processing method for a graphical developer of autonomous driving applications with strong versatility and high development efficiency to solve the problems of poor safety and real-time performance of autonomous driving.

[0045] The software processing method of the graphical developer of an autonomous driving application provided in the present application determines, in response to a software development instruction, a software development task corresponding to the target software indicated by the software development instruction, and based on a pre-built graphical development environment management system for autonomous driving, determines, according to the software development task, a target container corresponding to the software development task, and determines the dependency relationship between each software development task, and executes the software development task in the target container corresponding to the software development task according to the dependency relationship. The method improves the versatility and efficiency of the software processing of the graphical developer of the autonomous driving application, thereby improving the development effect of the autonomous driving application, and further improving the safety and real-time performance of the autonomous driving.

[0046] The technical solution of the present application and how the technical solution of the present application solves the above-mentioned technical problems are described in detail below with specific embodiments. The following specific embodiments can be combined with each other, and the same or similar concepts or processes may not be repeated in some embodiments. The embodiments of the present application will be described below in conjunction with the accompanying drawings.

[0047] Figure 1 Schematic diagram of the software processing method of the autonomous driving application graphical developer provided in this application Figure 1 ,like Figure 1 As shown, the method includes:

[0048] Step S101: In response to a software development instruction, determine a software development task corresponding to the target software indicated by the software development instruction.

[0049] Specifically, in response to the software development instruction, a software development task corresponding to the target software indicated by the software development instruction may be determined.

[0050] The software development instruction is used to indicate the target software to be developed for the vehicle. The software development instruction is used to instruct the development of the target software.

[0051] Among them, the present application does not limit the process of determining, in response to the software development instruction, the software development task corresponding to the target software indicated by the software development instruction. Optionally, in response to the software development instruction, the process of determining, in response to the software development instruction, the software development task corresponding to the target software indicated by the software development instruction may include the following steps: receiving the software development instruction and verifying the legality and integrity of the instruction to ensure that the instruction format is correct and contains all necessary information; parsing the software development instruction to obtain key information such as the name, version, functional requirements, etc. of the target software to be developed; determining the software development task corresponding to the target software to be developed based on the key information such as the name, version, functional requirements, etc. of the target software to be developed obtained by parsing.

[0052] Among them, this application does not limit the number and type of software development tasks corresponding to the target software indicated by the software development instructions. Optionally, the number and type of software development tasks corresponding to the target software indicated by the software development instructions correspond to the target software indicated by the software development instructions, for example, corresponding to key information such as the version and functional requirements of the target software indicated by the software development instructions. If the key information such as the version and / or functional requirements of the target software indicated by the software development instructions is different, the number and type of software development tasks corresponding to the target software indicated by the software development instructions are also different.

[0053] Step S102: Based on the pre-built graphical development environment management system for autonomous driving, determine the target container corresponding to the software development task according to the software development task, and determine the dependency relationship between the software development tasks.

[0054] Specifically, based on the pre-built graphical development environment management system for autonomous driving, according to the software development task determined in step S101, a target container corresponding to the software development task can be determined, and the dependency relationship between the software development tasks can be determined.

[0055] Among them, the graphical development environment management system for autonomous driving is a pre-built system for managing different autonomous driving development environments. Among them, this application does not limit the graphical development environment management system for autonomous driving, and any pre-built system for managing different autonomous driving development environments can be used as the graphical development environment management system for autonomous driving provided by this application. Specifically, based on the graphical development environment management system for autonomous driving, the management of the development environment no longer relies on manual operations. Therefore, when software development is carried out based on the graphical development environment management system for autonomous driving, the efficiency and versatility of software development are improved.

[0056] Among them, the target container is an environment container for executing software development tasks. Specifically, in the process of software development, the execution of software development tasks needs to rely on the corresponding development environment. The embodiment of the present application provides an environment for the execution of software development tasks by constructing an environment container. Among them, if the environment container for executing the software development task is not the environment container corresponding to the software development task, it will result in the failure of the execution of the software development task, thereby affecting the development of the software. Therefore, after determining the software development task corresponding to the target software indicated by the software development instruction, the target container corresponding to each software development task can be determined. Optionally, different software development tasks may correspond to the same target container.

[0057] Among them, if multiple software development tasks are determined in step S101, some of the software development tasks, or all of the software development tasks among the determined software development tasks may have a certain execution order, that is, all or some of the software development tasks need to be executed in sequence in a certain execution order to achieve the development of the target software to be developed. Therefore, after determining the software development tasks corresponding to the target software indicated by the software development instruction, the dependencies between the software development tasks can be determined. Optionally, the determination result can be that there is no dependency between the software development tasks, and each software development task can be executed independently. Optionally, the determination result can be that there is a dependency between some of the software development tasks, and each software development task with a dependency can be executed according to the determined dependency, and each software development task without a dependency can be executed independently. Optionally, the determination result can also be that there is a dependency between all development tasks, and each software development task can be executed according to the determined dependency.

[0058] Among them, the present application does not limit the process of determining the target container corresponding to the software development task according to the software development task and determining the dependency relationship between the software development tasks based on the pre-built graphical development environment management system for autonomous driving. Optionally, the environment instance corresponding to the software development task can be determined based on the pre-built graphical development environment management system for autonomous driving; wherein the environment instance is a pre-built instance for executing the software development task; according to the environment instance corresponding to the software development task, the target container corresponding to the software development task is determined; according to the environment instance corresponding to the software development task, the dependency relationship between the software development tasks is determined.

[0059] Step S103: Execute the software development task in the target container corresponding to the software development task according to the dependency relationship.

[0060] Specifically, according to the dependency relationship between the software development tasks determined in step S102, the software development tasks may be executed in the target containers corresponding to the software development tasks determined in step S102.

[0061] For the description of the dependency relationship, reference may be made to the description in step S102 and will not be repeated here.

[0062] The software processing method of the graphical developer of an autonomous driving application provided in an embodiment of the present application determines, in response to a software development instruction, a software development task corresponding to the target software indicated by the software development instruction, and based on a pre-built graphical development environment management system for autonomous driving, determines, according to the software development task, a target container corresponding to the software development task, and determines the dependency relationship between the software development tasks, and executes the software development task in the target container corresponding to the software development task based on the dependency relationship. The method improves the versatility and efficiency of the software processing of the graphical developer of the autonomous driving application, thereby improving the development effect of the autonomous driving application, and further improving the safety and real-time performance of the autonomous driving.

[0063] Figure 2 Schematic diagram of the software processing method of the autonomous driving application graphical developer provided in this application Figure 2 ,like Figure 2 As shown, in this embodiment Figure 1 Based on the embodiment, a graphical development environment management system based on a pre-built autonomous driving system is described in detail, and a process of determining a target container corresponding to a software development task according to a software development task and determining dependencies between software development tasks is described. The method includes:

[0064] Step S201: Determine an environment instance corresponding to a software development task based on a pre-built graphical development environment management system for autonomous driving.

[0065] Specifically, based on the pre-built graphical development environment management system for autonomous driving, the environment instance corresponding to the software development task can be determined.

[0066] Among them, the description of the pre-built graphical development environment management system for autonomous driving can refer to the description in step S102, which will not be repeated here.

[0067] The environment instance is a pre-built instance for executing software development tasks. Specifically, the environment instance is an instance of software development tasks corresponding to each autonomous driving software executed in different autonomous driving development environments, which is constructed when building a graphical development environment management system for autonomous driving.

[0068] Among them, this application does not limit the number of software development tasks corresponding to each environment instance. Optionally, each environment instance corresponds to at least one software development task.

[0069] Step S202: Determine a target container corresponding to the software development task according to the environment instance corresponding to the software development task.

[0070] Specifically, according to the environment instance corresponding to the software development task determined in step S201, the target container corresponding to the software development task can be determined.

[0071] Among them, the present application does not limit the process of determining the target container corresponding to the software development task based on the environment instance corresponding to the software development task. Optionally, the environment instance indicates the environment container for executing the software development task, that is, the environment container determined during the construction process of the environment instance and used to execute the software development task corresponding to the environment instance.

[0072] Optionally, if the environment instance indicates an environment container for executing a software development task, the process of determining a target container corresponding to the software development task based on the environment instance corresponding to the software development task may include: determining the environment container for executing the software development task indicated by the environment instance as the target container of the software development task corresponding to the environment instance.

[0073] Specifically, based on the description in step S102, since the target container is an environment container for executing a software development task, after determining the environment instance corresponding to the software development task, the environment container for executing the software development task indicated by the corresponding environment instance can be determined as the target container of the software development task corresponding to the environment instance. Optionally, if a software development task corresponds to an environment instance, the environment container for executing the software development task indicated by the corresponding environment instance can be determined as the target container of the corresponding software development task. Optionally, if multiple software development tasks correspond to one environment instance, the environment container for executing the software development task indicated by the corresponding environment instance can be determined as the target container of each of the multiple corresponding software development tasks.

[0074] Among them, based on the pre-built environment instances, the correspondence between software development tasks and environment containers, the target container of each software development task can be determined efficiently and accurately, thereby improving the efficiency of software processing of applications and vehicles, thereby improving the development effect of autonomous driving applications, and further improving the safety and real-time performance of autonomous driving.

[0075] Step S203: Determine the dependency relationship between the software development tasks according to the environment instances corresponding to the software development tasks.

[0076] Specifically, according to the environment instance corresponding to the software development task determined in step S201, the dependency relationship between the software development tasks can be determined.

[0077] For the description of the dependency relationship between the software development tasks, reference may be made to the description in step S102, which will not be repeated here.

[0078] Among them, this application does not limit the process of determining the dependencies between software development tasks according to the environment instance corresponding to the software development task. Optionally, the environment instance indicates the environment template on which it is based, that is, the environment instance is an instance pre-built based on the environment template. Among them, the environment template is a template that defines the task flow under different autonomous driving development environments. Specifically, the environment template is a template that is constructed when building a graphical development environment management system for autonomous driving, and defines the task flow under different autonomous driving development environments.

[0079] Among them, the present application does not limit the environment template. Any template that defines the task flow in different autonomous driving development environments can be used as the environment template provided by the present application. Optionally, the specific table structure of the environment template may include but is not limited to: project type table, environment template table, environment variable table, task table, tool table, workpiece table, tool parameter table and other table structures.

[0080] Optionally, the project type table (project_type) is used to define the project types supported by the environment template, that is, the middleware types, such as the autosar type, ros type and other project types. Optionally, the project type table includes but is not limited to: project type, project type name, project type description and other contents.

[0081] Optionally, the environment template table (environment_template) is used to store basic information of the environment template, associate the environment variables required by the current environment template, that is, the environment variable table, and the task flow supported by the current middleware type. Optionally, the environment template table includes but is not limited to: template ID, template name, middleware type (project type) corresponding to the template, task flow ID corresponding to the template, template creation time, template update time, etc.

[0082] Optionally, the environment variable table (environment_variables) is used to store environment variables associated with the environment template, used for environment configuration, and supports defining different variables in different templates. Optionally, the environment variable table includes but is not limited to: environment variables, template IDs corresponding to environment variables, environment variable names, environment variable aliases, environment variable values, and changed variable types.

[0083] Optionally, the task flow table (task) defines the identifier, dependency and priority of the task, wherein tasks can be dynamically arranged through dependency, and the priority determines the scheduling order. Optionally, the task flow table includes, but is not limited to: task type, tool ID corresponding to the task, execution order of the tool corresponding to the task, input artifact ID corresponding to the task, output artifact ID corresponding to the task, whether the task supports asynchronous operation, template ID corresponding to the task, etc.

[0084] Optionally, a tool table (tools) is used to define tools used in the environment template, such as compilation tools, deployment tools, etc. The tool table is used to record all possible tools used in the environment template. Optionally, the tool table includes but is not limited to the tool type, the task ID corresponding to the tool, the tool name, the tool alias, etc.

[0085] Optionally, an artifact table (artifacts) is used to define the tool's dependent artifacts and output artifacts, such as compiled code packages, configuration files and other artifacts, which are usually generated during tool deployment or build process. Optionally, the artifact table includes but is not limited to: artifacts, template IDs corresponding to the artifacts, artifact paths, artifact names, artifact aliases, artifact types and other contents.

[0086] Optionally, a tool parameter table (tool_params) is used to store tool parameter settings, which is used to define the runtime configuration of each tool, where parameters can be required or optional. Optionally, the tool parameter table includes, but is not limited to: tool parameters, tool command ID, tool parameter name, tool parameter value, tool default parameter value, whether the tool parameter is a required parameter, etc.

[0087] The design of environment templates can ensure the correctness and consistency of environment configuration when creating, updating, and deleting environment instances by standardizing the structure of environment configuration. Dependencies between environment templates and tasks, tools, artifacts, etc. can be defined. The system can automatically schedule tasks and configure the environment based on these dependencies to ensure that tasks are executed in the appropriate environment. It helps to simplify the management and maintenance of the environment, especially when the environment is large or changeable. As a standard data structure, it can be integrated with other systems or tools to support cross-system environment management and operations.

[0088] Based on the above description of the environment template, the environment instance can be an instance of the software development task corresponding to each autonomous driving software constructed based on the environment template described above, executed in different autonomous driving development environments. Optionally, the specific table structure of the environment instance can include but is not limited to: an environment instance table, a tool instance table, a container table and other table structures.

[0089] Optionally, the environment instance table (environment) is used to record the actual deployed environment instance and associate it with the environment template, container table and tool instance table. Optionally, the environment instance table includes but is not limited to: environment instance ID, environment template corresponding to the environment instance, environment instance name, container ID corresponding to the environment instance and other contents.

[0090] The container table (containers) is used to record development tasks, that is, the container information required for tool execution. Optionally, each container contains the execution environment of one or more tools. Optionally, the container table includes but is not limited to: container ID, container type, container name, container status, container configuration, etc. Optionally, the container type includes but is not limited to: SSH type, docker type, etc.

[0091] The tool instance table (env_commands) is used to record tool commands or scripts executed in the environment container. These commands are associated with the environment template and container and are used to execute tasks in the container. Optionally, the tool instance table includes, but is not limited to: command ID, environment instance ID corresponding to the tool instance, absolute path of the command, command parameters, etc.

[0092] The standardized design of environment instances can support flexible configuration across platforms and container types. It also supports automated management of environment configuration and container configuration to improve reusability. It can improve the flexibility and scalability of the system when facing multiple types of containers.

[0093] Optionally, multiple environment instances can be constructed based on one environment template.

[0094] Optionally, if the environment instance indicates an environment template based on which the environment template is a template that defines the task flow in different autonomous driving development environments, the process of determining the dependencies between the software development tasks according to the environment instance corresponding to the software development task may include: determining the environment template corresponding to the software development task according to the environment instance corresponding to the software development task. Determining the dependencies between the software development tasks according to the tools and artifacts of the software development task indicated by the environment template corresponding to the software development task, and the dependencies between the tools and artifacts.

[0095] Optionally, based on the above description of environment templates and environment instances, according to the environment instance corresponding to the software development task, the process of determining the environment template corresponding to the software development task may include: first determining the environment template corresponding to the environment instance corresponding to the software development task, and determining the environment template as the environment template corresponding to the software development task. Optionally, based on the description of the correspondence between the environment instance and the software development task in step S201, if multiple software development environments correspond to one environment instance, then the environment templates corresponding to the multiple software development environments are also the same. Optionally, based on the above description of the correspondence between the environment template and the environment instance, if the software development task of the target software corresponds to multiple environment instances, then the environment templates corresponding to the multiple environment instances may be the same or may not be the same.

[0096] Optionally, the environment template indicates the tools and artifacts of the software development task, and the dependencies between the tools and artifacts. The tools are used to perform the software development task. The artifacts are obtained after performing the software development task.

[0097] Optionally, based on the above description of the environment template, the tools and artifacts of each software development task indicated by the environment template, as well as the dependency relationship between the tools and artifacts, can be determined based on the task flow table, tool table, and artifact table corresponding to the environment template. For example, if the target software corresponds to software development task A and software development task B, and based on the task flow table, tool table, and artifact table corresponding to the environment template, it can be determined that software development task A corresponds to tool a, and the corresponding output artifact is artifact 1, and software development task B corresponds to tool b, and the corresponding input artifact is artifact 1, then it can be determined that tool b depends on the output artifact of tool a, that is, artifact 1, and thus it can be determined that software development task B depends on software development task A.

[0098] Optionally, the process of determining the dependency relationship between the software development tasks according to the tools and artifacts of the software development tasks indicated by the environment template corresponding to the software development tasks, and the dependency relationship between the tools and artifacts, may include:

[0099] If it is determined that the tool of the current software development task has a dependent artifact, then the current software development task has a dependent software development task, and the current software development task has a dependent software development task, which is the software development task corresponding to the tool that generates the dependent artifact;

[0100] If it is determined that the tool of the current software development task has no dependent artifacts, then the current software development task has no dependent software development tasks.

[0101] Optionally, a dependency topology graph of the software development task can be generated by calling the dependency topology generation algorithm buildGraph(task), that is, the dependency relationship between each software development task is determined. Among them, the dependency topology graph is a directed graph that represents the relationship between software development tasks (tools) and artifacts. Nodes represent tasks (tools) or artifacts, and edges represent the dependencies between tasks (tools) and artifacts. Through the dependency topology graph, the system can clearly understand the dependencies between each software development task and the execution order between software development tasks. If a circular dependency is found, the system will generate an acquisition log and notify the user to modify the corresponding strategy.

[0102] Among them, in the process of determining the dependencies between software development tasks according to the environment instances corresponding to the software development tasks, the environment template corresponding to the environment instance is first determined, which can accurately determine the tools and artifacts corresponding to the software development tasks, as well as the dependencies between the tools and artifacts, thereby improving the accuracy of determining the dependencies between the software development tasks based on the tools and artifacts corresponding to the determined software development tasks, as well as the dependencies between the tools and artifacts, and further improving the accuracy of software processing of applications and vehicles, thereby improving the development effect of autonomous driving applications, and further improving the safety and real-time performance of autonomous driving.

[0103] The graphical development environment management system based on pre-built autonomous driving provided in the embodiment of the present application determines the target container corresponding to the software development task according to the software development task, and determines the process of determining the dependency relationship between the software development tasks. The environment instance corresponding to the software development task is determined based on the pre-built graphical development environment management system for autonomous driving, and the target container corresponding to the software development task is determined according to the environment instance corresponding to the software development task. The dependency relationship between the software development tasks is determined according to the environment instance corresponding to the software development task. By first determining the environment instance, the target container corresponding to the software development task and the dependency relationship between the software development tasks can be accurately determined, thereby further improving the efficiency of software processing of applications and vehicles, thereby improving the development effect of autonomous driving applications, and further improving the safety and real-time performance of autonomous driving.

[0104] In a possible embodiment, the process of executing a software development task in a target container corresponding to the software development task according to a dependency relationship may include: according to the dependency relationship, if it is determined that the software development task has no dependent software development tasks, executing the tool of the software development task in the target container corresponding to the software development task to execute the corresponding software development task; according to the dependency relationship, if it is determined that the software development task has dependent software development tasks, after the dependent software development tasks are executed, executing the tool of the software development task in the target container corresponding to the software development task to execute the corresponding software development task.

[0105] Specifically, based on the above description of the relationship between the software development task and the tool, if the tool of the software development task is executed in the target container corresponding to the software development task, the software development task is also executed.

[0106] Specifically, based on the dependency relationship, if it is determined that the software development task is an independent software development task, the tool of the software development task can be executed in the target container corresponding to the software development task to execute the corresponding software development task. Optionally, based on the dependency relationship, if multiple software development tasks are determined to be independent software development tasks, the tools of the software development task can be executed in parallel or in a preset execution order in the target containers corresponding to the software development tasks to execute the corresponding multiple software development tasks. For example, the software development task of the independent software development task can be executed by calling the software development task execution method executeIndependentTasks().

[0107] Specifically, according to the dependency relationship, if it is determined that a software development task has a dependent software development task, after the dependent software development task is executed, the tool of the software development task can be executed in the target container corresponding to the software development task to execute the corresponding software development task.

[0108] Optionally, based on the dependency relationship, if it is determined that a software development task has a dependent software development task, before executing the software development task, it is possible to check whether the dependent software development task has been executed, that is, whether the dependent artifact has been generated. For example, the status check method checkDependencies() can be called to check whether the dependent artifact has been generated.

[0109] Optionally, according to the checking process described above, if it is determined that the software development task on which it depends has not been executed, that is, the artifact on which it depends has not been generated, then the software development task can be controlled to enter the waiting queue. Optionally, after the software development task is controlled to enter the waiting queue, it can be checked regularly at a preset time period whether the software development task on which it depends has been executed, that is, whether the artifact on which it depends has been generated. For example, it can be determined regularly whether the artifact on which it depends has been generated by calling the periodic status check method retryDependenciesCheck().

[0110] Optionally, after the artifact generation is completed, it is also possible to check whether the artifact is in a usable state, so as to improve the reliability of the execution of the software development task and further improve the reliability of the software processing of the application and the vehicle.

[0111] Optionally, a tool for executing a software development task in a target container corresponding to the software development task is executed to execute the corresponding software development task. After the corresponding artifact is output, the information of the output artifact can be recorded in an artifact information table. For example, the artifact information in the artifact information table can be updated by calling the artifact update method updateArtifactStatus(). Optionally, the artifact information included in the artifact information table includes, but is not limited to, artifact name, artifact type, artifact path, and other information. Optionally, if the artifact information table is updated, that is, the artifact status is updated, the software development task that depends on the artifact can be notified to improve the execution efficiency of the software development task, thereby improving the efficiency of software processing of applications and vehicles.

[0112] Optionally, if it is determined that the software development task is a software development task on which other software development tasks depend, the tool for the software development task is executed in the target container corresponding to the software development task to execute the corresponding software development task and output the corresponding artifact, that is, the artifact on which other tasks depend.

[0113] Among them, in the process of executing the software development task in the target container corresponding to the software development task according to the dependency relationship, if it is determined that the software development task has no dependent software development task, then the corresponding software development task is executed directly by means of a tool that executes the software development task in the target container corresponding to the software development task, which can improve the execution efficiency of the software development task. If it is determined that the software development task has dependent software development tasks, then after the dependent software development tasks are executed, the corresponding software development task is executed by means of a tool that executes the software development task in the target container corresponding to the software development task. This can ensure that each software development task is executed in sequence, avoid resource waste and reduce errors, and also improve the execution efficiency and accuracy of the software development tasks. Based on the above description, the efficiency and accuracy of software processing of applications and vehicles can be improved, thereby improving the development effect of autonomous driving applications and further improving the safety and real-time performance of autonomous driving.

[0114] In a possible embodiment, the environment instance further indicates a tool instance corresponding to a tool for the software development task; wherein the tool instance includes instructions for executing the tool;

[0115] Specifically, for a description of the tool instance and the instructions for executing the tool included in the tool instance, please refer to Figure 2 The description of the tool instance table in the illustrated embodiment will not be repeated here.

[0116] Optionally, if the environment instance also indicates a tool instance corresponding to the tool for the software development task; and the tool instance includes instructions for executing the tool, then the process of executing the tool for the software development task in the target container corresponding to the software development task to execute the corresponding software development task may include: in the target container corresponding to the software development task, executing the instructions for executing the tool included in the tool instance corresponding to the tool for the software development task to execute the corresponding software development task.

[0117] Specifically, in a target container corresponding to a software development task, the process of executing the corresponding software development task using the instructions for executing the tool included in the tool instance corresponding to the tool for executing the software development task may include: determining the tool instance corresponding to the tool for the software development task and the instructions for executing the tool included in the tool instance based on the environment instance corresponding to the software development task; and executing the corresponding software development task using the instructions for executing the tool included in the tool instance corresponding to the tool for executing the software development task in the target container corresponding to the software development task.

[0118] Among them, in the process of executing the tool of the software development task in the target container corresponding to the software development task, by first determining the tool instance, the instructions for executing the tool can be accurately determined, thereby improving the accuracy of the execution of the software development task, and further improving the accuracy of the software processing of the application and the vehicle, thereby improving the development effect of the autonomous driving application, and further improving the safety and real-time performance of the autonomous driving.

[0119] In a possible embodiment, the software processing method for an application and a vehicle further includes: determining whether a tool for the software development task is installed in a target container corresponding to the software development task; if it is determined that the tool is installed, executing the tool for executing the software development task in the target container corresponding to the software development task to execute the corresponding software development task; otherwise, generating and presenting prompt information;

[0120] The prompt information indicates that the software development task has failed to be executed. Optionally, the prompt information also indicates the reason for the failure to execute the software development task. Optionally, the prompt information generated here indicates that the reason for the failure to execute the software development task is that the tool for the software development task is not installed in the target container corresponding to the software development task. Optionally, the prompt information also indicates the target container information and the information of the tool not installed.

[0121] Among them, before executing the tool for executing the software development task in the target container corresponding to the software development task to execute the corresponding software development task, it is first determined whether the tool for the software development task is installed in the target container corresponding to the software development task. This can improve the reliability of the execution of the software development tool and further improve the reliability of software processing of applications and vehicles, thereby improving the development effect of autonomous driving applications and further improving the safety and real-time performance of autonomous driving.

[0122] Optionally, in the process of constructing the pre-built autonomous driving graphical development environment management system described above, and in the process of the software processing method of the autonomous driving application graphical developer, it can be implemented through an application programming interface-software development kit API-SDK. Optionally, it can mainly include the following functions:

[0123] The configuration management function (ConfigManager) is used to manage the addition, deletion, modification and query operations of multiple environments, and encapsulates API calls related to environment configuration. For example: Get all environment configuration information supported by the current system, that is, environment instance information, and return a configuration list of all environments, including basic information of each environment, getAllEnvironments(). Get the specific variable configuration of the current configuration environment and return the configuration parameters of the specified environment, getAllEnvironmentConfig(environmentType). Add a new environment configuration, the parameter config is the detailed data of the environment configuration, including environment type, path, required variables and other information, addEnvironment(environmentType, config). Modify the configuration of an existing environment, identify the target environment to be modified according to the environment name (name), and update its configuration, updateEnvironment(name, config). Delete the environment configuration with the specified name. After deletion, the environment will no longer be usable to ensure that only valid environment configurations are retained in the system, deleteEnvironment(name). Support filtering by environment type, return a list of environments that meet the conditions, return a list of environments that meet the conditions, listEnvironmentsByType(type).

[0124] The task management function (TaskManager) is responsible for submitting the task list to be executed for different environment instances. For example: submit a task to a specified environment and return the task ID, submitTask(env, taskConfig). Query the execution status of the task, getTaskStatus(taskId). Get the execution result of the task, getTaskResult(taskId). Cancel the executing task, cancelTask(taskId). Get the execution results of all tasks getAllTaskResults().

[0125] General utility functions (Utility) are used to provide general utility functions, such as parameter validation. For example: validateParameters(params) to verify whether the passed parameters are legal.

[0126] The error handling function (ErrorHandler) is used to uniformly handle errors and ensure that the front end obtains clear error information and response status. For example: return detailed error information based on the error code, handleError(errorCode).

[0127] Optionally, the specific implementation process of the above functions may include:

[0128] During SDK initialization, the user specifies the backend API base URL through the constructors of ConfigManager and TaskManager and completes SDK initialization.

[0129] Environment configuration operation: Users call methods such as addEnvironment and updateEnvironment to operate the backend environment configuration. The method parameters are standardized JSON schemas, and the method call returns a Promise object or exception information.

[0130] Submitting a task: Users submit tasks through the submitTask method, specifying the target environment and task parameters. The SDK automatically converts the task information into a request format that the backend can recognize and returns a unique identifier for the task.

[0131] Query and obtain results: Users call getTaskStatus to query the task execution status, or call getTaskResult to obtain the task result. The SDK automatically processes the backend response and returns standardized result data.

[0132] Error handling: The SDK internally captures network exceptions and configuration errors that may occur during the interface call process, and provides a unified error log and feedback information through ErrorHandler.

[0133] Among them, the application programming interface - software development kit API-SDK has the following functions: Encapsulation of complexity. API-SDK can encapsulate the complex underlying operations in the development environment management system, including but not limited to API calls, tool configuration, environment deployment, etc. Developers do not need to deeply understand these underlying details. They can complete environment configuration, task management and other operations by calling the high-level interface provided by SDK, which greatly reduces the development threshold and makes it easy for non-professional managers to get started. Automated management. Through the interface provided by SDK, developers can automate the creation, update and deletion of execution environments, the scheduling and execution of tasks, and the configuration of tools and resources. This automation capability not only improves work efficiency, but also reduces the risk of human error. Cross-platform and cross-environment management. A major advantage of API-SDK design is its cross-platform and cross-environment management capabilities. SDK encapsulates platform differences, so that developers do not need to care about the subtle differences between different platforms or environments. They only need to call a unified interface to perform the same operations on different platforms or environments. This consistency greatly simplifies the management of the development environment and reduces the complexity of platform switching. Improve development efficiency. Since API-SDK provides high-level interfaces and automation capabilities, developers can focus more on the development of the autonomous driving software itself without spending a lot of time and energy on the management of the development environment. This not only improves development efficiency, but also enables developers to respond to market changes and customer needs more quickly. Promote team collaboration. API-SDK's standardized interfaces and automated management capabilities also help promote team collaboration. Team members can share the same development environment configuration and operation processes, thereby improving the efficiency and consistency of team collaboration. In addition, through API-SDK, team members can also easily share and reuse code and resources, further accelerating the software development process. In summary, API-SDK plays a vital role in the management of the autonomous driving development environment. It encapsulates the underlying complexity, provides high-level interfaces and automated management capabilities, making the management of the development environment more efficient, consistent and predictable.

[0134] Optionally, during the construction process of the pre-built autonomous driving graphical development environment management system described above, and during the software processing method of the autonomous driving application graphical developer, all key data can be uniformly stored through a suitable database table structure env-component.

[0135] Optionally, the data to be stored mainly includes the following parts:

[0136] The creation of an environment template involves multiple configuration files and software packages. The detailed configuration data of the template is stored in the template database table through the API or by calling storeTemplate() to store the configuration information of the template in the database.

[0137] When a user requests to create a new environment instance, the createEnvironmentInstance() method can be called to generate an environment instance according to the configuration content in the template. At this time, the state and configuration of the environment instance generated by the system according to the template data can be saved in the environment instance table.

[0138] The user provides task information by calling submitTask(taskDetails), including the tool to be used and the associated environment instance ID. The execution configuration of the tool depends on the environment instance and template information. The task scheduling module obtains the detailed configuration information of the environment instance through getEnvironmentConfig(). The execution of the tool depends on the configuration file and template definition. The scheduling module dynamically loads the parameters required for tool execution through loadToolConfig(). In addition, it queries whether the tools required for the task are installed in the current environment to ensure that each task runs in the specified environment instance and can call the relevant tools correctly.

[0139] By calling the integrateTaskExecutionData(taskId) method, the above information is integrated into the task scheduling module, and the buildExecutionOrder(taskGraph) method is called to generate the execution order based on the task dependencies. Ensure the relationship between the environment instance and the tool execution. For example, in task scheduling, it is necessary to integrate the environment instance, tool configuration, template definition and other information across modules to determine the execution order of the task.

[0140] When the tool is executed, monitorExecutionStatus() is used to monitor the task status in real time. When the task is executed, the execution log is recorded in real time, and the log information is stored in the log management system through logTaskExecution(taskId, logContent). After the execution is completed, the task status and execution results are updated through updateTaskStatus(). Users can call getTaskDetails(taskId) to view the detailed status, execution log and results of the task.

[0141] By providing a unified interface and standardized data management method, the configuration and management of the development environment are simplified, and through automated task scheduling and tool execution, the efficiency and stability of the environment and task execution are ensured.

[0142] In env-component, data management must first ensure the centralized storage and consistency of data. This requires the design of a suitable database table structure to uniformly store all key data, including environment instances, template information, tool configuration, scheduling tasks, execution logs, etc. Data is stored through a database management system (Sqlite), while ensuring high data availability and high-performance query.

[0143] Figure 3 Schematic diagram of the software processing method of the autonomous driving application graphical developer provided in this application Figure 3 ,like Figure 3 As shown, in this embodiment Figure 1 or Figure 2 Based on the embodiment, the construction process of the pre-built graphical development environment management system for autonomous driving is described in detail. The method includes:

[0144] Step S301: obtain the software package and configuration information of each autonomous driving software in each autonomous driving development environment, and build an environment template corresponding to each autonomous driving development environment based on the software package and configuration information of each autonomous driving software in each autonomous driving development environment.

[0145] Specifically, the software package and configuration information of each autonomous driving software in each autonomous driving development environment can be obtained.

[0146] Among them, the software packages and configuration information of each autonomous driving software in each autonomous driving development environment.

[0147] Optionally, the process of constructing an environment template corresponding to each autonomous driving development environment based on the software package and configuration information of each autonomous driving software under each autonomous driving development environment may include: creating an environment template table and an engineering type table corresponding to each autonomous driving development environment based on the software package and configuration information of each autonomous driving software under each autonomous driving development environment; defining a task flow table, an environment variable table, a workpiece table, and a tool table based on the environment template table; and creating a tool parameter table based on the configuration information and the defined tool table.

[0148] Step S302: construct environment instances corresponding to each environment template according to the environment template corresponding to each autonomous driving development environment.

[0149] Specifically, according to the environment templates corresponding to the development environments of each autonomous driving, environment instances corresponding to each environment template can be constructed.

[0150] Optionally, the process of constructing environment instances corresponding to each environment template according to the environment template corresponding to each autonomous driving development environment may include: creating an environment instance table according to the environment template corresponding to each autonomous driving development environment; creating a container table according to the environment instance table and a list of currently available containers; and creating a tool instance table according to the container table and the environment instance table.

[0151] Among them, the environment instance can be defined based on different environment templates, and different environment templates provide preset environment template tables, project type tables, task flow tables, environment variable tables, workpiece tables, tool tables, and tool parameter tables. Optionally, the preset tables provided by the environment template can be switched and adjusted through the template management function.

[0152] In the process of creating a container table according to the environment instance table and the list of currently available containers, an appropriate container may be selected based on information such as the container name and the environment type.

[0153] To ensure the consistency of task execution, the execution instructions and parameters in all environments are standardized. Different environment instances may require different instruction sets or execution methods. The system adapts and converts the task execution instructions of different development environments through a unified instruction management framework to ensure the feasibility of cross-environment execution.

[0154] Optionally, after the user submits the task, the system binds the task configuration to the target container and calls the execution tool corresponding to the container. The execution tool path, environment variables and other parameter information in the container are automatically passed to the task execution stage through the container configuration. During the task execution process, there may be dependencies between tasks. For example, the input of a task depends on the output of another task. The system arranges tasks through the task management module to ensure that tasks are executed in the correct order. The dependencies between tasks are dynamically resolved and automatically processed to ensure the order of task execution and data consistency.

[0155] Optionally, the system also provides a real-time task status monitoring function, allowing developers to query the execution status of tasks (such as: pending, executing, completed, failed, etc.). The execution status of tasks is tracked through the task management module and returned through a unified API interface. After the task is completed, the system stores the execution results of the task (such as log files, compiled products, etc.) and provides front-end queries through the interface provided by the task management module. In scenarios where there are dependencies between tasks, the system dynamically adjusts the execution logic and data flow of subsequent tasks based on the results of the task output.

[0156] The construction process of the pre-built autonomous driving graphical development environment management system provided in the embodiment of the present application obtains the software package and configuration information of each autonomous driving software in each autonomous driving development environment, and constructs the environment template corresponding to each autonomous driving development environment according to the software package and configuration information of each autonomous driving software in each autonomous driving development environment, and constructs the environment instance corresponding to each environment template according to the environment template corresponding to each autonomous driving development environment, wherein, according to the software package and configuration information of each autonomous driving software in each autonomous driving development environment, the environment template corresponding to each autonomous driving development environment is constructed, so that all environment configurations conform to a unified format, which is convenient for storage, query and modification, can improve the versatility of development environment management, and further improve the versatility of software processing of the autonomous driving application graphical developer, wherein, based on the environment template corresponding to the autonomous driving development environment, the corresponding environment instance can be quickly generated, thereby improving the efficiency of software processing of the autonomous driving application graphical developer.

[0157] Among them, the software processing method of the graphical developer of the autonomous driving application provided in the embodiment of the present application can be implemented based on the graphical development platform of the autonomous driving application, such as the GAASD platform. Optionally, the API-SDK module, Env-Component module, environment configuration module, environment template module and other modules can be set in the graphical development platform to implement the software processing method of the graphical developer of the autonomous driving application provided in the embodiment of the present application.

[0158] Specifically, the API-SDK module is an interface encapsulation library for developers, which provides a set of standardized interfaces for task execution in different environments. Through the SDK, the front-end can interact with the back-end system to implement operations on multi-environment configuration, task submission, task monitoring, and container management.

[0159] Specifically, the Env-Component module is mainly responsible for the schema data management and maintenance of environment configuration, environment templates, and tool orchestration and scheduling. By providing standardized interfaces and Schema data formats, it ensures the standardization of different environment configurations, implements the management of environment templates, and supports different types of task execution and tool scheduling.

[0160] Specifically, the environment configuration module defines the structure and data format of the environment configuration. By using Schema design, the system can standardize and verify the environment configuration. The environment configuration Schema mainly describes information such as environment type, required resources, dependencies, tool execution path, environment variables, container configuration, etc. Ensure that all environment configurations conform to a unified format for easy storage, query, and modification.

[0161] Specifically, the environment template module defines the template format that needs to be followed when creating an environment. It is a collection of multiple predefined configuration items for quickly building a new environment. The environment template schema contains the basic configuration information required for the environment, such as container type, resource requirements, operating system version, dependency packages, execution path, etc. It allows users to quickly generate an environment configuration that meets their needs by selecting an appropriate template without having to manually set each configuration item.

[0162] Figure 4 A schematic diagram of the structure of the software processing device of the autonomous driving application graphical developer provided in this application, such as Figure 4 As shown, the vehicle software processing device 40 provided in this embodiment includes:

[0163] The first determination module 401 is used to determine the software development task corresponding to the target software indicated by the software development instruction in response to the software development instruction; wherein the software development instruction is used to indicate the target software to be developed for the vehicle;

[0164] The second determination module 402 is used to determine the target container corresponding to the software development task based on the pre-built graphical development environment management system for autonomous driving, and determine the dependency relationship between the software development tasks; wherein the graphical development environment management system for autonomous driving is a pre-built system for managing different autonomous driving development environments; the target container is an environment container for executing the software development task;

[0165] The processing module 403 is used to execute the software development task in the target container corresponding to the software development task according to the dependency relationship.

[0166] In one possible implementation, the second determination module 402 includes a first determination unit, which is used to determine the environment instance corresponding to the software development task based on a pre-built graphical development environment management system for autonomous driving; wherein the environment instance is a pre-built instance for executing the software development task; a second determination unit, which is used to determine the target container corresponding to the software development task according to the environment instance corresponding to the software development task; and a third determination unit, which is used to determine the dependency relationship between the software development tasks according to the environment instance corresponding to the software development task.

[0167] In a possible implementation, the environment instance indicates an environment container for executing a software development task; the second determination unit is specifically configured to determine the environment container for executing the software development task indicated by the environment instance as a target container for the software development task corresponding to the environment instance.

[0168] In one possible implementation, the environment instance indicates an environment template on which it is based; wherein the environment template is a template that defines the task flow in different autonomous driving development environments; a third determination unit is specifically used to determine the environment template corresponding to the software development task according to the environment instance corresponding to the software development task; the environment template indicates the tools and artifacts of the software development task, and the dependencies between the tools and artifacts; the tools are used to execute the software development task; the artifacts are obtained after executing the software development task; the dependencies between the software development tasks are determined according to the tools and artifacts of the software development task indicated by the environment template corresponding to the software development task, and the dependencies between the tools and artifacts.

[0169] In one possible implementation, processing module 403 is specifically used to, based on the dependency relationship, if it is determined that the software development task has no independent software development task, execute the tool of the software development task in the target container corresponding to the software development task to execute the corresponding software development task; based on the dependency relationship, if it is determined that the software development task has a dependent software development task, after the dependent software development task is executed, execute the tool of the software development task in the target container corresponding to the software development task to execute the corresponding software development task.

[0170] In one possible implementation, the environment instance also indicates a tool instance corresponding to the tool for the software development task; wherein the tool instance includes instructions for executing the tool; the processing module 403 is further specifically used to execute the instructions for executing the tool included in the tool instance corresponding to the tool for the software development task in a target container corresponding to the software development task, so as to execute the corresponding software development task.

[0171] In one possible implementation, the processing module 403 is also used to determine whether a tool for the software development task is installed in the target container corresponding to the software development task; if it is determined to be installed, the tool for executing the software development task in the target container corresponding to the software development task is executed to execute the corresponding software development task; otherwise, a prompt message is generated and presented; wherein the prompt message indicates a failure in executing the software development task.

[0172] In one possible implementation, the processing module 403 is further used to obtain the software package and configuration information of each autonomous driving software in each autonomous driving development environment, and to construct an environment template corresponding to each autonomous driving development environment based on the software package and configuration information of each autonomous driving software in each autonomous driving development environment; and to construct an environment instance corresponding to each environment template based on the environment template corresponding to each autonomous driving development environment.

[0173] The vehicle software processing device provided in this embodiment can execute the method provided in the above method embodiment. Its implementation principle and technical effect are similar, and this embodiment will not be described in detail here.

[0174] Figure 5 This is a schematic diagram of the structure of the electronic device provided in this application. Figure 5 As shown, the electronic device 50 provided in this embodiment includes: at least one processor 501 and a memory 502. Optionally, the device 50 also includes a communication component 503. The processor 501, the memory 502 and the communication component 503 are connected via a bus 504.

[0175] In a specific implementation process, at least one processor 501 executes the computer-executable instructions stored in the memory 502, so that at least one processor 501 executes the above method.

[0176] The specific implementation process of the processor 501 can be found in the above method embodiment, and its implementation principle and technical effect are similar, so this embodiment will not be repeated here.

[0177] In the above embodiments, it should be understood that the processor may be a central processing unit (CPU), or other general-purpose processors, digital signal processors (DSP), application-specific integrated circuits (ASIC), etc. A general-purpose processor may be a microprocessor or any conventional processor. The steps of the method disclosed in the invention may be directly implemented as being executed by a hardware processor, or may be executed by a combination of hardware and software modules in the processor.

[0178] The memory may include a high-speed memory (Random Access Memory, RAM), and may also include a non-volatile memory (Non-volatile Memory, NVM), such as at least one disk memory.

[0179] The bus may be an Industry Standard Architecture (ISA) bus, a Peripheral Component Interconnect (PCI) bus, or an Extended Industry Standard Architecture (EISA) bus, etc. The bus may be divided into an address bus, a data bus, a control bus, etc. For ease of representation, the bus in the drawings of the present application is not limited to only one bus or one type of bus.

[0180] The present application also provides a computer program product, including a computer program, which implements the above method when executed by a processor.

[0181] The present application also provides a computer-readable storage medium, in which computer-executable instructions are stored. When a processor executes the computer-executable instructions, the above method is implemented.

[0182] The above-mentioned readable storage medium can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as static random access memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, magnetic disk or optical disk. The readable storage medium can be any available medium that can be accessed by a general or special-purpose computer.

[0183] An exemplary readable storage medium is coupled to a processor so that the processor can read information from the readable storage medium and write information to the readable storage medium. Of course, the readable storage medium can also be a component of the processor. The processor and the readable storage medium can be located in an application specific integrated circuit (Application Specific Integrated Circuits, referred to as: ASIC). Of course, the processor and the readable storage medium can also exist in the device as discrete components.

[0184] The division of units is only a logical function division, and there may be other divisions in actual implementation, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be an indirect coupling or communication connection through some interface, device or unit, which can be electrical, mechanical or other forms.

[0185] The units described as separate components may or may not be physically separated, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed on multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.

[0186] In addition, each functional unit in each embodiment of the present invention may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit.

[0187] If the function is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, or the part that contributes to the prior art, or the part of the technical solution, can be embodied in the form of a software product. The computer software product is stored in a storage medium, including several instructions for a computer device (which can be a personal computer, server, or network device, etc.) to perform all or part of the steps of the methods of each embodiment of the present invention. The aforementioned storage medium includes: U disk, mobile hard disk, read-only memory (ROM, Read-Only Memory), random access memory (RAM, Random Access Memory), disk or optical disk, etc. Various media that can store program codes.

[0188] Those skilled in the art can understand that all or part of the steps of implementing the above-mentioned method embodiments can be completed by hardware related to program instructions. The aforementioned program can be stored in a computer-readable storage medium. When the program is executed, the steps of the above-mentioned method embodiments are executed; and the aforementioned storage medium includes: ROM, RAM, disk or optical disk and other media that can store program codes.

[0189] Finally, it should be noted that those skilled in the art will readily conceive of other embodiments of the present invention after considering the specification and practicing the invention disclosed herein. The present invention is intended to cover any variations, uses or adaptations of the present invention, which follow the general principles of the present invention and include common knowledge or customary technical means in the art not disclosed by the present invention, are not limited to the precise structure described above and shown in the drawings, and may be modified and changed in various ways without departing from the scope thereof. The scope of the present invention is limited only by the appended claims.

Claims

1. A software processing method for an autonomous driving application graphical developer, characterized in that: include: In response to the software development instruction, determining a software development task corresponding to the target software indicated by the software development instruction; wherein the software development instruction is used to indicate the target software to be developed for the vehicle; Based on a pre-built graphical development environment management system for autonomous driving, according to the software development task, a target container corresponding to the software development task is determined, and the dependency relationship between the software development tasks is determined; wherein the graphical development environment management system for autonomous driving is a pre-built system for managing different autonomous driving development environments; the target container is an environment container for executing the software development task; The software development task is executed in a target container corresponding to the software development task according to the dependency relationship.

2. The method according to claim 1, characterized in that Based on the pre-built graphical development environment management system for autonomous driving, according to the software development task, a target container corresponding to the software development task is determined, and dependencies between the software development tasks are determined, including: Based on the pre-built graphical development environment management system for autonomous driving, determine the environment instance corresponding to the software development task; wherein the environment instance is a pre-built instance for executing the software development task; Determining a target container corresponding to the software development task according to the environment instance corresponding to the software development task; Dependencies between the software development tasks are determined according to the environment instances corresponding to the software development tasks.

3. The method according to claim 2, characterized in that The environment instance indicates an environment container for executing a software development task; Determining a target container corresponding to the software development task according to the environment instance corresponding to the software development task includes: The environment container for executing the software development task indicated by the environment instance is determined as the target container of the software development task corresponding to the environment instance.

4. The method according to claim 2, characterized in that: The environment instance indicates an environment template based on which the environment template is defined; wherein the environment template is a template for defining task flows in different autonomous driving development environments; Determining dependencies between the software development tasks according to the environment instances corresponding to the software development tasks includes: Determine an environment template corresponding to the software development task according to the environment instance corresponding to the software development task; the environment template indicates the tools and artifacts of the software development task, and the dependency relationship between the tools and artifacts; the tools are used to execute the software development task; the artifacts are obtained after executing the software development task; Dependencies between the software development tasks are determined based on the tools and artifacts of the software development tasks indicated by the environment template corresponding to the software development tasks, and the dependencies between the tools and artifacts.

5. The method according to claim 4, characterized in that Executing the software development task in a target container corresponding to the software development task according to the dependency relationship includes: If it is determined according to the dependency relationship that the software development task has no dependent software development task, a tool for the software development task is executed in a target container corresponding to the software development task to execute the corresponding software development task; According to the dependency relationship, if it is determined that the software development task has a dependent software development task, after the dependent software development task is executed, the tool of the software development task is executed in the target container corresponding to the software development task to execute the corresponding software development task.

6. The method according to claim 5, characterized in that The environment instance also indicates a tool instance corresponding to a tool for a software development task; wherein the tool instance includes instructions for executing the tool; A tool for executing a software development task in a target container corresponding to the software development task to execute the corresponding software development task includes: In the target container corresponding to the software development task, the tool instance corresponding to the tool for executing the software development task includes the instructions for executing the tool, so as to execute the corresponding software development task.

7. The method according to claim 5, characterized in that The method further comprises: Determining whether a tool for the software development task is installed in a target container corresponding to the software development task; If it is determined that it has been installed, executing a tool for executing the software development task in a target container corresponding to the software development task to execute the corresponding software development task; Otherwise, a prompt message is generated and presented; wherein the prompt message indicates that the execution of the software development task has failed.

8. The method according to any one of claims 1 to 6, characterized in that: The construction process of the pre-built autonomous driving graphical development environment management system includes: Obtaining software packages and configuration information of each autonomous driving software in each autonomous driving development environment, and constructing environment templates corresponding to each autonomous driving development environment according to the software packages and configuration information of each autonomous driving software in each autonomous driving development environment; According to the environment templates corresponding to the development environments of each autonomous driving, environment instances corresponding to each environment template are constructed.

9. A software processing device for an autonomous driving application graphical developer, characterized in that: include: A first determination module is used to determine, in response to a software development instruction, a software development task corresponding to the target software indicated by the software development instruction; wherein the software development instruction is used to indicate the target software to be developed for the vehicle; A second determination module is used to determine, based on a pre-built graphical development environment management system for autonomous driving, a target container corresponding to the software development task according to the software development task, and to determine dependencies between the software development tasks; wherein the graphical development environment management system for autonomous driving is a pre-built system for managing different autonomous driving development environments; and the target container is an environment container for executing software development tasks; A processing module is used to execute the software development task in a target container corresponding to the software development task according to the dependency relationship.

10. An electronic device, characterized in that: include: Memory, processor; The memory stores computer-executable instructions; The processor executes the computer-executable instructions stored in the memory, so that the processor performs the method according to any one of claims 1 to 8.

Images