Internet-based remote intelligent commissioning method and system

Abstract

The present invention relates to an Internet-based remote intelligent commissioning method and system. The method comprises: constructing a commissioning task graph on the basis of commissioning tasks in a commissioning plan and the commissioning sequence of the commissioning tasks; setting a node weight and an edge weight of each node in the commissioning task graph; on the basis of the commissioning task graph, performing hierarchical division on the commissioning task graph to obtain one or more commissioning task sub-graphs; on the basis of the commissioning task graph, vertically dividing the commissioning task graph to obtain one or more commissioning task sub-graphs; and a commissioning terminal executing the commissioning tasks on the basis of the commissioning task sub-graphs. According to the present invention, the commissioning plan is quantitatively evaluated as a whole on the basis of the commissioning task graph, and the commissioning plan is adaptively adjusted on the basis of the characteristics of the commissioning tasks, thereby greatly improving the efficiency of large-batch commissioning, achieving very high efficiency of automated execution.

Description

A remote intelligent debugging method and system based on the Internet

Technical field

[0001] The present invention belongs to the field of intelligent debugging technology, and in particular relates to an Internet-based remote intelligent debugging method and system. [Background Technology]

[0002] With the continuous increase in server computing and storage capabilities, remote commissioning based on the Internet and TCP / IP protocol has become a common commissioning model. By establishing a remote testing system based on Internet Plus technology, test data resources can be shared, comprehensively improving commissioning capabilities. In the field of industrial control technology, due to the complexity of automated industrial equipment, commissioning is often required during machine production. Once industrial equipment enters the formal production environment, users may also need to control the industrial equipment application program by pausing, resuming, and single-stepping according to on-site needs. For multi-threaded industrial equipment, precise multi-threaded commissioning is required. However, existing commissioning often relies on remote control platforms to control industrial equipment.

[0003] When commissioning objects such as devices, programs, and applications, it's often necessary to pre-commission the underlying objects and their individual components to ensure they can interact and execute properly after establishing relationships with other objects. However, this type of commissioning typically targets individual objects and doesn't address the diverse scenarios that arise from factors such as different execution environments, different data sets, or the possibility of long chains of sequential relationships between objects. Furthermore, remote commissioning lacks real-time visibility into actual conditions, making it impossible to adjust the object's environmental and input parameters accordingly. Consequently, commissioning efficiency is low. Furthermore, remote commissioning is only efficient when conducted in large quantities, as commissioning of individual objects can be, or often already is, completed locally. Therefore, how to efficiently complete commissioning in long chains of sequential relationships, in different execution environments, and with different data sets, and how to leverage the server's computing and storage capabilities while taking into account the capabilities of the commissioning terminals, remains a technical challenge. The present invention is based on a commissioning task graph, quantifies the overall evaluation of the commissioning plan, and adaptively adjusts the commissioning plan according to the characteristics of the commissioning task, thereby greatly improving the efficiency of large-scale commissioning and achieving high automated execution efficiency.

[0004] [Summary of the invention]

[0005] In order to solve the above problems in the prior art, the present invention proposes an Internet-based remote intelligent debugging method and system, the method comprising:

[0006] Step S1: A commissioning plan is stored in a commissioning server; the commissioning plan includes commissioning tasks and their commissioning sequence; the commissioning plan commissions the commissioning tasks and the sequential relationship formed based on the commissioning sequence; a commissioning task graph is constructed based on the commissioning tasks and their commissioning sequence in the commissioning plan; wherein: each node in the commissioning task graph is a commissioning task, and the edge is the commissioning sequence between commissioning tasks; each node in the commissioning task graph has a node weight; wherein: each commissioning task is provided with a commissioning set; the commissioning set includes one or more commissioning use cases, and each commissioning use case includes a set of data input sets and a data output set;

