Embedded non-sensitive intelligent debugging method and device and electronic equipment

Abstract

The invention provides an embedded non-sensitive intelligent debugging method and device and electronic equipment, and the method comprises the steps: monitoring a target debugging event generated based on a debugging interface, and obtaining the event information of the target debugging event; through the debugging adapter, based on the event information of the target debugging event, generating a target debugging instruction for the debugging tool; and calling a debugging tool to process the target debugging instruction to obtain a target debugging result, and displaying the target debugging result through the debugging interface. The code debugging efficiency can be improved.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of computer, in particular to an embedded non-inductive intelligent debugging method and device and electronic equipment. BACKGROUND

[0002] In the software development process, debugging code is an indispensable step, through which defects in the code can be found and solved. In embedded development, because of the performance of the target machine, cross-compilation is usually used, that is, the code is developed and compiled on a personal computer or even a server with better performance, and then the compiled binary is copied to the target machine for running. When the program runs incorrectly, debugging is needed to locate the position of the problem.

[0003] Currently, the code is usually debugged by adding print logs to determine the position of the problem. Although this method is easy to implement, the efficiency of debugging the code is very low. Therefore, there is an urgent need for a solution that can improve the efficiency of code debugging. SUMMARY

[0004] Therefore, the embodiments of the present application aim to provide an embedded non-inductive intelligent debugging method and device and electronic equipment to improve the efficiency of code debugging.

[0005] In a first aspect, the embodiments of the present application provide an embedded non-inductive intelligent debugging method, applied to a first device, the first device running a debugging adapter, the debugging adapter embedded with a debugging tool, the method comprising: monitoring a target debugging event occurring based on a debugging interface, obtaining event information of the target debugging event; generating a target debugging instruction for the debugging tool based on the event information of the target debugging event through the debugging adapter; calling the debugging tool to process the target debugging instruction to obtain a target debugging result, and displaying the target debugging result through the debugging interface.

[0006] In one embodiment, generating a target debugging instruction for the debugging tool based on the event information of the target debugging event through the debugging adapter comprises: determining the target debugging instruction for the debugging tool based on a preset correspondence between the event information of the debugging event and the debugging instruction, and based on the event information of the target debugging event.

[0007] In an embodiment, the preset correspondence between the event information of the debugging event and the debugging instruction, and based on the event information of the target debugging event, the target debugging instruction for the debugging tool is determined, including: in response to the target debugging event belonging to a first preset event, based on the first preset correspondence between the event information of the debugging event and the debugging instruction, the basic debugging instruction corresponding to the event information of the target debugging event is determined; the debugging parameter carried in the event information of the target debugging event is obtained, and based on the preset instruction template, the debugging parameter and the basic debugging instruction are combined to obtain the target debugging instruction; in response to the target debugging event belonging to a second preset event, based on the second preset correspondence between the event information of the debugging event and the debugging instruction, the target debugging instruction corresponding to the event information of the target debugging event is determined.

[0008] In an embodiment, the debugging parameter includes any of the following: a condition parameter of a conditional breakpoint; a trigger parameter of a data breakpoint; information of a thread setting a breakpoint; information of a traced process.

[0009] In an embodiment, the second device runs a debugging controller, and the debugging controller is embedded with a proxy service of the debugging tool, and the debugging tool processes the target debugging instruction to obtain a target debugging result, including: the debugging tool sends the target debugging instruction to the proxy service of the debugging tool based on the communication connection between the debugging adapter and the debugging controller, so that the proxy service of the debugging tool controls the target code deployed in the second device to run the target debugging instruction to obtain the target debugging result, and returns the target debugging result.

[0010] In an embodiment, before the debugging tool processes the target debugging instruction, the method further includes: in response to a second device specified event occurring in the debugging interface, obtaining information of the second device, or based on a preset configuration file, obtaining information of the second device; based on the information of the second device, establishing a communication connection between the debugging adapter and the debugging controller running in the second device.

[0011] In an embodiment, based on the information of the second device, the communication connection between the debugging adapter and the debugging controller running in the second device is established, including: based on the information of the second device, environment verification is performed; in response to the result of the environment verification being verification passed, the communication connection between the debugging adapter and the debugging controller running in the second device is established.

[0012] In an embodiment, the environment verification includes at least one of the following: based on the communication connection parameter of the second device, verifying whether the first device and the second device can establish a communication connection; verifying whether the device parameter of the second device can meet a preset parameter condition.

[0013] In an embodiment, the debugging adapter corresponds to the debugging interface, or the debugging adapter corresponds to a workspace of the debugging interface.

[0014] In an embodiment, the target debugging instruction and the target debugging result both have a debugging session identifier, and after the target debugging result is obtained, the method further includes matching the target debugging result to the target debugging instruction having the same debugging session identifier.

[0015] In a second aspect, an embodiment of the present application provides an embedded non-inductive intelligent debugging system, including: a first device and a second device; the first device runs a debugging adapter, the debugging adapter is embedded with a debugging tool, and the first device is configured to execute the method of the first aspect; the second device runs a debugging controller, the debugging controller is embedded with a proxy service of the debugging tool, and the debugging adapter and the debugging controller are connected through a communication connection, so that the proxy service controls the target code deployed on the second device to run the target debugging instruction for the debugging tool, and obtains a target debugging result.

[0016] In a third aspect, an embodiment of the present application provides an embedded non-inductive intelligent debugging device, which is deployed in a first device, the first device runs a debugging adapter, the debugging adapter is embedded with a debugging tool, and the device includes: a monitoring module configured to monitor a target debugging event occurring based on a debugging interface, and obtain event information of the target debugging event; a control module configured to control the debugging adapter, generate a target debugging instruction for the debugging tool based on the event information of the target debugging event; call the debugging tool to process the target debugging instruction, so as to obtain a target debugging result, and display the target debugging result through the debugging interface.

[0017] In a fourth aspect, an embodiment of the present application provides a computer readable storage medium, which stores a computer program, and the computer program is executed to implement the steps of the method of the first aspect.

[0018] In a fifth aspect, an embodiment of the present application provides an electronic device, including: one or more processors; and a memory associated with the one or more processors, the memory being configured to store program instructions, the program instructions being executed by the one or more processors to implement the steps of the method of the first aspect.

[0019] In a sixth aspect, an embodiment of the present application provides a computer program product, including a computer program, the computer program being executed to implement the steps of the method of the first aspect.

