Boost logo

Boost :

From: Simonson, Lucanus J (lucanus.j.simonson_at_[hidden])
Date: 2008-05-09 14:18:50

Boris Gubenko wrote:
>> Steven Watanabe wrote:
>>> Ok. It would be great if compilers supported this directly.
>> Just fyi: the cxx compiler has verbose template instantiation
>> mode. On Tru64, for example:
Steven wrote:
>I only see function template instantiations, I'm more interested in
>class template instantiations because that's where the metaprogramming
>is done. Am I missing something?
>I'd also like to have all template instantiations, not just those
>that are triggered from inside other template instantiations.
>(Although this doesn't make a huge difference)

This is the icc documentation for the -prof-gen flag. Apparently it
instruments the code for every basic block to enable profile guided
optimization later on. This should include template instantiates and
basic blocks from inlined functions.

prof-gen, Qprof-gen
Instruments a program for profiling.
IDE Equivalent
Windows: General > PGO Phase
IA-32 architecture, Intel(r) 64 architecture, IA-64 architecture
Linux and Mac OS X: -prof-gen
Windows: /Qprof-gen
OFF Programs are not instrumented for profiling.
This option instruments a program for profiling to get the execution
count of each basic block. It also creates a new static profile
information file (.spi).
If -prof-genx or /Qprof-genx is specified, extra information (source
position) is gathered for code-coverage tools. If you do not use a
code-coverage tool, this option may slow parallel compile times.
If you are doing a parallel make, this option will not affect it.
These options are used in phase 1 of the Profile Guided Optimizer (PGO)
to instruct the compiler to produce instrumented code in your object
files in preparation for instrumented execution.

Later on you would use -prof-gen-sampling to, among other things, create
a map from object code to line number in the source code. This map
should be a superset of data you are looking for, which is instantiation
count for templates. For templates that don't end up with any object
code (meta-functions) I think you would find no instantiations in the
map, whereas you might still find that the compiler evaluated the
meta-function many times with your warning based approach. I guess it
depends on what you are looking for.

prof-gen-sampling, Qprof-gen-sampling

Prepares application executables for hardware profiling (sampling) and
causes the compiler to generate source code mapping information.
IDE Equivalent


IA-32 architecture
Linux and Mac OS X: -prof-gen-sampling
Windows: /Qprof-gen-sampling

OFF Application executables are not prepared for hardware profiling
and the compiler does not generate source code mapping information.

This option prepares application executables for hardware profiling
(sampling) and causes the compiler to generate source code mapping

The application executables are prepared for hardware profiling by using
the profrun utility followed by a recompilation with option -prof-use
(Linux and Mac OS X) or /Qprof-use (Windows). This causes the compiler
to look for and use the hardware profiling information written by
profrun (by default, into a file called pgopti.hpi).

This option also causes the compiler to generate the information
necessary to map hardware profile sample data to specific source code
lines, so it can be used for optimization in a later compilation. The
compiler generates both a line number and a column number table in the
debug symbol table.

This process can be used, for example, to collect cache miss information
for use by option ssp on a later compilation.
Alternate Options

See Also

prof-use, Qprof-use compiler options

ssp, Qssp compiler options

My own interest is that I would like to do performance profiling and
tuning of template instantiated code with VTune. It looks like these
compiler options in icc are more well suited to that than the static
information you are looking for.

Is there a way to write a meta-function that implements a counter?

The idea is that each time a template is instantiated by the compiler a
meta-function counter (inserted by a script similar to your warning)
would be evaluated. Then you could collect the counts computed at
compile time and print them to file at runtime along with the assocated
type name information from the counter's template parameter.

template <typename T>
struct meta_counter {...};

template < something>
struct my_template {
        //inserted by script

I'm not sure how retrieving the count would work. Perhaps you can
create a global const with set to the value and just use nm to retrive
the value.

I have no idea how to fully implement this right now, but perhaps Steven
can run with the idea.


Boost list run by bdawes at, gregod at, cpdaniel at, john at