CN112000584B

CN112000584B - Debugging method and debugging system for CPU program based on IDE debugging framework

Info

Publication number: CN112000584B
Application number: CN202011160052.7A
Authority: CN
Inventors: 陈健; 种挺; 刘亮; 张茜歌; 张海峰; 原义栋
Original assignee: State Grid Information and Telecommunication Co Ltd; Beijing Smartchip Microelectronics Technology Co Ltd
Current assignee: State Grid Information and Telecommunication Co Ltd; Beijing Smartchip Microelectronics Technology Co Ltd
Priority date: 2020-10-27
Filing date: 2020-10-27
Publication date: 2021-01-29
Anticipated expiration: 2040-10-27
Also published as: CN112000584A

Abstract

The invention relates to the technical field of program debugging, and provides a debugging method, a debugging system and a storage medium for a CPU program based on an IDE debugging framework. The debugging method comprises the following steps: creating a starting program corresponding to the debugging state according to the debugging state of the CPU program; judging the type of the starting program, and determining whether to create a debugging program according to the type of the starting program. The invention improves the debugging method for the CPU program based on the IDE debugging frame, classifies the debugging starting program, and determines whether to create the debugging program according to the type of the starting program. When the CPU program is in a debugging state, the created debugging program can be protected under the condition that a user operates the debugging program by mistake or clicks a Debug button for multiple times, so that the fault tolerance of the IDE development environment is better, the IDE development environment is ensured to be in a healthy state, and the research and development efficiency is greatly improved.

Description

Debugging method and debugging system for CPU program based on IDE debugging framework

Technical Field

The invention relates to the technical field of program debugging, in particular to a debugging method for a CPU program based on an IDE debugging framework, a debugging system for the CPU program based on the IDE debugging framework and a storage medium.

Background

In the CPU chip program debugging stage, a CPU development tool provides a set of development tool system for chip debugging, including development tool software and development tool hardware. The development tool software comprises an Integrated Development Environment (IDE), a Compiler (Compiler), an ASSembler (ASSembler), a Linker (Linker), a Debugger (Debugger) and the like; the development tool hardware is a set of development board, the hardware logic of the CPU is simulated through the FPGA and some peripheral circuits, and the debugging function of the CPU is realized by matching with the development tool software. When CPU software debugs, research personnel can control IDE to realize the debugging of CPU, and the whole flow is: the IDE development environment analyzes the parameters through the dynamic library, issues the parameters to the USB device driver, issues commands or data through the device driver and the hardware, and simultaneously, the device driver can return the device state to the dynamic library and finally transmits the result to the IDE interface. Therefore, the development of the CPU is not separated from the IDE development environment, and the quality of the IDE development environment seriously influences the debugging of the CPU program.

A common CPU Integrated Development Environment (IDE) is a plug-in integrated on the basis of Eclipse CDT, the interaction between the IDE development environment and a chip is completed, and a debugging framework of the IDE inherits the debugging framework of the Eclipse CDT. The Eclipse CDT original ecology debugging frame can Debug the program for many times, as long as a user clicks a Debug button, the original ecology debugging frame can always establish the debugging program, namely a single program can enter a plurality of debugging states, but when the CPU is debugged, the user initiates a debugging instruction for the CPU again through the IDE Debug button (or the user mistakenly operates and clicks the Debug button for many times), so that a chip can enter an Error mechanism, the last feedback result can be transmitted to an IDE development environment, the IDE debugging module is caused to fail, and even the IDE debugging module can be used only by restarting the IDE. How to protect the integrity of the IDE development environment while the CPU is in a debug state becomes a matter of significant consideration when designing the IDE development environment.

Aiming at the problem of protecting the integrity of an IDE development environment, the existing IDE design is mainly solved based on a user level, namely, a user does not operate the IDE to send a debugging instruction to a chip after initiating a CPU debugging once, and the debugging instruction can be initiated again after a CPU debugging state is closed. Once a user clicks the Debug button for multiple times in case of misoperation, the IDE is broken down and needs to be opened again after closing the IDE, and the Debug steps are repeatedly operated, wherein the repeated operation needs waiting time, and the research and development efficiency is seriously influenced.

Disclosure of Invention

The present invention provides a debugging method and a debugging system for CPU program based on IDE debugging framework to solve the above problems.

In order to achieve the above object, an aspect of the present invention provides a debugging method for a CPU program based on an IDE debugging framework, the method including:

creating a starting program corresponding to the debugging state according to the debugging state of the CPU program;