[0020] This application provides an embedded, non-invasive intelligent debugging method, device, and electronic device. A debugging tool is embedded in a debugging adapter. Upon detecting a target debugging event on the debugging interface, the debugging adapter generates a target debugging instruction for the debugging tool. This allows the debugging tool to process the target debugging instruction and generate the target debugging result, which is then displayed on the debugging interface. Users no longer need to learn various debugging instructions; code debugging can be completed through target debugging events. This reduces the user's learning cost and improves the efficiency of code debugging. BRIEF DESCRIPTION OF THE DRAWINGS

[0021] Figure 1 This is a schematic block diagram of the structure of an embedded non-sensing intelligent debugging system provided by one embodiment of the present application.

[0022] Figure 2 This is a flow chart of an embedded non-sensing intelligent debugging method provided by an embodiment of the present application.

[0023] Figure 3 This is a schematic diagram of the correspondence relationship between the debugging interface, the debugging adapter and the debugging controller provided in an embodiment of the present application.

[0024] Figure 4 This is a schematic diagram of a verification process for establishing a communication connection between a debug adapter and a debug controller provided by an embodiment of the present application.

[0025] Figure 5 This is a schematic block diagram of the structure of an embedded non-sensing intelligent debugging device provided in one embodiment of the present application.

[0026] Figure 6 This is a schematic block diagram of the structure of an electronic device provided in one embodiment of the present application. DETAILED DESCRIPTION

[0027] The following will be combined with the drawings in the embodiments of this application to clearly and completely describe the technical solutions in the embodiments of this application. Obviously, the embodiments described are only part of the embodiments of this application, not all of the embodiments. Based on the embodiments in this application, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of this application.

[0028] The terms used in the embodiments of the present application are for the purpose of describing specific embodiments only and are not intended to limit the present application. The singular forms "a", "an", "the" and "the" used in the embodiments of the present application and the appended claims are also intended to include plural forms unless the context clearly indicates otherwise.

[0029] It should be understood that the term "and / or" as used herein merely describes an associated relationship between associated objects, and can represent three relationships, for example, A and / or B can represent three cases of A alone, A and B together, and B alone. In addition, the character " / " herein generally represents an "or" relationship between the associated objects before and after it.

[0030] Depending on the context, the word "if" as used herein can be interpreted to mean "when" or "upon" or "in response to determining" or "in response to detecting." Similarly, depending on the context, the phrase "if it is determined" or "if (a stated condition or event) is detected" can be interpreted to mean "when it is determined" or "in response to determining" or "when (a stated condition or event) is detected" or "in response to detecting (a stated condition or event)."

[0031] Currently, debugging code is usually done in the following ways:

[0032] (1) Determine the location of the problem by adding print logs, which is the simplest and easiest way to implement. However, the inventors found in their research that this method, although simple and easy to implement, requires modification of the code, cross-compilation, copying and running, and viewing print logs every time a print log is added, which results in a very low efficiency in actual operation, as this process needs to be repeated frequently to complete code debugging.

[0033] (2) In embedded development, the most common operating system running on the target machine is Linux, and the most powerful debugging tool on Linux is the GNU Debugger (GNU Debugger, abbreviated as gdb). However, the inventors found in their research that directly using gdb to debug code also has some problems: first, a gdb for the target machine architecture needs to be specially compiled; second, gdb debugging instructions need to be specially learned; third, gdb generally requires the source code to be on the same device, but in embedded development, the source code is usually not on the target machine, so it cannot be debugged in real time in combination with the source code.

[0034] (3) using gdb / gdbserver to debug code, in which way, first, compile gdbserver of target machine architecture, run gdbserver on the target machine, run gdb on the device where the source code is located, then gdb and gdbserver communicate through Remote Serial Protocol (RSP), input gdb instruction in gdb to carry out source code level debugging. The inventor found in the research that this way is more practical, but also more cumbersome, each time debugging needs to execute a series of instructions before debugging, the efficiency is low; and users also need to learn more gdb instructions, the user learning cost is high.

[0035] Therefore, an embodiment of the present application provides an embedded non-inductive intelligent debugging method, applied to a first device, the first device running a debugging adapter, the debugging adapter embedded with a debugging tool. The method specifically comprises: monitoring a target debugging event occurring based on a debugging interface, obtaining event information of the target debugging event; generating a target debugging instruction for the debugging tool based on the event information of the target debugging event through the debugging adapter; calling the debugging tool to process the target debugging instruction to obtain a target debugging result, and displaying the target debugging result on the debugging interface. The debugging tool can support multiple debugging functions, when the target debugging event occurring on the debugging interface is monitored, the target debugging instruction for the debugging tool is generated based on the event information of the target debugging event through the debugging adapter, the debugging tool executes the corresponding debugging function according to the target debugging instruction, so as to obtain the target debugging result, and the target debugging result is displayed on the debugging interface. For the user, the target debugging instruction can be automatically generated by triggering the target debugging event on the debugging interface, and the automatic execution of the code debugging operation is controlled based on the target debugging instruction, the user is not aware during the debugging process, and the target debugging result directly observed on the debugging interface can be directly observed. In the present scheme, the user does not need to directly write the debugging instruction, the learning cost of the user for the debugging instruction is reduced, and the code debugging efficiency is improved.

[0036] Next, the embedded non-inductive intelligent debugging system of the present application is introduced.

[0037] Figure 1 is a structural schematic block diagram of the embedded non-inductive intelligent debugging system provided by an embodiment of the present application. As shown in Figure 1As shown, the embedded non-inductive intelligent debugging system 100 provided by the present application can include a first device 110 and a second device 120, wherein the first device 110 runs a debugging adapter 111, the debugging adapter 111 is embedded with a debugging tool 112, the second device 120 runs a debugging controller 121, and the debugging controller 121 is embedded with an agent service 122 of the debugging tool 112. The first device 110 further includes a debugging interface 113.

