Method and system for tracing and displaying execution of nested functions

[0001] The present invention generally relates to the field of program debugging; more particularly, the invention relates to a tool for generating and analyzing a trace of the execution of nested functions.

[0002] When programs are coded with programming languages using symbolic names, such as Java, a debugger program can be used. A debugger is a program controlling the execution of a program to be debugged, allowing the programmer to step through the program, catch the data and monitor conditions, such as the values of the variables to correct the problem. When the programming language does not use symbolic names, one other way to debug a program is to include at strategic points in the code, macro instructions which will generate a trace in a trace file at execution time. The trace file is analyzed after execution with a trace analyzer.

[0003] Basically a trace tool provides parameter tracing for dumping to the trace file the parameters provided to a function, the entryexit tracing to follow the calling sequence of functions and the event tracing to track the occurrence of specific events in your program.

[0004] TraceMon Plus today is a tracing and logging utility for Visual C 6.0 language sold by TWI AG. It consists of the TMPlus program and a trace analyzer CTracer. In TraceMon Plus, to follow the execution of functions in the code, a trace is activated with the CTRACE_SCOPE, a macro used at the entry point of a function. This macro detects when the function exits.

[0005] With most of the tracing tools available today, once the trace macros have been inserted in the source code, at execution time the trace elements are generated and stored in a trace file. A convenient function of trace analyzer enables users to view and manipulate trace files easily and rapidly. The user friendly trace analyzers use a Graphical User Interface viewer as described in the RD4108301 IBM article of the Research Disclosure journal Number 415 of November 1998 published by Kenneth Mason Publication Ltd. A simple tree structure illustrates the nested functions of the code. Error code searching and simple graphics are provided to display the states of the trace information.

[0006] However, even using a graphical trace analyzer it is not possible today to analyze more deeply the execution of nested functions. More particularly, there is a need for identifying the execution of functions not coded with exceptions but with return codes. This is the case of code developed in the operating systems when the commands or applications have no need of exceptions. It would be of great help to be able to follow the execution of nested function calls and to know which of the nested function of one thread of a multi-thread environment has not been executed successfully. When functions are nested, the programmer wants to diagnose the problem in the execution of one thread, tracking it in the tree structure of nested functions and identifying the ones having failed. The non fatal failures are very difficult to identify as the application being a deamon, despite the error, continues to run, always generating tons of trace logs. The cause of the error cannot be identified as well because it is hidden by a failing event or a correlation of failing events. So there is a need for easily, quickly analyze fairly big collection of tracing information (for instance up to 10 Mbytes of trace log) to identify a problem occurred sometime in the past and in a piece of code to be located and modified.

[0007] It is thus an object of the present invention to provide a method for tracing, during the execution of a program, designated variable values, event status and information on entryexit of functions.

[0008] A further object is to trace the result of execution of one thread of all nested functions using return codes.

[0009] It is also an object of the invention to be able to illustrate in an easy way the information on the result of execution of all the nested functions.

[0010] The objects are reached by the use of a method of identifying errors in the source code stored on a computer of program components comprising nested functions which may use return codes and executed in a multithread environment, said method comprising the steps of:

[0011] using an editor operating on the computer, adding in the source code of said components at least the following macros: an ENTRY macro at the beginning of each function, an EXIT macro at the normal execution end of each function, a TRACE macro wherever a specific information needs to be dumped and a QUIT macro in the code in the place where an unexpected condition occurs;

[0012] compiling source code into executable code using the code source compiler on the computer;

[0013] executing said executable code on the computer including trace macro code, each time an ENTRY or EXIT macro being executed, logging a trace record in a trace file comprising the name of the corresponding function, each time a TRACE macro being executed, logging a trace record in the trace file comprising the dumped specific information, and, each time a QUIT macro being executed, logging a trace record in the trace file comprising the name of the corresponding function and jumping to the execution of the EXIT macro of said corresponding function.

[0014] The objects are further achieved by executing on a computer accessing the trace file and after a command has been entered at the computer requesting the analyze of the trace file:

[0015] reading a trace record in the trace file;

[0016] if the trace record has been created by the execution of an ENTRY macro, displaying on a screen of the computer the function name as a representation of a node, becoming the current node, of a tree illustrating the structure of the components comprising nested functions;

[0017] if the trace record has been created by the execution of a QUIT macro, marking on the screen the current node as a failing function, the parent tree node becoming the current node;

