Bugs & Wishes
Cost Entities known to KCachegrind
An assembler instruction at a specified address.
- Source Line of a Function
All instructions that the compiler (via debug information) maps to a given source line specified by source file name and line number, and which are
executed in the context of some function. The latter is needed because
a source line inside of an inlined function can appear in the context of multiple functions. Instructions without any mapping to an actual
source line are mapped to line number 0 in file "???".
- Adress Range, Source Range
Either all instructions mapping into a range of addresses, or all source
lines in a given range of source line numbers.
All source lines of a given function make up the function itself.
A function is specified by its name and its location in some binary object
if available. The latter is needed because binary objects of a single
program each can hold functions with the same name (these can be accessed
e.g. with dlopen/dlsym; the runtime linker resolves functions in a given
search order of binary objects used).
If a profiling tool can not detect the symbol name of a function, e.g. because debug information is not available, either the address of the first executed instruction typically is used, or "???".
- Binary Object
All functions whose code is inside the range of a given binary object, either
the main executable or a shared library.
- Source File
All functions whose first instruction is mapped to a line of the
given source file.
Symbol names of functions typically are hierarchically ordered in name spaces,
e.g. C++ namespaces, or classes of object oriented languages. Thus, a class
can hold functions of the class or embedded classes itself.
- Profile Part
Some time section of a profile run, with a given thread ID, process ID,
(host machine?), and command line executed. We could distinguish
Thread Profiles, or full profile runs, but these are all looked at the
some kind of entity for easier and more flexible use of KCachegrind.
As seen from the list, a set of cost entities often defines another cost entity. Thus, there is a inclusion
hierarchy of cost entities which should be obvious from the description above.
- Call from instruction address to target function
- Call from source line to target function
- Call from source function to target function
- (Un)conditional Jump from source to target instruction
- (Un)conditional Jump from source to target line
Jumps between functions are not allowed, as this makes no sense in a
call graph. Thus, constructs like exception handling and long jumps in C
have to be translated to popping the call stack as needed.
- Data Access Range
The address range of a given data access (read/write) in a execution run,
given as lowest address of the touched memory range, and the size in number
- Data Type Access Range
The offset range into a given data type used in the program. Mapping from
an actual data address into data type offset is typically done using
debug information from the compiler.
- Data Type
As data types can recursively include data types themself (e.g. C++ class record, aggregation, or inheritance relation, or C union or record), a data
type can contain access ranges or data types itself.