[0038] The debugging interface 113 and the debugging adapter 111 are in communication connection, the debugging adapter 111 and the debugging controller 121 are in communication connection, and the debugging tool 112 and the agent service 122 are in communication connection. The debugging interface 113 monitors a target debugging event occurring thereon, and obtains event information of the target debugging event; the debugging adapter 111 generates a target debugging instruction for the debugging tool 112 based on the event information of the target debugging event; the debugging tool 112 invokes the agent service 122 to control the target code deployed in the second device 120 to run the target debugging instruction, and obtains a target debugging result. The debugging adapter 111 returns the target debugging result to the debugging interface 113 for display. The communication connection mode can adopt a socket mode, which reduces the code amount and makes the operation of the user more convenient. The debugging tool 112 and the agent service 122 can be in communication connection through RSP.

[0039] The debugging interface 113 and the debugging adapter 111, and the debugging adapter 111 and the debugging controller 121 can formulate a message interface through a Protobuf protocol, and the debugging adapter 111 and the debugging controller 121 can also formulate a message interface through the Protobuf protocol. Alternatively, a debugging access protocol (DAP) interface is adopted as a message interface in the present application, and functions such as compiling code, issuing a file, starting a debugging session, and state monitoring are added to the DAP, and the message interface is redefined through the Protobuf protocol, so that the debugging interface 113 and the debugging adapter 111 are decoupled, to meet the purpose of flexibly selecting the debugging interface 113. The debugging interface 113 can be a self-developed debugging interface, or can be a debugging interface of an existing integrated development environment (IDE), and the present application does not limit the debugging interface 113. As long as the message format sent by the debugging interface 113 matches the format defined by the protobuf interface, the debugging interface 113 can be in communication connection with the debugging adapter 111.

[0040] In an optional embodiment, the first device 110 can be a host computer, and the second device 120 can be a target machine. It should be understood that, Figure 1The number of the first device 110 and the second device 120 in the system is only illustrative. According to the implementation needs, there can be any number of the first device 110 and the second device 120.

[0041] Figure 2 is a flowchart of an embedded non-inductive intelligent debugging method provided by an embodiment of the present application. The method can be executed by the first device in the system shown in Figure 1 As shown in Figure 2 The method can include the following steps:

[0042] Step 201: Monitor a target debugging event based on a debugging interface, and obtain event information of the target debugging event.

[0043] Step 203: Generate a target debugging instruction for a debugging tool based on the event information of the target debugging event through a debugging adapter.

[0044] Step 205: Call the debugging tool to process the target debugging instruction to obtain a target debugging result, and display the target debugging result through the debugging interface.

[0045] As can be seen, when the target debugging event based on the debugging interface is monitored, the target debugging instruction for the debugging tool embedded in the debugging adapter is generated, so that the debugging tool processes the target debugging instruction to generate the target debugging result, and the target debugging result is displayed on the debugging interface. For the user, there is no need to specially learn various debugging instructions, and the code debugging can be completed through the target debugging event, thus reducing the learning cost of the user and improving the efficiency of the code debugging.

[0046] The steps in the above flow and the effects that can be further produced will be described in detail below in combination with embodiments. It should be noted that the "first", "second", and the like involved in the present disclosure do not have the limitation of size, order, and quantity, and are only used to distinguish in name. For example, "the first device" and "the second device" are used to distinguish two devices in name. For example, "the first preset event" and "the second preset event" are used to distinguish different preset events in name. And so on.

[0047] First, the step 201 "monitoring a target debugging event based on a debugging interface, and obtaining event information of the target debugging event" in the above flow will be described in detail in combination with an embodiment.

[0048] The debugging interface (Graphical User Interface, GUI for short) in the application can provide a visual interface for interaction with the user. The user can perform code debugging operations through the debugging interface, and the debugging interface also displays the debugging results after the user performs the code debugging operations, such as highlighting, refreshing the interface, and the like.

[0049] The debugging event can be an event corresponding to the user's operation of debugging the code, can be a debugging event generated by the user through manual triggering of a control on the debugging interface, can be a debugging event generated by the user through voice control of the debugging interface, or can be in other forms, which are not limited in the application.

[0050] Next, step 202 “generating, by the debugging adapter, a target debugging instruction for the debugging tool based on the event information of the target debugging event” in the above process will be described in detail in combination with embodiments.

[0051] In an embodiment, generating, by the debugging adapter, a target debugging instruction for the debugging tool based on the event information of the target debugging event comprises: determining the target debugging instruction for the debugging tool based on a preset correspondence between the event information of the debugging event and the debugging instruction, and based on the event information of the target debugging event.

[0052] The debugging adapter can play a role of receiving messages from the debugging interface, performing related debugging tasks in combination with the debugging controller according to the received messages, and finally returning the obtained debugging results to the debugging interface for display. The debugging tool implements complex string parsing logic to process various debugging instructions.

[0053] Optionally, the debugging adapter can be referred to as a Debug Adapter. The debugging tool can be GDB.

[0054] Different debugging events can correspond to different debugging instructions. For example, the debugging event is an event of setting a breakpoint, the event information can include a breakpoint debugging type and a location of the breakpoint, and the debugging instruction can be used to instruct highlighting of the breakpoint when the program runs to the breakpoint. Therefore, the corresponding debugging instructions can be set in advance for different debugging events, and the preset correspondence between the event information of the debugging event and the debugging instruction is encapsulated as a message interface. After the first device monitors the target debugging event occurring on the debugging interface, the event information of the target debugging event is obtained, and the event information of the target debugging event is sent to the debugging adapter through the message interface between the debugging interface and the debugging adapter. The debugging adapter determines the target debugging instruction corresponding to the event information of the target debugging event according to the preset correspondence between the event information of the debugging event and the debugging instruction, so as to realize conversion of the target debugging event into the target debugging instruction.

[0055] For the user, it is only necessary to generate a debugging event through the debugging interface to automatically match the corresponding debugging instruction, so that the execution of the debugging instruction can realize the debugging of the code, without the need for special learning of various debugging instructions, thereby reducing the learning cost of the user, and further improving the code debugging efficiency.

[0056] In an embodiment, the debugging adapter comprises a parsing module, and the parsing module is embedded with a debugging tool. The debugging adapter generates a target debugging instruction for the debugging tool based on the event information of a target debugging event through the parsing module. That is, when the parsing module receives the event information of the target debugging event, the target debugging event is converted into the target debugging instruction according to the preset corresponding relationship between the event information of the debugging event and the debugging instruction, and the target debugging instruction is transmitted to the debugging tool.