[0007] Step S2: Set the node weight and edge weight of each node in the commissioning task graph, and determine whether the commissioning plan is storage-constrained or compute-constrained based on the node weight and edge weight. If the commissioning plan is storage-constrained, proceed to step S3; otherwise, proceed to step S4. Wherein: compute-constrained means that the resource constraints during the execution of the commissioning plan are computing resources; storage-constrained means that the resource constraints during the execution of the commissioning plan are storage resources.

[0008] The step S2 specifically includes the following steps:

[0009] Step S21: Setting the node weight WTP of the kth node in the commissioning task graph k , the edge weight WTL of the edge emitted by the kth node k,kx ; Where: k is the node number; kx is the entry node of the edge sent by the kth node; Specifically: Set WTP k =TC k TC k It is the normalized value of the storage space required by the input set / output set of the debugging case in the debugging task; WTL k,kx =CT k CT k is the normalized value of the computational effort of the commissioning task corresponding to the kth node;

[0010] Step S22: Calculate the storage load MLD of the commissioning task graph = Σ k (WTP k +ε); calculate the computing load of the commissioning task graph MLD = Σ (k,kx) WTL k,kx ×WTP kx When the node out-degree is greater than 1, kx refers to multiple different nodes. ε is the adjustment remainder, which is used to represent the normalized value of the storage load required by the adjustment task itself.

[0011] Step S23: Comparing the storage load and the load level to determine the load level corresponding to the commissioning task graph; comparing the computing load and the computing level to determine the computing level corresponding to the commissioning task graph; if the load level is greater than the computing level, determining the system as storage-limited; otherwise, determining the system as computing-limited;

[0012] Step S24: If the commissioning plan is storage-limited, proceed to step S3; otherwise, proceed to step S4;

[0013] Step S3: hierarchically partition the commissioning task graph to obtain one or more commissioning task subgraphs. Hierarchical partitioning involves allocating weights among the commissioning task subgraphs while preserving the graph structure or the connectivity of the graph, thereby achieving hierarchical partitioning of the graph structure. Based on the node weight of each node in the commissioning task subgraph, a corresponding number of commissioning use cases and their included input and output sets are allocated to each node.

[0014] Step S4: Vertically partition the debugging task graph to obtain one or more debugging task subgraphs; wherein vertical partitioning is to split the graph structure or the connection relationship of the graph while retaining the weight value; and based on the node weight of each node in the debugging task subgraph, a corresponding number of debugging use cases and the input sets and output sets contained therein are allocated to each node.

[0015] Step S5: assign each of the one or more debugging task subgraphs to an idle debugging terminal; the debugging terminal sequentially executes each debugging task involved in the debugging task subgraph based on the assigned debugging task subgraph.

[0016] Furthermore, each debugging task has a unique task number, and each input set and output set has a unique internal number.

[0017] Furthermore, the joint ID of a task and its input set is externally unique.

[0018] Furthermore, a unique subgraph number is set for each debugging task subgraph; the combination of the subgraph number and the debugging task number forms a unique mixed number for each debugging task in different debugging task subgraphs.

[0019] Furthermore, a correspondence between load levels and different storage load ranges is preset; a correspondence between calculation levels and different calculation load ranges is preset; and the load level or calculation level is obtained by querying the correspondence.

[0020] Furthermore, there are multiple debugging terminals, and the debugging terminals are used to perform debugging tasks based on the input set and obtain the output set.

[0021] Furthermore, the debugging server is a cloud server.

[0022] A remote intelligent debugging platform based on the Internet includes a processor coupled to a memory, wherein the memory stores program instructions. When the program instructions stored in the memory are executed by the processor, the remote intelligent debugging method based on the Internet is implemented.

[0023] A computer-readable storage medium includes a program, which, when running on a computer, enables the computer to execute the Internet-based remote intelligent debugging method.

[0024] A remote intelligent debugging system based on the Internet is configured to execute the remote intelligent debugging method based on the Internet.

[0025] The beneficial effects of the present invention include:

