This allows you to set a flag to show the thread id of what was recorded.
Use this to help disassociate similar threads in a process to figure out
which thread is consuming a majority of the Total time of that process.
That way the descendant graphs can generate the self values but ignore the
summary augmentation (as that would mess up the generated values).
This fixes it so that showing the descendants tree keeps proper Total
and Self values.
We still have some work to do here so it doesn't mess up the summary
augmentation, but this is a start on re-generating the callgraphs for a
specific symbol.
This function will list the symbols in a traceable in a way that is
suitable for showing in a GtkListView or GtkColumnView. For example, that
requires creating copies of the symbols so that duplicates do not cause
hickups with GtkListItemManager.
This is handy so that we don't have to keep multiple objects around to
handle this request. Otherwise we'd need to keep references to the
document and that is a bit annoying.
This of course has a limit of about an hour (in tv_nsec), but that is
far longer than we can realistically record anyway.
This uses the intersection of all the bitset from the frame to the root to
first reduce the number of traceables to look at. Once we have the
intersection, we check the traceables for prefix and yield another list
model using that bitset index on the same traceables list model.
This can be used to show a supplimental list of all the traceables for a
callgraph up to certain node.
This has an indirect object (SysprofCallgraphSymbol) so that we can provide
plumbing to get the callgraph as well as the augmented data from the
indirection object.
This allows for callgraphs to show overview in the functions list which
contains the same augmentation that the descendants view does.
This interjects a node for unwindable traces so that cost gets accounted
to the process, but is not just at the [process] graph item as that makes
it very hard to subtract to figure out what it was.
Instead just insert an [Unwindable] node and cost-account to that.
This allows us to have augmentation at the summary level so that things
like the weighted callgraph or memprof callgraph can add their respective
summary data up the chain of function calls.
We still need to figure out the right way to plumb in the augmentation data
so that things that need to walk up the chain are possible, but this first
gets things in order to do that.
If we are trying to get the file bytes and they are compressed, we may need
to transparently decompress those bytes. That way if the API requested
"/proc/cpuinfo" but really got "/proc/cpuinfo.gz" it still gets the same
bytes to consume.
If we want /proc/kallsyms and we discover /proc/kallsyms.gz, then use the
/proc/kallsyms.gz instead and transparently decompress it. Also, list the
file in sysprof_document_list_files() as /proc/kallsyms instead of
/proc/kallsyms.gz as that is really the intention (but mark the compressed
bit for decoding the chunks).
I want to move a bunch of this "contrib" style sources into their own
area so we can statically link them but keep them separate from main
sysprof code.
We need to do what binfile was doing and make the address relative to the
text_offset. We also need to ignore the text offset of the debuglink files
and pass it the text_offset of the original ELF.
This fixes a bunch of symbolization in the callgraph.
If our entire stack was in kernel address context, inject the
"- - Kernel - -" symbol at the top of the stack trace so that accounting
gets properly assigned to the kernel. This is typical with kernel processes
such as kworker.
We may need to know the final address context so we can inject symbols as
necessary into the top of the callgraph. We know it when generating the
symbols, so just yield it to the caller too.
