Re: Extending functionality of -frepo

[Mike Stump <mrs at apple dot com>]

On Sep 5, 2005, at 12:09 AM, Noe Aljaz ITICMN wrote:
> 2. Define macro NO_TEMPLATE_INSTANTIATION during normal compilation  
> and
> un-define it when g++ is called by collect2,
>
> and making this accessible via some new compiler option (e.g. - 
> frepo2)?
>
> Why would this be good?

Normal compiles instantiate items as determined by the database.  It  
is a known waste of compile time to not so instantiate such things,  
as we know they will be instantiated.  So, the entire concept doesn't  
make much sense to me, unless you only are only interested in the  
speedup from those units that don't use any definitions.  Now, if we  
know that no definition is needed in a file, having it disappear the  
definitions is enticing, but after you benchmark it against pch, I  
suspect you'll wonder why you bothered.

> 1. Code in foo.cpp normally compiles without including big_header.h
> (from bar.tpp). This makes it impossible for foo.cpp to become
> inadvertently dependant on the code from big_header.h.

One can already reap this benefit by the #ifdef/-D during  
compilation, so I don't see any benefit.

> 2. Compilation of foo.cpp and every source file that includes bar.h is
> much faster since the implementation of bar.tpp is not seen by the
> compiler.

Likewise.

> 3. Definitions for the bar class template and the big_header are only
> compiled by collect2 during template instantiations. If bar<int> is
> commonly used in the code, compilation times would be significantly
> reduced.

Reduced when compared to pch?  With pch, all the common things are  
instantiated once, and only once for the entire project build.  I  
suspect compilation time would not be reduced.

One thing that might be interesting would be to have -frepo take an  
argument that names a file that is the database for the application,  
so that the decisions can be made up front and eliminate the need to  
recompile.  This improves the 1st compile time and doesn't alter the  
incremental time.