Abstract: A method and apparatus for identifying a minimum call tree data structure from a plurality of call tree data structures are provided. With the apparatus and method, call tree data structures are generated for two or more executions of a build of a computer program. The apparatus and method perform a “tree-minimization” operation in which the two or more call trees generated during runs of the computer program are walked and only those nodes that are present in each of the tree data structures are maintained in a minimized tree data structure. In addition, the minimum values for these common nodes are maintained in the minimized tree data structure. In this way, asynchronous events are removed from the minimum tree data structure and analysis may focus on those areas of the computer program that are consistent between runs of the computer program.

Abstract: Hardware assist to autonomically patch code. The present invention provides hardware microcode to a new type of metadata to selectively identify instructions to be patched for specific performance optimization functions. The present invention also provides a new flag in the machine status register (MSR) to enable or disable a performance monitoring application or process to perform code-patching functions. If the code patching function is enabled, the application or process may patch code at run time by associating the metadata with the selected instructions. The metadata includes pointers pointing to the patch code block code. The program code may be patched autonomically without modifying original code.

Abstract: Illustrative embodiments disclose presenting coverage data relating to data access occurring during execution of code. The coverage data containing data access indicators associated with memory locations is obtained. The data access indicators that have been set by a processor in the data processing system in response to access of the memory locations during execution of the code by the processor are identified to form set data access indicators. Each set instruction access indicator is associated with a portion of the memory locations allocated for the code. A presentation for coverage data is generated, wherein the set data access indicators are identified in the presentation.

Abstract: A method, an apparatus, and a computer program product in a data processing system are presented for using hardware assistance for gathering performance information that significantly reduces the overhead in gathering such information. Performance indicators are associated with instructions or memory locations, and processing of the performance indicators enables counting of events associated with execution of those instructions or events associated with accesses to those memory locations. The performance information that has been dynamically gathered from the assisting hardware is available to the software application during runtime in order to autonomically affect the behavior of the software application, particularly to enhance its performance. For example, the counted events may be used to autonomically collecting statistical information about the ability of a software application to successfully acquire a semaphore.

Abstract: An improved method, apparatus, and computer instructions for generating trace data. In response to detecting a new trace event, a determination is made as to whether the new trace event occurred at an expected period of time with respect to a prior trace event. A time stamp in the trace data is placed in response to a determination that the new trace event did not occur at the expected period of time, wherein time stamps occurring at the expected period if time are eliminated from the trace data and wherein compression of the trace data occurs.

Abstract: An improved method, apparatus, and computer instructions for generating trace data. In response to detecting a trace event, a determination is made as to whether identifiers for the trace event match recorded identifiers for a record in a set of previously recorded trace events. Location information for the record is placed in the trace data if a match between identifiers for the trace event and recorded identifiers for the record in the set of previously recorded trace events.

Abstract: An improved method, apparatus, and computer instructions for generating trace data. In response to detecting a new trace event, a determination is made as to whether the new trace event occurred at an expected period of time with respect to a prior trace event. A time stamp in the trace data is placed in response to a determination that the new trace event did not occur at the expected period of time, wherein time stamps occurring at the expected period if time are eliminated from the trace data and wherein compression of the trace data occurs.

Abstract: A method and system for tracing profiling information using per thread metric variables with reused kernel threads is disclosed. In one embodiment kernel thread level metrics are stored by the operating system kernel. A profiler request metric information for the operating system kernel in response to an event. After the kernel thread level metrics are read by the operating system for a profiler, their values are reset to zero by the operating system kernel. The profiler then applies the metric values to base metric values to appropriate Java threads that are stored in nodes in a tree structure base on the type of event and whether or not the kernel thread has been reused. In another embodiment non-zero values of thread level metrics are entered on a liked list. In response to a request from a profiler, the operating system kernel reads each kernel thread's entry in the linked list and zeros each entry.

Abstract: An improved method, apparatus, and computer instructions for generating trace data. In response to detecting a trace event, a determination is made as to whether identifiers for the trace event match recorded identifiers for a record in a set of previously recorded trace events. Location information for the record is placed in the trace data if a match between identifiers for the trace event and recorded identifiers for the record in the set of previously recorded trace events.

Abstract: An improved method, apparatus, and computer instructions for generating trace data. In response to detecting a new trace event, a determination is made as to whether the new trace event occurred at an expected period of time with respect to a prior trace event. A time stamp in the trace data is placed in response to a determination that the new trace event did not occur at the expected period of time, wherein time stamps occurring at the expected period if time are eliminated from the trace data and wherein compression of the trace data occurs.

Abstract: A method and system for detecting and counting bytecode sequences in a data processing system is provided. A bytecode tree data structure is used to represent sequences of bytecodes. A bytecode sequence is a subset of consecutive bytecodes within the set of bytecodes. The bytecode tree data structure contains a set of nodes in which each node represents a bytecode in a bytecode sequence or subsequence and in which a path through the bytecode tree data structure represents a bytecode sequence or subsequence. Each node of the bytecode tree data structure records one or more bytecode occurrence statistics for its corresponding bytecode in a set of bytecode sequences or subsequences. In order to determine the frequency of occurrence of common bytecode sequences and subsequences, a bytecode sequence tree data structure is generated from a set of bytecode sequences.

