Folding similar templates into one

Meta jared771 at gmail.com
Thu Jun 27 14:24:48 PDT 2013


On Thursday, 27 June 2013 at 03:47:39 UTC, Jonathan M Davis wrote:
> That's _very_ dependent on what the function does. A prime 
> counter-example
> would be overloaded operators like opBinary which uses their 
> string template
> arguments in mixins within the function, thereby generating 
> completely
> different functions. And I believe that that is by far the more 
> common use of
> strings as template parameters.

This may be true. Any kind of optimization would probably have to 
ignore most operator functions. Another heavy use of strings, 
however, is string lambdas. Checking if two string lambdas are 
the same is a simple string comparison, and then that template 
can be compiled once and all copies can be ellided. Then it's 
just a call to that template wherever it is used with that 
particular lambda in the program. I think this could be done with 
any template that accepts some kind of lambda function, but it 
may be somewhat tricky currently to figure out if two non-string 
lambda are equal, and I believe that DMD currently generates a 
unique lambda wherever one is used.

> Also, when using strings and integral values such as __FILE__ 
> and __LINE__,
> the functions _do_ have different code.
>
> auto foo(string file = __FILE__, size_t line = __LINE__)(Bar b)
> {
>  auto f = file;
>  auto l = line;
>
>  ....
> }
>
> ends up generating different code depending on the values of 
> file or line. The
> code is _not_ identical. The only way for the code not to vary 
> is for those
> arguments to be runtime arguments. If they're compile-time 
> arguments, then by
> definition, they affect the generated code if they're ever used.

I do know that the code generated is different. Turning 
compile-time arguments into run-time arguments will, 
unfortunately, completely defeat the point, as you know. It's a 
tricky problem, because you can't just partially compile a 
function and then change the compile-time arguments as you 
encounter each new instantiation. If we could do that, we 
wouldn't have this problem, and we would probably be using Common 
Lisp.

> Yes, it is theoretically possible for the compiler to use the 
> same template
> definition under certain circumstances (especially if you're 
> dealing with
> something like a templated struct that ultimately ends up with 
> exactly the
> same layout across multiple instantiations), but the only way 
> that the
> compiler could avoid duplicating the code with something like 
> __FILE__ and
> __LINE__ being used as template arguments is to translate them 
> into function
> arguments, because if the function has only one definition, 
> then it can't have
> different values for the file or line number.

This is something that could be potentially solved on the binary 
level, if you're sure that varying the value of a template 
argument will not affect how it functions. I'm not an expert on 
how DMD works, but could this possibly be done after the native 
code is generated, but before optimizations are performed? Just 
throwing out ideas.


More information about the Digitalmars-d mailing list