Task execution method and device of heterogeneous system, computer device and storage medium

Abstract

Embodiments of the present application disclose a task execution method and device of a heterogeneous system, computer equipment and a storage medium, and relate to the technical field of computers. The method is used in an edge node in a heterogeneous system, the heterogeneous system is composed of a center node and edge nodes, and each edge node is used to implement the same function. The method comprises: receiving a target task issued by the center node, the target task being used to instruct the edge node to implement a process of a target function, and different edge nodes corresponding to the same target task; converting the target task into a target executable file according to a self-architecture system, the target executable file being composed of executable instructions, and different architecture systems corresponding to different executable files; and running the target executable file to implement the target function. The step of converting the target task into the target executable file is allocated to the edge node, which reduces the amount of data processed by the center node, reduces the occupation of network bandwidth, and improves the real-time performance of issuing the target task.

Description

Technical Field

[0001] This application relates to the field of computer technology, and in particular to a task execution method, apparatus, computer device, and storage medium for heterogeneous systems. Background Technology

[0002] When a central node in a heterogeneous system issues a target task to an edge node, it generates the target task at the central node and generates an executable file based on the architecture of the edge nodes that need to execute the target task.

[0003] In related technologies, edge nodes in heterogeneous systems typically choose different architectures based on different working environments or scenarios, such as x86 architecture and ARM architecture. For different architectures, the central node needs to generate corresponding executable files for the specific architecture of the edge node before it can be distributed to the edge node for execution. Summary of the Invention

[0004] This application provides a task execution method, apparatus, computer device, and storage medium for heterogeneous systems. The technical solution is as follows:

[0005] On one hand, embodiments of this application provide a task execution method for a heterogeneous system. The method is used for edge nodes in the heterogeneous system, which consists of a central node and edge nodes, with each edge node performing the same function. The method includes:

[0006] The center node receives a target task, which is used to instruct the edge node to implement the target function, and different edge nodes correspond to the same target task.

[0007] The target task is converted into a target executable file according to its own architecture. The target executable file consists of executable instructions, and different architectures correspond to different executable files.

[0008] Run the target executable file to achieve the target function.

[0009] On the other hand, embodiments of this application provide a task execution method for a heterogeneous system. The method is used for a central node in the heterogeneous system, which consists of a central node and edge nodes, with each edge node performing the same function. The method includes:

[0010] A target task is generated based on the target function to be implemented by the edge node. The target task is used to instruct the edge node to implement the target function, and different edge nodes correspond to the same target task.

[0011] Receive the selection operation for the edge node and send the target task to the edge node.

[0012] On the other hand, embodiments of this application provide a task execution device for a heterogeneous system. The device is used for edge nodes in the heterogeneous system, which consists of a central node and edge nodes, with each edge node performing the same function. The device includes:

[0013] The receiving module is used to receive the target task issued by the central node. The target task is used to instruct the edge node to implement the target function, and different edge nodes correspond to the same target task.

[0014] The conversion module is used to convert the target task into a target executable file according to its own architecture. The target executable file consists of executable instructions, and different architectures correspond to different executable files.

[0015] The runtime module is used to run the target executable file to achieve the target function.

[0016] On the other hand, embodiments of this application provide a task execution device for a heterogeneous system. The device is used as a central node in the heterogeneous system, which consists of a central node and edge nodes, with each edge node performing the same function. The device includes:

[0017] The generation module is used to generate target tasks based on the target functions to be implemented by the edge nodes. The target tasks are used to instruct the edge nodes on the process of implementing the target functions, and different edge nodes correspond to the same target tasks.

[0018] The sending module is used to receive the selection operation for the edge node and send the target task to the edge node.

[0019] On the other hand, embodiments of this application provide a heterogeneous system, which includes edge nodes and a central node; the edge nodes and the central node are respectively used to implement the task execution method of the heterogeneous system described above.

[0020] On the other hand, embodiments of this application provide a computer device, the computer device including a processor and a memory; the memory stores at least one instruction, the at least one instruction being executed by the processor to implement the task execution method of the heterogeneous system described above.

[0021] On the other hand, embodiments of this application provide a computer-readable storage medium storing a computer program, which is loaded and executed by a processor to implement the task execution method for heterogeneous systems described above.

[0022] On the other hand, embodiments of this application provide a computer program product, which includes computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform the task execution method for heterogeneous systems described above.

[0023] The beneficial effects of the technical solutions provided in this application include at least the following:

[0024] In this embodiment, edge nodes in a heterogeneous system receive target tasks from the central node, convert the target tasks into corresponding executable files based on their own architecture, and then run the executable files to achieve the corresponding target functions. Compared to the method where the central node converts the target file into a corresponding executable file based on the specific architecture of the edge node, this solution distributes the step of converting the target task into an executable file to the edge nodes. This reduces the amount of data processed by the central node, lowers network bandwidth usage, and improves the real-time performance of sending target tasks. Attached Figure Description

[0025] Figure 1 A network topology diagram of a heterogeneous system provided in one embodiment of this application is shown;