Abstract: A method and system for monitoring performance of a program using global metric variables to provide the support in an symmetric multiprocessor (SMP) system. A Java virtual machine (Jvm) either calls the profiler whenever bytes are allocated or provides an interface to allow the profiler to determine the value of the change in the metric for the current thread. The profiler then applies the changes to a metric for the current thread. Alternatively, per processor data areas are maintained for storing per processor metric values. Whenever a thread switch occurs or there is a request for the metric on a specified thread, an operating system kernel updates the thread level metric values with changes in the values per processor metrics.

Abstract: The value of non-discrete metric variables are synchronized at the processor level. When the profiler requests metric information for non-discrete metric variables, the operating system kernel obtains a global value for the requested metric rather than obtaining per-processor metric values for each processor. The global value may be written to trace records. By using a single global per-processor metric for all processors, a single global value of the last metric variable may be used for calculating the resources consumed on all processors since a last recorded event.

Abstract: A program is profiled with enablement of trace record generation during a first period of time and with disablement of trace record generation during a second period of time. The number of trace records output during the first period of time is determined, and a trace overhead calibration value is computed as an average time for writing the number of trace records output during the first period of time. The trace overhead calibration value may be stored for subsequent use in a profiling-related process in the data processing system. The trace overhead compensation value represents the amount of time required to generate a trace record, and the trace times retrieved from the trace records are adjusted to compensate for the amount of time required to generate those trace records.

Abstract: A user may specify a vector of metrics to be used while profiling a program. The vector of metrics may optionally be thread-relative. In response to a notification of an occurrence of the current event, a thread-relative elapsed metric is computed by: determining a current thread; retrieving a stored reference metric for the preceding event of the current thread; obtaining a current reference metric; and computing the thread-relative elapsed metric as a difference between the current reference metric and the stored reference metric. In order to prevent the generation of redundant metric information, the information associated with the vector of metrics maybe placed into the trace records in several different space-saving formats.

Abstract: An apparatus and method for cataloging symbolic data for use in performance analysis of computer programs is provided. The apparatus and method stores symbolic data for loaded modules during or shortly after a performance trace and utilizes the stored symbolic data when performing a performance analysis at a later time. A merged symbol file is generated for a computer program, or application, under trace. The merged symbol file contains information useful in performing symbolic resolution of address information in trace files for each instance of a module. During post processing of the trace information generated by a performance trace of a computer program, symbolic information stored in the merged symbol file is compared to the trace information stored in the trace file. The correct symbolic information in the merged symbol file for loaded modules is identified based a number of validating criteria.

Abstract: A method and system for detecting memory leaks in an object-oriented environment during real-time trace processing is provided. During the profiling of a program executing in a data processing system, a profiler processes events caused by the execution of the program, and the profiler maintains a profile data structure containing execution-related metrics for the program. The execution-related metrics may include object allocation and deallocation metrics that are associated with object processing initiated on behalf of an executing method. An object allocator allocates objects during the execution of the program and modifies object allocation metrics in the profile data structure. Object metrics are stored in a particular location and a pointer to that location is stored in a hash table associated with the object's ID. In another embodiment the pointer to the location is stored in a shadow heap in the same relative position as the position of the object in the heap.

Abstract: A method and system for detecting and recovering from errors in trace data is provided. The trace data records selected events for executing routines, and the routines corresponding to the events are represented as one or more nodes in a tree structure. The events may be entries and exits to executing methods. A trace record identifying a routine is read, and an error condition is detected in which the identified routine does not match a routine corresponding to a current node in the tree structure. The tree structure is searched for a node that corresponds to the identified routine. Performance statistics, such as execution time, are attributed to nodes in the tree structure. In response to a determination that the current node is a root node of the tree structure, then a new node for the identified routine is added to the tree structure as a child node of the root node and spliced into the tree at the root node.

Abstract: A method and system for compensating for output overhead in trace data is provided by analyzing and compensating for the overhead associated with outputting trace information to a trace buffer or a trace file in the form of trace records. A trace record represents an occurrence of some profiling event of interest. Each trace record contains a starting timestamp representing the time at which the generation of the trace record was commenced and an ending timestamp representing the time at which the generation of the trace record was completed. In order to compute the period of execution time attributable to the application program or system being profiled, a starting timestamp of a trace record is compared with the ending timestamp of a preceding trace record, and the difference between the timestamps is directly related to the execution time of the application program or system being profiled.

Abstract: A method and system for detecting memory leaks in an object-oriented environment during real-time trace processing is provided. During the profiling of a program executing in a data processing system, a profiler processes events caused by the execution of the program, and the profiler maintains a profile data structure containing execution-related metrics for the program. The execution-related metrics may include object allocation and deallocation metrics that are associated with object processing initiated on behalf of an executing method. An object allocator allocates objects during the execution of the program and modifies object allocation metrics in the profile data structure. An object deallocator, such as a garbage collector, deallocates objects during the execution of the program and modifies object deallocation metrics in the profile data structure. The object allocation metrics and the object deallocation metrics may be compared to identify memory leaks.