CN113568825A - Program flow debugging method, device, equipment and storage medium - Google Patents
Program flow debugging method, device, equipment and storage medium Download PDFInfo
- Publication number
- CN113568825A CN113568825A CN202110574485.5A CN202110574485A CN113568825A CN 113568825 A CN113568825 A CN 113568825A CN 202110574485 A CN202110574485 A CN 202110574485A CN 113568825 A CN113568825 A CN 113568825A
- Authority
- CN
- China
- Prior art keywords
- node
- nodes
- sub
- data
- subprocess
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
- 238000000034 method Methods 0.000 title claims abstract description 139
- 238000003860 storage Methods 0.000 title claims abstract description 12
- 238000013515 script Methods 0.000 claims description 40
- 230000006870 function Effects 0.000 claims description 29
- 238000004590 computer program Methods 0.000 claims description 17
- 238000012545 processing Methods 0.000 claims description 12
- 238000000354 decomposition reaction Methods 0.000 claims description 4
- 238000009826 distribution Methods 0.000 claims description 3
- 230000008569 process Effects 0.000 abstract description 27
- 238000013024 troubleshooting Methods 0.000 abstract description 7
- 230000005856 abnormality Effects 0.000 abstract description 3
- 238000010586 diagram Methods 0.000 description 10
- 230000000694 effects Effects 0.000 description 5
- 238000012360 testing method Methods 0.000 description 4
- 230000009471 action Effects 0.000 description 3
- 238000011161 development Methods 0.000 description 3
- 238000012163 sequencing technique Methods 0.000 description 3
- 230000002159 abnormal effect Effects 0.000 description 2
- 238000012423 maintenance Methods 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000004075 alteration Effects 0.000 description 1
- 238000009530 blood pressure measurement Methods 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 238000013480 data collection Methods 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000000750 progressive effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/3644—Software debugging by instrumenting at runtime
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/30—Monitoring
- G06F11/34—Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment
- G06F11/3409—Recording or statistical evaluation of computer activity, e.g. of down time, of input/output operation ; Recording or statistical evaluation of user activity, e.g. usability assessment for performance assessment
- G06F11/3414—Workload generation, e.g. scripts, playback
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/3632—Software debugging of specific synchronisation aspects
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
Abstract
The embodiment of the application provides a program flow debugging method, a program flow debugging device, program flow debugging equipment and a storage medium, and relates to the technical field of computers, wherein the method comprises the following steps: the method comprises the steps of decomposing the execution of the process into a plurality of nodes and the connection relation of the nodes, advancing the process according to the connection relation, collecting the execution data of the nodes through the node sub-process when the node is advanced to a certain node, and visually displaying the collected execution data, so that each node is transparent to developers, the execution condition and performance of each node are known, the developers can quickly position error positions according to the collected execution information when abnormality occurs, error troubleshooting is timely performed, and the time spent on online error troubleshooting is reduced. And through the collected execution information, developers can quickly reproduce the input data of the error node to realize breakpoint debugging.
Description
Technical Field
The embodiment of the application relates to the technical field of computers, in particular to a program flow debugging method, a program flow debugging device, program flow debugging equipment and a storage medium.
Background
Currently, after a developer completes a functional process in development, the developer needs to test a program. When an error occurs in the debugging process, a developer usually needs to spend a lot of time to locate the position where the problem really occurs, and the breakpoint debugging is difficult to perform, and the replay can be attempted only by adding logs and then reissuing. In addition, the development personnel can not visually check the real-time running process of the program, can not test the performance of the program and the like in the debugging process.
Disclosure of Invention
The embodiment of the application provides a program flow debugging method, a program flow debugging device, program flow debugging equipment and a storage medium, and aims to solve the technical problems that the existing flow debugging method is long in time-consuming in positioning error positions, difficult in breakpoint debugging, incapable of being visually checked and incapable of testing performance.
A first aspect of an embodiment of the present application provides a program flow debugging method, where the method includes:
decomposing a program flow into a plurality of nodes and the connection relation of the plurality of nodes, and marking a starting node in the plurality of nodes;
configuring a node sub-process of each node aiming at the plurality of nodes, wherein the type of the node sub-process comprises the following steps: command subprocess, analysis subprocess and index subprocess;
inputting initialization parameters to the starting node to cause the plurality of nodes to advance according to the connection relationship and to perform their own functions when advancing to any of the plurality of nodes, and,
the command sub-process collects the execution data of the node while the node performs its own function,
the analysis sub-process reads the data collected by the command sub-process after the command sub-process collects the data, carries out standardized processing on the data,
and after the data processed by the index sub-process is analyzed, reading the standardized data, and visually displaying the standardized data according to a preset format.
Optionally, configuring, for the plurality of nodes, a node sub-process of each node, including:
for the plurality of nodes, configuring a node sub-process of each node, comprising:
aiming at the plurality of nodes, analyzing a node sub-process required to be configured according to the function of each node;
selecting a target script corresponding to each node subprocess in a knowledge base, wherein the knowledge base comprises a plurality of scripts;
and configuring the target script on a node.
Optionally, the method further comprises:
and distributing the nodes on different threads according to the connection relation so that the nodes are processed on different threads.
A second aspect of the embodiments of the present application provides a program flow debugging apparatus, where the apparatus includes:
the decomposition module is used for decomposing the program flow into a plurality of nodes and the connection relation of the plurality of nodes, and marking initial nodes in the plurality of nodes;
a node configuration module, configured to configure node sub-processes of each node for the plurality of nodes, where the types of the node sub-processes include: command subprocess, analysis subprocess and index subprocess;
a pushing module, configured to input initialization parameters to the initial node, so that the plurality of nodes are pushed according to the connection relationship, and when pushing to any node in the plurality of nodes, the node executes its own function, and,
the command sub-process collects the execution data of the node while the node performs its own function,
the analysis sub-process reads the data collected by the command sub-process after the command sub-process collects the data, carries out standardized processing on the data,
and after the data processed by the index sub-process is analyzed, reading the standardized data, and visually displaying the standardized data according to a preset format.
Optionally, the node configuration module includes:
the analysis submodule is used for analyzing the node subprocess which needs to be configured according to the function of each node aiming at the plurality of nodes;
the selection submodule is used for selecting a target script corresponding to each node subprocess in a knowledge base, and the knowledge base comprises a plurality of scripts;
and the configuration submodule is used for configuring the target script on the node.
Optionally, the apparatus further comprises:
and the distribution module is used for distributing the nodes on different threads according to the connection relation so as to enable the nodes to be processed on different threads.
A third aspect of embodiments of the present application provides a readable storage medium, on which a computer program is stored, which, when executed by a processor, implements the steps in the method according to the first aspect of the present application.
A fourth aspect of the embodiments of the present application provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, where the processor executes the computer program to implement the steps of the method according to the first aspect of the present application.
By adopting the program flow debugging method provided by the application, the execution of the flow is decomposed into the connection relations of a plurality of nodes and the nodes, the flow is pushed according to the connection relations, the execution data of the nodes is collected through the node sub-flows when the flow is pushed to a certain node, and the collected execution data is visually displayed, so that each node is transparent to developers, the execution condition and the performance of each node are known, the developers can quickly position error positions according to the collected execution information when an abnormality occurs, error troubleshooting is timely carried out, and the time spent on online error troubleshooting is reduced. And through the collected execution information, developers can quickly reproduce the input data of the error node to realize breakpoint debugging.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings needed to be used in the description of the embodiments of the present application will be briefly introduced below, and it is obvious that the drawings in the following description are only some embodiments of the present application, and it is obvious for those skilled in the art that other drawings can be obtained according to these drawings without inventive exercise.
Fig. 1 is a flowchart of a program flow debugging method according to an embodiment of the present application;
fig. 2 is a functional block diagram of a program flow debugging apparatus according to an embodiment of the present application.
Detailed Description
The technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application, and it is obvious that the described embodiments are some, but not all, embodiments of the present application. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present application.
Referring to fig. 1, fig. 1 is a flowchart of a program flow debugging method according to an embodiment of the present application.
As shown in fig. 1, the method comprises the steps of:
step S110, the program flow is decomposed into a plurality of nodes and a connection relationship between the plurality of nodes, and the initial node is marked in the plurality of nodes.
The program is operated according to a preset flow, and the preset program flow is divided into a plurality of nodes and connection relations among the nodes. A node represents one step of the program flow, the program flow is decomposed into a multi-step execution process, each step has respective functions and can realize different demand points, and each step is used as a node in the debugging process.
After the process is decomposed, a service flow is defined, wherein each node represents a part of the service flow which the user wants to be transparent.
For example, for a product selection process, when a user clicks on a certain type of product, the processes that may be involved include: and obtaining the type of commodities in the database, obtaining historical order data of the user, sequencing or prompting the obtained commodity data of the type, and displaying the sales promotion activity of each commodity. Obviously, this process, i.e. depending on the function: and acquiring commodity data, sequencing commodities, displaying sales promotion activities, and decomposing the data into different nodes.
After the nodes are decomposed, the initial nodes are marked, wherein the initial nodes are the initial positions of the process or the nodes without the connection of the nodes at the upper level, cannot be pushed by data output by the nodes and can only be started by external input, so that the initial nodes are marked for subsequent use.
The nodes have a connection relation, and the connection relation represents the trigger sequence and trigger conditions of the nodes. The trigger sequence specifies the trigger direction of the node, the trigger condition indicates under what kind of conditions the previous node triggers the next node, the trigger condition may be manual trigger or automatic trigger, for example, it may be set to automatically trigger some simple nodes, when the previous node collects data/collected data meets the requirement, it automatically triggers the next node, for complex nodes, it may be set to manually trigger, only when the user clicks, it will trigger the next node.
Step S120, configuring a node sub-process of each node for the plurality of nodes, where the type of the node sub-process includes: command subprocess, analysis subprocess, and index subprocess.
For the nodes obtained by decomposition, configuring a node sub-process of each node, wherein the types of the node sub-processes comprise: command subprocess, analysis subprocess, and index subprocess. The method includes the steps that data collection processes are divided into three basic sub-processes, a command sub-process is used for collecting the data of the nodes, a sub-process is used for reading the data collected by the command sub-process and conducting standardization processing on the data, an index sub-process is used for reading the standardized data, and the standardized data are displayed visually according to a preset format.
Preferably, configuring a node sub-process of each node for the plurality of nodes includes:
aiming at the plurality of nodes, analyzing a node sub-process required to be configured according to the function of each node;
selecting a target script corresponding to each node subprocess in a knowledge base, wherein the knowledge base comprises a plurality of scripts;
and configuring the target script on a node.
In order to collect and display the execution data of the node, the implementation of this process is divided into three basic sub-processes, namely a command sub-process, an analysis sub-process, and an index sub-process. The node sub-processes which need to be configured are analyzed according to the functions of the nodes, and because the functions of each node are different, the required data acquisition methods are different, and in addition, because the data acquired by each node are different, the corresponding analysis sub-processes and the index sub-processes are also different. And each node selects a corresponding sub-process according to the self condition.
In this embodiment, the node sub-flow is implemented by using a script, that is, the node sub-flow is written into a script in advance. Script in the computer field means that an executable file is written according to a certain format using a specific descriptive language, because the syntax and structure of the Script are usually simple, the Script is usually simple to use, and the Script usually takes the "interpretation" of the easily modified program as the operation mode without the "compilation", so that the development capacity of the Script is better than the operation performance. A script can connect various existing components to complete related tasks, and the communication between the script and program components written in other languages is very powerful, and service components can be glued together.
The script can adopt JavaScript, lua, shell, regex, sql, go and other formats, provides a more convenient deployment mode for developers focusing on different languages, and is convenient for the developers of different languages to acquire data.
The data acquisition is carried out in the form of the script, so that the manual operation is not needed, the workload of operation and maintenance personnel is reduced, the performance bottleneck of the existing data acquisition method can be broken through, and high-frequency and high-efficiency acquisition is supported.
The scripts of the nodes come from a pre-established knowledge base, the scripts are accumulated in the knowledge base, operation and maintenance personnel can compile scripts which are possibly used according to actual conditions and store the scripts in the knowledge base, the knowledge base can accumulate the scripts compiled in the debugging process besides the scripts compiled in advance, namely, the scripts generated in the pre-compiling and debugging process are accumulated in the knowledge base, and the application can be rapidly adapted to any asset through the accumulated scripts.
The script can also be customized by a developer according to the requirement, commands, indexes and analysis data scripts and then configured on the nodes, and the flexible configuration of the acquisition task is realized without using the script of a knowledge base.
Step S130, inputting initialization parameters to the initial node to make the plurality of nodes advance according to the connection relationship, and when the initial node advances to any node in the plurality of nodes, the node executes its own function, and,
the command sub-process collects the execution data of the node while the node performs its own function,
the analysis sub-process reads the data collected by the command sub-process after the command sub-process collects the data, carries out standardized processing on the data,
and after the data processed by the index sub-process is analyzed, reading the standardized data, and visually displaying the standardized data according to a preset format.
The initialization parameters, which are parameters required to be input for the program flow operation, such as the commodity type in the above example, are input to the start node. After the initial node receives the parameters and executes the self function, the node of the next level is pushed according to the connection relation, after the node of the next level is pushed and executes the self function, the node of the next level connected with the node of the next level is pushed according to the connection relation, and the nodes of all levels are gradually pushed until all the nodes are completely executed. And executing the flow, wherein the flow is pushed downwards step by step through a connection relation such as a user clicking an event, and the part of the execution event is fed back to the user, so that the user can know what happens to each part. After the execution of the service flow is finished, the result and various abnormal information generated in the result can be collected and fed back to the user.
The nodes are pushed to execute the functions contained in the nodes, and when the nodes execute, the command subprocess collects the execution data of the nodes, wherein the execution data comprises an execution result, execution time, exit data and entry data.
And informing the analysis sub-process after the command sub-process collects the data, reading the data collected by the command sub-process by the analysis sub-process, and carrying out standardized processing on the data.
And informing the index sub-process after the data is processed by the analysis sub-process, reading the standardized data by the index sub-process, and visually displaying the standardized data according to a preset format.
The collected execution information is spliced into the environment and is uniformly informed to the user, the operation result of each step is transparent to the user, and when abnormal information occurs, the error information is recorded into the environment, so that the user can conveniently and timely perform error troubleshooting.
The method can be used for pressure measurement of the program flow, so that the information of each node of the program flow becomes transparent.
Preferably, the method further comprises:
and distributing the nodes on different threads according to the connection relation so that the nodes are processed on different threads.
Parallel nodes can be distributed on different threads, in the example, the commodity selection process in the example, the above process is assumed to be that when a user clicks a certain type of commodity, the commodity of the type in the database is obtained, in parallel, historical order data of the user is obtained to sequence or prompt the commodity, a result is output, the promotion activity of each commodity is obtained, and the promotion activity is displayed below a commodity column. In this process, there are two parallel nodes after the commodity data node is acquired: and acquiring historical data of users for sequencing, and acquiring data of sales promotion activities for displaying.
For the type of parallel nodes, the nodes can be distributed on different threads, and the thread is the minimum unit for an operating system to carry out operation scheduling. In most cases, it is included in a process and is the actual unit of operation in the process. A thread refers to a single sequential control flow in a process. By distributing the nodes on different threads, each thread executes different tasks in parallel, and the execution throughput rate of the program and the execution efficiency of the program are improved.
By adopting the program flow debugging method provided by the application, the execution of the flow is decomposed into the connection relations of a plurality of nodes and the nodes, the flow is pushed according to the connection relations, the execution data of the nodes is collected through the node sub-flows when the flow is pushed to a certain node, and the collected execution data is visually displayed, so that each node is transparent to developers, the execution condition and the performance of each node are known, the developers can quickly position error positions according to the collected execution information when an abnormality occurs, error troubleshooting is timely carried out, and the time spent on online error troubleshooting is reduced. And through the collected execution information, developers can quickly reproduce the input data of the error node to realize breakpoint debugging.
In addition, when the program flow is expanded to expand the nodes to increase the instance integrity, the execution information of the nodes is known, so that the information of the known nodes can be directly utilized to quickly check whether the newly added nodes are correct or not for newly developed expansion nodes. Compared with the existing program debugging method, the method has the advantages that after the new program flow is configured, deployment personnel can test whether the flow is effective or not more quickly.
Based on the same inventive concept, an embodiment of the present application provides a program flow debugging apparatus. Referring to fig. 2, fig. 2 is a functional block diagram of a program flow debugging apparatus according to an embodiment of the present application.
As shown in fig. 2, the apparatus includes:
a decomposition module 210, configured to decompose a program flow into a plurality of nodes and a connection relationship between the plurality of nodes, and mark a starting node in the plurality of nodes;
a node configuring module 220, configured to configure a node sub-process of each node for the plurality of nodes, where the type of the node sub-process includes: command subprocess, analysis subprocess and index subprocess;
a pushing module 230, configured to input an initialization parameter to the initial node, so that the plurality of nodes are pushed according to the connection relationship, and when pushing to any node in the plurality of nodes, the node performs its own function, and,
the command sub-process collects the execution data of the node while the node performs its own function,
the analysis sub-process reads the data collected by the command sub-process after the command sub-process collects the data, carries out standardized processing on the data,
and after the data processed by the index sub-process is analyzed, reading the standardized data, and visually displaying the standardized data according to a preset format.
Preferably, the node configuring module 220 includes:
the analysis submodule is used for analyzing the node subprocess which needs to be configured according to the function of each node aiming at the plurality of nodes;
the selection submodule is used for selecting a target script corresponding to each node subprocess in a knowledge base, and the knowledge base comprises a plurality of scripts;
and the configuration submodule is used for configuring the target script on the node.
Preferably, the apparatus further comprises:
and the distribution module is used for distributing the nodes on different threads according to the connection relation so as to enable the nodes to be processed on different threads.
Based on the same inventive concept, another embodiment of the present application provides a readable storage medium, on which a computer program is stored, where the computer program, when executed by a processor, implements the steps in the program flow debugging method according to any of the above embodiments of the present application.
Based on the same inventive concept, another embodiment of the present application provides an electronic device, which includes a memory, a processor, and a computer program stored in the memory and running on the processor, and when the processor executes the computer program, the electronic device implements the steps in the program flow debugging method according to any of the above embodiments of the present application.
For the device embodiment, since it is basically similar to the method embodiment, the description is simple, and for the relevant points, refer to the partial description of the method embodiment.
The embodiments in the present specification are described in a progressive manner, each embodiment focuses on differences from other embodiments, and the same and similar parts among the embodiments are referred to each other.
As will be appreciated by one of skill in the art, embodiments of the present application may be provided as a method, apparatus, or computer program product. Accordingly, embodiments of the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, embodiments of the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
Embodiments of the present application are described with reference to flowchart illustrations and/or block diagrams of methods, terminal devices (systems), and computer program products according to embodiments of the application. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing terminal to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing terminal, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing terminal to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing terminal to cause a series of operational steps to be performed on the computer or other programmable terminal to produce a computer implemented process such that the instructions which execute on the computer or other programmable terminal provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
While preferred embodiments of the present application have been described, additional variations and modifications of these embodiments may occur to those skilled in the art once they learn of the basic inventive concepts. Therefore, it is intended that the appended claims be interpreted as including the preferred embodiment and all such alterations and modifications as fall within the true scope of the embodiments of the application.
Finally, it should also be noted that, herein, relational terms such as first and second, and the like may be used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Also, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or terminal that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or terminal. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other like elements in a process, method, article, or terminal that comprises the element.
The above detailed description is given to a program flow debugging method, apparatus, device and storage medium provided by the present application, and a specific example is applied in the present application to explain the principle and implementation manner of the present application, and the description of the above embodiment is only used to help understanding the method and core ideas of the present application; meanwhile, for a person skilled in the art, according to the idea of the present application, there may be variations in the specific embodiments and the application scope, and in summary, the content of the present specification should not be construed as a limitation to the present application.
Claims (8)
1. A program flow debugging method is characterized by comprising the following steps:
decomposing a program flow into a plurality of nodes and the connection relation of the plurality of nodes, and marking a starting node in the plurality of nodes;
configuring a node sub-process of each node aiming at the plurality of nodes, wherein the type of the node sub-process comprises the following steps: command subprocess, analysis subprocess and index subprocess;
inputting initialization parameters to the starting node to cause the plurality of nodes to advance according to the connection relationship and to perform their own functions when advancing to any of the plurality of nodes, and,
the command sub-process collects the execution data of the node while the node performs its own function,
the analysis sub-process reads the data collected by the command sub-process after the command sub-process collects the data, carries out standardized processing on the data,
and after the data processed by the index sub-process is analyzed, reading the standardized data, and visually displaying the standardized data according to a preset format.
2. The method of claim 1, wherein configuring a node sub-flow for each node for the plurality of nodes comprises:
aiming at the plurality of nodes, analyzing a node sub-process required to be configured according to the function of each node;
selecting a target script corresponding to each node subprocess in a knowledge base, wherein the knowledge base comprises a plurality of scripts;
and configuring the target script on a node.
3. The method of claim 1, further comprising:
and distributing the nodes on different threads according to the connection relation so that the nodes are processed on different threads.
4. An apparatus for debugging a program flow, the apparatus comprising:
the decomposition module is used for decomposing the program flow into a plurality of nodes and the connection relation of the plurality of nodes, and marking initial nodes in the plurality of nodes;
a node configuration module, configured to configure node sub-processes of each node for the plurality of nodes, where the types of the node sub-processes include: command subprocess, analysis subprocess and index subprocess;
a pushing module, configured to input initialization parameters to the initial node, so that the plurality of nodes are pushed according to the connection relationship, and when pushing to any node in the plurality of nodes, the node executes its own function, and,
the command sub-process collects the execution data of the node while the node performs its own function,
the analysis sub-process reads the data collected by the command sub-process after the command sub-process collects the data, carries out standardized processing on the data,
and after the data processed by the index sub-process is analyzed, reading the standardized data, and visually displaying the standardized data according to a preset format.
5. The apparatus of claim 4, wherein the node configuration module comprises:
the analysis submodule is used for analyzing the node subprocess which needs to be configured according to the function of each node aiming at the plurality of nodes;
the selection submodule is used for selecting a target script corresponding to each node subprocess in a knowledge base, and the knowledge base comprises a plurality of scripts;
and the configuration submodule is used for configuring the target script on the node.
6. The apparatus of claim 4, further comprising:
and the distribution module is used for distributing the nodes on different threads according to the connection relation so as to enable the nodes to be processed on different threads.
7. A computer-readable storage medium, on which a computer program is stored which, when being executed by a processor, carries out the steps of the method according to any one of claims 1 to 3.
8. An electronic device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, characterized in that the steps of the method according to any of claims 1 to 3 are implemented when the computer program is executed by the processor.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110574485.5A CN113568825B (en) | 2021-05-25 | 2021-05-25 | Program flow debugging method, device, equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110574485.5A CN113568825B (en) | 2021-05-25 | 2021-05-25 | Program flow debugging method, device, equipment and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113568825A true CN113568825A (en) | 2021-10-29 |
| CN113568825B CN113568825B (en) | 2024-03-15 |
Family
ID=78161578
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110574485.5A Active CN113568825B (en) | 2021-05-25 | 2021-05-25 | Program flow debugging method, device, equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113568825B (en) |
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114201149A (en) * | 2022-02-18 | 2022-03-18 | 北京阿丘科技有限公司 | Operation flow generation method, device and system and computer readable storage medium |
| CN114462900A (en) * | 2022-04-13 | 2022-05-10 | 云智慧（北京）科技有限公司 | Method, device and equipment for splitting service active node |
| CN115080387A (en) * | 2022-06-01 | 2022-09-20 | 广州鲁邦通智能科技有限公司 | Front-end visual debugging method, system, equipment and readable storage medium |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20130166886A1 (en) * | 2008-11-24 | 2013-06-27 | Ruchira Sasanka | Systems, apparatuses, and methods for a hardware and software system to automatically decompose a program to multiple parallel threads |
| CN105302549A (en) * | 2015-09-29 | 2016-02-03 | 莱诺斯科技(北京)有限公司 | Multiple-language-supporting test process generating, debugging and executing system |
| CN107194549A (en) * | 2017-05-05 | 2017-09-22 | 南京南瑞继保电气有限公司 | The visual presentation method that a kind of energy efficiency indexes are decomposed |
| CN107818043A (en) * | 2016-09-13 | 2018-03-20 | 东华软件股份公司 | Method and apparatus for program debugging |
| CN112817720A (en) * | 2021-01-30 | 2021-05-18 | 北京奇保信安科技有限公司 | Visual workflow scheduling method and device and electronic equipment |
-
2021
- 2021-05-25 CN CN202110574485.5A patent/CN113568825B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20130166886A1 (en) * | 2008-11-24 | 2013-06-27 | Ruchira Sasanka | Systems, apparatuses, and methods for a hardware and software system to automatically decompose a program to multiple parallel threads |
| CN105302549A (en) * | 2015-09-29 | 2016-02-03 | 莱诺斯科技(北京)有限公司 | Multiple-language-supporting test process generating, debugging and executing system |
| CN107818043A (en) * | 2016-09-13 | 2018-03-20 | 东华软件股份公司 | Method and apparatus for program debugging |
| CN107194549A (en) * | 2017-05-05 | 2017-09-22 | 南京南瑞继保电气有限公司 | The visual presentation method that a kind of energy efficiency indexes are decomposed |
| CN112817720A (en) * | 2021-01-30 | 2021-05-18 | 北京奇保信安科技有限公司 | Visual workflow scheduling method and device and electronic equipment |
Cited By (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114201149A (en) * | 2022-02-18 | 2022-03-18 | 北京阿丘科技有限公司 | Operation flow generation method, device and system and computer readable storage medium |
| CN114462900A (en) * | 2022-04-13 | 2022-05-10 | 云智慧（北京）科技有限公司 | Method, device and equipment for splitting service active node |
| CN114462900B (en) * | 2022-04-13 | 2022-07-29 | 云智慧（北京）科技有限公司 | Method, device and equipment for splitting service active node |
| CN115080387A (en) * | 2022-06-01 | 2022-09-20 | 广州鲁邦通智能科技有限公司 | Front-end visual debugging method, system, equipment and readable storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN113568825B (en) | 2024-03-15 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN113568825B (en) | Program flow debugging method, device, equipment and storage medium | |
| US6421822B1 (en) | Graphical user interface for developing test cases using a test object library | |
| US6658649B1 (en) | Method, apparatus and article of manufacture for debugging a user defined region of code | |
| US6978440B1 (en) | System and method for developing test cases using a test object library | |
| US20120116561A1 (en) | Program testing apparatus, method of testing a program, and program testing program | |
| US8434058B1 (en) | Integrated system and method for validating the functionality and performance of software applications | |
| US9098633B2 (en) | Application testing | |
| US8918760B2 (en) | Test script generation for application image validation | |
| CN103049371A (en) | Testing method and testing device of Android application programs | |
| US7178135B2 (en) | Scope-based breakpoint selection and operation | |
| US20110016452A1 (en) | Method and system for identifying regression test cases for a software | |
| CN110347085B (en) | Automated test system, method, vehicle, and computer-readable medium | |
| CN106227654A (en) | A kind of test platform | |
| CN102479152A (en) | Method and device for obtaining tool automatic test results on basis of Android platform | |
| JP2000122886A (en) | Program production system of semiconductor testing device | |
| JP6568017B2 (en) | Test support apparatus and test support method | |
| Agarwal et al. | Copilot Evaluation Harness: Evaluating LLM-Guided Software Programming | |
| CN116541270B (en) | Method and device for testing adaptation verification of operating system | |
| KR101271821B1 (en) | Steel process middleware application error analysis system and error analysis method using the same | |
| Rentschler et al. | Interactive visual analytics for efficient maintenance of model transformations | |
| CN102760086A (en) | Data detection control method and device based on flexible testing technology | |
| CN114594943B (en) | Data modeling method, device, equipment and storage medium | |
| CN114265735A (en) | Equipment testing method, system, device and computer readable storage medium | |
| Köckerbauer et al. | Scalable parallel debugging with g-Eclipse | |
| Guo et al. | A business process explorer: recovering and visualizing e-commerce business processes |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |