Program debugging method and device thereof

Abstract

The application discloses a program debugging method and device, and belongs to the technical field of program development. The method comprises the following steps: a graphical user interface (GUI) is used to show an execution graph of a program to a user, the execution graph comprises one or more execution nodes, and each execution node represents an execution step of the program; a node display adding instruction sent by the user is received; a display node is added at an output end of a target execution node in the one or more execution nodes based on the node display adding instruction; debugging of the program is started according to an instruction of the user; and the display node is used to provide output data of the target execution node in the debugging process to the user. The application enriches the function of visual debugging of the program development platform based on the execution graph of the program.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of program development, and particularly relates to a program debugging method and device. BACKGROUND

[0002] At present, in order to facilitate developers to develop programs, some manufacturers provide program development platforms. Developers can arrange an execution graph of a program according to implementation logic of the program, and use the execution graph to debug the program. The execution graph is used to represent an execution flow of the program, an execution node of the execution graph is used to represent an execution step of the program, and the execution node can be specifically an operator with a specific function, and an edge between the execution nodes in the execution graph is used to represent an execution order and a dependency relationship between steps.

[0003] However, the program debugging function based on the execution graph provided by the existing program development platform is relatively single. SUMMARY

[0004] The present application provides a program debugging method and device, and enriches the function of visualizing program debugging based on an execution graph of a program by a program development platform. The technical scheme provided by the present application is as follows:

[0005] In a first aspect, the present application provides a program debugging method, which comprises: displaying an execution graph of a program to a user through a graphical user interface (GUI), the execution graph comprising one or more execution nodes, each execution node representing an execution step of the program; receiving a display node adding instruction sent by the user; adding a display node at an output end of a target execution node in the one or more execution nodes based on the display node adding instruction; starting debugging of the program according to an instruction of the user; and providing output data of the target execution node in the debugging process to the user by using the display node.

[0006] In the program debugging method, the user can add a display node at an output end of any target execution node in an execution graph according to actual needs during program debugging based on the execution graph, and obtain output data of the target execution node in the debugging process through the display node, thereby enriching the function of visualizing program debugging based on the execution graph of the program by the program development platform.

[0007] In an implementable manner, the output data of the target execution node in the debugging process is provided to the user by using the display node, specifically comprising: receiving display configuration information set by the user for the display node; and providing the output data of the target execution node in the debugging process to the user by using the display node according to the display configuration information.

[0008] By setting the display node, the display node can display the output data of the target execution node according to the user's will, further enriching the function of the program development platform and improving the user's development experience.

[0009] Optionally, the display configuration information includes: a display data type, and / or a display strategy.

[0010] Optionally, the display node supports display of data of multiple data types. When the display node supports display of data of multiple data types, diversified display of program development results can be achieved, further enriching the function of the program development platform.

[0011] Optionally, the display data type includes one or more of the following types: image, video, audio, character, numerical value, and program data object.

[0012] Optionally, the display strategy includes any of the following: displaying the output data of the target execution node at the pause time when the program is paused; displaying the output data of the target execution node between the last pause time and the current pause time when the program is paused; displaying the output data of the target execution node at the time when the running time of the program reaches a specified time length; displaying the output data of the target execution node between the last time when the running time of the program reaches the specified time length and the current time when the running time of the program reaches the specified time length; displaying the output data of the target execution node in real time; and displaying the output data of the target execution node when the output data of the target execution node meets a specified filtering condition.

[0013] It should be noted that if the display mode of the display node and the display data type are not set, the display node provides the output data of the target execution node in the debugging process to the user, including: identifying the data type of the output data; using the display node to display the output data using a display mode adapted to the data type of the output data.

[0014] In a second aspect, the present application provides a program debugging device, which comprises: an interaction module for controlling display of an execution graph of a program to a user through a graphical user interface (GUI), the execution graph comprising one or more execution nodes, each execution node representing an execution step of the program; the interaction module is configured to receive a display node adding instruction sent by the user; a processing module is configured to add a display node at an output end of a target execution node in the one or more execution nodes based on the display node adding instruction; the interaction module is further configured to start debugging of the program according to an instruction of the user; and the interaction module is further configured to provide output data of the target execution node in the debugging process to the user using the display node.

[0015] Optionally, the interaction module is configured to receive the display configuration information set by the user for the display node, and provide, according to the display configuration information, the output data of the target execution node in the debugging process to the user by using the display node.

[0016] Optionally, the display configuration information comprises a display data type and / or a display strategy.

[0017] Optionally, the display data type comprises one or more of the following types: image, video, audio, character, numerical value, and program data object.

[0018] Optionally, the display strategy comprises one of the following: displaying the output data of the target execution node at the time of pausing when the program is paused; displaying the output data of the target execution node between the time of the last pausing and the time of the current pausing when the program is paused; displaying the output data of the target execution node at the time of reaching the specified duration when the running duration of the program reaches the specified duration; displaying the output data of the target execution node between the time of the last reaching the specified duration and the time of the current reaching the specified duration when the running duration of the program reaches the specified duration; displaying the output data of the target execution node in real time during the debugging process; and displaying the output data of the target execution node when the output data of the target execution node meets the specified filtering condition.

[0019] Optionally, the interaction module receives the display configuration information set by the user for the display node, and the receiving specifically comprises: providing, by using a GUI, a setting interface of the display configuration information to the user; and receiving the display configuration information selected by the user in the setting interface.

[0020] In a third aspect, the present application provides a computer device, which comprises a processor and a memory, and the memory stores a computer program; when the processor executes the computer program, the computer device implements the method provided in the first aspect and any optional implementation manner of the present application.

[0021] In a fourth aspect, the present application provides a non-transitory computer readable storage medium, when instructions in the computer readable storage medium are executed by a processor, the method provided in the first aspect and any optional implementation manner of the present application is implemented.

[0022] In a fifth aspect, the present application provides a computer program product comprising instructions, when the computer program product is run on a computer, the computer is caused to execute the method provided in the first aspect and any optional implementation manner of the present application. BRIEF DESCRIPTION OF DRAWINGS

[0023] Figure 1 is a schematic diagram of an execution graph of a program for implementing video analysis provided by an embodiment of the present application;

[0024] Figure 2 is a schematic diagram of an application scenario related to a program debugging method provided by an embodiment of the present application;

[0025] Figure 3 is a schematic diagram of an application scenario related to another program debugging method provided by an embodiment of the present application;

[0026] Figure 4 is a flowchart of a program debugging method provided by an embodiment of the present application;

[0027] Figure 5 is a flowchart of an initial program to which a user performs an operation provided by an embodiment of the present application;

[0028] Figure 6 is a schematic diagram of a graphical user interface of a program development platform provided by an embodiment of the present application;

[0029] Figure 7 is a schematic diagram of a graphical user interface of a program development platform provided by an embodiment of the present application, in which an execution graph is displayed;

[0030] Figure 8 is a schematic diagram of a program development platform provided by an embodiment of the present application, in which a display node is added to an execution graph;

[0031] Figure 9 is a schematic diagram of a program development platform provided by an embodiment of the present application, in which a display mode of a display node is set;

[0032] Figure 10 is a schematic diagram of a first setting interface provided by an embodiment of the present application;

[0033] Figure 11 is a schematic diagram of a program debugging method provided by an embodiment of the present application, in which a graphical user interface and an execution framework are cooperated to realize program debugging;

[0034] Figure 12 is a schematic diagram of a program development platform provided by an embodiment of the present application, in which a display node displays output data of a target execution node;

[0035] Figure 13 is a structural schematic diagram of a program debugging device provided by an embodiment of the present application;

[0036] Figure 14 is a structural schematic diagram of a computer device provided by an embodiment of the present application. DETAILED DESCRIPTION

[0037] To make the objectives, technical solutions, and advantages of the present application clearer, the following will further describe the embodiments of the present application in detail with reference to the accompanying drawings.

[0038] Currently, some manufacturers provide a program development platform for the convenience of developers to develop programs. Developers can use the program development platform to develop the algorithm of the program (such as developing an operator or developing an algorithm according to an existing operator), debug the program, and deploy the business implemented by the program online (for example, packaging the operators and program logic included in the program into a container, and running the program through the container to provide corresponding business services). Among them, a set of one or more operations performed on an operation object is called an operator. An algorithm is used to implement a specific function, and the algorithm can be represented by a program, and the algorithm usually includes one or more operators.

[0039] In addition, the program development platform can be a cloud service provided to users through a cloud platform, or the program development platform can also be a service provided to users through other resource platforms, or the program development platform can also be in the form of an application installation package, installed by users on the local device of the user, and the local device provides services to the user through the client.

[0040] Among them, when developing a program by using the program development platform, after the user completes the development of the required operator of the program, the user can arrange the execution graph of the program in the graphical user interface (GUI) of the program development platform according to the implementation logic of the program, and can also debug the program based on the execution graph. The execution graph is used to represent the execution flow of the program, and the execution graph includes one or more execution nodes, each execution node is used to represent an execution step of the program, and the edges between the execution nodes are used to represent the execution order and dependency relationship between the execution steps. The input data of an execution node can be the output data of the previous execution node of the execution node, and after the execution step represented by any execution node is completed, zero or more outputs are generated.

[0041] However, the program debugging function based on the execution graph provided by the current program development platform is relatively single. For example, when debugging the program by using the program development platform, the user cannot decide the data to be viewed and select the type of data to be viewed, resulting in poor user debugging experience.

[0042] The embodiments of the present application provide a program debugging method. In the program debugging method, the execution graph of the program is displayed to the user through the graphical user interface, the display node is added at the output end of the target execution node based on the display node adding instruction sent by the user, and the output data of the target execution node in the debugging process is provided to the user by using the display node. In the process of debugging the program based on the execution graph, the display node can be added at the output end of the execution node of the execution graph according to the will of the user, the visual display of the output result of the step in the program is realized, the function of the program development platform is enriched, and the development experience of the user is improved.

[0043] As mentioned above, an execution graph is used to represent the execution flow of a program. Execution nodes in the execution graph represent execution steps of the program, and edges between execution nodes represent the execution order and dependencies between steps. In one possible implementation of this application embodiment, the execution graph is represented as a directed acyclic graph. For example, Figure 1 This is an execution diagram of a program for implementing video analysis provided in an embodiment of this application. For example... Figure 1 As shown, the execution graph includes six execution nodes (each rectangle represents an execution node), each node representing a step of the program. Execution nodes are connected by arrows, which are called edges between execution nodes. According to the execution graph, the program includes six steps: video decapsulation, video decoding, face detection, drawing detection bounding boxes, video decoding, and video encapsulation. The execution order and dependencies between these six steps are as follows: Upon receiving the video to be processed, the video is first decapsulated to obtain a video data packet. Then, the video data packet is decoded to obtain a video image. Next, face detection and detection bounding boxes are drawn on the video image. After obtaining the face detection result, detection bounding boxes are drawn on the face detection result. Then, the image with drawn detection bounding boxes is video encoded to obtain a video data packet. Finally, the video data packet is encapsulated, and the encapsulated result is output.

[0044] The execution graph is displayed on the graphical user interface (GUI), allowing users to debug the program by performing related operations within the GUI. During program execution, the invocation of each execution node and the data transfer between them are handled by the program's execution framework, which ensures the correct invocation of each step of the program. In other words, debugging the execution graph is achieved through the collaborative effort of the GUI and the execution framework.

[0045] The implementation of calling execution nodes through the execution framework is as follows: When any execution node receives a user's debugging request, the graphical user interface (GUI) transmits the operation indicated by the debugging request to the execution framework. The execution framework then performs the corresponding operation on the program according to the operation indicated by the debugging request and returns the operation result to the GUI, so that the GUI can provide feedback to the user on the operation result. The implementation of data transfer between execution nodes through the execution framework is as follows: When execution node A uses the output data of execution node B as input data, after executing the program step represented by execution node B, the execution framework transmits the output data of that program step to the program step represented by execution node A.

[0046] Figure 2is a schematic diagram of an application scenario to which a program debugging method provided in embodiments of the present application relates. As shown in Figure 2 The application scenario includes a terminal 10 and a server 11. The terminal 10 and the server 11 are communicatively connected through a wired or wireless network.

[0047] Optionally, the terminal 10 can be a computer, a personal computer, a cloud host, a portable mobile terminal, a multimedia player, an electronic book reader, or a wearable device, etc. The server 11 can be a single server, or a server cluster composed of several servers, or a cloud computing service center.

[0048] The application scenario shown in Figure 2 There are various implementation manners of the program development platform, which are described below by taking two implementable manners as examples:

[0049] In the first implementable manner, the server 11 is configured to provide a terminal 10 with a related function package (such as a program installation package) required for implementing a program development platform. The terminal 10 is configured to obtain the function package required for implementing the program development platform from the server 11, and provide the program development platform for a user by running the function package. For example, the terminal 10 can download a program installation package for implementing the program development platform from the server 11, install the program installation package in the terminal 10, and perform a related program development operation on a program according to a related request for developing the program sent by the user, to provide the function of the program development platform for the user. That is, in this implementation manner, the terminal 10 is configured to interact with the user, and after obtaining the related function package required for implementing the program development platform from the server 11, the terminal 10 can provide the function of the program development platform for the user by running the function package without depending on the server 11. The function of the program development platform includes the function implemented by the terminal 10 by executing the program debugging method provided in embodiments of the present application.

