Re: Instrumenting code for profiling.

par_ianth@yahoo.com (PK) wrote
> I had a question regarding how compilers do instrumentation to
> collect profile information. Specifically, how do compilers handle the
> part of mapping the collected profile back to the original program
> (which is without the instrumentation).
>
> Say a program X is instrumented with profiling calls for gathering
> branch execution frequency. If I use the virtual address of the branch
> instruction as the index or key against which I collect the frequency
> of that branch, then I have a problem since the virtual address would
> be completely different in the instrumented version and in the
> non-instrumented version. So how do I maintain this mapping between
> the profile data that I collect and the actual instruction in the
> program? I think I need some sort of 'unique' id for each branch in
> the original program. Could someone give me some pointers about how
> this is done in the commercial compilers?


One thing that you can do, depending on the situation, is to run the
program inside an instruction-level simulator that is capable of
gathering the profiling information that you want. For example, a
simulator might collect an execution count for each instruction, a
branch direction count, etc. You can then use this information and the
mapping back to the source program to get source frequency
information.


Depending on how accurate the simulation is (for example, the
simulator may not mimic the real processor's pipeline), you can get
more or less accurate results.


In my work, I have written a simulator for an embedded architecture
that fully simulates the behavior of the hardware at the clock cycle
level. It then allows "probes" to be inserted at various instructions,
and the probes "fire" when that instruction executes. Thus the probe
can collect profiling information, branch frequency, enable other
probes, etc.


This is a good approach if you can get it--it doesn't require hacking
the program or the compiler.

Return to the comp.compilers page.
Search the comp.compilers archives again.