Re: Running a preprocessor from GPS?

["Randy Brukardt" <randy@rrsoftware.com>]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 2377 bytes --]

<gautier_niouzes@hotmail.com> wrote in message 
news:eed7de55-d776-426d-a0e8-9d536fa2dad0@googlegroups.com...
>Le mercredi 29 juillet 2015 22:40:08 UTC+2, Randy Brukardt a écrit :

>> Besides, a compiler has a better idea of what can and should be inlined 
>> than
>> a programmer.

>About the "should", and assuming you want code optimization in time: do you 
>know
> any compiler having a better idea than a programmer of what should be 
> inlined?

Janus/Ada would have, had the full design ever have been implemented.

I suspect that some obscure compilers have done it, but I don't know for 
sure. It depends on having link-time or JIT code generation, where the 
entire program can be processed at once. JIT is even better as it typically 
has hints about the usage of the routines, so it can know which ones are 
"hot". Else there would be some benefit to "hotness" hints.

But the basic idea is that one specifies how much code expansion is 
allowable (from none to something just short of infinite - paging pressure 
means that performance will decrease at some amount of expansion, so one 
always wants to stop there), and then the compiler choses optimizations 
(inlining, loop unrolling, partial evaluation/body duplication) to meet that 
goal, maximizing "bang-for-the-buck" -- that is, getting the most value out 
of the allowed expansion. There is no way that a programmer can do that, as 
the number of calculations required is far beyond what a programmer can do.

Moreover, there are some inlinings (or partial evaluations, if inlining 
isn't practical for some reason) that should always be accomplished. For 
instance, any subprogram that is called exactly once is a candidate, since 
any parameters eliminated will reduce both the time and space of the 
program. These can't reasonably be identified by a programmer. In the 
specific case of Janus/Ada, any generic that is instantiated exactly once 
will have all calls to a subprogram declared in that generic having a common 
generic descriptor parameter -- eliminating that cuts overhead and opens up 
the possibility of other optimizations (giving code quality much closer to a 
template implementation).

And so on.

If there aren't compilers that do this, it is sad, because it means that 
programs are a lot larger and slower than they have to be.

                                        Randy.