[0018] if the trace macro has been created by the 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;

[0019] if the trace macro has not been created by the execution of an EXIT macro, storing in the memory of the computer, the corresponding dumped specific information of the TRACE macro as a leaf of the current node;

[0020] repetitively executing the previous steps up to the end of the trace file.

[0021] With the tracing model of the present invention the programmer can collect trace with a semantic marking the success (EXIT macro) or failure (QUIT macro) in the execution of the nested functions called on one specific thread. Then, using this semantic he can selectively access this trace data and work on the corresponding source code in a user friendly way.

[0022] If a function exits with failure, this information can be raised up to the first function call: this is a principle similar to an exception. Using the trace analyzer, the developer can visualize which function was in error and at what level of nesting it happened.

[0023] In a traditional trace model having only the exit with no error tracing, to be able to identify the successful execution of the functions in a trace file, the developer will have choose to lowest level of filter for the trace messages which generates a huge trace file they results in loss of readability. On the contrary with the trace analyzer of a trace generated with the tracing model of the present invention, the entire trace file is shown in a single view. The nodes in green of the function tree representation illustrate a successful execution as the nodes in red illustrate an unsuccessful execution of the function. The nodes in green can be collapsed in the trace view as the red nodes can be expanded allowing to see the corresponding detailed trace information. Furthermore, once identified, the corresponding invalid portion of the code can be displayed on the same screen view.

[0024] The productivity is increased when debugging a complex program product using for instance C-language, being multi-threaded and using deamons. With the solution of the present invention, the time needed to find useful information in huge trace files is minimized.

[0025] FIG. 1 illustrates the computing environment of the preferred embodiment;

[0026] FIG. 2 is the general flow chart of the trace process according to the preferred embodiment;

[0027] FIG. 3 is a trace line according to the preferred embodiment;

[0028] FIG. 4 is the screen print provided by the trace analyzer according to the preferred embodiment for a 1 MB trace file;

[0029] FIG. 5 is the general flow chart of the interpretation of the trace file by the trace analyzer.

[0030] FIG. 1 illustrates the computing environment implementing the trace method according to the preferred embodiment. The programs (100) is installed on a computer which may be the workstation of the developer (110) or a remote computer. The programmer accesses the source code from his workstation through an editor (120) using a graphical user interface (GUI, 130). The pre-processor and C language compiler programs (140) compile source code (150) that the programmer wants to test and which is stored in libraries. The code libraries are partitioned, each partition comprising a code component corresponding to the coding of a C language function. The source code includes trace macros added by the programmer to his original source code that he wants to test. The code macros including the trace macros are expanded by the pre-processor which generates intermediate macros to be compiled by the C language compiler. The output of the compiler is the object code (150) which is executed in its environment (160), for instance as a process in the preferred embodiment. The trace is activated during code execution. One output of the code execution is the trace file (170) where the trace is logged during program execution. This completes the trace generation environment. In the same computer or in a separate computer the trace file is analyzed. The trace analyzer environment comprises the trace file (170), the trace analyzer program (180) which reads the trace lines in the trace file and the workstation user interface (screen, keyboards etc.). Using a Graphical User Interface developed using the facilities of the operating system of the workstation, the trace analyzer converts the trace lines of the trace files into a graphical representation of the execution of the code. The representation is displayed on the screen and the user can interactively ask the trace analyzer to perform trace classification, give details on the code execution, and finally display on the screen the source code of a function in error. This allows the developer to check where the problem is. When technical people maintain the code for a customer they can inform the customer if a fix is needed or if just a call failed.

[0031] FIG. 2 is a general flow chart describing the steps performed by the developer using the method as implemented in the preferred embodiment. The first step (200) is performed by the developer who introduces the trace macros in each source code component. The detail of macros of the preferred embodiment is described later in the text. Trace macros are first used to mark the entry and exit of the function. These macros are respectively located at the beginning and at the end of the function code. The entry and exit macros trace the beginning and the normal end of the execution of the function. Tracing entry and exit for each function generates a lot of trace this implies a large processing time and a large amount of trace information. A trace macro is used to tag the trace log with a line of text which can also details print the variable values. An additional macro in the preferred embodiment is a quit macro tracing a failing execution of the function. The quit macro is located in the source code in the places where the normal execution flow is abandoned. It allows dumping of return code value. Also to each trace macro is associated a level of trace: this level qualifies how important is this trace, this level is specified when starting trace logging during program execution.