[0050] In the second implementable manner, the terminal 10 is configured to generate a request according to a related operation of developing a program indicated by a user, and send the request to the server 11. The server 11 is configured to perform a related program development operation on the program according to the received request, and feed back a result of the operation on the program to the terminal. Correspondingly, the terminal 10 is also configured to show the result of the operation on the program to the user. That is, in this implementation manner, the program development platform provided for the user needs to be implemented in cooperation with the terminal 10 and the server 11, wherein the terminal 10 is configured to interact with the user and the server 11, and the server 11 is configured to perform a related development operation on the program according to the request for the user sent by the terminal 10 to the server 11. The function of the program development platform includes the function implemented by the server 11 by executing the program debugging method provided in embodiments of the present application.

[0051] In the second implementation manner, the program development platform can be provided through a cloud platform. At this time, the server 11 can be implemented through a cloud computing service center. A large number of basic resources owned by a cloud service provider are deployed in the cloud computing service center. For example, computing resources, storage resources, network resources and the like are deployed in the cloud computing service center. The cloud computing service center can provide the program development platform by using the large number of basic resources. Correspondingly, a user can access the cloud platform through a browser and a client and the like on the terminal 10, and use the program development platform provided by the cloud platform.

[0052] At this time, as shown in Figure 3 The program development platform provided by the server 11 can be abstracted into a cloud service (hereinafter referred to as a program development cloud service) for developing a program by the cloud service provider in the cloud platform. After the user purchases the program development cloud service in the cloud platform, the cloud platform can provide the user with the program development platform by using the resources in the cloud computing center, so that the user develops the algorithm of the program and debugs the program through the program development platform. Alternatively, the cloud platform can be a cloud platform of a central cloud, a cloud platform of an edge cloud or a cloud platform including a central cloud and an edge cloud, and the embodiments of the present application do not make specific limitation thereto.

[0053] Alternatively, in the second implementation manner, the program development platform can also be implemented through other resource platforms other than the cloud platform. At this time, the server 11 can be implemented through the resources in the other resource platforms, and provide the user with the program development platform.

[0054] It should be understood that the above is an exemplary description of the application scenarios of the program debugging method provided by the embodiments of the present application, and does not constitute a limitation on the application scenarios of the program debugging method. It can be known by those skilled in the art that the application scenarios can be adjusted according to application requirements as the business requirements change, and the embodiments of the present application do not make one-by-one enumeration.

[0055] The implementation process of the program debugging method provided by the embodiments of the present application will be described below by taking the program development platform provided through the second implementation manner as an example. When the program development platform is provided through the first implementation manner described above, the implementation manner can be correspondingly referred to the implementation manner of providing the program development platform through the second implementation manner. As shown in Figure 4 The implementation process of the program debugging method can include the following steps:

[0056] Step 401, the server receives a program arrangement instruction for a program, executes a program arrangement operation indicated by the program arrangement instruction, and generates an execution graph.

[0057] The program orchestration operation includes one or more of adding an execution node, deleting an execution node, adjusting a position of an execution node, and adding a connection relationship between execution nodes.

[0058] The user can access the program development platform on the terminal, for example, using a browser or a client to access the program development platform. When the user accesses the program development platform, the display screen of the terminal displays a graphical user interface of the program development platform, and the user can perform operations in the graphical user interface to trigger program orchestration instructions for the program. After the terminal receives the user's operation, it can generate program orchestration instructions and send them to the server. After the server receives the program orchestration instructions, it performs the program orchestration operations indicated by the program orchestration instructions, for example, performs one or more program orchestration operations of adding an execution node, deleting an execution node, adjusting a position of an execution node, and adding a connection relationship between execution nodes to generate an execution graph of the program. After generating the execution graph of the program, the server provides the terminal with related data of the execution graph, so that the terminal displays the execution graph in the graphical user interface of the program development platform. Alternatively, each program orchestration instruction can indicate one program orchestration operation, or each program orchestration instruction can indicate multiple program orchestration operations, which are not limited in the embodiments of the present application.

[0059] The program to which the user triggers the program orchestration instruction can be an initial program developed by the user using the program development platform, or an initial program uploaded by the user to the program development platform in advance, at which time the user can debug and improve the initial program by using the program development platform. Alternatively, there is no initial program when the user triggers the program orchestration instruction, at which time the user can associate existing operators or algorithms provided by the program development platform to establish an execution order and dependency relationship between the existing operators or algorithms to obtain an initial program through the process of generating an execution graph.

[0060] For example, assume that Figure 5 a flowchart of the initial program to which the user triggers the program orchestration instruction, Figure 6 When the user starts accessing the program development platform, the terminal displays a graphical user interface of the program development platform. As shown in Figure 6 The second column from top to bottom of the graphical user interface is provided with buttons of starting debugging, single-step debugging, and pausing debugging from left to right, and the third column from top to bottom of the graphical user interface is divided into three functional modules, which are a node selection module on the left, an execution graph orchestration module on the upper right, and a program editing module on the lower right. The user can select an execution node in the node selection module by dragging or clicking, etc. to trigger program orchestration instructions for the initial program. And as shown in Figure 6As shown, different node types are divided in the node selection module, so that the user can select the required node in one or more nodes included in the corresponding type according to the function of the node. For example Figure 6 As shown, the node selection module includes input type, output type, image processing type, video processing type and debugging type, and the image processing type includes an execution node for flipping an image and an execution node for color adjustment of an image, and the video processing type includes an execution node for demultiplexing processing of a video, an execution node for decoding a video, an execution node for multiplexing processing of a video and an execution node for encoding a video.

[0061] According to Figure 5 As shown in the flowchart, the execution flow of the initial program includes video unpacking of the to-be-processed video, video decoding of the video data packet obtained by unpacking, horizontal flipping of the image obtained by video decoding, video encoding of the horizontally flipped image, and video packaging of the data packet obtained by encoding. Then, the user can execute the following operations according to the initial program: selecting the input execution node in the input type, selecting the demultiplexing execution node, the decoding execution node, the encoding execution node and the multiplexing execution node in the video processing type, selecting the flipping execution node in the image processing type, and determining the execution order of the selected execution nodes as: the input execution node, the demultiplexing execution node, the decoding execution node, the flipping execution node, the encoding execution node and the multiplexing execution node. The terminal generates corresponding program arrangement instructions according to the operations executed by the user, and sends the program arrangement instructions to the server. The server can generate the execution graph of the initial program according to the program arrangement instructions, and send the related data of the execution graph to the terminal. After receiving the related data, the terminal can display the execution graph as shown in Figure 7 in the execution graph arrangement module.