[0026] Figure 2 A flowchart illustrating a task execution method for a heterogeneous system provided in an exemplary embodiment of this application is shown;

[0027] Figure 3 A flowchart illustrating a task execution method for a heterogeneous system provided in another exemplary embodiment of this application is shown;

[0028] Figure 4 A flowchart of a task execution method for a heterogeneous system provided in another exemplary embodiment of this application is shown;

[0029] Figure 5 This is a DAG graph constructed based on process information and target operators, provided in an exemplary embodiment of this application;

[0030] Figure 6 A flowchart illustrating a task execution method for a heterogeneous system provided in another exemplary embodiment of this application is shown;

[0031] Figure 7 It shows a structural block diagram of a task execution device for a heterogeneous system provided in one embodiment of this application;

[0032] Figure 8 This invention provides a structural block diagram of a task execution device for a heterogeneous system according to an embodiment of the present application.

[0033] Figure 9 A structural block diagram of a computer device provided in an exemplary embodiment of this application is shown. Detailed Implementation

[0034] To make the objectives, technical solutions, and advantages of this application clearer, the embodiments of this application will be described in further detail below with reference to the accompanying drawings.

[0035] In this article, "multiple" refers to two or more. "And / or" describes the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can represent: A alone, A and B simultaneously, or B alone. The character " / " generally indicates that the preceding and following related objects have an "or" relationship.

[0036] Network topology diagram: A network topology diagram refers to the physical layout of various devices interconnected by transmission media; it connects computers and other devices in a network in a specific way. A network topology diagram typically shows the network configuration and interconnections of network servers, computer devices, and workstations. Its structure mainly includes star, ring, bus, distributed, tree, mesh, and cellular topologies. In this embodiment, the network topology diagram includes central and edge nodes. The central node is the computer device or network server that issues tasks, while the edge nodes are the edge devices used to execute tasks.

[0037] Heterogeneous architecture: Computer processors typically encompass different architectures, each with its own instruction set. For example, the ARM and x86 architectures correspond to different instruction sets. Computer devices with different architectures need to encode instructions according to their own instruction sets, compiling the source code into corresponding binary files before they can be executed.

[0038] In related technologies, when a central node needs to send tasks to edge nodes, the tasks to be sent must first be designed at the central node. However, due to differences in working environments and actual needs, different edge nodes usually adopt different architectures to form heterogeneous systems. Since different architectures correspond to different instruction sets, when sending tasks, the central node needs to compile the tasks to be sent into different versions of executable files according to the specific architecture of the edge nodes, and then send them to the edge nodes. When the heterogeneous system contains many edge nodes with different architectures, the central node needs to compile the corresponding version of the executable file for the edge nodes with different architectures. When the sent tasks contain a large amount of data, it will compete for network bandwidth and affect the real-time performance of the sent tasks.

[0039] In this embodiment, when a task needs to be distributed, the process of compiling the executable file is extracted from the central node and instead distributed to the edge nodes that need to execute the task. The central node is only responsible for generating the task to be distributed and then distributing it to the specific edge nodes. When the edge node receives the distributed task, it compiles it into the corresponding executable file according to its own architecture and then executes it. By distributing the step of converting the executable file to the specific edge nodes, the amount of data processed by the central node can be reduced, network bandwidth consumption can be reduced, and the real-time performance of task distribution can be improved.

[0040] Please refer to Figure 1 This diagram illustrates a network topology of a heterogeneous system according to an embodiment of this application. The network topology includes a central node 110 and edge nodes 120.

[0041] A network topology diagram typically includes at least one central node 110 and multiple edge nodes 120. The central node 110 is a computer device or network server in a heterogeneous system responsible for distributing tasks. When the central node 110 is a network server, it can be at least one of a single server, multiple servers, a cloud computing platform, or a virtualization center, primarily providing backend services to the edge nodes 120. Alternatively, an edge node can be a computer device or workstation responsible for managing all edge nodes 120. In this embodiment, the central node 110 generates and distributes target tasks to the edge nodes 120. Optionally, the central node 120 can also provide data upload and download services to the edge nodes 120, and can also receive feedback from the edge nodes 120 regarding the task processing process and results.

[0042] The central node 110 establishes a communication connection with the edge node 120 through a wireless network or a wired network.

[0043] Edge node 120 is at least one of electronic devices such as mobile phones, desktop computers, tablet computers, multimedia playback devices, and laptop computers, as well as workstations. In this embodiment, edge node 120 is a heterogeneous architecture, meaning that edge node 120 specifically includes multiple architecture systems. Different architecture systems correspond to different instruction sets. Edge node 120 is used to receive tasks issued by central node 110, compile the issued tasks into executable files, and then implement the corresponding target functions. Optionally, all edge nodes 120 in this heterogeneous system can implement the same functions. Optionally, edge node 120 can also upload and download data through central node 110, and provide feedback to central node 110 on the processing process and results of tasks.