[0032] The second step (210) is for compiling source code. During this step, the C pre-processor expands the macros according to the definitions into code language, C language in the preferred embodiment, using an intermediate set of macros not available to the programmer (see detailed description later in the text). These two first steps have been accomplished in the development environment of the developers. This environment comprises a computer having an editor to modify the code, a language compiler for instance C language. The language compiler has been enriched with a pre-processor for trace macro expansion into C language ready to be compiled by the standard language compiler.

[0033] The third step (220) is for executing the code and for activating the trace. The two activations can be done separately. In a customer environment, the trace is activate to be able to detect a problem in the execution of the customer. When activating a trace a level of trace is specified. The trace macro code is executed simultaneously to the other lines of codes. The real execution of the expanded trace macros and the contributions inside the trace file is dependent on the level of trace set for the product and for each component. Such level is compared with the level of the original macro. All qualifying macros contribute to the trace file simultaneously. This step is performed in the test environment which is a computer. It can be performed on the same computer than the computer used for development or on a different computer because the tests can be performed by different programmers or because the execution of the code requires a different computing environment.

[0034] The fourth step (230) is for analyzing the trace log file using via the trace analyzer. The trace file records are read. Each execution of a function is detected in the trace file and displayed on the screen as a branch (also called node) of a tree representing the code component tree structure. The nested function are represented as node and child node of the tree. If a function has been successfully executed, the node is colored in green. If a function execution has failed, the node is colored in red. A trace message logged during the execution of a function is displayed on the computer screen by clicking with the mouse of the computer on the corresponding node. The trace messages are the leafs of the node. With this visualization tool, the developer by clicking in a field near the node can display its function source code in a separate window screen. If no tree node is red (answer NO to test 240), this means that no function exited in error, the flow chart end is reached. If a node is red (answer Yes to test 240) the developer can visualize the corresponding source code and identify the error. This trace analyzing is performed in the product support environment. This is a computer able to run Graphical User Interface applications. The programmer or tester can use this part of the application during the development phase of the code. When the code is in production mode, the product support environment are the technical people doing maintenance of the code to identify problems in the code. Using the visualization of the tree of the execution, the developer can identify the node(s) or child node(s) in error for a given thread. The developer will change the source code (260) corresponding to the failing function(s) inserting new trace macros, if necessary.

[0035] FIG. 3 is an example of trace line generated by the method of the preferred embodiment. The first two characters (300) represent the coded identification of a code component where the trace macro has been executed. The following character string (310) represent a timestamp dating the trace line recording. The logging target (320) is then stored: this field identifies the client (in the client-server environment) which has sent a remote request to the server which is logging this trace. As a matter of fact, the server trace will comprise traces both from execution of its own processes and from execution of a specific code that a client has remotely requested to be executed. The next double field (330) includes the Process identifier (PID) and the Thread ID (TID). Trace logging can be performed for one process id and a specific thread in it if this process is a multithread process. This trace selection is useful for long running deamons. The next field (340) is the trace level which is a number from 0 to 5 characterizing the type of trace which the trace line belongs to. The following character string (350) in the trace line is the tracing function name. A character string follows (360) corresponding to a message coded by developer identifying an event at execution time or the name of the trace macro marking, for instance, the beginning or the end of the execution of the corresponding function code. This character string may include variable values.

[0036] In the preferred embodiment the developer uses the following four macros in the source code to trace program execution: TME_ENTRY, TRACE, TME_QUIT and TME_EXIT/TME_EXIT_NO_RC.

[0037] TME_ENTRY has one parameter, the function name which is a character string representing the name of the C function:

[0038] TME_ENTRY (<function_name>)

[0039] The TME_ENTRY macro is inserted, inside each C function, as the first statement, after all variables declaration. The object of this trace macro is to insert in each trace-line, that may be generated by the current function the <function_name> character string. Also, this macro is used by the trace analyzer to correlate the trace line with the source code of the function. As an example, these are the declarations for the function co_exec_pgm:

DC_SHORT co_exec_pgm	(DC_VOID	*	tws,
	DC_CHAR	*	command,
	DC_ULONG	*	ccode,
	DC_CHAR	*	outfile)
	DC_LONG orig_uid 0;
	...
	TIME_ENTRY(co_exec_pgm);