[0062] Step 402, the server receives the display node adding instruction sent by the user, and adds a display node at the output end of the target execution node in one or more execution nodes based on the display node adding instruction.

[0063] In the process of accessing the program development platform, the user can add a display node at the output end of one or more execution nodes in the execution graph according to application requirements. After the server adds the display node at the output end of the target execution node according to the display node addition instruction, the server sends relevant data of the execution graph after adding the display node to the terminal, and the terminal can display the execution graph after adding the display node on the graphical user interface of the program development platform according to the relevant data. The user touches the display node addition instruction, and the implementation of adding the display node at the output end of the target execution node can refer to the related description in step 401, which will not be repeated here.

[0064] For example, continuing to take the execution graph shown in Figure 7 FIG. 2 as an example, the user adds display nodes at the output ends of the decoding execution node and the flipping execution node according to debugging requirements, and the execution graph after adding the display nodes is as shown in Figure 8 FIG. 3.

[0065] Optionally, the display node can support data display of multiple data types. The multiple data types include one or more of the following types: image, video, audio, character, numerical value, program data object, and tensor, etc. The tensor is a physical quantity described by a square matrix. For example, gradient (field), vector field, exterior differential potential, and Riemann metric are all tensors. The program data object includes structured data, and the structured data refers to data represented and stored by a relational database, which is in a two-dimensional form. For example, the two-dimensional data of students represented by name and class is structured data. When the display node supports data display of multiple data types, the diversified display of program development results can be achieved, further enriching the functions of the program development platform.

[0066] It should be noted that the execution order of step 401 and step 402 can be adjusted according to application requirements. For example, step 401 can be executed first to generate the execution graph of the program, and then step 402 can be executed to add the display node at the output end of the execution node of the generated execution graph. Alternatively, step 402 can be executed in the process of executing step 401. For example, after adding the decoding execution node, the display node can be added at the output end of the decoding execution node, and then the flipping execution node can be added after the decoding execution node. Moreover, the terminal can send the instruction to the server after generating one instruction, or the terminal can send the specified number of instructions to the server after generating the specified number of instructions, or the terminal can send all the instructions generated by the terminal in the current time period to the server every time period, which is not limited in the embodiments of the present application.

[0067] In step 403, the server receives the display configuration information set by the user for the display node, and sets the display node according to the display configuration information.

[0068] Optionally, the display configuration information comprises a display data type and / or a display policy. That is, the user can set one or more of the display policy and the displayable data type of the display node, so that the display node displays data according to the display configuration information. The user can send the display configuration information to the terminal by specifying an operation, and the terminal can forward the display configuration information to the server. The server sets the display node according to the display configuration information, and then sends relevant data of the set display node to the terminal, so that the display node displays data according to the setting. The implementation of the user triggering the setting request until the server setting the display node according to the setting request can refer to the related description in step 401, which will not be repeated here.

[0069] Optionally, the server receives the display configuration information set by the user for the display node, specifically comprising: the server controls the terminal to provide a setting interface of the display configuration information to the user through the graphical user interface, receives the display configuration information selected by the user in the setting interface, and then receives the display configuration information sent by the terminal to the server.

[0070] In an implementation, after the user adds the display node at the output end of the target execution node, the user can perform a specifying operation on the display node in the graphical user interface to trigger a setting request of the display configuration information of the display node. The terminal can forward the setting request to the server. After receiving the setting request, the server controls the terminal to display a setting interface of the display configuration information in the graphical user interface, receives the display configuration information selected by the user in the setting interface of the display configuration information, and then sends the display configuration information to the server, so that the server sets the display node according to the display configuration information selected by the user.

[0071] As an example, the user can right-click the display node using a mouse, and select an option of setting the display configuration information in the dialog box popped up after clicking the display node, as shown in FIG. 6. Figure 9 The dialog box shown in FIG. 6 includes an option of the display configuration information. After receiving the selection of the user, the terminal provides a setting interface of the display configuration information to the user through the graphical user interface, as shown in FIG. 7. Figure 10 The setting interface of the display configuration information shown in FIG. 7 displays one or more alternative options of the display configuration information, and the user can click the alternative option to be selected using a mouse. After receiving the selection of the user, the terminal sends the display configuration information selected by the user to the server. The server sets the display node according to the display configuration information selected by the user, and then sends relevant data of the set execution graph to the terminal, so that the terminal displays data according to the setting. In the dialog box shown in FIG. 6 and the setting interface of the display configuration information shown in FIG. 7, Figure 9 Figure 10 ​The display position of the interface can be adjusted according to application requirements, and this is only an example.

[0072] Optionally, the alternative of the display data type includes one or more of the following types: image, video, audio, character, numerical value, and program data object. It should be understood that the data type of the output data of the target execution node can be different according to different application requirements, and at this time, the user can select a suitable display data type according to the requirements, so that the display node can effectively display the output data of the target execution node. The embodiments of the present application do not enumerate all the alternatives of the display mode.

[0073] For example, according to the flowchart shown in Figure 5 As can be seen from the flowchart, the output data of the video decoding execution node is an image, and the output data of the horizontal flip execution node is an image. In order to enable the user to see the effect of the horizontal flip execution node on the image, the user can add a display node at the output end of the video decoding execution node and the output end of the horizontal flip execution node, and set the display data type of the display node added at the output end of the video decoding execution node and the output end of the horizontal flip execution node to be an image.

[0074] Optionally, the alternative of the display strategy can include any one or more of the following:

[0075] The first display strategy is to display the output data of the target execution node at the pause time when the program is paused. That is, the display node displays the output data of the target execution node when the program is paused, and the displayed output data is the output data of the target execution node last received by the display node in the current debugging process.

[0076] For example, during the process of debugging the program based on the execution graph, the user starts the debugging of the program at t1, pauses the debugging of the program at t2, restarts the debugging of the program at t3, and pauses the debugging of the program at t4. According to the first display strategy, the display node can display the output data of the target execution node last received in the debugging process from t1 to t2 between t2 and t3, and the display node can display the output data of the target execution node last received in the debugging process from t3 to t4 after the pause debugging process at t4.