[0044] Please refer to Figure 2 This document illustrates a flowchart of a task execution method for a heterogeneous system provided in an exemplary embodiment of this application. This embodiment uses this method for... Figure 1 Taking edge node 120 as an example, the method includes the following steps:

[0045] Step 201: Receive the target task issued by the central node. The target task is used to instruct the edge nodes to implement the target function, and different edge nodes correspond to the same target task.

[0046] A central node is a device in a heterogeneous system that manages edge nodes. The central node issues target tasks to the edge nodes, enabling them to perform corresponding target functions. Typically, a heterogeneous system contains multiple edge nodes. The central node establishes a network topology with all edge nodes to achieve unified management. This network topology can be one of several structures, such as star, ring, bus, distributed, or mesh, depending on the specific tasks performed by the edge nodes and the environment. Furthermore, when the network topology is complex and to ensure orderly management of all edge nodes, multiple central nodes can be set up in the heterogeneous system. These central nodes can exchange data to improve the stability of the heterogeneous system. The specific network topology and the number of central nodes can be determined based on actual conditions; this embodiment does not impose any limitations on this.

[0047] In a heterogeneous system, edge nodes are responsible for receiving target tasks from the central node. Edge nodes are typically devices deployed in the field environment. They execute corresponding target functions based on the assigned target tasks. The target task instructs the edge node on the process to achieve the target function. The edge node executes the process sequentially according to the target task to achieve the corresponding target function. Furthermore, different edge nodes in a heterogeneous system can simultaneously receive and execute the same target task based on the established network topology.

[0048] Step 202: Convert the target task into a target executable file according to its own architecture. The target executable file consists of executable instructions, and different architectures correspond to different executable files.

[0049] Because heterogeneous systems typically contain numerous edge nodes, and these edge nodes often employ heterogeneous hardware architectures to meet their operational requirements based on their specific working environments and functionalities, different architectures can only run corresponding file formats. For example, ARM, x86, MIPS, and RISC architectures each have different instruction sets, thus only running their respective executable versions. When a central node needs to distribute target tasks to multiple edge nodes across various architectures, the central node must convert each target task into a separate executable version for each edge node before distributing it to enable the edge nodes to perform their intended functions. However, this approach hinders unified management of edge nodes, increases the data volume processed by the central node, and impacts the real-time performance of task distribution. Therefore, this solution directly distributes the generated target tasks to the edge nodes, distributing the conversion of the target executable files to each edge node. Each edge node then converts the target task into the corresponding executable file based on its own architecture. The generated executable files differ for edge nodes with different architectures.

[0050] To illustrate, edge node A and edge node B are computer devices deployed using ARM architecture and x86 architecture, respectively. When edge node A and edge node B receive the target task issued by the central node, edge node A converts the target task into executable file A based on the ARM architecture, while edge node B converts the target task into executable file B based on the x86 architecture. Executable file A and executable file B are respectively composed of executable instructions of the corresponding architecture.

[0051] Step 203: Run the target executable file to achieve the target function.

[0052] Once the edge node converts the target task into a target executable file based on its own architecture, it runs the target executable file to achieve the corresponding target function.

[0053] Optionally, during the execution of the target executable file, the edge node can also feed back the generated data and data processing results to the central node.

[0054] In summary, in this embodiment, edge nodes in a heterogeneous system receive target tasks from the central node, convert the target tasks into corresponding executable files based on their own architecture, and then run the executable files to achieve the corresponding target functions. Compared to the method where the central node converts the target file into a corresponding executable file based on the specific architecture of the edge node, this solution distributes the step of converting the target task into an executable file to the edge nodes. This reduces the amount of data processed by the central node, lowers network bandwidth usage, and improves the real-time performance of issuing target tasks.

[0055] Please refer to Figure 3 This document illustrates a flowchart of a task execution method for a heterogeneous system provided in an exemplary embodiment of this application. This embodiment uses this method for... Figure 1 Taking the central node 110 shown as an example, the method includes the following steps:

[0056] Step 301: Generate target tasks based on the target functions of edge nodes. The target tasks are used to instruct the edge nodes on the process of implementing the target functions, and different edge nodes correspond to the same target tasks.

[0057] When a central node requires edge nodes in a heterogeneous system to perform specific target functions, it needs to generate corresponding target tasks based on the process by which the edge nodes perform these functions. This allows the edge nodes to execute the target tasks according to the specific process after receiving them. Furthermore, different edge nodes in a heterogeneous system can simultaneously receive and execute the same target tasks based on the established network topology.

[0058] Step 302: Receive the selection operation for the edge node and send the target task to the edge node.

[0059] Since heterogeneous systems typically contain multiple edge nodes, users need to select the edge node that needs to perform the target function based on actual requirements. When the central node receives the selection operation for the edge node, it sends the target task to the corresponding edge node so that the edge node that receives the target task can execute the target task.

[0060] In one possible approach, the network topology can be viewed at the central node, and the edge nodes from which the target task needs to be sent can be selected. After receiving the selection operation for the edge node, the target task can be sent to the selected edge node.