[0040] The result of trace macro execution in the trace log is:

[0041] This record advises that the execution of the co_exec_pgm function has started at the corresponding timestamp (06:19:29 PM). The first field 27 identifies the component code component where the trace macro has been executed. The trace analyzer when reading this trace line, executes the following commands to search in the built tree code (%build_tree%) the function code. These commands used also to start the GUI are from Unix commands available on Unix workstations and Windows PC:

	> cd %build_tree%
	> grep co_exec_pgm*.*

[0042] The result of the search is

	dvacoims.c: TME_ENTRY(co_exec_pgm);

[0043] Consequently, the function is located in the dvacoims.c module.

[0044] The TRACE macro has the following syntax:

[0045] TRACE<x> (<format>, <parameters>)

[0046] <format> is a character string in printf like format, representing some textual string to be dumped, possibly including reference to other parameters.

[0047] <parameters> is an optional list of variables defined in the context of the current function that may be added to the TRACE macro.

[0048] <x> is a numeric value (from 0low_level to 5high_level in the preferred embodiment) that qualifies the importance of the trace information. TRACE0 is for a very low level information as TRACE4 and TRACE5 are used for tracing severe or fatal errors.

[0049] Whenever a useful information needs to be dumped with or without parameters, the TRACE macro is inserted in the source code. The TRACE macro allows to dump the context of the function and values of variables at this point of the execution. The TRACE <x> statement is really dumped in the trace file only if the current product trace level is less or equal to the <x> level.

[0050] If the product trace level is 6, no trace is generated by the program.

[0051] If the product trace level is 5, only TRACE5 statements are dumped.

[0052] If the product trace level is 4, only TRACE5/TRACE4 are dumped.

[0053] If the product trace level is 3, only TRACE5 . . . TRACE3 are dumped.

[0054] If the product trace level is 2, only TRACE5 . . . TRACE2 are dumped.

[0055] If the product trace level is 1, only TRACE5 . . . TRACE1 are dumped.

[0056] If the product trace level is 0, TRACE5 . . . TRACE0 are all dumped.

[0057] The product trace level is set at activation of the trace during program execution. In the preferred embodiment, a product trace level can be set per each component.

[0058] As an example hereafter, are provided code and trace, generated by co_exec_pgm, if product trace level for component CO (common routines) is less or equal to 2.

[0059] Code:

	DC_SHORT co_exec_pgm (DC_VOID * tws,
	DC_CHAR	*	command,
	DC_ULONG	*	ccode,
	DC_CHAR	*	outfile)
	DC_LONG orig uid 0;
	...
	TME_ENTRY(co_exec_pgm);
	...
	TRACE2( )Starting program %s, command));
	if (co_full_path(tws,command))
	TRACE4( )full path name not found));

[0060] At execution, the corresponding trace file records are:

27 06:19:29PM	225 239 0	: >>>>>>>>>> ENTRY
gigioser	co_exec_pgm
01 06:19:29PM	225 239 2	: Starting program c:calc.exe
gigioser	co_exec_pgm
01 06:19:30PM	225 239 4	: full path name not found
gigioser	co_exec_pgm

[0061] A programmer can use TME_QUIT trace macro inside a function code, in the code locations where a failure needs to be detected and when the normal flow of the current function has to be abandoned. With this macro, the programmer wants to track an unexpected condition in the trace. The programmer may want to set the failing return code, before such macro. The programmer may want to log a warning/error trace, before such macro. This macro is key to distinguish between a normal exit and a failure exit from inside a function. The GUI trace analyzer is able to detect that such failure occurred, marking the function as failed (red color in the code tree structure displayed on the screen).

[0062] The calling function, detecting the return code, may keep TME_QUIT-ting (in which case the failure (red color) is propagated upwards), or may handle the failure (in which case the failure propagation (red color) is stopped and caller function terminates with a TME_EXIT, if no other errors occurs). This is illustrated with the GUI trace analyzer snapshot described later in relation with FIG. 4.

[0063] As illustrated in the example provided later with the TME_EXIT macros, the implementation of TME_QUIT dumps a specific TAG (<><><><><> QUITTING) in the trace file and jumps to the end of the function where the exiting return code is also dumped.

[0064] The TME_EXIT and TME_EXIT_NO_RC trace macros have the following syntax:

[0065] TME_EXIT(<rc>)

