WO2009093220A2

WO2009093220A2 - Sal debugging

Info

Publication number: WO2009093220A2
Application number: PCT/IB2009/050290
Authority: WO
Inventors: Winthrop L. Saville; Thomas Merritt
Original assignee: Nxp B.V.
Priority date: 2008-01-25
Filing date: 2009-01-25
Publication date: 2009-07-30
Also published as: WO2009093220A3

Abstract

A method and system of debugging of software where debug statements are condensed during program execution and later expanded into a user-friendly format. A method in accordance with the present disclosure logs debug information and identifiers associated with debugging statements within a program that are configured to output a formatted log used for debugging the program. The identifiers indicate locations of the debugging statements within the program. Formatting information associated with the debugging statements is compiled and stored in a database. Once the programmer wishes to debug the program, during post-processing, the formatting information associated with the identifiers is extracted from the database. The debug information is then rendered using the extracted formatting information such that the rendered debug information depicts the formatted log that the debugging statements are configured to output. The rendered debug information is displayed as the formatted log used for debugging the program.

Description

SAL DEBUGGING

Debugging a software program is generally performed using one of two techniques. One technique is an interactive technique, where a special application takes full or partial control of the program to be debugged and allows the programmer to debug the program at a very low level. These types of applications are generally capable of dumping memory, setting break points, single- stepping the application and watching execution of the program through watch points that may be implemented in software or hardware. The interactive technique performs very well for debugging linear programs. Programs that are highly dynamic or that must respond within certain periods of time are harder to debug using the interactive technique. This is because the interactive technique either changes the real-time behavior of the program or provides only a limited view of what the program is actually doing.

Another technique requires a programmer to log information to a computer memory, serial port or other entity in order to modify the application from a debug print statement. Using the logging technique has less effect on the behavior of the program to be debugged because the logging technique typically does not explicitly interrupt the program's flow or timing. However, the application performance may still suffer if there is a significantly high quantity of information or if the bandwidth of the destination (e.g., memory) is too small. Accordingly, the logging technique requires the programmer to constantly balance the quantity and quality of the debug information so as to not change the behavior of the program to be debugged but still provide enough information to diagnose the program's problem.

In exemplary embodiments of the present disclosure is provided a Sal debugging method and system. The Sal debugging method and system ensures that the amount of information logged remains low while still providing high quality information by condensing the debugging information itself. In one exemplary embodiment according to the present invention, there is provided a method of debugging a software program, wherein the method logs debug information and identifiers associated with debugging statements within the program that are configured to output a formatted log used for debugging the program, the identifiers indicating locations of the debugging statements within the program, compiles formatting information associated with the debugging statements and stores the formatting information in a database, during post processing: extracts the formatting information associated with the identifiers from the database and renders the debug information using the extracted formatting information such that the rendered debug information depicts the formatted log that the debugging statements are configured to output, and displays the rendered debug information as the formatted log for debugging.

The debug information may include debug variables and time stamps. The debug variables may be selectively enabled to vary the quantity of the debug information.

The identifiers may each include a module identifier and a line number. The module identifier may be 16 bits and the line identifier may be 16 bits.

The compiled formatting information may be stored in the database by the module identifier and the line number.

Rendering and displaying the debug information may be performed on a different computer system to avoid latency in the program. Rendering and displaying the debug information may be performed on the same computer system with less priority than execution of the program to avoid latency in the program. Scanning the source code and logging the debug information and the identifiers may be performed continuously over at least three days without adversely affecting the program.

In another aspect according to an exemplary embodiment of the present invention, there is provided a software debugging system that includes an application configured for logging debug information and identifiers associated with debugging statements within a program that are configured to output a formatted log used for debugging the program, the identifiers indicating locations of the debugging statements within the program, a database for storing compiled formatting information associated with the debugging statements, a processing unit used in conjunction with the application for extracting the formatting information associated with the identifiers from the database and rendering the debug information using the extracted formatting information during post-processing such that the rendered debug information depicts the formatted log that the debugging statements are configured to generate, and a display for displaying the rendered debug information as the formatted log for debugging.

In another aspect according to an exemplary embodiment of the present invention, there is provided a method of fine grain control for debugging a software program that includes executing the program, wherein the program includes debugging statements configured to output a formatted log for debugging, ignoring the output of the debugging statements and logging debug information and identifiers associated with the debugging statements, the identifiers indicating locations of the debugging statements within the program, storing formatting information associated with the debugging statements in a database, during post-processing: extracting the formatting information associated with the identifiers from the database and rendering the debug information using the extracted formatting information such that the rendered debug information depicts the formatted log that the debugging statements are configured to output, and displaying the rendered debug information as the formatted log for debugging. The accompanying drawings, together with the specification, illustrate exemplary embodiments of the present invention, and, together with the description, serve to explain the principles of the present invention: Fig. 1 is a flow diagram illustrating an exemplary method of debugging a software program according to an exemplary embodiment of the present disclosure.