[0061] Since the central node only needs to generate target tasks based on the target functions of the edge nodes, it does not need to know the architecture of the edge nodes, nor does it need to convert the target tasks into target executable files that can be executed by the corresponding architecture. Therefore, the real-time performance of issuing target tasks is higher. After the edge nodes receive the target tasks, they then convert the target tasks according to their own architecture to achieve the corresponding target functions.

[0062] In summary, in this embodiment, the central node in the heterogeneous system generates target tasks based on the target functions that the edge nodes need to implement. After generating the target tasks, the central node does not convert the target tasks into executable target files according to the architecture of the edge nodes. Instead, upon receiving a selection operation for an edge node, the central node directly sends the target tasks to the selected edge nodes, enabling the edge nodes receiving the target tasks to implement the corresponding target functions. In comparison, this scheme can reduce the amount of data processed by the central node, reduce network bandwidth consumption, and achieve higher real-time performance in sending target tasks.

[0063] Please refer to Figure 4 This document illustrates a flowchart of a task execution method for a heterogeneous system provided in an exemplary embodiment of this application. This embodiment uses this method for... Figure 1 Taking the center node 110 and edge node 120 as examples, the method includes the following steps:

[0064] Step 401: Based on the target function of the edge node, the central node determines the process information corresponding to the target function, as well as the target operator and configuration parameters used when executing the process indicated by the process information.

[0065] In a heterogeneous system, the central node distributes target tasks to all edge nodes through a task publishing platform or application. This task publishing platform has the function of generating target tasks. Optionally, the central node can also use this task publishing platform to monitor tasks and schedule resources for all edge nodes.

[0066] Typically, before issuing a target task to an edge node, the central node needs to determine the process information, target operators, and configuration parameters to be used when executing the processes indicated by the process information, based on the target functions required by the edge nodes. The process information indicates the various processes that the edge nodes need to execute, while the target operators and configuration parameters implement the functions of each process. The target operators are selected from the operator library in the task issuing platform, which contains operators that implement the entire process.

[0067] To ensure that edge nodes can recognize the target tasks issued by the central node, the operator libraries of the edge nodes and the central node need to be consistent. That is, when a user adds an operator to the operator library of the central node, the operator libraries of all edge nodes in the heterogeneous system can be automatically synchronized through the task publishing platform to ensure that the operator libraries of the edge nodes and the central node are consistent.

[0068] For illustration, if the target function is for edge nodes to detect body temperature and mask wearing status of people in a passageway, the corresponding process information includes image acquisition, video decoding, mask detection, and image writing. The corresponding target operators are acquisition operator, decoding operator, detection operator, and writing operator. The configuration information consists of the relevant parameters that need to be configured for the corresponding process. For example, configuration parameters for the image acquisition process include the camera's acquisition frequency and resolution, while configuration parameters for the decoding process include image format and image conversion frequency.

[0069] Step 402: Construct a directed acyclic graph (DAG) based on process information and target operators.

[0070] The purpose of obtaining the target operator and configuration parameters is to construct a Directed Acyclic Graph (DAG). DAGs are widely used in task simulation and resource scheduling. Running distributed programs or distributed systems through DAGs is more logical and also facilitates task deployment.

[0071] Taking the aforementioned target function as an example, such as Figure 5 It is a DAG graph constructed based on process information and target operators. The DAG graph includes image acquisition process 501, video decoding process 502, object detection process 503, and image writing process 504. Each process corresponds to a node in the DAG graph, and each node has its own target operator and configuration parameters, which are used to control the edge nodes to perform corresponding functions according to the preset configuration parameters and processes.

[0072] Step 403: Convert the DAG graph into a target task. The target task is in at least one of markup language format and JSON format.

[0073] Since the central node cannot directly distribute the DAG graph to the edge nodes, after the central node constructs the DAG graph, it is also necessary to convert the DAG graph into a target task. The target task can be in at least one of markup language format and JSON format, such as converting the DAG graph into a target task in Extensible Markup Language (XML) format.

[0074] Step 404: Obtain the edge node list, which contains at least one edge node.

[0075] After generating the target task, it is also necessary to select the edge nodes to distribute the target task. In one possible implementation, an edge node list can be retrieved from the task publishing platform. The edge node list displays all edge nodes included in the heterogeneous system. In addition, it can also display the system architecture adopted by the edge nodes and the specific location of the edge nodes. Users can select the edge node to distribute the target task from the edge node list according to their actual needs, as shown in Table 1.

[0076] Table 1

[0077] edge nodes System Architecture Location Edge node A X86 Export A Edge node B ARM Export B Edge node C MIPS Export C

[0078] For example, when a user wants the edge nodes at exit A and exit C to execute a target task, then edge node A and edge node C are the edge nodes that need to issue the target task.

[0079] In another possible implementation, the network topology diagram of the heterogeneous system can also be displayed in the task publishing platform, and the location information of the edge nodes can be marked in the network topology diagram. Users can select edge nodes according to the location information.

[0080] Step 405: Receive the selection operation for edge nodes and send the target task to the selected edge nodes.