[0066] TME_EXIT_NO_RC( )

[0067] <rc> is the return code of the current function. If the current function is returning a void, the TME_EXIT_NO_RC macro must be used. A programmer uses only one TME_EXIT statement (or TME_EXIT_NO_RC for functions defined as void) inside a function. Such macro should be the last statement of the function. TME_EXIT(<rc>) and TME_EXIT_NO_RC( ) provide a jumping label, so that all the TME_QUIT macros of the function can jump to this point. Such macros mark the end of records of the current function inside the trace file.

[0068] Hereafter a sample code snippet including TME_ENTRY, TME_QUIT and TME_EXIT trace macros:

DC_SHORT co_exec_pgm	(DC_VOID	*	tws,
	DC_CHAR	*	command,
	DC_ULONG	*	ccode,
	DC CHAR	*	outfile)
	...
	TME_ENTRY (co_exec_pgm);
	...
	rc WinExec(command, SW_SHOWNORMAL, &process_id);
	if(rc < 32)
	TRACE5( )Unable to execute program %s (rc %ld),
command, errno));
	rc CO_ERR_EXEC_FAILED;	// 1003
	TME_QUIT;
	...
	rc GetExitCodeProcess(process_id);
	if(rc > WARNING_EXIT_CODE)
	TRACE5( )Program %s executed with warnings (rc %ld),
command, rc));
	rc CO_ERR_EXEC_WITH_WARNINGS;	// 1004
	TME_QUIT;
	TRACE2( )Program %s executed successfully, command));
	rc DC_OK;
	TME_EXIT_RC(%hx, rc);

[0069] The two following examples illustrate the result of QUIT macro in a case of error. In these two examples the ENTRY macro generates a trace line identifying the beginning of execution of the function, a TRACE macro provides a text describing the error, the return code of the function, the QUIT macro generates a quitting trace line message indicating that the function has ZO failed and jumping to the EXIT macro at the end of the function a new trace line is generated by the EXIT macro identifying the end of the function. The first example includes trace records in the trace file generated by the code above in case of a file not found error:

27 06:19:29PM gigioser	225 239 0 co_exec_pgm	: >>>>>>>>>> ENTRY
01 06:19:29PM gigioser	225 239 5 co_exec_pgm	: Unable to execute program c:calc.exe (rc 2)
27 06:19:30PM gigioser	225 239 0 co_exec_pgm	: <><><><><> QUITTING
27 06:19:30PM gigioser	225 239 0 co_exec_pgm	: return data 1003
27 06:19:30PM gigioser	225 239 0 co_exec_pgm	: <<<<<<<<<< EXIT

[0070] A second example with trace records in the trace file generated by the code above in case of an execution with warnings error:

27 06:19:29PM gigioser	225 239 0 co_exec_pgm	: >>>>>>>>>> ENTRY
01 06:19:29PM gigioser	225 239 5 co_exec_pgm	: Program c:calc.exe executed with warnings (rc 5)
27 06:19:30PM gigioser	225 239 0 co_exec_pgm	: <><><><><> QUITTING
27 06:19:30PM gigioser	225 239 0 co_exec_pgm	: return data 1004
27 06:19:30PM gigioser	225 239 0 co_exec_pgm	: <<<<<<<<<< EXIT

[0071] Possible trace records in the trace file generated by the above code in case of a execution without warnings error:

27 06:19:29PM gigioser	225 239 0 co_exec_pgm	: >>>>>>>>>> ENTRY
01 06:19:29PM gigioser	225 239 2 co_exec_pgm	: Program c:calc.exe executed successfully
27 06:19:30PM gigioser	225 239 0 co_exec_pgm	: return data 0
27 06:19:30PM gigioser	225 239 0 co_exec_pgm	: <<<<<<<<<< EXIT

[0072] The following Macros or APIs are not available to the programmer: TME_EXIT_POINT, TME_EXIT_RC/TME_EXIT_VOID, TRACEIO, TRC, co_trc and co_trc_test.

[0073] In the preferred embodiment, at compilation time, these macros are built by expansion of the TME_ENTRY, TRACE, TME_QUIT and TME_EXIT/TME_EXIT_NO_RC trace macros used in the source code by the programmer.

[0074] TME_EXIT_POINT

[0075] is a jumping label that TME_QUIT refers to

[0076] TME_EXIT_RC

[0077] is used by TME_EXIT (not void function case)

