Method and system for tracing and displaying execution of nested functions

Share
Save
Discuss
Claim

Share On Facebook Share On Twitter Share By Email
Save Item
Save Item
Add to
my lists

Filing Information

  • Patent Number: US7120901
  • Application Number: US10235599
  • Filing date: 09/05/2002
  • Issue date: 10/10/2006
  • Prior Publication Data:
  • Predicted expiration date: 02/16/2024
  • Patent term adjustment: 529
Explore Your Innovation Network™ for an introduction to:

Innovation Network Your First Name:
 Last Name:
  
Already a member? Sign In
  • U.S. Classifications: 717/128  · 714/45  · 717/130  · 714/48  · 717/127  ·
  • International Classifications: G06F944 · G06F1100 ·
  • Foreign Priority: EP01480099 - 10/26/2001 ·
  • View document at: (opens new window):
    USPTO  ·  PAIR  ·  esp@cenet  ·  Patent Family
    * Related patent documents may or may not exist on these sites
33 Claims, 5 Drawings


Abstract

A method and system for tracing the failing or successful execution of nested functions coded with return codes in a thread during its execution. The method comprises an ENTRY and EXIT trace macro to mark the beginning and the end of execution of the function, a TRACE macro to record messages and program variable values, and a QUIT macro marking the failing execution of the corresponding function. Using a Graphical User Interface, an interactive trace analyzer reads the trace file and displays the tree structure of the nested functions and marks, by using different colors, the success or failure of each of them. The trace analyzer utilities help the user to quickly identify the error in the source code corresponding to a function with a failing execution.

References Cited

U.S. Patent Documents

Document NumberAssigneesInventorsIssue/Pub Date
US4462077* Bell Telephone Laboratories, Incorporated York Jul 1984
US4965717* Tandem Computers Incorporated Cutts et al. Oct 1990
US5119377* International Business Machines Corporation Cobb et al. Jun 1992
US5327568* Ltd. Hitachi Maejima et al. Jul 1994
US5598564* Barker, III Jan 1997
US5724505* Lucent Technologies Inc. Argade et al. Mar 1998
US5748878* Applied Microsystems, Inc. Rees et al. May 1998
US5852449* Scientific and Engineering Software Esslinger et al. Dec 1998
US5898873* International Business Machines Corporation Lehr Apr 1999
US5903759* 3 Com Corporation Sun et al. May 1999
US5960199* International Business Machines Corporation Brodsky et al. Sep 1999
US6002872* International Machines Corporation Alexander et al. Dec 1999
US6079032* Lucent Technologies, Inc. Peri Jun 2000
US6126329* Rational Software Coporation Bennett et al. Oct 2000
US6158024* International Business Machines Corporation Mandal Dec 2000
US6161216* EMC Corporation Shagam Dec 2000
US6202199* Mutek Solutions, Ltd. Wygodny et al. Mar 2001
US6230313* Cray Inc. Callahan et al. May 2001
US6269276* Roche Diagnostics Corporation Akhavan et al. Jul 2001
US6353923* Microsoft Corporation Bogle et al. Mar 2002
US6493868* Texas Instruments Incorporated DaSilva et al. Dec 2002
US20020095661* Angel et al. Jul 2002
US20030023956* Dulberg et al. Jan 2003
* cited by examiner

Other Publications

Tivoli Software Distribution Reference Manual Version 4.0.
Research Disclosure Nov. 1998 No. 415, Article No. 41583, “Trace Viewer”, p. 1513.

Patent Family


Read Patent

Read patent