[0081] Once the central node receives the selection operation for the edge node, it sends the target task to the selected edge node.

[0082] In typical heterogeneous systems, edge nodes encompass multiple system architectures. If the central node were to generate corresponding executable files for each system architecture's edge nodes, it would increase its workload. Furthermore, after generating the corresponding executable files, it would need to select edge nodes sequentially according to the corresponding system architecture before distributing them, further reducing task delivery efficiency. To effectively reduce the workload of the central node and improve task delivery efficiency, after generating the target task, the central node no longer transforms the target task but directly distributes it to the edge nodes, which then transform it into the target executable file based on their own architecture.

[0083] Step 406: Receive the target task issued by the central node. The target task is used to instruct the edge nodes to implement the target function, and different edge nodes correspond to the same target task.

[0084] The implementation method of this step can be referred to step 201, and will not be repeated here in this embodiment.

[0085] Step 407: The edge node parses the target task to determine the process information and configuration parameters for implementing the target function. The target task is in at least one of markup language format and JSON format.

[0086] The selected edge nodes receive the target task from the central node via a network connection. The format of the target task received by the edge nodes is consistent with that in step 403, such as an XML format target task. After receiving the target task, the edge nodes begin to parse it. The purpose of parsing is to determine the process and target operators required to achieve the target function. Figure 6 As shown, the specific process of parsing the target task may include the following steps:

[0087] Step 407A: Obtain the parameter information contained in the target task.

[0088] As can be seen from the above, the central node converts the DAG graph into a target task in a markup language format or JSON format that is easy to transmit. However, the edge nodes cannot directly run the target task in this format. At this time, it is necessary to first read the parameter information contained in the target task. This parameter information contains the process information for implementing the target function, as well as the target operator and configuration parameters used when executing the process information.

[0089] Step 407B: Based on the parameter information, determine the process information and the target operator and configuration parameters to be used when executing the process indicated by the process information.

[0090] Since the edge nodes and the central nodes use a unified task publishing platform and have the same operator library, after the edge nodes obtain the parameter information contained in the target task, they match the parameter information with the operators in the operator library to determine the flow information of the target task and the target operator and configuration parameters used when executing the flow indicated by the flow information.

[0091] As illustrated in the example above, the acquisition operator, decoding operator, detection operator, and writing operator are matched from the operator library. The corresponding process information includes the acquisition process, video decoding process, object detection process, and image writing process. Furthermore, the configuration parameters for each process can be determined. For example, the acquisition process is configured with a camera shooting frequency of 5MHz; the video decoding process is configured with an h264 video format; the object detection process is configured with human body temperature (detected by a temperature sensor at edge nodes) and the wearing of a mask; and the image writing process is configured with a bounding box for the face and display of human body temperature information. Optionally, alarm parameters can also be set to display alarm information in the image when a human body temperature exceeds the normal range or when a mask is not worn.

[0092] In one possible implementation, to ensure that edge nodes can accurately perform the target function according to the target task, after obtaining the process information, target operator, and configuration parameters, a DAG graph can be further constructed and then verified. The verification can include verifying the logical order and data structure of the DAG graph. When the data structure or logical order is incorrect, error information can be promptly reported to the central node, instructing the central node to reissue the target task. When the verification of the DAG graph passes, step 408 is then executed.

[0093] Step 408: Based on the instruction set, process information, and configuration parameters corresponding to its own architecture, the target task is converted into a target executable file.

[0094] Once the edge node obtains the process information and configuration parameters, it can convert the target task into a target executable file based on its own architecture. For different architectures, due to differences in instruction sets, it is also necessary to convert the target operators and configuration parameters into executable command lines, compile them, and obtain a target executable file executable for the corresponding architecture before the target function can be implemented. Specifically, for example... Figure 8 As shown, the process may also include the following steps:

[0095] Step 408A: Based on the target operator and configuration parameters, the target task is converted into an executable command line.

[0096] After the edge node determines the target operator and configuration parameters, it converts the target task into an executable command line through the task publishing platform. The executable command line is a programming language that the edge node can recognize, such as C or Python.

[0097] Step 408B: Based on the instruction set corresponding to its own architecture, compile the executable command line into a target executable file.

[0098] As shown in Table 1, edge nodes in heterogeneous systems typically employ multiple architectures due to their varying working environments and different hardware computing power requirements. Different architectures correspond to different instruction sets, thus necessitating the generation of target executable files in corresponding formats.

[0099] Using the illustrative example above, the ARM architecture uses a unified instruction set format with fewer types, resulting in faster processing speeds but lower computing power. In contrast, the x86 architecture has a more complex and diverse instruction set, leading to slower processing speeds but providing greater computing power, making it suitable for handling complex tasks. Therefore, in densely populated areas with high foot traffic, edge nodes often require higher computing power, so edge node A can use the x86 architecture. Conversely, in areas with lower foot traffic where computing power requirements are less stringent, edge node B can use the ARM architecture.