[0078] TME_EXIT_VOID

[0079] is used by TME_EXIT_NO_RC (void function case)

[0080] TRACEIO

[0081] is the real logging macro referred to all macros but TRACE<x>TRC

[0082] is invoked by TRACEIO or TRACE<x>, handles the per-component log level.

[0083] co_trc_test( )

[0084] is a C language function that checks logging level co_trc( )

[0085] is a C language function that do the trace logging

[0086] The C compiler pre-processor of the preferred embodiment converts trace macros used by the programmer to the set of macros above and applies successive conversions to obtain C language functions according to the following example:

[0087] Programmer trace macros definition using TRACEIO:

define TME_ENTRY(x)	static DC_CHAR TME_trcmodx;
	TRACEIO( )>>>>>>>>>>
	ENTRY))
define TME_QUIT	TRACEIO( )<><><><><>
	QUITTING));
	goto TME_exit
define TME_EXIT_RC(x, rc)	TRACEIO( )return data x , rc));
	TRACEIO( )<<<<<<<<<< EXIT));
	return rc
define TME_EXIT_VOID	TRACEIO( )<<<<<<<<<< EXIT));
	return
define TME_EXIT_POINT	TME_exit:
define TME_EXIT(x)	TME_EXIT_POINT; TME_EXIT
	RC(%hx, x)
define TME_EXIT_NO	TME_EXIT_POINT; TME_EXIT
RC( )	VOID

[0088] TRACEIO/TRACE<x> macro definition into TRC, depending to the Component/Level. In the following example, COMMID/DASID/GIID/ . . . are compiler definition activated for components COMM/DAS/GI/ . . . :