[0026] (1) The present invention uses an abstracted commissioning task graph to quantitatively describe and evaluate the commissioning plan as a whole. Based on the node weights and edge weights, the present invention determines whether the commissioning plan is storage-constrained or computation-constrained, and discovers the differentiated characteristics of the commissioning tasks included in the commissioning plan. This allows the present invention to adaptively adjust the commissioning plan and its corresponding commissioning task graph, thereby universally improving the execution efficiency of the commissioning plan.

[0027] (2) Based on the debugging task graph, the debugging task graph is hierarchically divided to obtain one or more debugging task subgraphs; based on the debugging task graph, the debugging task graph is vertically divided to obtain one or more debugging task subgraphs; for the cases of limited computing and limited storage, the efficiency of large-scale debugging is differentially improved.

[0028] (3) Each of one or more debugging task subgraphs is assigned to a debugging terminal; the automation level of debugging is improved through intelligent allocation; hybrid coding and joint coding are used to asynchronously discover and locate abnormalities in the execution process of debugging tasks with long chain sequence relationships, and the corresponding minimum debugging cycle is re-executed regardless of where the abnormality occurs; through the continuous updating of the initial node, the minimum overhead of different test cases in the debugging process with long chain sequence relationships is fully covered, thereby improving the intelligence level of remote debugging.

Brief Description of the Drawings

[0029] The drawings described herein are used to provide a further understanding of the present invention and constitute a part of this application, but do not constitute an improper limitation of the present invention. In the drawings:

[0030] FIG1 is a schematic diagram of the Internet-based remote intelligent debugging method provided by the present invention. [Specific implementation method]

[0031] The present invention will be described in detail below with reference to the accompanying drawings and specific embodiments. The exemplary embodiments and descriptions are only used to explain the present invention but are not intended to limit the present invention.

[0032] The present invention proposes a remote intelligent debugging method based on the Internet, as shown in Figure 1, the method includes the following steps:

[0033] Step S1: A commissioning plan is stored in a commissioning server; the commissioning plan includes commissioning tasks and their commissioning sequence; the commissioning plan commissions the commissioning tasks and a long chain sequence relationship formed based on the commissioning sequence; a commissioning task graph is constructed based on the commissioning tasks and their commissioning sequence in the commissioning plan; wherein: each node in the graph is a commissioning task, and an edge is a commissioning sequence between commissioning tasks; each node in the graph has a node weight; wherein: each commissioning task is provided with a minimum commissioning set; after completing the commissioning plan, the minimum commissioning set of the commissioning task needs to be commissioned; the minimum commissioning set includes one or more commissioning use cases, and each commissioning use case includes a set of data input sets and a data output set;

[0034] Preferably, the weight value of the node is positively correlated with the debugging complexity and / or the number of debugging cases of the debugging task corresponding to the node;

[0035] The data input set is the input data set for executing the debugging task, and the data output set is the output data set for executing the debugging task. Obviously, the output data set of one debugging task may be the data input set of another debugging task.

[0036] Because the same commissioning task may be commissioned sequentially with multiple commissioning tasks due to the commissioning sequence, a node is connected to one or more directed edges. In other words, the out-degree and in-degree of a node can be 0, 1, 2, and so on. When both the out-degree and in-degree of a node are 0, it becomes an independent commissioning task. Commissioning independent tasks is relatively simple and the technology is mature, so we will not elaborate on it in depth here.

[0037] Preferably, each debugging task has a unique task number, and each input set and output set has a unique internal number; the joint number formed by the task number and its input set is externally unique; for example: the joint code Ta_I6, and Ta_O5;

[0038] Step S2: Set the node weight and edge weight of each node in the commissioning task graph, and determine whether the commissioning plan is storage-constrained or compute-constrained based on the node weight and edge weight. If the commissioning plan is storage-constrained, proceed to step S3; otherwise, proceed to step S4. Wherein: compute-constrained means that the resource constraints during the execution of the commissioning plan are computing resources; storage-constrained means that the resource constraints during the execution of the commissioning plan are storage resources.