[0100] After the edge node converts the target task into an executable command line, it also needs to compile the executable command line according to its own architecture. The compilation process can be implemented through the compilation module in the task publishing platform, or the edge node can compile the executable command line through a compiler to obtain the target executable file. Since the instruction sets of edge nodes with different architectures are not the same, the target executable files obtained after compilation are also different.

[0101] Step 409: Run the target executable file to achieve the target function.

[0102] Once the edge node is compiled into the target executable file, it is then run to implement the corresponding target function.

[0103] It should be noted that the target executable file is a binary file compiled by the edge node according to the instruction set. Although the target executable files compiled by edge nodes of different architectures are not the same, the target functions implemented are the same. For example, they can all detect body temperature and mask wearing status of people.

[0104] In this embodiment of the application, the process of converting the target task into the target executable file is transferred from the central node to the edge node. The central node is only responsible for constructing the directed acyclic graph (DAG) based on the process information and the target operator, converting the DAG into the target task, and then sending the target task to the designated edge node. The target executable file is no longer compiled according to the architecture of the edge node.

[0105] For edge nodes that receive the target task, the target operator and configuration parameters contained in the parameter information are obtained by parsing the parameter information in the target task, which facilitates the subsequent construction of the DAG graph and its verification and compilation.

[0106] After the edge node determines the target operator and configuration parameters, it further transforms the target task into an executable command line. This allows the executable command line to be compiled into a target executable file based on the instruction set corresponding to its own architecture, and then the target executable file to be run to achieve the target function.

[0107] refer to Figure 7 This illustrates a structural block diagram of a task execution device in a heterogeneous system provided in one embodiment of this application.

[0108] The device is used for edge nodes in a heterogeneous system, which consists of a central node and edge nodes, with each edge node performing the same function. The device includes:

[0109] The receiving module 701 is used to receive the target task issued by the central node. The target task is used to instruct the edge node to implement the target function, and different edge nodes correspond to the same target task.

[0110] The conversion module 702 is used to convert the target task into a target executable file according to its own architecture. The target executable file consists of executable instructions, and different architectures correspond to different executable files.

[0111] The execution module 703 is used to run the target executable file to achieve the target function.

[0112] Optionally, the conversion module 702 includes:

[0113] The parsing unit is used to parse the target task, determine the process information and configuration parameters for implementing the target function, wherein the target task is in at least one of markup language format and JSON format;

[0114] The first conversion unit is used to convert the target task into the target executable file based on the instruction set corresponding to its own architecture, the process information, and the configuration parameters.

[0115] Optionally, the parsing unit is further configured to:

[0116] Obtain the parameter information contained in the target task;

[0117] Based on the parameter information, the process information and the target operator and configuration parameters used when executing the process indicated by the process information are determined;

[0118] The target operator is selected from the operator library based on the process information. The operator library contains operators for implementing different processes, and the operator libraries of the edge nodes and the center nodes are the same.

[0119] Optionally, the first conversion unit is further configured to:

[0120] Based on the target operator and the configuration parameters, the target task is converted into an executable command line;

[0121] Based on the instruction set corresponding to its own architecture, the intermediate instructions are compiled into the target executable file.

[0122] Optionally, the device further includes:

[0123] The verification module is used to construct a directed acyclic graph (DAG) based on the target operator and the configuration parameters, and to verify the DAG. The verification process includes verifying the logical order and data structure of the DAG.

[0124] The judgment module is used to perform the step of converting the target task into an executable command line in response to the successful verification of the DAG graph.

[0125] Optionally, the architecture of the edge node includes at least one of the following: ARM architecture, x86 architecture, MIPS architecture, and RISC-V architecture, with different architectures corresponding to different instruction sets.

[0126] refer to Figure 8 This illustrates a structural block diagram of a task execution device in a heterogeneous system provided in one embodiment of this application.

[0127] The device is used as a central node in a heterogeneous system, which consists of a central node and edge nodes, with each edge node performing the same function. The device includes:

[0128] The generation module 801 is used to generate a target task based on the target function to be implemented by the edge node. The target task is used to instruct the edge node to implement the target function, and different edge nodes correspond to the same target task.

[0129] The sending module 802 is used to receive the selection operation of the edge node and send the target task to the edge node.

[0130] Optionally, the generation module 801 includes:

[0131] The determining unit is configured to determine, based on the target function of the edge node, the process information corresponding to the target function and the target operator and configuration parameters used when executing the process indicated by the process information, wherein the target operator is selected from the operator library based on the process information, the operator library contains operators for implementing different processes, and the operator libraries of the edge node and the center node are consistent.

[0132] The construction unit is used to construct a directed acyclic graph (DAG) based on the process information and the target operator.

[0133] The second conversion unit is used to convert the DAG graph into the target task, wherein the target task is in at least one of markup language format and JSON format.

[0134] Optionally, the sending module 802 includes:

[0135] The acquisition unit is used to acquire an edge node list, wherein the edge node list contains at least one edge node;

[0136] The sending unit is used to receive the selection operation for the edge node and send the target task to the selected edge node.

