Sun Microsystems, Inc.

Oracle America, Inc.

Oracle International Corporation

Nicolai Kosche

Peter Carl Damron

Martin S Itzkowitz

Christopher P Aoki

Brian J Wylie

Adam R Talcott

Kenneth Tracton

Douglas E Walls

Robert Cypher

Gregory Frederick Grohoski

Joseph I Chamdani

Paul Joseph Jordan

Mario I Wolczko

Partha P Tirumalai

Sanjay Patel

Andrew G Tucker

Erik Nordmark

John P Petry

James Laudon

Bart Smaalders

Farnad Sajjadian

Jarrett J Lu

Oleg V Mazurov

Yukon L Maruyama

Arpana Jayaswal

David D Pagan

Sidney J Hummert

Milton E Barber

Jeff Bonwick

Dave Singleton

A system and method for profiling a software application may include means for operating on context-specific data and costs. The system may include a descriptor apparatus for specifying identifiers of extended address elements to be profiled and locations for storing corresponding data values. In some embodiments, a list of variables to be included in profiling may be registered with an event agent and values of the variables may be captured in response to detection of a system event. Registering variables to be profiled may involve conveying a list of the variables or a pointer to such a list to the event agent. The event agent may associate the values of the registered variables with the detected system event and may store them in an event space database. The database may be accessed by a data space profiler to identify performance bottlenecks dependent on one or more registered variable values.

Method and apparatus for associating user-specified data with events in a data space profiler

A system and method for profiling runtime system events of a computer system may include associating a data source type with detected system events. The system events may be detected dependent on information included in a reply message received by a processor in response to a data request or other transaction request message. The reply message may include information characterizing a source type of a source of data included in the reply message. The source type information may indicate that the source is remote or local; that it is a shared or a private storage location; that the data is supplied via a cache-to-cache transfer; or that the data is sourced from a coherency domain other than that of the requesting process. Instructions, events, messages, and replies may be sampled, and extended address information corresponding to the samples may be stored in an event set database for performance analysis.

Apparatus and method for profiling system events in a fine grain multi-threaded multi-core processor

A data space profiler may include an analysis engine that associates runtime events of profiled software applications with execution costs and extended address elements. Relational agents in the analysis engine may apply functions to profile data collected for each event to determine the extended address element values to be associated with the event. Each extended address element may correspond to a data profiling object (e.g., hardware component, software construct, data allocation construct, abstract view) involved in each event. The extended address element values may be used to index into an event set for the profiled software application to present costs from the perspective of these profiling objects. A filtering mechanism may also be used to extract profile data from the event set corresponding to events that satisfy the filter criteria. By alternating between presentation of profiling object views and filtered event data, performance bottlenecks and their causes may be identified.

Method and apparatus for specification and application of a user-specified filter in a data space profiler

A system and method for profiling a network application may provide for operating on context-specific data and costs. The system may include an apparatus for associating local extended address elements with a message sent from a first computing system to a second computing system across a network. The second computing system may store the received information as remote extended address information and may store its own local extended address information. An event agent may capture values of local and/or remote extended address elements in response to detecting the message or another system event and may associate the extended address elements with the message or system event in an event set accessible by a data space profiler. The extended address information may include time stamps. An event agent may determine network latency dependent on time stamps of messages and may generate an event if the latency exceeds a predetermined threshold.

Method and apparatus for data space profiling of applications across a network

A system and method for profiling a software application may include means for capturing profiling information corresponding to an instruction identified as having executed coincident with the occurrence of a runtime event, and for associating the profiling information with the event in an event set. In some embodiments, the identified instruction, which may have triggered the event, may be located in the program code sequence at a predetermined position relative to the current program counter value at the time the event was detected. The predetermined relative position may be fixed dependent on the processor architecture and may also be dependent on the event type. The predetermined relative position may be zero, indicating that when the event was detected, the program counter value corresponded to an instruction associated with the event. If the identified instruction is an ambiguity-creating instruction, an indication of ambiguity may be associated with the event.

Method and apparatus for identifying instructions associated with execution events in a data space profiler

A data space profiler may include a graphical user interface (GUI) for sorting, aggregating and displaying profile data associated with runtime events of a profiled software application. This profile data may include costs associated with events as well as extended address elements and other code behavior attributes associated with them. The GUI may include means for selecting a perspective from which cost data is to be presented as well as presentation options for displaying the data. The presentation options may include panning and zooming options, which may determine how the data is sorted and/or aggregated for display. The GUI may also include means for specifying filter criteria, which may be used to determine which data to display. By providing means to alternate the display of profile data according to different perspectives and filtering criteria, the GUI may facilitate identification of performance bottlenecks of the profiled application and the causes thereof.

Method and apparatus for sorting and displaying costs in a data space profiler