[0039] The step S2 specifically includes the following steps:

[0040] Step S21: Set the node weight WTP of the kth node in the task graph k , the edge weight WTL of the edge emitted from the kth node k,kx ; Where: k is the node number; kx is the entry node of the edge from the kth node; Specifically: Set WTP k =TC k TC k It is the storage space requirement or normalized value of the input set / output set of the commissioning case in the commissioning task; WTL k,kx =CT k CT k is the normalized value of the computational effort of the commissioning task corresponding to the kth node;

[0041] Preferably, the demand and calculation amount are both pre-processed values. Obviously, as the number of test cases increases, the corresponding storage space demand may also increase. During the test process, the storage overhead caused by data loading needs to be considered. This contradiction is particularly prominent for debugging.

[0042] Step S22: Calculate the storage load MLD of the commissioning task graph = Σ k (WTP k +ε); calculate the computing load of the commissioning task graph MLD = Σ (k,kx) WTL k,kx ×WTP kx ; Of course, since the out-degree may be greater than 1, kx may refer to multiple different nodes;

[0043] Preferably; ε is the adjustment remainder; it can be used to represent the storage load required by the adjustment task itself;

[0044] Preferred: ε=1Unit;

[0045] Step S23: Comparing the storage load and the load level to determine the load level corresponding to the commissioning task graph; comparing the computing load and the computing level to determine the computing level corresponding to the commissioning task graph; if the load level is greater than the computing level, determining the system as storage-limited; otherwise, determining the system as computing-limited;

[0046] Preferably: presetting the correspondence between the load level and different storage load ranges; presetting the correspondence between the calculation level and different calculation load ranges; obtaining the load level or calculation level by querying the correspondence;

[0047] Step S24: If the commissioning plan is storage-limited, proceed to step S3; otherwise, proceed to step S4;

[0048] Step S3: hierarchically partitioning the commissioning task graph based on the commissioning task graph to obtain one or more commissioning task subgraphs; wherein the hierarchical partitioning is performed by allocating weights between the commissioning task subgraphs while preserving the graph structure or the connection relationship of the graph, thereby achieving hierarchical partitioning;

[0049] The step S3 specifically includes the following steps:

[0050] Step S31: Determine the current commissioning task map;

[0051] Preferably: the initial graph of the current commissioning task graph is set to the commissioning task graph; that is, the commissioning task graph determined in step S2;

[0052] Step S32: Determine whether there is an edge in the current debugging task graph; if not, proceed to step S36; if yes, obtain the node with the largest weight in the current debugging task graph, construct an initial temporary subgraph based on the node with the largest weight; set the node weight of the node with the largest weight in the temporary subgraph to 0;

[0053] Preferably: if the weight values ​​of all nodes are the same at this time, proceed to step S36;

[0054] Step S33: Determine whether there is a node k and a node kx in the current debugging task graph, and whether there is an edge ln connecting the two in the current debugging task graph. k,kx or ln kx,k ; So that the node kx already exists in the temporary subgraph, and if the node k, edge ln k,kx or ln kx,k After being added to the temporary subgraph, the total out-degree and total in-degree of the temporary subgraph are equal; if they exist, proceed to step S34; otherwise, proceed to step S35;

[0055] Preferred: On the edge k,kx or ln kx,k Selecting only one case will make the temporary subgraph a unidirectional connected graph, which is convenient for the execution of subsequent debugging tasks and debugging situations with long chain sequence relationships.

[0056] Preferred: the overall out-degree is the sum of the out-degrees of all nodes in the temporary subgraph; the overall in-degree is the sum of the in-degrees of all nodes in the temporary subgraph;