[0137] Please refer to Figure 9 This illustration shows a schematic diagram of the structure of a computer device provided in an exemplary embodiment of this application. Specifically, the computer device includes a Central Processing Unit (CPU) 901, a system memory 904 including random access memory 902 and read-only memory 903, and a system bus 905 connecting the system memory 904 and the CPU 901. The computer device 900 also includes a basic input / output system (I / O system) 906 that facilitates the transfer of information between various devices within the computer, and a mass storage device 907 for storing the operating system 913, application programs 914, and other program modules 915.

[0138] The basic input / output system 906 includes a display 908 for displaying information and an input device 909 for user input, such as a mouse or keyboard. Both the display 908 and the input device 909 are connected to the central processing unit 901 via an input / output controller 910 connected to the system bus 905. The basic input / output system 906 may also include the input / output controller 910 for receiving and processing input from multiple other devices such as a keyboard, mouse, or electronic stylus. Similarly, the input / output controller 910 also provides output to a display screen, printer, or other types of output devices.

[0139] Mass storage device 907 is connected to central processing unit 901 via a mass storage controller (not shown) connected to system bus 905. Mass storage device 907 and its associated computer-readable media provide non-volatile storage for computer device 900. That is, mass storage device 907 may include computer-readable media (not shown) such as hard disks or drives.

[0140] Without loss of generality, computer-readable media can include computer storage media and communication media. Computer storage media includes volatile and non-volatile, removable and non-removable media implemented using any method or technology for storing information such as computer-readable instructions, data structures, program modules, or other data. Computer storage media includes random access memory (RAM), read-only memory (ROM), flash memory or other solid-state storage technologies, compact disc read-only memory (CD-ROM), digital versatile disc (DVD) or other optical storage, magnetic tape cassettes, magnetic tape, disk storage, or other magnetic storage devices. Of course, those skilled in the art will recognize that computer storage media are not limited to the above. The system memory 904 and mass storage device 907 described above can be collectively referred to as memory.

[0141] The memory stores one or more programs, which are configured to be executed by one or more central processing units 901. The one or more programs contain instructions for implementing the above methods. The central processing unit 901 executes the one or more programs to implement the task execution method for heterogeneous systems provided in the above method embodiments.

[0142] According to various embodiments of this application, the computer device 900 can also be connected to a remote computer on a network, such as the Internet, for operation. That is, the computer device 900 can be connected to a network 912 via a network interface unit 911 connected to a system bus 905, or the network interface unit 911 can be used to connect to other types of networks or remote computer systems (not shown).

[0143] The memory also includes one or more programs stored in the memory, and the one or more programs include steps performed by a computer device in the methods provided in the embodiments of this application.

[0144] In addition, those skilled in the art will understand that the structure of the electronic device shown in the above figures does not constitute a limitation on the electronic device. The electronic device may include more or fewer components than shown, or combine certain components, or have different component arrangements. For example, the electronic device may also include radio frequency circuits, input units, sensors, servers, power supplies, etc., which will not be described in detail here.

[0145] This application provides a computer-readable storage medium storing at least one instruction, which is loaded and executed by a processor to implement the task execution method for heterogeneous systems provided in the above-described method embodiments.

[0146] This application also provides a computer program product or computer program that includes computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform any of the heterogeneous system task execution methods described in the above embodiments.

[0147] The sequence numbers of the embodiments in this application are for descriptive purposes only and do not represent the superiority or inferiority of the embodiments.

[0148] Those skilled in the art will understand that all or part of the steps of the above embodiments can be implemented by hardware or by a program instructing related hardware. The program can be stored in a computer-readable storage medium, such as a read-only memory, a disk, or an optical disk.

[0149] The above are merely optional embodiments of this application and are not intended to limit this application. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the protection scope of this application.

Claims

1. A task execution method for a heterogeneous system, characterized in that, The method is used for edge nodes in a heterogeneous system, which consists of a central node and edge nodes, with each edge node performing the same function. The method includes: The edge node receives the target task issued by the central node. The target task is used to instruct the edge node to implement the target function. Different edge nodes correspond to the same target task. The target task is a task description file in a unified format and cannot be directly executed by the edge node. The target task is parsed to determine the process information and configuration parameters for implementing the target function; Based on the instruction set corresponding to its own architecture, the process information, and the configuration parameters, the target task is converted into a target executable file. The target executable file consists of executable instructions, and different architectures correspond to different executable files. The central node does not need to obtain the architecture information of the edge node in advance before issuing the target task. Run the target executable file to achieve the target function.

2. The method according to claim 1, characterized in that, The target task is in at least one of markup language format and JSON format.

3. The method according to claim 2, characterized in that, The step of parsing the target task to determine the process information and corresponding configuration parameters for implementing the target function includes: Obtain the parameter information contained in the target task; Based on the parameter information, the process information and the target operator and configuration parameters used when executing the process indicated by the process information are determined; The target operator is selected from the operator library based on the process information. The operator library contains operators for implementing different processes, and the operator libraries of the edge nodes and the center nodes are the same.