Fig. 2 is a block diagram of an exemplary software debugging system according to an exemplary embodiment of the present disclosure. In the following detailed description, only certain exemplary embodiments of the present invention are shown and described, simply by way of illustration. As those skilled in the art would realize, the described embodiments may be modified in various different ways, all without departing from the spirit or scope of the present invention. Accordingly, the drawings and description are to be regarded as illustrative in nature, and not restrictive. In exemplary embodiments according to the present invention, Sal debugging system and method is provided. According to exemplary embodiments, debugging statements are condensed during program execution and later expanded into a user-friendly (i.e., human readable) format. In an aspect, the debugging statements are configured to output a formatted log. The output of the debugging statements may be ignored during program execution and parameters of the debugging statements, such as debug information (e.g., debug variables and time stamps) and identifiers (e.g., locations of the debugging statements) may be logged. During post-processing, formatting information of the debugging statements may be compiled and used to reassemble the formatted log by rendering the debug information in conjunction with the formatting information.

Referring to Fig. 1, there is disclosed a method 100 of debugging a software program according to an exemplary embodiment of the present disclosure. At block 110, a program is executed. The program includes debugging statements configured to output a formatted log for debugging. Alternatively, the method may start at block 120 and not command the program to execute. At block 120, debug information and identifiers are logged from the debugging statements. This may include ignoring the output of the debugging statements. The identifiers indicate locations of the debugging statements within the program, and may include module identifiers and line numbers. The module identifiers and line numbers help pinpoint the precise locations of the debugging statements within the program. Rather than creating a formatted log of debug statements, according to the method 100, a condensed version of the debug statements is logged without the formatting information. The identifiers (e.g., unique identifiers) enable the software debugging system to determine where the debugging statements are in order to display the debug information correctly during post- processing. In one embodiment, executing the program and logging the debug information and the identifiers may be performed continuously over three to five days without adversely affecting operation of the program. However, the present invention is not limited thereto, and the logging of the debug information and the identifiers may be performed continuously over a longer or shorter period of time in other embodiments. At block 130, formatting information associated with the debugging statements is compiled and the formatting information is stored in a database. Block 130 may be performed during source code compiling, or any other time before extracting the formatting information from the database at Block 140. The database entries provide a "map" or a "key" such that the formatting information may be matched to the identifiers logged during execution of the program. For example, the database entries may be organized by module identifier and line number to easily correspond to the locations of the identifiers of the debugging statements. The formatting information is later used to render and display the debug information as a formatted log, precisely the same as the debugging statements are configured to output.

The formatting information, not logged with the debug information and the unique identifiers during program execution, is collected or compiled independently sometime before postprocessing such that a larger quantity of debug information may be logged at a significantly high quality (e.g., fine-grain) in the same amount of time. The quantity of debug information that may be logged is dependent on how sensitive the program is to debugging applications running in parallel with the program to be debugged. This is particularly important if the program must be tested over long periods of time, such as three to five days. One of ordinary skill in the art would recognize the advantages of having the capability of fine-grain analysis over long periods of time without influencing the performance of the program to be debugged.

At block 140, the formatting information associated with the identifiers is extracted from the database during post-processing. The identifiers were previously obtained during execution of the program and logged in parallel with the debug information from the debugging statements.

At block 150, the debug information is rendered using the extracted formatting information such that the rendered debug information depicts the formatted log that the debugging statements were configured to generate. This may be performed during post-processing, or alternatively, when the programmer is ready to display the formatted log. The debug information may include debug variables and time stamps; the time stamps may be used to determine when the errors occurred, helping the programmer to more accurately debug his or her program and to recreate the debugging statements. At block 160, the rendered debug information is displayed as the formatted log for debugging. Once the formatted log is displayed, the programmer is able to debug the program using a large quantity of fine-grain debug information while ensuring that the logging task has not unduly influenced the program during runtime.

Referring to Fig. 2, a software debugging system 200 according to an exemplary embodiment of the present disclosure includes a processing unit 202, a memory 204, a database 206, an input/output ("I/O") interface 208 and a display 210.

The processing unit 202 is shown coupled to the memory 204, the database 206, the I/O interface 208 and the display 210, and may generally perform calculations, analysis, data processing, data routing or other functions generally performed by a generic processor. In one embodiment, an application 205 is stored on the memory 204 and configured for executing a program including debugging statements configured to output a formatted log for debugging and logging debug information and identifiers. Alternatively, the application 205 may be configured for logging debug information and identifiers and not command the program to execute. The debug information may include debug variables and time stamps. The debug variables may be selectively enabled to vary the type and quantity of data logged. In one embodiment, a user may enter values for the debug variables just prior to the runtime to select the type and quantity of data logged. The identifiers may be used to identify different locations within the program, and may include module identifiers and line numbers of the program. During program execution, the application 205 may be executed in conjunction with the processing unit 202 and log debug information and identifiers to a file. This file may be stored on the memory 204 for later retrieval. Alternatively, or in conjunction with the memory 204, the file may be stored on a hard disk or other large-capacity storage device. Testing of certain programs may require a large quantity of data to be stored for later retrieval and may even be stored on external large-capacity storage devices via the I/O interface 208. One of ordinary skill in the art would recognize that the processing and storage of debug data is a system parameter and depends on the requirements of the system to be designed. Accordingly, there are numerous ways one of ordinary skill in the art may process and store debug data in accordance with the present disclosure. Before post-processing, the application 205 may be executed in conjunction with the processing unit 202 and compile and route formatting information to the database 206 for later retrieval. The database 206 may be managed by a database management system ("DBMS"). During postprocessing, the application 205 may be executed in conjunction with the processing unit 202 to extract the formatting information associated with the identifiers logged during program execution from the database 206. Once the formatting information is extracted from the database 206, the processing unit 202 in conjunction with the application 205 may render the debug information using the extracted formatting information such that the rendered debug information depicts the formatted log that the debugging statements were configured to generate.

