Once a PC from a hardware counter event corresponding to a precise memory operation has been found, Performance Analyzer uses instruction identifiers and descriptors provided by the compiler in its hardware profiling support information to derive the associated program data object.
The term data object is used to refer to program constants, variables, arrays and aggregates such as structures and unions, along with distinct aggregate elements, described in source code. Depending on the source language, data object types and their sizes vary. Many data objects are explicitly named in source programs, while others may be unnamed. Some data objects are derived or aggregated from other (simpler) data objects, resulting in a rich, often complex, set of data objects.
Each data object has an associated scope, the region of the source program where it is defined and can be referenced. This scope might be global (such as a load object), a particular compilation unit (an object file), or a function. Identical data objects might be defined with different scopes, or particular data objects referred to differently in different scopes.
Data-derived metrics from hardware counter events for memory operations collected with backtracking enabled are attributed to the associated program data object type. These metrics propagate to any aggregates containing the data object and the artificial <Total>, which is considered to contain all data objects (including <Unknown> and <Scalars>). The different subtypes of <Unknown> propagate up to the <Unknown> aggregate. The following section describes the <Total>, <Scalars>, and <Unknown> data objects.
Data objects are fully described by a combination of their declared type and name. A simple scalar data object {int i} describes a variable called i of type int, while {const+pointer+int p} describes a constant pointer to a type int called p. Spaces in the type names are replaced with underscore (_), and unnamed data objects are represented with a name of dash (-), for example, {double_precision_complex -}.
An entire aggregate is similarly represented {structure:foo_t} for a structure of type foo_t. An element of an aggregate requires the additional specification of its container, for example, {structure:foo_t}.{int i} for a member i of type int of the previous structure of type foo_t. Aggregates can also themselves be elements of (larger) aggregates, with their corresponding descriptor constructed as a concatenation of aggregate descriptors and, ultimately, a scalar descriptor.
While a fully qualified descriptor might not always be necessary to disambiguate data objects, it provides a generic complete specification to assist with data object identification.
The <Total> data object is an artificial construct used to represent the program’s data objects as a whole. All performance metrics, in addition to being attributed to a distinct data object (and any aggregate to which it belongs), are attributed to the special data object <Total>. It appears at the top of the data object list. Its data can be used to give perspective to the data for other data objects.
While aggregate elements have their performance metrics additionally attributed into the metric value for their associated aggregate, all of the scalar constants and variables have their performance metrics additionally attributed into the metric value for the artificial <Scalars> data object.
Under various circumstances, event data can not be mapped to a particular data object. In such cases, the data is mapped to the special data object named <Unknown> and one of its elements as follows:
Module with trigger PC not compiled with -xhwcprof
No event-causing instruction or data object was identified because the object code was not compiled with hardware counter profiling support.
Backtracking failed to find a valid branch target
No event-causing instruction was identified because the hardware profiling support information provided in the compilation object was insufficient to verify the validity of backtracking.
Backtracking traversed a branch target
No event-causing instruction or data object was identified because backtracking encountered a control transfer target in the instruction stream.
No identifying descriptor provided by the compiler
The compiler did not provide data object information for the memory-referencing instruction.
No type information
The compiler did not identify the instruction as a memory-referencing instruction.
Not determined from the symbolic information provided by the compiler
The compiler did not have symbolic information for the instruction. Compiler temporaries are generally unidentified.
Backtracking was prevented by a jump or call instruction
No event-causing instructions were identified because backtracking encountered a branch or call instruction in the instruction stream.
Backtracking did not find trigger PC
No event-causing instructions were found within the maximum backtracking range.
Could not determine VA because registers changed after trigger instruction
The virtual address of the data object was not determined because registers were overwritten during hardware counter skid.
Memory-referencing instruction did not specify a valid VA
The virtual address of the data object did not appear to be valid.