System of debugging software through use of code markers inserted into spaces in the source code during and after compilation

• US 5,265,254 A
• Filed: 08/14/1991
• Issued: 11/23/1993
• Est. Priority Date: 08/14/1991
• Status: Expired due to Term

• Current Assignee: Agilent Technologies, Inc.
• Original Assignee: Hewlett-Packard Company (HP Inc.)
• Inventors: Blasciak, Andrew, Parets, Greg
• Primary Examiner(s): Lee, Thomas C.
• Assistant Examiner(s): ORZECH, JENNIFER
• Application Number:
  US07/744,849
• Time in Patent Office: 832 Days
• Field of Search: 395/275, 395/700, 395/800, 395/575, 395/400, 371/19
• US Class Current: 717/130
• CPC Class Codes: G06F 11/3466 Performance evaluation by tracing or monitoring
• CPC Class Codes: G06F 11/3624 by performing operations on the source code, e.g. via a compiler
• CPC Class Codes: G06F 11/3636 by tracing the execution of the program
• CPC Class Codes: G06F 11/3644 by instrumenting at runtime

Abstract

A system for inserting code markers for observing indications (external to the microprocessor upon which the software operates) of the occurrence of an event in the execution of the software. Additional instructions or markers are added to the software to be debugged to produce simple, encoded, memory references to otherwise unused memory or I/O locations that will always be visible to a logic analyzer as bus cycles. Although the code markers cause a minimal intrusion in the underlying software, they make tracing events by a conventional logic analyzer much simpler and allow for performance evaluations in manners not heretofore possible. In particular, the inserted code markers provide a method of dynamically extracting information from a running software system under test using simple low intrusion print statements, encoded I/O writes on procedure entries and exits and the like. Generally, the code markers are inserted at compile time or interactively during the debug session to make visible critical points in the code execution, such as function calls, task creation, semaphore operations and other resource usage so as to speed isolation of problems at test points during debugging.

Claims

1. A system for dynamically characterizing and debugging a software system operating on a host computer, comprising:

a marker database for storing code markers representative of characterizing and debugging information;

means for inserting certain of said code markers from said marker database at predetermined locations within compiled functional source code blocks of said software system whereby other source code in said compiled functional source code blocks is thereby moved into empty spaces int he compiled functional source code blocks of said software system such that said compiled functional source code blocks may be executed without recompiling of said functional source code block with said inserted code markers, said empty spaces in the compiled functional source code blocks of said software system having been inserted prior to compiling of said source code of said software system at positions logically between separate functional source code blocks of said software system, said inserted code markers representing desired user characterizing and debugging information at said predetermined locations;

means for collecting said inserted code markers from said software system during execution of said software system;

a marker memory for storing said collected code markers; and

means for displaying the characterizing and debugging information associated with the collected code markers.

2. A system as in claim 1, wherein said characterizing and debugging information comprises at least one of (a) parameter values for software parameters to be monitored which are passed between respective functional code blocks and (b) time measurements between detection of respective code markers collected during execution of said software system.

3. A system as in claim 1, wherein said collecting means comprises a marker collection software process which collects said code markers and state information associated with the code markers as they are received from said software system during execution.

4. A system as in claim 3, wherein said marker collection software process time stamps said collected code markers as they are received from said software system during execution and places the time stamped code markers in said marker memory.

5. A system as in claim 1, wherein said collecting means comprises a marker analyzer having pattern recognition means for isolating said code markers from the rest of a data stream output from said software system during execution and for identifying said isolated code markers.

6. A system as in claim 5, wherein said marker analyzer further comprises event counting/timing means for starting and stopping the code marker collecting on the occurrence of specific events and for time stamping said collected code markers as they are received from said software system during execution.

7. A system as in claim 6, wherein said marker memory stores said collected code markers from said marker analyzer and count/timer information from said event counting/timing means.

8. A system as in claim 7, wherein said marker analyzer further comprises processing means for eliminating some of the code markers stored in said marker memory prior to display of said code markers by said displaying means.

9. A method for dynamically characterizing and debugging a software system operating on a host computer, comprising the steps of:

adding a number of extra spaces in the source code of said software system following each functional source code block of said software system, said number of extra spaces being determined by at least one of the size of the function, number of software parameters and number of local variables of each functional source code block;

compiling said software system with said extra spaces;

linking the source code having said extra spaces with a marker library containing code marker data structures;

determining a type of code marker desired by a user from said marker library for use in characterizing and debugging said software system and storing the location and type of the desired code marker in a code marker database;

inserting each desired code marker into said software system at a predetermined location within said functional source code block such that other source code in said functional source code block is moved into said extra spaces without relinking of said source code with said marker library;

executing said software system on said host computer;

capturing said inserted code markers as they appear during said executing step;

checking said captured code markers against said code marker database to determine the location and type of said captured code markers; and

displaying the captured code markers checked in said checking step.

10. A method as in claim 9, comprising the further step of time stamping the captured code markers prior to said checking step.

11. A method as in claim 10, comprising the further step of calculating the processing time spent in a given functional source code block of said software system in accordance with time stamps on said captured code markers.

12. A method as in claim 9, wherein said displaying step includes the step of displaying values of said software parameters of said software system for said captured code markers.

13. A method as in claim 9, wherein said code marker inserting step dynamically links respective functional source code blocks of said software system by performing the steps of:

extracting from said software system functional source code blocks which are to be dynamically linked and inserting each code marker desired by said user at predetermined locations within said extracted functional source code blocks;

compiling said extracted functional source code blocks so as to produce an object file;

dynamically linking said object file with a symbol object file for resolving references in said functional source code blocks to variables defined external to said functional source code blocks; and

overwriting the dynamically linked extracted functional source code blocks on top of the corresponding functional source code blocks in a memory of said host computer.