[0077] The second display strategy is to display all output data of the target execution node between the last pause time and the current pause time when the debugging of the program is paused. The last pause time is the pause time before the current pause time in the process of pausing the debugging of the program. That is, the display node displays the output data of the target execution node when the debugging of the program is paused, and the displayed output data is all output data received by the display node in the whole process of the current debugging.

[0078] For example, in the process of debugging the program based on the execution graph, the user starts the debugging of the program at t1, pauses the debugging of the program at t2, restarts the debugging of the program at t3, and pauses the debugging of the program at t4. According to the second display strategy, the display node can display all output data of the target execution node received between t2 and t4 in the pause debugging process after t4, that is, all output data of the target execution node received in the whole debugging process from t3 to t4.

[0079] The third display strategy is to display the output data of the target execution node at the time when the running time of the program reaches a specified time length. That is, the display node displays the output data of the target execution node when the running time of the program reaches the specified time length, and the displayed output data is the last received output data in the process of reaching the specified time length by the display node. The specified time length can be set by the user according to application requirements.

[0080] For example, assuming that the specified time length set by the user is T, and the debugging of the program is started at t1 in the process of debugging the program based on the execution graph, the display node can display the output data of the target execution node last received in the period of t1+T at t1+T.

[0081] The fourth display strategy is to display all output data of the target execution node between the last time when the running time of the program reaches a specified time length and the current time when the running time of the program reaches the specified time length. That is, the display node displays the output data of the target execution node when the running time of the program reaches the specified time length, and the displayed output data is all output data received by the display node in the whole process of reaching the execution time in the current process. The specified time length can be set by the user according to application requirements.

[0082] For example, assuming that the specified time length set by the user is T, and the debugging of the program is started at t1 in the process of debugging the program based on the execution graph, the display node can display all output data of the target execution node received in the period of t1+T at t1+T.

[0083] The fifth display strategy is to display the output data of the target execution node in real time during the debugging process.

[0084] For example, the user starts the debugging of the program at t1 during the debugging of the program based on the execution graph, and the display node can display the received output data of the target execution node in real time from t1.

[0085] The sixth display strategy is to display the output data of the target execution node when the output data of the target execution node meets the specified filtering condition. The specified filtering condition can be set by the user according to the application requirement. Optionally, the specified filtering condition can be that the size of the output data of the target execution node meets a specified numerical range.

[0086] For example, assuming that the output of the target execution node is a voltage waveform, and the specified filtering condition set by the user is that the amplitude of the voltage waveform is [-a, a], then during the debugging of the program based on the execution graph, the display node displays the voltage waveform only when the output data of the target execution node received by the display node indicates that the amplitude of the voltage waveform is within the range of [-a, a], and the display node does not display the voltage waveform when the output data of the target execution node received by the display node indicates that the amplitude of the voltage waveform at at least one time exceeds the range of [-a, a].

[0087] It should be noted that when the display nodes are added to the multiple execution nodes in the execution graph, the setting modes of different display nodes can be the same or different. Meanwhile, one or more display strategies can be set for the same display node as long as the multiple display strategies set for the display node do not conflict.

[0088] It should be further noted that the server can determine whether to set the display node according to the display configuration information according to the application requirement after receiving the display configuration information, that is, the server can select whether to perform the setting operation in this step 403 according to the application requirement. Moreover, if the setting operation of the display node is performed, the display node can display data according to the set display configuration when displaying data by using the display node. If the setting operation of the display node is not performed, the server can control the display node to display data according to the display configuration information when displaying data by using the display node. For example, when the display configuration information includes the display strategy, the display strategy limits the display timing of the display data and the specified filtering condition that needs to be met by the output data, the server controls the display node to display data according to the display strategy, including that the server sends the output data meeting the specified filtering condition to the display node and instructs the display node to display the output data meeting the specified filtering condition at the display timing indicated by the display strategy.

[0089] Step 404, the server receives a start debugging control instruction for the program, and starts debugging the program.

[0090] After generating the execution graph, adding the presentation node to the execution node, and setting the presentation node, the debugging of the program can be started. After the terminal generates the start debugging control instruction according to the operation of the user, the terminal sends the start debugging control instruction to the server, and the server can start debugging the program according to the start debugging control instruction. Moreover, the implementation manner of the user triggering the terminal to generate the start debugging control instruction can be correspondingly referred to the implementation manner of the user triggering the terminal to generate other instructions in the foregoing steps, and details are not described herein.

[0091] The implementation process of starting the debugging of the program can be realized by the graphical user interface and the execution framework. In an implementation manner, as shown in FIG. 6, the implementation process of starting the debugging of the program by the graphical user interface and the execution framework includes the following steps. Figure 11 After the terminal receives the triggering operation of the user on the graphical user interface, the terminal generates a start debugging control instruction. The graphical user interface delivers the start debugging control instruction to the execution framework. After the execution framework receives the start debugging control instruction, the execution framework starts the debugging process of the program, and returns to the graphical user interface that the state of the program has been adjusted to the start debugging state, thereby completing the start of the program.

[0092] Step 405, the server receives other debugging control instructions for the program, and performs control operations indicated by the other debugging control instructions on the program.

[0093] After starting the debugging process of the program, the user can also perform other debugging operations on the program according to the debugging requirements. The terminal generates other debugging control instructions according to the triggering operation of the user, and sends the other debugging control instructions to the server. The server performs control operations indicated by the other debugging control instructions on the program according to the other debugging control instructions, so as to meet different debugging requirements of the user on the program.

[0094] Optionally, the control operation indicated by the other debugging control instruction comprises: controlling to stop the debugging process of the program, controlling to pause the debugging process of the program, controlling to pause the debugging of the program after the execution node in the one or more execution nodes outputs data, and controlling to perform single-step debugging on the program. The controlling to pause the debugging of the program after the execution node in the one or more nodes outputs data refers to the breakpoint debugging of the program. The controlling to perform single-step debugging on the program refers to stopping the debugging of the program after executing one program step represented by the execution node each time. Optionally, the breakpoint debugging and the single-step debugging can be realized by pre-setting or according to the real-time control of the user. Moreover, the realization process of realizing the breakpoint debugging and the single-step debugging by pre-setting is described below with reference to the realization process of setting the display mode of the display node to the specified display mode, which is not repeated here.

[0095] The control operation of the program performed by the other debugging control instruction can also be realized by the graphical user interface cooperating with the execution framework. In an implementable manner, as shown in Figure 11 The realization process of realizing the pause of the debugging of the program by the graphical user interface cooperating with the execution framework comprises: after the terminal receives the triggering operation of the user on the graphical user interface, generating a pause debugging control instruction, the graphical user interface delivers the pause debugging control instruction to the execution framework, the execution framework receives the pause debugging control instruction, pauses the debugging process of the program, and returns to the graphical user interface that the state of the program has been adjusted to the pause debugging state, thereby completing the pause debugging of the program. When realizing the other debugging control operation of the program by the graphical user interface cooperating with the execution framework, the realization process can be correspondingly referred to the realization process of realizing the pause of the debugging of the program by the graphical user interface cooperating with the execution framework.