judging the type of the starting program, and determining whether to create a debugging program according to the type of the starting program.

Further, the creating a boot program corresponding to the debugging state according to the debugging state of the CPU program includes:

determining whether the CPU program enters a debugging state or not according to the configuration information, debugging starting information and the project name of the project;

under the condition that the CPU program does not enter a debugging state, a first type of starting program is created;

in the case where the CPU program has entered a debug state, a second type of startup program is created.

Further, the determining whether to create a debugging program according to the type of the startup program includes:

if the type of the starting program is the first type, a debugging program is created to debug the CPU program;

and if the type of the starting program is the second type, not creating the debugging program, creating a user pop-up box, and releasing system resources when the user pop-up box is closed.

Further, the user pop-up box is configured to be manually closed, and is configured to be automatically closed when not manually closed within a preset time.

Further, the method for creating the user pop-up box comprises the following steps:

and adding the thread of the user pop-up box into the thread of the debugging user interface by adopting a thread synchronization technology, and canceling the action of sending a debugging instruction to the dynamic library.

The invention improves the debugging method for the CPU program based on the IDE debugging frame, classifies the debugging starting program, and determines whether to create the debugging program according to the type of the starting program. When the CPU program is in a debugging state, the created debugging program can be protected under the condition that a user operates the debugging program by mistake or clicks a Debug button for multiple times, so that the fault tolerance of the IDE development environment is better, the IDE development environment is ensured to be in a healthy state, and the research and development efficiency is greatly improved.

Another aspect of the present invention provides a debugging system for a CPU program based on an IDE debugging framework, the system comprising:

the starting module is used for creating a starting program corresponding to the debugging state according to the debugging state of the CPU program;

and the session module is used for judging the type of the starting program and determining whether to create a debugging program according to the type of the starting program.

Further, the system further comprises: an application module; when the session module judges that the type of the starting program is a first type, the application module creates a debugging program to debug the CPU program;

and when the session module judges that the type of the starting program is the second type, the application module does not create a debugging program, creates a user pop-up box and releases system resources when closing the user pop-up box.

The debugging system carries out customized design on the starting module and the session module based on the IDE debugging frame, and can protect the created debugging program under the condition that a user operates the debugging system by mistake or clicks a Debug button for multiple times when a CPU program is in a debugging state, so that the fault tolerance of the IDE development environment is better, the IDE development environment is ensured to be in a healthy state, and the research and development efficiency is greatly improved.

The present invention also provides a storage medium having stored thereon computer program instructions which, when executed by a processor, implement the above-described debugging method for a CPU program based on an IDE debugging framework.

Additional features and advantages of embodiments of the invention will be set forth in the detailed description which follows.

Drawings

The accompanying drawings, which are included to provide a further understanding of the embodiments of the invention and are incorporated in and constitute a part of this specification, illustrate embodiments of the invention and together with the description serve to explain the embodiments of the invention without limiting the embodiments of the invention. In the drawings:

FIG. 1 is a flow chart of a debugging method for a CPU program based on an IDE debugging framework provided by one embodiment of the invention;

FIG. 2 is a flowchart of a CPU program debugging process of a user interface provided by an embodiment of the present invention;

FIG. 3 is a block diagram of a debugging system for a CPU program based on an IDE debugging framework provided by one embodiment of the invention.

Detailed Description

The following detailed description of embodiments of the invention refers to the accompanying drawings. It should be understood that the detailed description and specific examples, while indicating the present invention, are given by way of illustration and explanation only, not limitation.

FIG. 1 is a flowchart of a debugging method for a CPU program based on an IDE debugging framework according to an embodiment of the present invention. As shown in fig. 1, an embodiment of the present invention provides a debugging method for a CPU program based on an IDE debugging framework, where the method includes:

s1) creating a startup program corresponding to the debugging state of the CPU program according to the debugging state.

When the IDE initiates a debugging request, determining whether the CPU program enters a debugging state or not through the configuration information, debugging starting information and the project name of the project; under the condition that the CPU program does not enter a debugging state, a first type of starting program is created; in the case where the CPU program has entered a debug state, a second type of startup program is created. In one particular embodiment: the types of Launch programs (boot programs) are customized and classified: debugging the created Launch program for the first time to be of a first type; when the debugging state is not closed, the created Launch program is of the second type; after the debug state is closed, the Launch program created again is of the first type. Whether the CPU program enters a debugging state is judged through config (configuration information) of the project, debug launch (debugging start information), the project name and the like. If the current CPU program is not in a debugging state, creating a Launch program of a first type; if the current CPU program is already in a debugging state, a Launch program of a second type is created.