[0057] In an embodiment, the debugging adapter comprises a communication module, and the debugging adapter realizes communication with the debugging interface and communication with the debugging controller through the communication module. Optionally, the communication module can also perform network packet processing on the received data, and can realize communication diagnosis, and can also realize protobuf serialization / deserialization and the like.

[0058] In an embodiment, based on the preset corresponding relationship between the event information of the debugging event and the debugging instruction, and based on the event information of the target debugging event, the target debugging instruction for the debugging tool is determined, comprising: in response to the target debugging event belonging to a first preset event, determining a basic debugging instruction corresponding to the event information of the target debugging event based on a first preset corresponding relationship between the event information of the debugging event and the debugging instruction; obtaining a debugging parameter carried in the event information of the target debugging event, and combining the debugging parameter and the basic debugging instruction based on a preset instruction template to obtain the target debugging instruction; in response to the target debugging event belonging to a second preset event, determining the target debugging instruction corresponding to the event information of the target debugging event based on a second preset corresponding relationship between the event information of the debugging event and the debugging instruction.

[0059] In this embodiment, by encapsulating various debugging functions as the message interface of the debugging adapter, various debugging instructions can be integrated in the debugging tool, thereby reducing the learning cost of the user and further improving the efficiency of code debugging.

[0060] The first preset event can include an event of setting a conditional breakpoint, an event of setting a data breakpoint, an event of multi-thread debugging, an event of multi-process debugging, and the like; the first preset corresponding relationship can be a corresponding relationship between the event information of the first preset event and the debugging instruction; and the basic debugging instruction can be an instruction for instructing to trigger a set breakpoint.

[0061] If the target debugging event belongs to the first preset event, then after determining the basic debugging instruction, the debugging parameters carried in the event information of the target debugging event can be obtained. For example, if the target debugging event is an event for setting a conditional breakpoint, the debugging parameters can be the conditional parameters of the conditional breakpoint; if the target debugging event is an event for setting a data breakpoint, the debugging parameters can be the trigger parameters of the data breakpoint; if the target debugging event is an event for multi-thread debugging, the debugging parameters can be information about the thread setting the breakpoint; if the target debugging event is an event for multi-process debugging, the debugging parameters can be information about the tracked process. That is, the debugging parameters include any of the following: conditional parameters of a conditional breakpoint; trigger parameters of a data breakpoint; information about the thread setting the breakpoint; and information about the tracked process. By obtaining the debugging parameters, the debugging parameters can be combined with the basic debugging instruction based on the preset instruction template to obtain the target debugging instruction.

[0062] Among them, conditional breakpoints mean that the breakpoint will only take effect when specific conditions are met, and the program will be suspended, so as to efficiently locate the problem. The conditional parameters of the conditional breakpoint may include: number of hits (the breakpoint takes effect after hitting n times), expression (the breakpoint takes effect when the expression is true), etc.; data breakpoints refer to monitoring the variables specified in the program, thereby triggering the breakpoint, interrupting the program running, and quickly locating the code position where the variable value is located. The trigger parameters of the data breakpoint may include the access status and / or variable value of the variable in the program. The trigger type may include access trigger (monitoring a certain variable, triggering the breakpoint when the variable is accessed) and modification trigger (monitoring a certain variable, triggering the breakpoint when the variable is modified); multi-threaded debugging refers to locating and resolving problems in multi-threaded programs. To solve the problem, the information of the thread for setting the breakpoint can include the identification information, running information, execution path, etc. of the specific thread. Breakpoints (including conditional breakpoints and data breakpoints) can be set on specific threads. Only the specified thread can be debugged (when the breakpoint is hit, only the specified thread is paused, and other threads continue to run unaffected). It can also be set to pause all threads when the breakpoint of a certain thread is hit; multi-process debugging refers to locating and solving problems in multi-process programs. The information of the tracked process can include the identification information, execution information, resource usage, etc. of the process. When a program creates (forks) a child process, you can choose to track the parent process, the child process, or both the parent and child processes at the same time.

[0063] The second preset event can include an event of setting a breakpoint, an event of single-step debugging, an event of reverse assembly debugging, an event of viewing a stack, an event of viewing memory, an event of viewing a register, an event of source code path mapping, an event of loading a DWARF (Debugging With Attributed Record Formats, a standard format for storing debugging information) file, and the like; and the second preset correspondence can be a correspondence between event information of the second preset event and a debugging instruction. Through the second preset correspondence, a target debugging instruction corresponding to event information of a target debugging event can be directly determined.

[0064] Next, the step 203 of "calling a debugging tool to process the target debugging instruction to obtain a target debugging result" in the above flow is described in detail in combination with an embodiment.

[0065] In an embodiment, the second device runs a debugging controller, the debugging controller is embedded with a proxy service of the debugging tool, and the calling of the debugging tool to process the target debugging instruction to obtain the target debugging result includes: the debugging tool sends the target debugging instruction to the proxy service of the debugging tool based on the communication connection between the debugging adapter and the debugging controller, so that the proxy service of the debugging tool controls the target code deployed on the second device to run the target debugging instruction to obtain the target debugging result, and returns the target debugging result. This embodiment can remotely debug the code on the second device on the first device through the proxy service on the second device, reduce the load of the second device, and greatly improve the debugging efficiency of the code.

[0066] The proxy service of the debugging tool is a service program used in cooperation with the debugging tool, is responsible for running the program to be debugged, and establishes a communication connection with the debugging tool. After receiving the target debugging instruction of the debugging tool, the target debugging instruction is executed and the target debugging result is returned to the debugging tool, so that the program on the second device is debugged on the first device.

[0067] Optionally, the debugging controller can be referred to as DebugController, and the proxy service of the debugging tool can be gdbserver.

[0068] The debugging controller includes a communication module and a debugging session management module. The communication module of the debugging controller and the communication module of the debugging adapter realize the communication connection between the debugging adapter and the debugging controller. In addition, the communication module of the debugging controller can also perform network packet processing on the received data, can realize communication diagnosis, and can realize functions such as protobuf serialization / deserialization.

[0069] The debugging session management module in the debugging controller is configured to start the agent service of the debugging tool after the communication connection is established between the debugging adapter and the debugging controller, so as to wait for the connection between the debugging tool and the agent service. Optionally, the debugging session management module can also detect the state of the current code debugging process in real time, and if it is detected that the code debugging process ends, the system resources related to the code debugging process in the second device can be recycled.