[0096] Step 406: The server provides the output data of the target execution node in the debugging process to the user by using the display node.

[0097] The server provides the output data of the target execution node in the debugging process to the user by using the display node refers to that the server sends the output data of the target execution node in the debugging process to the terminal, and the terminal displays the output data of the target execution node in the debugging process in the graphical user interface by using the display node.

[0098] Optionally, the step 406 can be realized by the graphical user interface cooperating with the execution framework. In an implementable manner, as shown in Figure 11As shown, the implementation process of this step 406 implemented by the graphical user interface and the execution framework includes: when the output data of the target execution node needs to be displayed by the display node, the graphical user interface sends a query request to the execution framework to query the output data of the target execution node, and after the execution framework receives the query request, the execution framework obtains the output data of the execution step represented by the target execution node and sends the output data to the graphical user interface, so that the display node in the graphical user interface displays data according to the output data.

[0099] If the user does not indicate the display configuration information, the display node can display data according to the default settings of the program development platform or automatically select an appropriate display mode when executing this step 406. If the user indicates the display configuration information, the display node can display data according to the display configuration information when executing this step 406. In addition, if the display node is set according to the display configuration information in step 403, the display node needs to display the output data of the target execution node in the debugging process according to the settings executed according to the display configuration information in this step 406.

[0100] Since the display configuration information includes the display data type and / or the display strategy, the implementation of the display node setting will be described below for different cases:

[0101] When the display configuration information includes the display data type, the implementation of the display node to provide the output data of the target execution node in the debugging process to the user includes: the display node uses the display data type indicated by the user to provide the output data to the user.

[0102] In one implementation, the implementation process includes: the display node identifies the data type of the output data, and when the data type of the output data is not the display data type indicated by the user, the display node converts the data type of the output data into the display data type indicated by the user, and then the display node uses the display mode suitable for the display data type indicated by the user to display the output data converted in the display data type.

[0103] For example, when the output data of the target execution node is a two-dimensional array, the data type of the output data is an array, and it is assumed that the display data type indicated by the user is an image. It can be known that the data type of the output data of the target execution node is not an image. Therefore, the display node can convert the two-dimensional array into an image and display the image converted from the two-dimensional array in the image display mode, thereby realizing the display of the output data of the target execution node.

[0104] And, the display mode adapted to the display data type indicated by the user can be automatically selected by the display node, or the display node can pre-store a corresponding relationship between display modes and data types adapted thereto, and the display node can query the corresponding relationship according to the display data type indicated by the user to obtain the display mode adapted to the display data type indicated by the user.

[0105] Corresponding to the setting of the data type displayed by the display node in step 403 to the specified data type, the display node provides the implementation mode of the output data of the target execution node in the debugging process to the user, including: the display node provides the output data to the user in the display mode adapted to the specified data type.

[0106] When the display configuration information includes a display strategy, the display node provides the implementation mode of the output data of the target execution node in the debugging process to the user, including: when the execution of the program meets the display strategy selected by the user, the display node provides the output data to the user according to the display strategy selected by the user.

[0107] In the first implementation mode, if the display strategy selected by the user is to display the output data of the target execution node at the pause time when the debugging of the program is paused, the display node can display the output data of the target execution node at the pause time when the debugging of the program is paused.

[0108] In the second implementation mode, if the display strategy selected by the user is to display all the output data of the target execution node between the last pause time and the current pause time when the debugging of the program is paused, the display node can display all the output data of the target execution node between the last pause time and the current pause time when the debugging of the program is paused.

[0109] In the third implementation mode, if the display strategy selected by the user is to display the output data of the target execution node at the time when the running time of the program reaches the specified time, the display node can display the output data of the target execution node at the time when the running time of the program reaches the specified time.

[0110] In the fourth implementation mode, if the display strategy selected by the user is to display all the output data of the target execution node between the last time when the running time of the program reaches the specified time and the current time when the running time of the program reaches the specified time, the display node can display all the output data of the target execution node between the last time when the running time of the program reaches the specified time and the current time when the running time of the program reaches the specified time.

[0111] In the fifth possible implementation, if the user selects the display strategy of real-time display of the target execution node's output data, then the display node can display the target execution node's output data in real time during the program's execution.

[0112] In the sixth possible implementation, if the user selects the display strategy of displaying the output data of the target execution node when the output data of the target execution node meets the specified filtering conditions, then the display node can display the output data of the target execution node when the output data of the target execution node meets the specified filtering conditions.

[0113] Additionally, when displaying the output data of the target execution node using a display node, a pop-up window can be displayed on the graphical user interface, and the output data of the target execution node can then be displayed in that window. Alternatively, the output data of the target execution node can be displayed directly at the location of the display node. Other implementation methods for displaying the output data of the target execution node using a display node will not be elaborated upon here.

[0114] For example, according to Figure 5 The flowchart shown illustrates that the output data of both the video decoding execution node and the horizontal flip execution node is an image. When the user adds display nodes to both the output ends of the video decoding execution node and the horizontal flip execution node, and the user-indicated display data type is an image, the display node added to the output end of the video decoding execution node can directly display the output data as an image after receiving it. Similarly, the display node added to the output end of the horizontal flip execution node can also directly display the output data as an image after receiving it. The images displayed by both are shown below. Figure 12 As shown, according to this Figure 12 As can be seen, the horizontal flipping of the image is achieved through the flipping operation.

[0115] It should be noted that the above is a schematic example of how a server provides a program development platform through a terminal, and the implementation can be adjusted according to application requirements. In one possible implementation, the implementation can be adjusted so that operations directly related to the graphical user interface are executed by the terminal, while operations directly related to the program are executed by the server. This application embodiment does not specifically limit this. For example, steps 401, 402, 403, and 406 are executed by the terminal, steps 404 and 405 are executed by the server, and the data required by the terminal is obtained by the terminal from the server.

[0116] To sum up, in the program debugging method provided in the embodiments of the present application, the user can add a display node at the output end of any target execution node of the execution graph according to actual needs in the process of debugging the program based on the execution graph, and knows the output data of the target execution node in the debugging process through the display node, thereby enriching the function of the program development platform in visualizing the program based on the execution graph of the program.

