An Apple patent (number 20100199266) involving software fingerprinting has appeared at the US Patent & Trademark Office. It relates generally to analyzing software performance, and more particularly, to a system, method, and program for graphically presenting code execution data in order to quickly identify of areas of code which may represent opportunities for optimization.
A system, method, and computer program for analyzing code execution and software performance characteristics are disclosed. Samples of executing code may be taken based on any of a number of various triggers. For example, samples may be triggered based on function calls, such as malloc calls. Alternatively, samples may be triggered based on occurrence of a specified event. Code execution is graphically displayed such that certain patterns may be easily identified. Multiple redundant function calls and areas of code having excessively deep function calls can be readily spotted. Such areas represent opportunities for performance optimization. The inventors are Christinia E. Warren, Sanjay K. Patel and Nathan Slingerland.
Here’s Apple’s summary of the invention: “In analyzing software performance, the impact of an operation on performance may be considered as a function of cost(operation)*use(operation). Traditional performance tools concentrate more on cost than on use. While prior art tools provide information about where time is being spent and how often functions are called, they do not provide any indication of how the function was called during program execution. To better understand a program’s behavior so as to provide insight into how a program may be optimized, use-based tracing would be desirable.
“A need therefore exists for a system, method, and tool for analyzing software performance characteristics that overcomes the limitations of the prior art. The present invention improves upon the prior art by presenting code execution information in such a way that conveys information pertaining to function usage. The present invention provides for the visual display of code execution data such that repetitive patterns and excessively deep function calls can be readily identified as areas in need of improvement (i.e., areas having suspect performance). Thus, the present invention allows for quick and efficient analysis of code execution by quickly finding areas of code that can be improved in order to optimize software performance.
“In accordance with certain embodiments of the present invention, a system, method, and program for analyzing code execution are provided, wherein a number of samples are taken of the code during run-time. For each sample, the program’s stack backtrace and other information can be recorded. In accordance with the present invention, sampling is not limited to time-based sampling. Samples may also be taken based on the occurrence of a specified function call (function call sampling). For example, samples may be taken based on the occurrence of a memory allocation call (memory allocation sampling).
“Samples may also be taken based on a specified hardware or operating system (‘OS’) event such as a crash, page fault, cache miss, instruction stall, or other event of interest (event sampling). A system trace may also be performed in order to understand scheduling behavior. A Java trace may also be performed in order to provide time/allocation tracing in Java. In time-based profiling, each sample may be displayed graphically as a plot of callstack depth versus time. For event-based sampling, each sample may be displayed as a plot of callstack depth versus event number. For malloc-based (i.e., memory-allocation-based) or other function-call-sampling or event-based sampling, each sample may be displayed as a plot of callstack depth versus sample number.
“By graphically displaying code execution chronologically, certain patterns in the code execution paths may be quickly and easily identified. Such patterns represent specific call patterns through the code. For example, repeated patterns in a graph in accordance with the invention indicates loops that walk through the same functions. Once recognized as an area in need of improvement, such areas may be optimized by, for example, removing invariant calculations from within a loop. Furthermore, areas of code having excessively deep function calls can be readily spotted. Such areas generally represent inefficient call sequences which can likely be improved to optimize performance. Oftentimes, dramatic performance gains may be achieved by optimizing only a small number of key functions which are responsible for the vast majority of CPU time used by a program.”