[0070] The target code is deployed in the second device, and the target code is configured to run the debugging instruction to obtain a debugging result of debugging the to-be-debugged code based on the debugging instruction. After the communication connection is established between the debugging adapter and the debugging controller, the debugging tool in the debugging adapter transmits the target debugging instruction to the agent service in the debugging controller, the agent service controls the target code to run the target debugging instruction to obtain a target debugging result, and returns the target debugging result to the debugging tool. The debugging adapter returns the target debugging result to the debugging interface through the communication module for display. Optionally, the target code can be a DebugController program.

[0071] In some embodiments, since the data formats of the data displayed by different debugging interfaces can be different, in order to ensure that the debugging interface can display the target debugging result, after the agent service returns the target debugging result to the debugging tool, the parsing module included in the debugging adapter can parse the target debugging result output by the debugging tool according to the data format that can be displayed by the debugging interface, and then returns the parsed data to the debugging interface after packaging, so that the debugging interface can display the target debugging result.

[0072] The debugging adapter includes a parsing module, and the parsing module is embedded with the debugging tool. The debugging adapter generates the target debugging instruction for the debugging tool based on the event information of the target debugging event through the parsing module. That is, after the parsing module receives the event information of the target debugging event, the target debugging event is converted into the target debugging instruction according to the preset corresponding relationship between the event information of the debugging event and the debugging instruction, and the target debugging instruction is transmitted to the debugging tool.

[0073] In an embodiment, before the debugging tool processes the target debugging instruction, the method further includes: in response to a second device specified event occurring in the debugging interface, obtaining information of the second device, or obtaining information of the second device based on a preset configuration file; and based on the information of the second device, establishing a communication connection between the debugging adapter and the debugging controller running in the second device.

[0074] The second device list can be displayed on the debugging interface. Through the identification information, Internet Protocol (IP) address, device parameters, load condition, and other information of all the current second devices displayed on the second device list, the user can select the second device according to the user's own needs. Correspondingly, the second device specifying event can be an event of the user selecting the second device. The user can generate the second device specifying event by manually performing a selection operation on the debugging interface or can generate the second device specifying event by selecting the second device through voice. Through the second device specifying event, the information of the second device is obtained, and based on the information of the second device, the communication connection between the first device and the second device is established, thereby establishing the communication connection between the debugging adapter and the debugging controller. The information of the second device is presented in a visual manner, and the user can quickly select the second device according to the user's own needs, thereby reducing the operation difficulty of the user.

[0075] The user can also set a configuration file on the device where the debugging interface is located in advance. The configuration file indicates the second device that establishes the communication connection with the first device. Therefore, the information of the second device can be obtained according to the configuration file, and based on the information of the second device, the communication connection between the first device and the second device is established, thereby establishing the communication connection between the debugging adapter and the debugging controller. In this way, the automation degree of obtaining the information of the second device can be improved, thereby improving the efficiency of obtaining the information of the second device.

[0076] In an embodiment, the number of the first devices and the number of the second devices can both be multiple. In this case, when the communication connection between the first device and the second device, or the communication connection between the debugging adapter and the debugging controller (one debugging adapter runs in one first device, and one debugging controller runs in one second device) is established, the correspondence relationship between the debugging adapter and the debugging controller needs to be determined, that is, the debugging adapter and the debugging controller can be one-to-one, one-to-many, or many-to-many. When the communication connection between the debugging interface and the debugging adapter is established, the correspondence relationship between the debugging interface and the debugging adapter needs to be determined, that is, the debugging adapter corresponds to the debugging interface, or the debugging adapter corresponds to the working area of the debugging interface.