A system and method for performance monitoring may use data collected from a hardware event agent comprising a hardware sampling mechanism and/or one or more hardware counters to increment one or more synthesized performance counters by an amount dependent on an expression involving the collected data. Each synthesized performance counter may be configured to count events of a different type and may comprise a machine addressable storage location. The event types may include various memory references or misses, branches, branch mispredictions, or any other event of interest in performance monitoring. The hardware event agent may comprise one or more instruction counters, cycle counters, timers, or other hardware performance counters. One hardware performance counter may be used in a time-multiplexed or data-multiplexed manner to monitor events of multiple event types. The hardware sampling mechanism may return a statistical packet for sampled instructions, which may be examined to determine the event type.

Method and apparatus for synthesizing hardware counters from performance sampling

Correlating profile data facilitates sophisticated code optimization. Going beyond one to one relationships between code execution hindrances and single code behavior attributes provides insight into code behavior at a finer level of granularity. The capability to aggregate profile data based on multiple code behavior attributes and filter based on instances thereof, allows code optimization decisions to be made based on presentation of profile data from various perspectives. Profile data, which includes code behavior attributes correlated with code execution hindrances, is aggregated based at least in part on a first code behavior attribute. Code behavior attributes include one or more of memory references, memory reference objects, functions, time ranges, processors, processes, threads, and source-level data objects. The aggregated profile data is filtered based on an instance of the first code behavior attribute. The filtered profile data is then aggregated based on one or more additional code behavior attributes.

Method and apparatus for correlating profile data

A system and method for profiling a software application may include means for defining a custom cost metric that includes a cost metric identifier and a cost function. The cost function may apply a mathematical formula to data extracted from an event set to calculate a respective cost metric value for each of one or more events in the event set. The data extracted from the event set may include one or more respective profiling object identifiers and one or more other respective costs associated with each of the one or more events. A cost associated with an event in the event space may be associated with a function or basic block of instructions. The cost function may include a distribution formula for attributing at least a portion of the cost associated with a function or basic block to each of the instructions comprising the function or basic block.

Method and apparatus for computing user-specified cost metrics in a data space profiler

Data address profiling allows determination of sources of code execution hindrance with different perspectives of memory references and allows correlation of sampled runtime events and memory reference objects, such as cache lines. Associating sampled runtime events with data addresses provides for efficient and targeted optimization of code with respect to data addresses and physical and/or logical memory reference objects (e.g., memory segments, heap variables, variable instances, stack variables, etc.). An instruction instance is identified in relation to a sampled runtime event. A data address is determined from the instruction instance. From the determined address, a memory reference object is ascertained.

Method and apparatus for profiling data addresses

A system and method for precisely identifying an instruction causing a performance-related event is disclosed. The instruction may be detected while in a pipeline stage of a microprocessor preceding a writeback stage and the microprocessor's architectural state may not be updated until after information identifying the instruction is captured. The instruction may be flushed from the pipeline, along with other instructions from the same thread. A hardware trap may be taken when the instruction is detected and/or when an event counter overflows or is within a given range of overflowing. A software trap handler may capture and/or log information identifying the instruction, such as one or more extended address elements, before returning control and initiating a retry of the instruction. The captured and/or logged information may be stored in an event space database usable by a data space profiler to identify performance bottlenecks in the application containing the instruction.

Method and apparatus for precisely identifying effective addresses associated with hardware events

Including source-level data object information in code profiling data enhances code optimization because it provides new perspectives to view code behavior. A method provides for identifying an operation instance of code that corresponds to a runtime event, which is detected in execution of the code. The detected event is attributed to a source-level data object that corresponds to a source-level representation of a language construct. The attribution is based on a predefined association between the identified operation instance and the language construct of the source-level representation that corresponds to the source-level data object.

Method and apparatus for data object profiling

Associating data source information with sampled runtime events allows identification of system components related to the sampled runtime events. Code can be optimized from the perspective of system components and for various architectures. A system provides a data source indication. The system associates the data source indication with a corresponding instruction instance. The instruction instance is related to a sampled runtime event, and the sampled runtime event is associated with the data source indication. The data source information and associated sampled runtime event can be supplied for profiling code.

Associating data source information with runtime events

Operations including inserted prefetch operations that correspond to addressing chains may be scheduled above memory access operations that are likely-to-miss, thereby exploiting latency of the 'martyred' likely-to-miss operations and improving execution performance of resulting code. More generally, certain pre-executable counterparts of likely-to-stall operations that form dependency chains may be scheduled above operations that are themselves likely-to-stall.

Aggressive prefetch of address chains

By maintaining consistency of instruction or operation identification between code prepared for profiling and that prepared using profiling results, efficacy of profile-directed code optimizations can be improved. In particular, profile-directed optimizations based on stall statistics are facilitated in an environment in which correspondence maintained between (i) instructions or operations whose execution performance may be optimized (or which may provide an opportunity for optimization of other instructions or operations) and (ii) particular instructions or operations profiled.

Growing community of inventors

San Francisco, CA, United States of America

Nicolai Kosche