Capturing and displaying computer program execution timing

Details Capturing and displaying computer program execution timing Capturing and displaying computer program execution timing

1997-10-02

2001-12-18

Powell, Mark R. (Department: 2122)

Data processing: software development, installation, and managem

Software program development tool

Translation of code

C717S152000

Reexamination Certificate

active

06332212

ABSTRACT:

A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent disclosure, as it appears in the Patent and Trademark Office patent files or records, but otherwise reserves all copyright rights whatsoever.
FIELD OF THE INVENTION
The present invention relates generally to computer software, and more specifically to displaying the execution timing of a computer program.
BACKGROUND OF THE INVENTION
The performance characteristics of a computer depend largely on the speed with which the software programs are executed. Although fast hardware increases program execution speed, performance increases can often be realized by optimizing the program code itself. Such optimization involves writing programs to execute efficiently and to take full advantage of available hardware resources. The performance of a particular program depends largely on the specific implementation or computer environment for which it is written, however performance bottlenecks that degrade performance may involve one or more common problems. These problems include useless computation produced by code that has been refined but not removed, needless re-computation caused by program modules that recompute values rather than storing results for later use, excessive or unnecessary requests for services that waste time on the service and incur large context switch times, and waiting for services requests to complete.
These bottlenecks provide opportunities for software engineers to increase program execution performance. For example, reducing the number of service or subprogram calls, or eliminating useless calls entirely may effectively reduce the bottlenecks associated with unnecessary computations. Likewise, caching a result for later reuse prevents the need to re-execute an operation.
Optimization of software code to increase program execution performance thus requires an accurate diagnosis and identification of the problems contributing to the execution bottlenecks. Although such diagnosis could be undertaken by a skilled programmer who can study the code to identify potential problem areas, this is an unrealistic approach for most computer programs. Manual processes for diagnosing program execution, such as timing how long a specific region of code takes to execute (either with a hand-held stopwatch, or by inserting additional software to read the computer's timer at places of interest), or by observing external indicators controlled by the software (alarms, LED indicators, etc.), are also available. Though effective, these techniques may be very tedious, since they require manual modification of the source code, and require a great deal of user attention. These constraints become greatly limiting on larger programs as the amount of information generated may become overwhelming. Furthermore, these manual methods provide no visibility into the internal operation of the software unless they have some external manifestation.
Most computer programs are complex structures involving hundreds of thousands of lines of code with nested operations, subroutines, and calls to various system resources. Furthermore, sophisticated programs are typically written in high level languages (e.g., Pascal, C, C++) that hide implementation details from the user. These make the performance implications of code writing much less apparent to the programmer. Thus, the programmer typically has very little insight into the performance characteristics of program code as it is being written. Furthermore, very few tools are available which allow a programmer to analyze the performance of the program after it is written to pinpoint specific bottlenecks in program execution. The software tools that are presently available to help an engineer analyze the execution of a particular section of code generally involve taking a statistical sampling and accumulating the total amount of time a program spends in specific sub-routines. Although these methods may accurately show the total amount of time a program spent in a sub-routine, they do not allow the programmer to observe the sequencing of operations and the relationships among hierarchical programs and subroutines. Also, these methods provide no straightforward insight into the coordination of multiple, cooperating processes. These sequences and hierarchical relationships are especially important when the software is controlling external instrumentation, as in industrial control or embedded system software. Furthermore, these methods generally require the recompiling or rebuilding of the software, which may be a very tedious and time-consuming task.
Although the problems described with regard to present software analysis programs apply generally to all computer software, the performance and bottleneck problems are especially acute in test program applications. Test programs, such as those used in Very Large Scale Integrated (VLSI) device test machines involve often complex hierarchical routines for the testing of various devices and operating parameters. Because test costs are often a large portion of the cost of integrated circuit devices, tests that take a long time to execute because of bottlenecks in the test code may add significantly to the cost of these devices.
SUMMARY AND OBJECTS OF THE INVENTION
One of the objects of the present invention is to provide a programmer with a graphical time-line representation of the execution sequence of a computer program or subroutine.
Another of the objects of the present invention is to provide a stack-nested representation in the time domain of the execution of a program to clearly show timing relationships among hierarchical portions of code, such as subroutines and loops within the program.
A further object of the present invention is to provide a stacked representation in the time domain across multiple processes (or processors), to clearly show program execution and stack nesting for several different programs, or concurrence amongst multiple processes.
A yet further object of the present invention is to display timeline and nested data as waveform patterns on a computer display device through a graphical user interface.
A method of displaying the execution timing of a hierarchically organized computer program with one or more subprograms is described. The time duration for execution of each of the subprograms within the computer program is measured. The execution time duration for the subprograms are represented as graphic objects, such that each of the graphic objects corresponds to the execution time of a specific subprogram. The graphic objects are then displayed on a display device. A first characteristic of the graphic objects represents the execution time duration for the corresponding subprogram, and a second characteristic of the graphic objects represents the hierarchical relationship among the subprograms within the program.
Other objects, features, and advantages of the present invention will be apparent from the accompanying drawings and from the detailed description that follows below.


REFERENCES:
patent: 3962685 (1976-06-01), Belle Isle
patent: 5168554 (1992-12-01), Luke
patent: 5442740 (1995-08-01), Parikh
patent: 5530373 (1996-06-01), Gibson et al.
patent: 5581696 (1996-12-01), Kolawa et al.
patent: 5732272 (1998-03-01), Gochee
patent: 5768500 (1998-06-01), Agrawal et al.
patent: 5832289 (1998-11-01), Shaw et al.
patent: 5903730 (1999-05-01), Asai et al.
Anthony R. Taylor, “An Analysis of ATE Computational Architecture,” LTX/Trillium (prior to Jul. 1997).
Pure Atria, “Performance Engineering”, pp. 1-10 (1995-1997).
Pure Atria, “Quantify Product Overview”, p. 1 (1995-1997).
Pure Atria, “What's New in Quantify 3.0”, pp. 1-2 (1995-1997).
Pure Atria, “Quantify Data Sheet”, pp. 1-2 (1995-1997).
Coffee, HiProf polishes profiles, PC Weeks, v14, n40, p48(1), 09,1997.*
Pure Atria, “Viewing Your Data with Quantify,” pp. 1-3 (1995-1997).
Deltamaster Product Description, LTX Trillium D

Affiliated with

Also associated with

Rating

Capturing and displaying computer program execution timing does not yet have a rating. At this time, there are no reviews or comments for this patent.

If you have personal experience with Capturing and displaying computer program execution timing, we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Capturing and displaying computer program execution timing will most certainly appreciate the feedback.

Rate now

Comments { 0 }

Profile ID: LFUS-PAI-O-2577326