[0117] It should be noted that the order of the steps of the program debugging method provided in the embodiments of the present application can be adjusted appropriately, and the steps can be increased or decreased as appropriate. Any person skilled in the art can easily think of changes within the technical scope disclosed in the present application, which should be covered within the protection scope of the present application, and thus will not be described again.

[0118] The embodiments of the present application also provide a program debugging device. The structural schematic diagram of the program debugging device is shown in Figure 13 As shown in Figure 13 The program debugging device 130 comprises:

[0119] The interaction module 1301 is configured to control the display of the execution graph of the program to the user through the graphical user interface (GUI), and the execution graph comprises one or more execution nodes, and each execution node represents an execution step of the program.

[0120] The interaction module 1301 is configured to receive the display node adding instruction sent by the user.

[0121] The processing module 1302 is configured to add a display node at the output end of a target execution node in the one or more execution nodes based on the display node adding instruction.

[0122] The interaction module 1301 is further configured to start the debugging of the program according to the instruction of the user.

[0123] The interaction module 1301 is further configured to provide the output data of the target execution node in the debugging process to the user by using the display node.

[0124] Optionally, the interaction module 1301 is specifically configured to receive the display configuration information set by the user for the display node, and provide the output data of the target execution node in the debugging process to the user by using the display node according to the display configuration information.

[0125] Optionally, the display configuration information comprises a display data type and / or a display strategy.

[0126] Optionally, the display data type comprises one or more of the following types: image, video, audio, character, numerical value, and program data object.

[0127] Optionally, the display strategy comprises any one of the following:

[0128] when the debugging of the program is paused, the output data of the target execution node at the pausing moment is displayed;

[0129] when the debugging of the program is paused, the output data of the target execution node between the last pausing moment and the current pausing moment is displayed;

[0130] when the running time of the program reaches a specified time length, the output data of the target execution node at the moment when the specified time length is reached is displayed;

[0131] when the running time of the program reaches a specified time length, the output data of the target execution node between the last moment when the specified time length is reached and the current moment when the specified time length is reached is displayed;

[0132] in the debugging process, the output data of the target execution node is displayed in real time;

[0133] and when the output data of the target execution node meets a specified filtering condition, the output data of the target execution node is displayed.

[0134] Optionally, the interaction module 1301 receives the display configuration information of the display node set by the user, specifically including: providing a setting interface of the display configuration information to the user through the GUI; receiving the display configuration information selected by the user in the setting interface.

[0135] In summary, in the program debugging apparatus provided in the embodiments of the present application, the user can add a display node at the output end of any target execution node of the execution graph during the process of debugging the program based on the execution graph, and obtain the output data of the target execution node in the debugging process through the display node, thereby enriching the function of the program development platform for visualizing the debugging of the program based on the execution graph of the program.

[0136] Those skilled in the art can clearly understand that, for the convenience and brevity of description, the specific working process of the apparatus and the modules described above can refer to the corresponding content in the foregoing method embodiments, which will not be described herein.

[0137] Figure 14 is a structural schematic diagram of a computer device provided in the embodiments of the present application. The computer device can be the terminal 10 or the server 11 described above. Figure 2 The computer device can be the terminal 10 or the server 11 described above. Figure 14As shown, the computer device 140 includes a memory 1401, a processor 1402, a communication interface 1403, and a bus 1404. The memory 1401, the processor 1402, and the communication interface 1403 are communicatively connected to each other through the bus 1404. The computer device 140 can include multiple processors 1402 to implement the functions of the different functional modules described above through different processors.

[0138] The memory 1401 can be a read only memory (ROM), a static storage device, a dynamic storage device, or a random access memory (RAM). The memory 1401 can store executable code sequences, and when the executable code sequences stored in the memory 1401 are executed by the processor 1402, the processor 1402 and the communication interface 1403 are configured to perform the program debugging method provided by the embodiments of the present application. The memory 1401 can also include software modules and data required by other running processes such as an operating system. The operating system can be LINUX TM , UNIX TM , WINDOWS TM , etc.

[0139] The processor 1402 can be a general-purpose central processing unit (CPU), a microprocessor, an application specific integrated circuit (ASIC), a graphics processing unit (GPU), or one or more integrated circuits.

[0140] The processor 1402 can also be an integrated circuit chip having a processing capability for signals. In the implementation process, part or all of the functions of the program debugging method of the present application can be completed by the integrated logic circuit of hardware or the instructions in the form of software in the processor 1402. The processor 1402 described above can also be a general processor, a digital signal processor (DSP), an application specific integrated circuit (ASIC), a field programmable gate array (FPGA) or other programmable logic device, a discrete gate or transistor logic device, a discrete hardware component. The disclosed methods, steps and logic block diagrams in the embodiments of the present application can be implemented or executed. The general processor can be a microprocessor or the processor can also be any conventional processor. The steps of the method disclosed in combination with the embodiments of the present application can be directly embodied as a hardware code processor for execution, or a combination of hardware and software modules in the code processor for execution. The software module can be located in a random memory, a flash memory, a read-only memory, a programmable read-only memory or an electrically erasable programmable memory, a register or other mature storage medium in the art. The storage medium is located in the memory 1401, and the processor 1402 reads the information in the memory 1401, and combines the hardware to complete the program debugging method of the embodiments of the present application.

[0141] The communication interface 1403 uses a transceiver module such as but not limited to a transceiver to realize the communication between the computer device 140 and other devices or communication networks. For example, the communication interface 1403 can be any one or any combination of the following devices: network interface (such as Ethernet interface), wireless network card and other devices with network access function.

[0142] The bus 1404 can include a path for transmitting information between various components (for example, the memory 1401, the processor 1402, the communication interface 1403) of the computer device 140.

[0143] It should be noted that when the computer device is a terminal, the computer device further includes a display screen for displaying the graphical user interface of the program development platform.

[0144] Each computer device 140 is connected through a communication network. Each computer device 140 is used to realize part of the functions of the program debugging method provided by the embodiments of the present application. Any computer device 140 can be a computer device (for example: server) in a cloud data center, or a computer device in an edge data center.

[0145] The description of the flow corresponding to each of the above figures has its own emphasis. The part not described in detail in a certain flow can be referred to the related description of other flows.

[0146] In the above embodiments, all or part of the steps can be implemented by software, hardware, firmware or any combination thereof. When implemented by software, all or part of the steps can be implemented in the form of a computer program product. The computer program product providing a program development platform includes one or more computer instructions, which, when loaded and executed on a computer device, implement all or part of the program debugging method provided by the embodiments.