[0057] The node kx already exists in the temporary subgraph, and if the node k and the edge ln k,kx or ln kx,k After being added to the temporary subgraph, the total out-degree and total in-degree of the temporary subgraph are equal; it can be replaced by: making the node kx already exist in the temporary subgraph, and if the node k, edge ln k,kx or lnkx,k After being added to the temporary subgraph, the overall out-degree and overall in-degree of the temporary subgraph are equal, and / or the out-degree and in-degree values ​​of all nodes in the temporary subgraph are made equal to the parallelism threshold; wherein: the parallelism threshold is equal to the number of parallel execution units included in the independent debugging terminal;

[0058] Step S34: Update the current debugging task graph and temporary subgraph to add the node k and node kx and their edge ln k,kx or ln kx,k Add to the temporary subgraph; specifically: reduce the node weights of nodes k and kx in the current debugging task graph; set WTP k =WTP k -1Unit;WTP kx =WTP kx -1Unit; correspondingly increase the node weights of nodes k and kx in the temporary subgraph; set the edge weights to be equal to WTL k,kx ; The decrement in the current debugging task graph is equal to the increment in the temporary subgraph; return to step S33; where: Unit is the normalized unit weight value;

[0059] If the node weight of node k in the current debugging task graph is 0, delete the node k and its associated edge ln in the current debugging task graph. k,kx or ln kx,k If the node weight of a node k in the current debugging task graph is reduced to 0, then set the edge weight of any associated edge to 0 (that is, delete the node or the edge); add an edge ln in the temporary subgraph k,kx And keep its variable weight unchanged; where: Unit is the unit value of the node weight;

[0060] Preferred: Unit=1;

[0061] Step S35: Use the temporary subgraph as the newly generated commissioning task subgraph; reset the temporary subgraph to be empty, and return to step S32;

[0062] Step S36: directly treating each independent unconnected subgraph part in the current debugging task graph as an independent debugging task subgraph;

[0063] Step S4: vertically partitioning the debugging task graph based on the debugging task graph to obtain one or more debugging task subgraphs; wherein the vertical partitioning is to split the graph structure or the connection relationship of the graph while retaining the weight value;

[0064] The step S4 specifically includes the following steps:

[0065] Step S41: The initial graph of the current commissioning task graph is set as the commissioning task graph; the current commissioning task graph is divided into two subgraphs so that the sum of all node weights of the two subgraphs is closest and / or the number of connecting edges between the two subgraphs is the least (that is, the number of divisions is the least); then the most likely occurrence of this is the division of the graph portion that does not have an order relationship or has a minimal order relationship;

[0066] Step S42: The two subgraphs are judged separately; if the subgraph meets condition 1, the subgraph is used as the newly generated debugging task subgraph; otherwise, the subgraph is used as the current debugging task graph and step S41 is re-executed until all subgraphs meet condition 1; wherein: condition 1 is: the storage load of the subgraph is less than a first storage load threshold and / or the out-degree and in-degree values ​​of all nodes in the subgraph are less than or equal to a first parallelism threshold; the first storage load threshold is related to the first storage resource size of the debugging terminal; the first parallelism threshold is related to the second storage resource size of the debugging terminal;

[0067] The first storage load is related to the size of the first storage resource of the debugging terminal; the first parallelism threshold is related to the size of the second storage resource of the debugging terminal; specifically: when the first storage resource is a memory resource, the second storage resource is a cache resource; when the first storage resource is a non-volatile storage resource, the second storage resource is a memory resource; the first storage load threshold is a normalized value of the average size of the available first storage resource in the debugging terminal; the first parallelism threshold is greater than or slightly greater than the amount of storage space required for the input set / output set of a unit debugging use case that can be accommodated by the second storage resource in the debugging terminal; in this way, when predictive execution is performed based on a subgraph, subsequent input sets can be directly loaded in advance into a higher-level storage space according to the direction of the data flow in the subgraph to speed up the execution of the debugging task;

[0068] Step S5: assigning each of the one or more commissioning task subgraphs to a commissioning terminal; the commissioning terminal sequentially executes each commissioning task involved in the commissioning task subgraph based on the assigned commissioning task subgraph; assigning a corresponding number of commissioning use cases to each node in the commissioning task subgraph based on its node weight; setting a unique subgraph number for each commissioning task subgraph; combining the subgraph number and the commissioning task number to form a unique mixed number for each commissioning task in different commissioning task subgraphs; and determining whether the commissioning task subgraph is completed correctly based on the unique mixed number;

[0069] That is, the larger the weight value of a node in the commissioning task subgraph is, the more commissioning cases it needs to complete;

[0070] The step S5 specifically includes the following steps:

[0071] Step S51: When a commissioning terminal completes the assigned commissioning task subgraph and becomes an idle commissioning terminal, an unprocessed subgraph is selected from the unassigned commissioning task subgraphs as a commissioning task subgraph and assigned to the idle commissioning terminal;

[0072] Preferably, the selection method is such that the debugging tasks included in the selected subgraph and the completed assigned debugging task subgraph contain the most repeated debugging tasks; and the selected debugging task subgraph is assigned to the idle debugging terminal;

[0073] Preferably: when all the commissioning task subgraphs are processed, the commissioning is completed, and the location of the abnormality can be determined based on the commissioning task subgraph number, hybrid code, joint code, input set and output set;

[0074] Step S52: Determine an initial node based on the commissioning task subgraph; the initial node refers to any other node in the commissioning task subgraph that can be reached from the initial node; if there is no initial node, commissioning of the commissioning task subgraph is terminated; and return to step S51;

[0075] Preferably: there are one or more initial nodes;

[0076] Step S53: The commissioning terminal loads the commissioning task data corresponding to the initial node and an unprocessed data input set; uses the unprocessed data input set as the current data input set; if no unprocessed data input set exists, returns to step S52 to redetermine the initial node;

[0077] Preferably: when there are multiple initial nodes, the corresponding debugging task data and one of the unprocessed data input sets need to be loaded simultaneously or sequentially;

[0078] Step S54: The commissioning terminal executes the commissioning task based on the unprocessed data input set of the commissioning task. Before executing the commissioning task, the commissioning terminal sends the unique mixed number and the unique joint number of the commissioning task input set to the commissioning server. After execution is completed, the commissioning terminal sends the unique joint number of the commissioning task output set to the commissioning server. If a commissioning task in the commissioning task subgraph has not been completed, the next commissioning task is executed according to the commissioning order of the commissioning tasks in the commissioning task subgraph (that is, the connection relationship of the edges) until all commissioning tasks in the commissioning task subgraph are completed or a restart command is received. After all commissioning tasks are completed, the process proceeds to step S55.

[0079] Preferably, after receiving the restart command, the commissioning terminal stops executing the current commissioning task, returns to step S52 and continues commissioning based on the current unprocessed data input set of the initial node of the commissioning task subgraph, and re-performs commissioning based on the current initial node and its current unprocessed data input set;

[0080] Furthermore, the debugging server performs the following steps asynchronously:

[0081] Step S54_sr: The commissioning server sequentially receives the unique hybrid code and the unique joint code; determines whether the execution order of the commissioning task subgraphs is correct based on the unique hybrid code and the commissioning task subgraph being completed by the commissioning terminal; queries the unique joint code of the correct commissioning task output set corresponding to the commissioning task input set based on the unique joint code; if the unique joint code of the correct commissioning task output set is the same as the received unique joint number of the commissioning task output set, the commissioning task execution logic is determined to be correct; if the execution order or logic is incorrect, the commissioning server sends a restart command to the commissioning terminal;

[0082] Preferably: pre-store the association between the unique joint number of the input set of the debugging task and the unique joint code of the correct output set of the debugging task subgraph;

[0083] Step S55: Determine whether the initial node still has an unprocessed data input set. If so, return to step S53. Otherwise, delete the initial node that does not have an unprocessed data input set in the commissioning task subgraph, and return to step S52 to redetermine the initial node.