Independent Claims | See all claims (33)

  1. 1. A method for identifying errors, in a source code stored on a computer, of program components having nested functions which may use return codes and which are executed in a multithread environment, said method comprising the steps of: using an editor operating on the computer, adding, in the source code of the program components, the following macros: an ENTRY macro at a beginning of each function, an EXIT macro at a normal execution end of each function, a TRACE macro wherever specific information needs to be dumped and a QUIT macro in a place where an unexpected condition occurs; compiling the source code into executable code using a code source compiler on the computer; executing said executable code, including trace macro code, wherein each time one of the ENTRY or EXIT macros is executed, logging a trace record in a trace file including a name of the corresponding function, each time a TRACE macro is executed, logging a trace record in the trace file including the dumped specific information, and, each time a QUIT macro is executed, logging a trace record in the trace file comprising the name of the corresponding function, and jumping to an execution of the EXIT macro of said corresponding function; reading a selected trace record in the trace file; if the selected trace record has been created by execution of an ENTRY macro, displaying on a screen of the computer the function name as a representation of a node, the node becoming a current node, of a tree illustrating a structure of the program components comprising nested functions; if the selected trace record has been created by execution of a QUIT macro, marking on the screen the current node as a failing function, a parent tree node becoming the current node; if the trace macro has been created by execution of an EXIT macro, marking the current node on the screen as a successfully executed function, the parent tree node becoming the current node; if the trace macro has not been created by execution of an EXIT macro, storing in a memory of the computer the corresponding dumped specific information of the TRACE macro as a leaf of the current node; and repetitively executing the previous steps up to an end of the trace file.
  2. 12. An information handling system for identifying errors, in a source code stored on the system, of program components having nested functions which may use return codes and which are executed in a multithread environment, said system comprising: an editor for adding, in the source code of the program components, the following macros: an ENTRY macro at a beginning of each function, an EXIT macro at a normal execution end of each function, a TRACE macro wherever specific information needs to be dumped and a QUIT macro in a place where an unexpected condition occurs; a code source compiler for compiling the source code into executable code on the system; means for executing the executable code, including trace macro code, wherein each time one of the ENTRY or EXIT macros is executed, a trace record is logged in a trace file including a name of the corresponding function, each time a TRACE macro is executed, a trace record is logged in the trace file including the dumped specific information, and, each time a QUIT macro is executed, a trace record is logged in the trace file comprising the name of the corresponding function, and execution jumps to the EXIT macro of said corresponding function; means for reading a selected trace record in the trace file; if the selected trace record has been created by execution of an ENTRY macro, means for displaying, on a screen of a display device, the function name as a representation of a node, the node becoming a current node, of a tree illustrating a structure of the program components comprising nested functions; if the selected trace record has been created by execution of a QUIT macro, means for marking on the screen the current node as a failing function, a parent tree node becoming the current node; if the trace macro has been created by execution of an EXIT macro, means for marking the current node on the screen as a successfully executed function, the parent tree node becoming the current node; and if the trace macro has not been created by execution of an EXIT macro, means for storing in a memory of the system, the corresponding dumped specific information of the TRACE macro as a leaf of the current node.
  3. 23. A computer program product stored in a computer operable media for identifying errors, in source codes stored on a computer system, of program components having nested functions which may use return codes and which are executed in a multithread environment, said program product comprising: means for using an editor for adding, in the source code of the program components, the following macros: an ENTRY macro at a beginning of each function, an EXIT macro at a normal execution end of each function, a TRACE macro wherever a specific information needs to be dumped and a QUIT macro in a place where an unexpected condition occurs; means for compiling the source code into executable code on the computer system; means for executing the executable code, including trace macro code, wherein each time one of the ENTRY or EXIT macros is executed, a trace record is logged in a trace file including a name of the corresponding function, each time a TRACE macro is executed, a trace record is logged in the trace file including the dumped specific information, and, each time a QUIT macro is executed, a trace record is logged in the trace file comprising the name of the corresponding function, and execution jumps to the EXIT macro of said corresponding function; means for reading a selected trace record in the trace file; if the selected trace record has been created by execution of an ENTRY macro, means for displaying, on a screen of a display device, the function name as a representation of a node, the node becoming a current node of a tree illustrating a structure of the program components comprising nested functions; if the selected trace record has been created by execution of a QUIT macro, means for marking on the screen the current node as a failing function, a parent tree node becoming the current node; if the trace macro has been created by execution of an EXIT macro, means for marking the current node on the screen as a successfully executed function, the parent tree node becoming the current node; and if the trace macro has not been created by execution of an EXIT macro, means for storing in a memory of the computer system, the corresponding dumped specific information of the TRACE macro as a leaf of the current node.