[0147] The computer device can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable devices. The computer instructions can be stored in a computer readable storage medium or transmitted from one computer readable storage medium to another computer readable storage medium, for example, the computer instructions can be transmitted from one website, computer, server or data center to another website, computer, server or data center through wired (such as coaxial cable, optical fiber, digital subscriber line) or wireless (such as infrared, wireless, microwave, etc.) mode. The computer readable storage medium stores computer program instructions providing a program development platform.

[0148] The embodiments of the present application also provide a storage medium, which is a non-volatile computer readable storage medium. When the instructions in the storage medium are executed by a processor, the program debugging method provided by the embodiments of the present application is implemented.

[0149] The embodiments of the present application also provide a computer program product containing instructions, which, when the computer program product is run on a computer, causes the computer to execute the program debugging method provided by the embodiments of the present application.

[0150] Those skilled in the art can understand that all or part of the steps of the above-mentioned embodiments can be completed by hardware, or by program instructing relevant hardware to complete, and the program can be stored in a computer readable storage medium. The storage medium mentioned above can be a read-only memory, a magnetic disk or an optical disk.

[0151] In the embodiments of the present application, the terms "first", "second" and "third" are only used for descriptive purposes, and cannot be understood as indicating or implying relative importance. The term "at least one" means one or more, and the term "multiple" means two or more, unless otherwise explicitly limited.

[0152] In the present application, the term "and / or" is only used to describe the association relationship of the associated objects, which means that there can be three relationships, for example, A and / or B can mean that A exists alone, A and B exist together, and B exists alone. In addition, the character " / " in this paper generally represents that the front and rear associated objects are a "or" relationship.

[0153] The above merely provides the optional embodiments of the present application, but does not intend to limit the present application. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application shall be included in the protection scope of the present application.

Claims

1. A program debugging method, characterized in that, The method includes: The program's execution graph is displayed to the user through a graphical user interface (GUI). The execution graph includes one or more execution nodes, each representing an execution step of the program. Receive user-sent instructions to add display nodes; Based on the instruction to add the display node, a display node is added to the output of the target execution node in one or more execution nodes; According to the user's instructions, debugging of the program is initiated, wherein debugging of the program is initiated at a first moment, debugging of the program is paused at a second moment, debugging of the program is initiated at a third moment, and debugging of the program is paused at a fourth moment. The display node is used to provide the user with the output data of the target execution node during the debugging process. The display node displays the output data of the target execution node last received during the debugging process from the first time to the second time between the second time and the third time. During the pause debugging process after the fourth time, the display node displays the output data of the target execution node last received during the debugging process from the third time to the fourth time. The process of initiating debugging of the program is as follows: Based on the first trigger operation received by the graphical user interface, a start debugging control instruction is generated. The start debugging control instruction is transmitted to the execution framework through the graphical user interface, so that the execution framework starts debugging of the program based on the start debugging control instruction, and returns to the graphical user interface that the program's state has been adjusted to the start debugging state. To pause debugging of the program: Based on the second trigger operation received by the graphical user interface, a pause debugging control command is generated and transmitted to the execution framework through the graphical user interface. The execution framework then pauses debugging of the program based on the pause debugging control command and returns to the graphical user interface that the program's status has been adjusted to pause debugging.

2. The method according to claim 1, characterized in that, The provision of output data of the target execution node during the debugging process to the user using the display node specifically includes: Receive the display configuration information set by the user for the display node; Based on the display configuration information, the display node provides the user with the output data of the target execution node during the debugging process.

3. The method according to claim 2, characterized in that, The display configuration information includes: the display data type, and / or, the display strategy.

4. The method according to claim 3, characterized in that, The data types displayed include one or more of the following: images, videos, audio, characters, numbers, and program data objects.

5. The method according to any one of claims 2-4, characterized in that, The step of receiving the display configuration information set by the user for the display node specifically includes: The GUI provides the user with a settings interface that displays configuration information; Receive the display configuration information selected by the user in the settings interface.

6. A program debugging device, characterized in that, The device includes: An interaction module is used to control the display of the program's execution graph to the user through a graphical user interface (GUI). The execution graph includes one or more execution nodes, each representing an execution step of the program. The interaction module is also used to receive a display node addition instruction sent by the user, wherein debugging of the program is started at a first moment, debugging of the program is paused at a second moment, debugging of the program is started at a third moment, and debugging of the program is paused at a fourth moment. The processing module is used to add a display node to the output of the target execution node in one or more execution nodes based on the instruction added by the display node; The processing module is also configured to initiate debugging of the program according to the user's instructions; The interaction module is also used to provide the user with the output data of the target execution node during the debugging process using the display node. The display node displays the output data of the target execution node last received during the debugging process from the first time to the second time between the second time and the third time. During the pause debugging process after the fourth time, the display node displays the output data of the target execution node last received during the debugging process from the third time to the fourth time. The process of initiating debugging of the program is as follows: Based on the first trigger operation received by the graphical user interface, a start debugging control instruction is generated. The start debugging control instruction is transmitted to the execution framework through the graphical user interface, so that the execution framework starts debugging of the program based on the start debugging control instruction, and returns to the graphical user interface that the program's state has been adjusted to the start debugging state. To pause debugging of the program: Based on the second trigger operation received by the graphical user interface, a pause debugging control command is generated and transmitted to the execution framework through the graphical user interface. The execution framework then pauses debugging of the program based on the pause debugging control command and returns to the graphical user interface that the program's status has been adjusted to pause debugging.

7. The apparatus according to claim 6, characterized in that, The interaction module is specifically used for: Receive the display configuration information set by the user for the display node; Based on the display configuration information, the display node provides the user with the output data of the target execution node during the debugging process.

8. The apparatus according to claim 7, characterized in that, The display configuration information includes: the display data type, and / or, the display strategy.

9. The apparatus according to claim 8, characterized in that, The data types displayed include one or more of the following: images, videos, audio, characters, numbers, and program data objects.

10. The apparatus according to any one of claims 7-9, characterized in that, The interaction module receives the display configuration information set by the user for the display node, specifically including: The GUI provides the user with a settings interface that displays configuration information; Receive the display configuration information selected by the user in the settings interface.

11. A computer device, characterized in that, The computer device includes a processor and a memory, wherein the memory stores a computer program; when the processor executes the computer program, the computer device implements the method according to any one of claims 1 to 5.

12. A non-transient computer-readable storage medium, characterized in that, When the instructions in the computer-readable storage medium are executed by a processor, the processor performs the method according to any one of claims 1 to 5.

13. A computer program product containing instructions, characterized in that, When the instructions in the computer program product are run on a computer, the computer performs the method according to any one of claims 1 to 5.

Images