define	TRACEIO( )	TRC(5,TME_INOUT,(tws, 0, TME_INOUT,
		TME_trcmod,
ifdef	COMMID
define	TRACE0( )	TRC(0,TME_CO,(tws, 0, TME_CO,
		TME_trcmod,
define	TRACE1( )	TRC(1,TME_CO,(tws, 1, TME_CO,
		TME_trcmod,
define	TRACE2( )	TRC(2,TME_CO,(tws, 2, TME_CO,
		TME_trcmod,
define	TRACE3( )	TRC(3,TME_CO,(tws, 3, TME_CO,
		TME_trcmod,
define	TRACE4( )	TRC(4,TME_CO,(tws, 4, TME_CO,
		TME_trcmod,
define	TRACE5( )	TRC(5,TME_CO,(tws, 5, TME_CO,
		TME_trcmod,
elif	DASID
define	TRACE0( )	TRC(0,TME_DB,(tws, 0, TME_DB,
		TME_trcmod,
define	TRACE1( )	TRC(1,TME_DB,(tws, 1, TME_DB,
		TME_trcmod,
define	TRACE2( )	TRC(2,TME_DB,(tws, 2, TME_DB,
		TME_trcmod,
define	TRACE3( )	TRC(3,TME_DB,(tws, 3, TME_DB,
		TME_trcmod,
define	TRACE4( )	TRC(4,TME_DB,(tws, 4, TME_DB,
		TME_trcmod,
define	TRACE5( )	TRC(5,TME_DB,(tws, 5, TME_DB,
		TME_trcmod,
elif	GIID
....

[0089] In the following example, TME_CO/TME_DB/ . . . are the constants associated to each component. 01, 02, 03, 04, . . . , 27 are the component id appearing as the first field of the trace line as illustrated in FIG. 3.

	define	TME_CO	0x01
	define	TME_DB	0x02
	define	TME_GI	0x03
	define	TME_CC	0x04
	...
	define	TME_INOUT	0x27

[0090] TRC macro definition into co_trc C function, depending on per-component trace level:

define TRC(1,c,p)
	if (co_trc_test(tws, 1, c) TRUE)
	co_trc p;
co_trc C function definition:
DC_VOID co_trc(DC_VOID* tws, DC_USHORT level, DC_USHORT comp, DC_CHAR* module,
	DC_CHAR* format, ...)
/*****************************************************************************/
/* Description:	*/
/* Write the trace message to the trace file.	*/
/* Parameters:	*/
/* tws	*/
*/ level	*/
/* comp	*/
/* module	*/
/*****************************************************************************/
	va_list arg_ptr;
	va_start(arg_ptr, format);
	vsprintf(TME_TCB>trc_txt, format, arg_ptr);
	...

[0091] Depending of which trace level is set for the overall product, or which trace level is set for each specific component, the execution of each C function gives a contribution to the trace file, according to the trace macros are executed during the processing.

[0092] Like in any other trace analyzer tool, the trace analyzer of the preferred embodiment access the trace file and can sort or group or filter the trace lines by component, process, thread, time each field of a trace line as described in FIG. 3. The trace analyzer uses Microsoft Windows GUI or any Unix Graphic Terminal in the preferred embodiment.

[0093] In FIG. 4 is provided the print screen displayed on the screen of the trace analyzer of the preferred embodiment. The example provided is extracted form a 1 Mbyte trace file containing the trace lines for the execution of a series of C functions nested in different threads. On the screen is represented the Process thread (400) identified by the id 210-227 stored in the trace records (330). This screen has been displayed after a startup dialog (a menu can be used as well) via the GUI has allowed the user to choose the process and/or thread execution he wants to analyze. On the left part of the screen is represented the tree structure (410) formed by a representation on the screen of the C functions nested in thread 210-227. In this example the C functions are represented by their name. The C function representations form the nodes of the tree. Each node is created by reading the ENTRY, QUIT and EXIT macro lines. The leafs attached to each node correspond to the TRACE macro line messages. Each triangle at left side of the node identifies a C function. The triangles are either red or green. When red, this means the C function execution failed. When the triangle is green the C function was executed successfully. Two other signs are used at the left side of each triangle. Clicking on a specific node name in the tree structure representation, the node structure, is expanded and the

[0094] is displayed on the left side of the node triangle. When the node structure is expanded, all the nested functions are displayed as child tree nodes. The node structure can be collapsed again by clicking a second time on the node name. In this case the O- sign appears on the left side of the node triangle. In the top right portion of the screen (420) an expanded view of the trace messages generated during the execution of the co_geth_secq C function is displayed. This expansion is for the failing execution of the co_geth_secq C function located at the thirteenth line of the tree structure displayed on the left of the screen. The co_geth_secq C function includes the nested co_get_signal C function for which the trace messages are displayed as well in the top right side of the screen. The bottom right part of the screen (430) contains the code lines corresponding to the C function for which the messages have been displayed in the top right part of the screen. By viewing this code lines, the programmer can understand the error and fix it. Still using the facilities of GUI, the man skilled in the art could also add to this screen a line of commands for activation of other useful services such as sorting or grouping or filtering the trace lines in the trace file by component, process, thread or any other field in trace lines. In the preferred embodiment the GUI being written in Java, there is no need of an intermediate file result of filtering, grouping or sorting. With the -mx switch of the Java Virtual Machine (JVM), one can ask as much memory as is needed (50 MB to 100 MB for instance) and navigation is fast.

[0095] FIG. 5 is the flow chart of method implemented in the trace analyzer of the preferred embodiment to display the tree structure of the nested C function on the screen as described in FIG. 4. The flow chart is a loop for reading the trace file lines. A trace line is read (500), if the end of file is reached (test 505) the algorithm is ended (510). If the end of file is not reached the trace line is tested (test 515) to see if it has been generated by an ENTRY trace macro. If this is an ENTRY trace macro line, a new child tree node is attached (logically) to the current parent node and displayed on the screen (520) with the name of the C function; then, the child node becomes the current node and the next trace line is read (500). If the trace line tested is not an ENTRY trace macro line, the trace line is tested (test 525) to see if it has been generated by a QUIT trace macro. If it is a QUIT trace macro, the triangle in front of the C function name in the tree structure displayed on the screen is colored in red (530) to advise that the C function execution has failed. The parent tree node becomes the current node (535) and a new trace line is read (500). If the trace line tested is not a QUIT trace macro line, the trace line is tested (test 540) to see if it has been generated by an EXIT trace macro. If the trace line tested is an EXIT trace macro line, the triangle in front of the C function name in the tree structure displayed on the screen is colored in green (545) to advise of the successful execution of the C function, the parent tree node becomes the current node and a new trace line is then read. If the trace line tested is not an EXIT trace macro line, this means that this is a TRACE macro line, then, a new leaf is attached to the current node, the message attached to this leaf is stored and will be displayed on the screen (550). As described in FIG. 4 the leafs are displayed in the top right part of the screen when the user requires it. Then, a next trace line is read (500).