4. The method according to claim 3, characterized in that, The process of converting the target task into a target executable file based on the instruction set corresponding to the architecture, the process information, and the corresponding configuration parameters includes: Based on the target operator and the configuration parameters, the target task is converted into an executable command line; Based on the instruction set corresponding to its own architecture, the executable command line is compiled into the target executable file.

5. The method according to claim 3, characterized in that, After determining the process information and the target operator and configuration parameters used when executing the process indicated by the process information, the method further includes: A directed acyclic graph (DAG) is constructed based on the target operator and the configuration parameters, and the DAG is validated. The validation process includes verifying the logical order and data structure of the DAG. In response to the successful verification of the DAG graph, the step of converting the target task into an executable command line is performed.

6. The method according to any one of claims 1 to 5, characterized in that, The architecture of edge nodes includes at least one of the following: ARM architecture, x86 architecture, MIPS architecture, and RISC-V architecture. Different architectures correspond to different instruction sets.

7. A task execution method for a heterogeneous system, characterized in that, The method is used for a central node in a heterogeneous system, which consists of a central node and edge nodes, with each edge node performing the same function. The method includes: Target tasks are generated based on the target functions of the edge nodes. The target tasks are used to instruct the edge nodes to implement the target functions. Different edge nodes correspond to the same target tasks. The target tasks are task description files in a unified format and cannot be directly executed by the edge nodes. The central node receives a selection operation for the edge node and sends the target task to the edge node. The edge node parses the target task to determine the process information and configuration parameters for implementing the target function. Based on the instruction set corresponding to its own architecture, the process information, and the configuration parameters, the central node converts the target task into a target executable file. The target executable file consists of executable instructions, and different architectures correspond to different executable files. The central node does not need to obtain the architecture information of the edge node in advance before sending the target task.

8. The method according to claim 7, characterized in that, The target task generated based on the target function of the edge node includes: Based on the target function of the edge node, determine the process information corresponding to the target function and the target operator and configuration parameters used when executing the process indicated by the process information. The target operator is selected from the operator library based on the process information. The operator library contains operators for implementing different processes, and the operator libraries of the edge node and the center node are consistent. Based on the process information and the target operator, a directed acyclic graph (DAG) is constructed. The DAG graph is converted into the target task, wherein the target task is in at least one of markup language format and JSON format.

9. The method according to claim 7, characterized in that, The step of receiving the selection operation for the edge node and sending the target task to the edge node includes: Obtain an edge node list, wherein the edge node list contains at least one edge node; The system receives the selection operation for the edge node and sends the target task to the selected edge node.

10. A heterogeneous system, characterized in that, The heterogeneous system includes edge nodes and a central node; The edge node is used to implement the task execution method of the heterogeneous system as described in any one of claims 1 to 6; The central node is used to implement the task execution method for heterogeneous systems as described in any one of claims 7 to 9.

11. A task execution device in a heterogeneous system, characterized in that, The device is used for edge nodes in a heterogeneous system, which consists of a central node and edge nodes, with each edge node performing the same function. The device includes: The receiving module is used to receive the target task issued by the central node. The target task is used to instruct the edge node to implement the target function. Different edge nodes correspond to the same target task. The target task is a task description file in a unified format and cannot be directly executed by the edge node. The conversion module is used to parse the target task, determine the process information and configuration parameters for implementing the target function; based on the instruction set corresponding to its own architecture, the process information and the configuration parameters, the target task is converted into a target executable file. The target executable file consists of executable instructions, and different architectures correspond to different executable files. The central node does not need to obtain the architecture information of the edge node in advance before issuing the target task. The runtime module is used to run the target executable file to achieve the target function.

12. A task execution device in a heterogeneous system, the device being used for a central node in the heterogeneous system, the heterogeneous system comprising a central node and edge nodes, wherein each edge node is used to perform the same function, the device comprising: The generation module is used to generate target tasks based on the target functions to be implemented by the edge nodes. The target tasks are used to instruct the edge nodes on the process of implementing the target functions. Different edge nodes correspond to the same target tasks. The target tasks are task description files in a unified format and cannot be directly executed by the edge nodes. The sending module is used to receive the selection operation for the edge node and send the target task to the edge node; The edge nodes are used to parse the target task, determine the process information and configuration parameters for implementing the target function; based on the instruction set corresponding to their own architecture, the process information and the configuration parameters, they convert the target task into a target executable file. The target executable file consists of executable instructions, and different architectures correspond to different executable files. The central node does not need to obtain the architecture information of the edge nodes in advance before issuing the target task.

13. A computer device, characterized in that, The computer device includes a processor and a memory; the memory stores at least one instruction, which is executed by the processor to implement the task execution method of the heterogeneous system as described in any one of claims 1 to 6, or to implement the task execution method of the heterogeneous system as described in any one of claims 7 to 9.

14. A computer-readable storage medium, characterized in that, The storage medium stores at least one instruction, which is executed by a processor to implement the task execution method of the heterogeneous system as described in any one of claims 1 to 6, or to implement the task execution method of the heterogeneous system as described in any one of claims 7 to 9.

Images