[0084] Preferably, before executing step S55, the unprocessed data input set of each node in the commissioning task subgraph is updated; if the data input set of a node has been executed during the execution of this commissioning task subgraph (the output set of the previous node is the same as the data input set of the node), the processing status of the input set of the node is set to processed; then, after the node becomes the initial node, its processed data input set will not be considered again;

[0085] Based on the same inventive concept, the present invention also provides an Internet-based remote intelligent debugging system, which is used to implement the above-mentioned Internet-based remote intelligent debugging method;

[0086] The system includes: a debugging terminal and a debugging server;

[0087] Preferably, there are multiple debugging terminals, and the multiple debugging terminals are connected to the debugging server via Internet communication;

[0088] Preferably: the commissioning server is a cloud server;

[0089] A computer program (also referred to as a program, software, software application, script, or code) can be written in any form of programming language, including assembly or interpreted languages, declarative or procedural languages, and it can be deployed in any form, including as a stand-alone program or as a module, component, subroutine, object, or other unit suitable for use in a computing environment. A computer program may, but need not, correspond to a file in a file system. A program can be stored in a portion of a file that holds other programs or data (e.g., one or more scripts stored in a markup language document), in a single file dedicated to the program, or in multiple collaborative files (e.g., files storing one or more modules, subroutines, or code portions). A computer program can be deployed to execute on one computer or on multiple computers located at one site or distributed across multiple sites and interconnected by a communication network.

[0090] It will be understood by those skilled in the art that embodiments of the present invention may be provided as methods, systems, or computer program products. Thus, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware. Furthermore, the present invention may take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to magnetic disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0091] The present invention is described with reference to the flowcharts and / or block diagrams of the methods, devices (systems), and computer program products according to the embodiments of the present application. It should be understood that each process and / or box in the flowchart and / or block diagram, as well as the combination of the processes and / or boxes in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing device to produce a machine, so that the instructions executed by the processor of the computer or other programmable data processing device produce a device for implementing the functions specified in one or more processes in the flowchart and / or one or more boxes in the block diagram.

[0092] These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing device to operate in a specific manner, so that the instructions stored in the computer-readable memory produce a product including an instruction device that implements the functions specified in one or more processes in the flowchart and / or one or more boxes in the block diagram.

[0093] These computer program instructions can also be loaded onto a computer or other programmable data processing device so that a series of operating steps are executed on the computer or other programmable device to produce a computer-implemented process, so that the instructions executed on the computer or other programmable device provide steps for implementing the functions specified in one or more processes in the flowchart and / or one or more boxes in the block diagram.

[0094] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and not to limit it. Although the present invention has been described in detail with reference to the above embodiments, ordinary technicians in the field should understand that the specific implementation methods of the present invention can still be modified or replaced by equivalents. Any modification or equivalent replacement that does not depart from the spirit and scope of the present invention should be covered by the scope of protection of the claims of the present invention.

Claims