The display 210 displays the rendered debug information such that the programmer may debug the program from a quasi-real-time log of the errors as they would have occurred during program execution. As will be understood by those of skill in the art, the present invention may be embodied in other specific forms without departing from the essential characteristics thereof. For example, while some embodiments of the software debugging system are depicted using generic computer hardware, the system may be adapted to networked client-server embodiments or embodiments using a wide-area network.

Accordingly, the foregoing description is intended to be illustrative, but not limiting, of the scope of the invention which is set forth in the following claims and their equivalents.

Claims

What is claimed is:

1. A method of debugging a software program comprising: logging debug information and identifiers associated with debugging statements within the program, the debugging statements being configured to output a formatted log used for debugging the program, the identifiers indicating locations of the debugging statements within the program; compiling formatting information associated with the debugging statements and storing the formatting information in a database; during post processing: extracting the formatting information associated with the identifiers from the database; rendering the debug information utilizing the extracted formatting information such that the rendered debug information depicts the formatted log that the debugging statements are configured to output; and displaying the rendered debug information as the formatted log used for debugging the program.

2. The method of claim 1, further comprising executing the program.

3. The method of claim 1, wherein the debug information comprises debug variables and time stamps.

4. The method of claim 3, wherein the debug variables are selectively enabled to vary the quantity of the debug information.

5. The method of claim 1, wherein each of the identifiers comprises a module identifier and a line number.

6. The method of claim 5, wherein the module identifier has 16 bits and the line identifier has 16 bits.

7. The method of claim 1 , wherein the compiled formatting information is stored in the database by module identifier and line number.

8. The method of claim 1, wherein the rendering and displaying of the debug information is performed on a different computer system from a computer system for executing the program to avoid program latency.

9. The method of claim 1, wherein the rendering and displaying of the debug information is performed on a computer system for executing the program with less priority than execution of the program to avoid program latency.

10. The method of claim 1, wherein the logging of the debug information and the unique identifiers is performed continuously over at least three days without adversely affecting operation of the program.

11. A software debugging system comprising: an application configured for logging debug information and identifiers associated with debugging statements within a program, the debugging statements being configured to output a formatted log used for debugging the program, the identifiers indicating locations of the debugging statements within the program; a database for storing compiled formatting information associated with the debugging statements; a processing unit utilized in conjunction with the application for extracting the formatting information associated with the identifiers from the database and rendering the debug information utilizing the extracted formatting information during post-processing such that the rendered debug information depicts the formatted log that the debugging statements are configured to generate; and a display for displaying the rendered debug information as the formatted log used for debugging the program.

12. The software debugging system of claim 11, wherein the application is further configured to execute the program.

13. The software debugging system of claim 11, wherein the debug information comprises debug variables and time stamps.

14. The software debugging system of claim 13, wherein the debug variables are selectively enabled to reduce the quantity of the debug information.

15. The software debugging system of claim 11, wherein each of the identifiers comprises a module identifier and a line number.

16. The software debugging system of claim 15, wherein the module identifier has 16 bits and the line identifier has 16 bits.

17. The software debugging system of claim 11, wherein the compiled formatting information is stored in the database by utilizing module identifier and line number.

18. The software debugging system of claim 11 , wherein a processing unit of a different computer system from a computer system for executing the program renders and displays the debug information to avoid latency.

19. The software debugging system of claim 11, wherein the processing unit renders and displays the debug information on a computer system for executing the program with less priority than execution of the program.

20. The software debugging system of claim 11, wherein the application is configured to scan the source code and to log the debug information and the unique identifiers continuously over at least three days without adversely affecting operation of the program.

21. A method of fine grain control for debugging a software program comprising: executing the program, wherein the program includes debugging statements configured to output a formatted log used for debugging the program; ignoring the output of the debugging statements and logging debug information and identifiers associated with the debugging statements, the identifiers indicating locations of the debugging statements within the program; storing formatting information associated with the debugging statements in a database; during post-processing: extracting the formatting information associated with the identifiers from the database; rendering the debug information using the extracted formatting information such that the rendered debug information depicts the formatted log that the debugging statements are configured to output; and displaying the rendered debug information as the formatted log used for debugging.