S2), judging the type of the starting program, and determining whether to create a debugging program according to the type of the starting program.

Judging the type of the starting program, and if the type of the starting program is a first type, creating a debugging program to debug the CPU program; and if the type of the starting program is the second type, not creating the debugging program, but creating a user pop-up box, and releasing system resources when closing the user pop-up box. The method for creating the user pop-up box comprises the following steps: and adding the thread of the user pop-up box into the thread of the debugging user interface by adopting a thread synchronization technology, and canceling the action of sending a debugging instruction to the dynamic library. The user pop-up box is configured to be manually closed and is configured to automatically close when not manually closed within a preset time.

In one particular embodiment: controlling the function of the Debug button by judging the type of the Launch program; if the Launch program is of the first type, a debugging program is established on an IDE interface, and the CPU program enters a debug state; if the Launch program is of the second type, the debugging program is not created, the SWT thread synchronization technology syncExec is adopted, a user pop-up box ' xxx Debug available started ' and a please check it again ' thread created by the JFace technology are added into an Eclipse Debug UI (debugging user interface) thread, the design of the pop-up box is completed on an IDE Debug page, and meanwhile, the IDE cancels the action of transferring debugger parameters to a DLL (dynamic library). When the user clicks an 'OK' button (close button) of the pop-up box, the IDE Debug page deletes redundant Debug C/C + + Application, and system resources are released. When the user pop-up box is designed, the operation of automatically closing the user pop-up box is added, the user does not manually close the user pop-up box within a preset time (for example, 10 seconds), the resource release thread of the pop-up box is in a dormant state, and once the preset time is exceeded, the resource release thread starts to execute, and the pop-up box is automatically closed. In the existing IDE Debug framework, the user clicks the Debug button again, and although the debugger is not created again, the system applies for resources for this purpose. In this embodiment, the operations of releasing the resource code block and destroying the Launch code block are added to the SWT thread synchronization, and the user clicks the close button of the pop-up box, that is, releases the system resource, and automatically deletes the redundant Debug C/C + + Application on the IDE Debug page.

FIG. 2 is a flowchart illustrating debugging of a CPU program of a user interface according to an embodiment of the present invention. As shown in fig. 2, when the user clicks the Debug button again by a misoperation, the Debug page pops up a prompt box (i.e., a user pops up a box), the user clicks the pop-up box OK button or waits for 10 seconds before the pop-up box disappears, the Debug page deletes redundant Debug applications, and executes the created Debug applications until the debugging is finished.

The embodiment of the invention improves the debugging method for the CPU program based on the IDE debugging frame, carries out customized design on Launch and Session architectures of Eclipse CDT, and can ensure the normal operation of the debugging program of the first type under the environment of a plurality of debugging programs. The method can protect the created debugging program under the condition that a user operates the debugging program in error or clicks a Debug button for multiple times when the CPU program is in the debugging state, so that the fault tolerance of the IDE development environment is better, the IDE development environment is ensured to be in a healthy state, and the research and development efficiency is greatly improved.

FIG. 3 is a block diagram of a debugging system for a CPU program based on an IDE debugging framework provided by one embodiment of the invention. As shown in FIG. 3, the embodiment of the present invention provides a debugging system for a CPU program based on an IDE debugging framework, which includes a start module, a session module and an application module. The starting module is used for creating a starting program corresponding to the debugging state according to the debugging state of the CPU program. The session module is used for determining the type of the starting program and determining whether to create a debugging program according to the type of the starting program.

The starting module determines whether the CPU program enters a debugging state or not according to the configuration information, debugging starting information and the project name of the project; under the condition that the CPU program does not enter a debugging state, a first type of starting program is created; in the case where the CPU program has entered a debug state, a second type of startup program is created. In one particular embodiment: the Launch module customizes and classifies the types of Launch programs (Launch programs): debugging the created Launch program for the first time to be of a first type; when the debugging state is not closed, the created Launch program is of the second type; after the debug state is closed, the Launch program created again is of the first type. Whether the CPU program enters a debugging state is judged through config (configuration information) of the project, debug launch (debugging start information), the project name and the like. If the current CPU program is not in a debugging state, creating a Launch program of a first type; if the current CPU program is already in a debugging state, a Launch program of a second type is created.