1. A remote intelligent debugging method based on the Internet, characterized in that: The method comprises: Step S1: A commissioning plan is saved in a commissioning server; the commissioning plan includes commissioning tasks and their commissioning sequence; the commissioning plan is commissioned for the commissioning tasks and the sequential relationship formed based on the commissioning sequence; a commissioning task graph is constructed based on the commissioning tasks and their commissioning sequence in the commissioning plan; wherein: each node in the commissioning task graph is a commissioning task, and the edge is the commissioning sequence between the commissioning tasks; each node in the commissioning task graph has a node weight; wherein: each commissioning task is provided with a commissioning set; the commissioning set includes one or more commissioning use cases, and each commissioning use case includes a set of data input sets and a data output set; Step S2: Set the node weight and edge weight of each node in the commissioning task graph, and determine whether the commissioning plan is storage-constrained or computing-constrained based on the node weight and edge weight; if the commissioning plan is storage-constrained, proceed to step S3; otherwise, proceed to step S4; wherein: computing-constrained means that the resource constraints of the commissioning plan during execution are computing resources; storage-constrained means that the resource constraints of the commissioning plan during execution are storage resources; The step S2 specifically includes the following steps: Step S21: Setting the node weight WTP of the kth node in the commissioning task graph k , the edge weight WTL of the edge emitted by the kth node k,kx ; Where: k is the node number; kx is the entry node of the edge sent by the kth node; Specifically: Set WTP k =TC k TC k It is the normalized value of the storage space required by the input set / output set of the commissioning case in the commissioning task; WTL k,kx =CT k CT k is the normalized value of the computational effort of the commissioning task corresponding to the kth node; Step S22: Calculate the storage load MLD of the commissioning task graph = Σ k (WTP k +ε); calculate the computing load of the commissioning task graph MLD = Σ (k,kx) WTL k,kx ×WTP kx ; When the node out-degree is greater than 1, kx refers to multiple different nodes; ε is the adjustment remainder; It is used to represent the normalized value of the storage load required by the adjustment task itself; Step S23: Compare the storage load and the load level to determine the load level corresponding to the commissioning task diagram; compare the computing load and the computing level to determine the computing level corresponding to the commissioning task diagram; when the load level is greater than the computing level, determine it as storage-limited type, otherwise, determine it as computing-limited type; Step S24: If the commissioning plan is storage-limited, proceed to step S3; otherwise, proceed to step S4; Step S3: hierarchically divide the commissioning task graph to obtain one or more commissioning task subgraphs; wherein: hierarchical division is to allocate weight values ​​between the commissioning task subgraphs while retaining the graph structure or the connection relationship of the graph, thereby realizing hierarchical division of the graph structure; based on the node weight of each node in the commissioning task subgraph, a corresponding number of commissioning use cases and the input sets and output sets contained therein are allocated to it; Step S4: vertically divide the commissioning task graph to obtain one or more commissioning task subgraphs; wherein: vertical division is to split the graph structure or the connection relationship of the graph while retaining the weight value; based on the node weight of each node in the commissioning task subgraph, a corresponding number of commissioning use cases and the input sets and output sets contained therein are allocated to it; Step S5: assign each of the one or more debugging task subgraphs to an idle debugging terminal; the debugging terminal sequentially executes each debugging task involved in the debugging task subgraph based on the assigned debugging task subgraph.

2. The remote intelligent debugging method based on the Internet according to claim 1 is characterized in that: Each commissioning task has a unique task number, and each input set and output set has a unique internal number.

3. The remote intelligent debugging method based on the Internet according to claim 2 is characterized in that: The combination of a task number and its input set is externally unique.

4. The remote intelligent debugging method based on the Internet according to claim 3 is characterized in that: A unique subgraph number is set for each commissioning task subgraph; a combination of the subgraph number and the commissioning task number forms a unique mixed number for each commissioning task in different commissioning task subgraphs.

5. The Internet-based remote intelligent debugging method according to claim 4 is characterized in that: Preset the corresponding relationship between the load level and different storage load ranges; the corresponding relationship between the calculation level and different calculation load ranges; and obtain the load level or the calculation level by querying the corresponding relationship.

6. The remote intelligent debugging method based on the Internet according to claim 5 is characterized in that: There are multiple debugging terminals, and the debugging terminals are used to perform debugging tasks based on the input set and obtain the output set.

7. The remote intelligent debugging method based on the Internet according to claim 6, characterized in that: The debugging server is a cloud server.

8. A remote intelligent debugging platform based on the Internet, characterized in that: It includes a processor, the processor is coupled to a memory, the memory stores program instructions, and when the program instructions stored in the memory are executed by the processor, the Internet-based remote intelligent debugging method described in any one of claims 1 to 5 is implemented.

9. A computer-readable storage medium, characterized in that: The invention comprises a program, which, when running on a computer, enables the computer to execute the Internet-based remote intelligent debugging method as described in any one of claims 1 to 5.

10. A remote intelligent debugging system based on the Internet, characterized in that: The system is configured to execute the Internet-based remote intelligent debugging method as described in any one of claims 1-5.

Images