[0077] The debugging adapter can include a working area management module to manage the connection relationship between the debugging interface, the debugging adapter, and the debugging controller. For details, refer to Figure 3 , Figure 3 FIG. 1 is a schematic diagram of the correspondence relationship between the debugging interface, the debugging adapter, and the debugging controller in a many-to-many connection provided by an embodiment of the present application. One debugging adapter (shown as debugging adapter A or debugging adapter B in FIG. 1) can correspond to multiple debugging interfaces (shown as debugging interface A, debugging interface B, and debugging interface C in FIG. 1) and multiple debugging controllers (shown as debugging controller A, debugging controller B, and debugging controller C in FIG. 1). Figure 3 Figure 3 ​Debug interface A, debug interface B, debug interface C) provide services, a debug adapter can also be connected to multiple debug controllers (in Figure 3 In the figure, debug controller A, debug controller B, and debug controller C are shown as communication connections. In such a many-to-many connection scenario, the debug adapter can manage each debug interface connected to the debug adapter through the workspace management module, as well as manage different debug controllers under the same debug interface. Therefore, more flexible debugging scenarios can be supported, and appropriate debugging architectures can be built according to different debugging scenarios. For example, one first device can be used to debug code on multiple second devices, and multiple first devices can be used to debug code on one second device, etc., thereby further improving code debugging efficiency. Optionally, the corresponding debugging scenario can be determined based on the load of the second device. For example, when the resources of the second device are sufficient, a debugging scenario in which one first device debugs code on one second device is adopted. When the resources of the second device are insufficient, a debugging scenario in which multiple first devices debug different codes on one second device is adopted. When the code and the compilation environment are located on the server, a debugging scenario in which multiple debugging interfaces correspond to one debug adapter can be adopted.

[0078] In an optional embodiment, the debugging interface and the debugging adapter may be in the same first device. In this case, the debugging interface or the working area of ​​the debugging interface in the first device corresponds to the debugging adapter. The debugging interface and the debugging adapter may or may not be in the same first device. For example, the debugging adapter runs on a server. In this case, the first device is the server, and the debugging interface is in the local device. In this case, multiple debugging interfaces or multiple debugging interface working areas can correspond to multiple debugging adapters.

[0079] In one embodiment, establishing a communication connection between a debug adapter and a debug controller running in the second device based on information about the second device includes: performing an environmental check based on the information about the second device; and establishing a communication connection between the debug adapter and the debug controller running in the second device in response to a result of the environmental check being a passed check.

[0080] When establishing the communication connection between the debugging adapter and the debugging controller, there can be a problem of connection failure due to the environment check of the second device failing. Therefore, the environment check of the second device is needed, so as to improve the success rate of the communication connection between the debugging adapter and the debugging controller, and reduce the problem of code debugging failure due to connection failure. The environment check at least includes the following at least one: checking whether the first device and the second device can establish the communication connection based on the communication connection parameter of the second device; and checking whether the device parameter of the second device can meet the preset parameter condition. Optionally, the communication connection parameter of the second device can include the IP address of the second device, the username and password required for the communication connection with the first device, etc.; the device parameter of the second device can include the hardware architecture and the operating system supported by the second device, etc.; and the preset parameter condition can be aarch64 hardware architecture and linux operating system.

[0081] In some embodiments, the debugging adapter further includes an environment check module, which is described with reference to Figure 4 , Figure 4 FIG. 1 is a schematic diagram of a verification process for establishing a communication connection between a debugging adapter and a debugging controller according to an embodiment of the present application. The process can include the following steps:

[0082] Step 401: Determine whether the first device and the second device can be connected through the communication connection parameter of the second device.

[0083] If yes, go to step 402; if no, go to step 408.

[0084] Step 402: Determine whether the device parameter of the second device is the preset parameter condition.

[0085] If yes, go to step 403; if no, go to step 408.

[0086] Step 403: Detect whether the target code in the second device is started.

[0087] If yes, go to step 407; if no, go to step 404.

[0088] Step 404: Detect whether the target code exists in the second device.

[0089] If yes, go to step 406; if no, go to step 405.

[0090] Step 405: Obtain the target code and transmit the target code to the second device.

[0091] Step 406: Start the service of the target code.

[0092] Step 407: Establish a communication connection between the debugging adapter and the debugging controller, so that the debugging tool and the proxy service are connected in communication.

[0093] Step 408: Generate an error message.

[0094] In an optional embodiment, the debugging adapter can further include a compiling module and a file transmission module. The user can select a debugging interface according to his own needs, and write code or modify source code on the device where the debugging interface is located. The compiling module in the debugging adapter performs a code compiling task, compiles the written code or the modified code, and the file transmission module in the debugging adapter transmits the compiled code to the second device, waiting for subsequent code debugging. The file transmission module can transmit a single file or multiple files at the same time.

[0095] For the user, after writing or modifying the code, the debugging interface generates a target debugging event, the communication module in the debugging adapter transmits the written or modified code to the compiling module, and transmits the target debugging event to the parsing module; the work area management module prepares the communication connection between the debugging interface, the debugging adapter and the debugging controller; the environment verification module verifies the environment of the communication connection between the debugging adapter and the debugging controller, and after the verification is passed, the work area management module establishes the communication connection between the debugging interface, the debugging adapter and the debugging controller; then the editing module automatically compiles the written or modified code, and the file transmission module automatically transmits the compiled code to the second device; the parsing module converts the target debugging event into a target debugging instruction according to the preset correspondence between the event information of the debugging event and the debugging instruction, and transmits the target debugging instruction to the debugging tool embedded in the parsing module. The debugging tool transmits the target debugging instruction to the proxy service in the debugging controller, so that the proxy service controls the target code to run the target debugging instruction to obtain a target debugging result, and returns the target debugging result to the debugging tool; the parsing module returns the target debugging result to the debugging interface for display. That is, after the user writes or modifies the code, only one key operation is needed to complete automatic editing, issuing and debugging, reducing the user's manual operation steps, reducing the user's learning cost of debugging instructions, and greatly improving the code debugging efficiency.

[0096] Optionally, the code debugging process can be started after the file transmission module transmits the compiled code to the second device, or the code debugging process can be started directly from the second device, or the code debugging process can be started through the attach method.

[0097] In an embodiment, the target debugging instruction and the target debugging result both have a debugging session identifier, and after obtaining the target debugging result, the method further comprises: matching the target debugging result to the target debugging instruction having the same debugging session identifier.

[0098] Different target debugging events correspond to different target debugging instructions. For example, if the target debugging event is setting a breakpoint, the target debugging instruction is used to instruct the program to stop at the breakpoint; if the target debugging event is adding a statement outputting key information in the program, the target debugging instruction is used to instruct recording of key information (such as the value of a variable, the calling condition of a function, the execution flow of the program, etc.) in the running process of the program. Therefore, a debugging session identifier needs to be set for each target debugging event, and in order to ensure matching of the target debugging event and the target debugging result and reduce the problem of incorrect debugging results displayed by the debugging interface, the same debugging session identifier as the target debugging event needs to be set for the target debugging instruction and the target debugging result, so that after obtaining the target debugging result, the target debugging result is matched to the target debugging instruction having the same debugging session identifier, and the debugging interface displays the correct target debugging result.

[0099] Optionally, in the code debugging process, after the user performs a target debugging operation, the user may not immediately respond to the target debugging operation to obtain a target debugging result, but needs to trigger a target debugging event to obtain the target debugging result. For example, after the user sets a breakpoint, the breakpoint is not immediately highlighted at the breakpoint, but is highlighted only when the program executes to the breakpoint. Therefore, multiple message interfaces can be set for the debugging adapter, each message interface is added with the same debugging session identifier as the target debugging event, each message interface is one-to-one corresponding to each target debugging operation, so that when the debugging interface calls the message interface, the message interface having the same debugging session identifier as the target debugging event is called, and the target debugging operation of the user and the target debugging result are matched.

[0100] Therefore, in the debugging interface, two threads can be set, one thread is used to capture the target debugging operation of the user, generate a target debugging event, and call a message interface of the debugging adapter to transmit the target debugging event carrying the debugging session identifier to the debugging adapter; and the other thread is used to receive the target debugging result returned by the same message interface of the debugging adapter, and match the target debugging result to the target debugging instruction having the same debugging session identifier, that is, match the target debugging result to the target debugging event to display the correct target debugging result.

[0101] The above describes particular embodiments of the present specification. Other embodiments are within the scope of the appended claims. In some cases, the acts or steps recited in the claims can be performed in an order other than that in the embodiments and still achieve desirable results. Additionally, the processes depicted in the figures do not necessarily require the particular order shown or sequential order to achieve the desired results. In certain implementations, multitasking and parallel processing can be advantageous or possible.

[0102] According to an embodiment of another aspect, an embedded non-inductive intelligent debugging device is provided. Figure 5 is a structural schematic block diagram of the embedded non-inductive intelligent debugging device provided by an embodiment of the present application. The device is arranged in Figure 1 the first device in the system as shown. As Figure 5 shown, the device 500 includes a monitoring module 501 and a control module 502. The main functions of each component unit are as follows:

[0103] The monitoring module 501 is configured to monitor a target debugging event occurring based on a debugging interface, and obtain event information of the target debugging event.

[0104] The control module 502 is configured to control a debugging adapter, generate a target debugging instruction for a debugging tool based on the event information of the target debugging event, call the debugging tool to process the target debugging instruction to obtain a target debugging result, and display the target debugging result through the debugging interface.

[0105] Further, the control module 502 can be further configured to determine the target debugging instruction for the debugging tool based on the event information of the target debugging event and a preset correspondence between the event information and the debugging instruction.

[0106] Further, the control module 502 can be further configured to: in response to the target debugging event belonging to a first preset event, determine a basic debugging instruction corresponding to the event information of the target debugging event based on a first preset correspondence between the event information and the debugging instruction; obtain a debugging parameter carried in the event information of the target debugging event, and combine the debugging parameter and the basic debugging instruction based on a preset instruction template to obtain the target debugging instruction; in response to the target debugging event belonging to a second preset event, determine the target debugging instruction corresponding to the event information of the target debugging event based on a second preset correspondence between the event information and the debugging instruction.

[0107] As one of the implementable ways, the debugging parameter includes any of the following: a condition parameter of a conditional breakpoint; a trigger parameter of a data breakpoint; information of a thread setting a breakpoint; information of a traced process.

[0108] Further, the second device runs a debugging controller, the debugging controller is embedded with a proxy service of the debugging tool, the control module 502 can be further configured to: the debugging tool sends the target debugging instruction to the proxy service of the debugging tool based on the communication connection between the debugging adapter and the debugging controller, so that the proxy service of the debugging tool controls the target code deployed in the second device to run the target debugging instruction to obtain the target debugging result, and returns the target debugging result.

[0109] Further, the control module 502 can be further configured to: before calling the debugging tool to process the target debugging instruction, in response to a second device specified event occurring on the debugging interface, obtain information of the second device, or obtain the information of the second device based on a preset configuration file; based on the information of the second device, establish the communication connection between the debugging adapter and the debugging controller running in the second device.

[0110] Further, the control module 502 can be further configured to: based on the information of the second device, perform environment verification; in response to the result of the environment verification being verification passed, establish the communication connection between the debugging adapter and the debugging controller running in the second device.

[0111] As one of the implementable modes, the environment verification includes at least one of the following: based on the communication connection parameter of the second device, verifying whether the first device and the second device can establish the communication connection; verifying whether the device parameter of the second device can meet the preset parameter condition.

[0112] As one of the implementable modes, the debugging adapter corresponds to the debugging interface, or the debugging adapter corresponds to the working area of the debugging interface.

[0113] Further, the target debugging instruction and the target debugging result both have a debugging session identifier, and the control module 502 can be further configured to: after obtaining the target debugging result, match the target debugging result to the target debugging instruction with the same debugging session identifier.

[0114] Each of the embodiments in the specification is described in a progressive manner, and the same or similar parts between the embodiments can be referred to each other. Each of the embodiments focuses on the difference from other embodiments. In particular, for system or device embodiments, since they are basically similar to the method embodiments, they are described more simply, and the relevant parts can be referred to the part of the method embodiments. The system and device embodiments described above are only illustrative, and the units described as separate components can or can not be physically separated, and the components shown as units can or can not be physical units, i.e. they can be located in one place or distributed on multiple network units. Some or all of the modules can be selected to achieve the purpose of the embodiment according to actual needs. Those skilled in the art can understand and implement it without creative labor.

[0115] It should be noted that the user information (including but not limited to user equipment information, user personal information, etc.) and data (including but not limited to data for analysis, stored data, displayed data, etc.) involved in the present application are information and data authorized by the user or authorized by all parties, and the collection, use and processing of related data need to comply with relevant laws, regulations and standards of relevant countries and regions, and provide corresponding operation portal for user to choose authorization or refusal.

[0116] In addition, the embodiment of the present application also provides a computer readable storage medium, which stores a computer program, and the program is executed to realize the steps of the method of any one of the preceding method embodiments.

[0117] And an electronic device, comprising:

[0118] One or more processors; and

[0119] A memory associated with the one or more processors, the memory storing program instructions that, when read and executed by the one or more processors, perform the steps of the method of any one of the preceding method embodiments.

[0120] The present application also provides a computer program product comprising a computer program which, when executed, implements the steps of the method of any one of the preceding method embodiments.

[0121] Wherein, Figure 6is a structural schematic block diagram of an electronic device provided by an embodiment of the present application, and can specifically include a processor 610, a video display adapter 611, a disk drive 612, an input / output interface 613, a network interface 614, and a memory 620. The processor 610, the video display adapter 611, the disk drive 612, the input / output interface 613, the network interface 614, and the memory 620 can be communicatively connected through a communication bus 630. The input / output interface 613 can also be referred to as an I / O interface 613.

[0122] The processor 610 can be implemented in a general-purpose CPU, a microprocessor, an application-specific integrated circuit (ASIC), or one or more integrated circuits, and is configured to execute related programs to implement the technical solutions provided by the present application.

[0123] The memory 620 can be implemented in a read-only memory (ROM), a random access memory (RAM), a static storage device, a dynamic storage device, or the like. The memory 620 can store an operating system 621 for controlling the operation of the electronic device 600, and a basic input / output system (BIOS) 622 for controlling the low-level operation of the electronic device 600. In addition, a web browser 623, a data storage management system 624, and an embedded non-inductive intelligent debugging device 500, and the like can also be stored. The embedded non-inductive intelligent debugging device 500 can be an application program for implementing the foregoing steps in the embodiments of the present application. In summary, when the technical solutions provided by the present application are implemented by software or firmware, the related program codes are stored in the memory 620 and executed by the processor 610.

[0124] The input / output interface 613 is configured to connect an input / output module to realize information input and output. The input / output module can be configured as a component in the device (not shown in the figure) or externally connected to the device to provide corresponding functions. The input device can include a keyboard, a mouse, a touch screen, a microphone, various sensors, and the like, and the output device can include a display, a speaker, a vibrator, an indicator light, and the like.

[0125] The network interface 614 is configured to connect a communication module (not shown in the figure) to realize the communication interaction between the device and other devices. The communication module can realize communication through a wired manner (such as a USB, a network cable, or the like) or a wireless manner (such as a mobile network, WIFI, Bluetooth, or the like).

[0126] Bus 630 includes a path for transferring information between the various components (e.g., processor 610, video display adapter 611, disk drive 612, input / output interface 613, network interface 614, and memory 620).

[0127] It should be noted that although the above device only shows the processor 610, video display adapter 611, disk drive 612, input / output interface 613, network interface 614, memory 620, bus 630, etc., but in the process of implementation, the device can also include other components necessary for normal operation. In addition, those skilled in the art can understand that the above device can also only contain the components necessary to implement the scheme of the present application, and does not have to contain all the components shown in the figure.

[0128] From the above description of the embodiments, those skilled in the art can clearly understand that the present application can be implemented by means of software and the necessary general hardware platform. Based on such understanding, the technical solutions of the present application can be embodied in the form of a computer program product, which can be stored in a storage medium such as ROM / RAM, disk, optical disk, etc., including a number of instructions for making a computer device (which can be a personal computer, server, or network device, etc.) execute the methods described in various embodiments or some parts of the embodiments of the present application.

[0129] The above provides a detailed description of the technical solutions of the present application. The specific examples are applied to the principles and implementation of the present application. The above description of the embodiments is only to help understand the method and its core idea of the present application; at the same time, for those skilled in the art, according to the idea of the present application, the specific implementation and application range will be changed. In conclusion, the content of the specification should not be understood as a limitation of the present application.

Claims

1. An embedded non-sensing intelligent debugging method, characterized in that: Applied to a first device, the first device running a debug adapter, the debug adapter having a built-in debug tool, the method comprising: Monitor target debugging events occurring on the debugging interface and obtain event information of the target debugging events; generating, by the debug adapter, a target debug instruction for the debug tool based on the event information of the target debug event; The debugging tool is called to process the target debugging instruction to obtain a target debugging result, and the target debugging result is displayed through the debugging interface.

2. The method according to claim 1, characterized in that The step of generating, by the debug adapter, a target debug instruction for the debug tool based on the event information of the target debug event includes: Based on a preset correspondence between the event information of the debugging event and the debugging instruction, and based on the event information of the target debugging event, a target debugging instruction for the debugging tool is determined.

3. The method according to claim 2, characterized in that The determining of the target debugging instruction for the debugging tool based on the preset correspondence between the event information of the debugging event and the debugging instruction and based on the event information of the target debugging event includes: In response to the target debugging event belonging to a first preset event, determining a basic debugging instruction corresponding to the event information of the target debugging event based on a first preset correspondence between the event information of the debugging event and the debugging instruction; obtaining a debugging parameter carried in the event information of the target debugging event, and combining the debugging parameter with the basic debugging instruction based on a preset instruction template to obtain a target debugging instruction; In response to the target debugging event belonging to a second preset event, a target debugging instruction corresponding to the event information of the target debugging event is determined based on a second preset correspondence between the event information of the debugging event and the debugging instruction.

4. The method according to claim 3, characterized in that The debugging parameters include any of the following: Conditional parameters for conditional breakpoints; Trigger parameters of data breakpoints; Information about the thread where the breakpoint is set; Information about the traced process.

5. The method according to claim 1, wherein The second device runs a debugging controller, wherein the debugging controller is embedded with an agent service of the debugging tool, and calling the debugging tool to process the target debugging instruction to obtain a target debugging result includes: Based on the communication connection between the debug adapter and the debug controller, the debug tool sends the target debug instruction to the debug tool's proxy service, so that the debug tool's proxy service controls the target code deployed on the second device to run the target debug instruction, obtain the target debug result, and return the target debug result.

6. The method according to claim 5, characterized in that Before calling the debugging tool to process the target debugging instruction, the method further includes: In response to a second device specified event occurring on the debugging interface, obtaining information about the second device, or obtaining information about the second device based on a preset configuration file; Based on the information of the second device, a communication connection is established between the debug adapter and a debug controller running in the second device.

7. The method according to claim 6, characterized in that The establishing a communication connection between the debug adapter and a debug controller running in the second device based on the information of the second device includes: Performing environmental verification based on the information of the second device; In response to a result of the environmental verification being a passed verification, a communication connection is established between the debug adapter and a debug controller running in the second device.

8. The method according to claim 7, characterized in that The environmental verification includes at least one of the following: Verifying, based on the communication connection parameters of the second device, whether a communication connection can be established between the first device and the second device; Verify whether the device parameters of the second device meet preset parameter conditions.

9. The method according to claim 7, characterized in that The debugging adapter corresponds to the debugging interface, or the debugging adapter corresponds to a working area of ​​the debugging interface.

10. The method according to any one of claims 1 to 9, characterized in that The target debugging instruction and the target debugging result both have a debugging session identifier. After obtaining the target debugging result, the method further includes: The target debugging result is matched to a target debugging instruction having the same debugging session identifier.

11. An embedded non-sensing intelligent debugging system, characterized in that: include: a first device and a second device; The first device runs a debug adapter, the debug adapter has a debug tool embedded therein, and the first device is configured to execute the method according to any one of claims 1 to 10; The second device runs a debugging controller, which has an embedded proxy service of the debugging tool. The debugging adapter and the debugging controller are connected via communication so that the proxy service controls the target code deployed on the second device to run target debugging instructions for the debugging tool to obtain target debugging results.

12. An embedded non-sensing intelligent debugging device, characterized in that: Deployed in a first device, the first device running a debug adapter, the debug adapter having a built-in debug tool, the apparatus comprising: A monitoring module is configured to monitor target debugging events occurring based on the debugging interface and obtain event information of the target debugging events; The control module is configured to control the debug adapter, generate a target debug instruction for the debug tool based on the event information of the target debug event, call the debug tool to process the target debug instruction to obtain a target debug result, and display the target debug result through the debug interface.

13. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed, the steps of the method according to any one of claims 1 to 10 are implemented.

14. An electronic device, characterized in that: include: one or more processors; as well as A memory associated with the one or more processors, the memory being configured to store program instructions, wherein the program instructions, when read and executed by the one or more processors, execute the steps of the method according to any one of claims 1 to 10.

15. A computer program product comprising a computer program, characterized in that When the computer program is executed, the steps of the method according to any one of claims 1 to 10 are implemented.

Images