The session module judges the type of a starting program, and when the session module judges that the type of the starting program is a first type, the application module creates a debugging program to debug the CPU program; and when the session module judges that the type of the starting program is the second type, the application module does not create a debugging program but creates a user pop-up box, and releases system resources when closing the user pop-up box. The method for creating the user pop-up box comprises the steps of adding a thread of the user pop-up box into a thread of a debugging user interface by adopting a thread synchronization technology, and canceling an action of sending a debugging instruction to a dynamic library. In one particular embodiment: the session module controls the function of the Debug button by judging the type of the Launch program; if the Launch program is of the first type, the application module creates a debugging program on an IDE interface, and the CPU program enters a debug state; if the Launch program is of the second type, the application module does not create a debugging program, but adopts the SWT thread synchronization technology syncExec, adds a user pop-up box ' xxx Debug available started ' and a please check it again ' thread created by the JFace technology into an Eclipse Debug UI (debugging user interface) thread, completes the design of the pop-up box on an IDE Debug page, and meanwhile, the IDE cancels the action of transferring the debugger parameters to a DLL (dynamic library). When the user clicks an 'OK' button (close button) of the pop-up box, the IDE Debug page deletes redundant Debug C/C + + Application, and system resources are released. When the user pop-up box is designed, the operation of automatically closing the user pop-up box is added, the user does not manually close the user pop-up box within a preset time (for example, 10 seconds), the resource release thread of the pop-up box is in a dormant state, and once the preset time is exceeded, the resource release thread starts to execute, and the pop-up box is automatically closed. In the existing IDE Debug framework, the user clicks the Debug button again, and although the debugger is not created again, the system applies for resources for this purpose. In this embodiment, the operations of releasing the resource code block and destroying the Launch code block are added to the SWT thread synchronization, and the user clicks the close button of the pop-up box, that is, releases the system resource, and automatically deletes the redundant Debug C/C + + Application on the IDE Debug page.

The embodiment of the invention carries out customized design on the starting module and the session module based on the IDE debugging frame, can protect the created debugging program under the condition that a user operates by mistake or clicks a Debug button for multiple times when the CPU program is in a debugging state, ensures that the IDE development environment has better fault tolerance, ensures that the IDE development environment is in a healthy state, and greatly improves the research and development efficiency.

The embodiment of the invention also provides a machine-readable storage medium, on which computer program instructions are stored, and the computer program instructions, when executed by a processor, realize the debugging method for the CPU program based on the IDE debugging framework.

As will be appreciated by one skilled in the art, embodiments of the present application may be provided as a method, system, or computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.

The present application is described with reference to flowchart illustrations and/or block diagrams of methods, systems and computer program products according to embodiments of the application. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

Finally, it should be noted that: the above embodiments are only for illustrating the technical solutions of the present invention and not for limiting the same, and although the present invention is described in detail with reference to the above embodiments, those of ordinary skill in the art should understand that: modifications and equivalents may be made to the embodiments of the invention without departing from the spirit and scope of the invention, which is to be covered by the claims.

Claims

1. A debugging method for a CPU program based on an IDE debugging framework is characterized by comprising the following steps:

judging the type of the starting program, and determining whether to create a debugging program according to the type of the starting program;

the creating of the starting program corresponding to the debugging state according to the debugging state of the CPU program comprises the following steps:

under the condition that the CPU program enters a debugging state, a second type of starting program is created;

the determining whether to create a debugging program according to the type of the startup program comprises:

2. The IDE debug framework based debugging method for CPU programs according to claim 1, wherein said user pop-up box is configured to be manually closed and is configured to be automatically closed when not manually closed within a preset time.

3. The debugging method for the CPU program based on the IDE debugging framework as claimed in claim 1, wherein the method for creating the user pop-up box comprises:

4. A debugging system for a CPU program based on an IDE debugging framework, the system comprising:

the session module is used for judging the type of the starting program and determining whether to create a debugging program according to the type of the starting program;

under the condition that the CPU program enters a debugging state, a second type of starting program is created; and

an application module to:

when the session module judges that the type of the starting program is the first type, a debugging program is created to debug the CPU program;

and when the session module judges that the type of the starting program is the second type, a debugging program is not created, a user pop-up box is created, and system resources are released when the user pop-up box is closed.

5. The IDE debug framework-based debugging system for CPU programs according to claim 4, wherein said method for creating a user pop-up box comprises:

6. A storage medium having stored thereon computer program instructions, which when executed by a processor implement the IDE debug framework based debugging method for a CPU program of any of claims 1-3.