Re: GNAT Optimization of Constant Expressions

[David Smith <david.smith@gmail.com>]

> > I agree for any function call, but in the special case of functions from
> > Generic_Elementary_Functions, it is _not_ asking a lot! A decent compiler
> > should perform optimizations around these functions as well as around
> > arithmetic operators.

The purpose in leaving them in was to test this aspect of the
optimization process.  This is a very common expression to see in
legacy scientific codes written by novices, and I wanted to know if
GNAT can handle naive structures as well as Fortran compilers do.  If
it can't, then many scientists and potential Ada converts will be
turned off because they'll write a naive bit of code for a benchmark
and find that Ada is much slower than Fortran without trying to
understand why.

I understand that the FP ops are not associative, but doesn't the gcc -
O3 imply that the user chooses speed over accuracy?  And especially if
the user passes -ffast-math the compiler should get the hint.

> There are optimizations that you can do safely, like common subexpression
> evaluation, but there are many fewer of them than you have with integer
> optimizations. Luckily, most of the code in a program (any program, once you
> take address calculations like array indexing into account) is integer code.
> It is very important to do a good job on integer expressions, much less
> valuable of float ones (because of the limited things that you can do).

This may be true, but FP ops are very expensive, so trimming those can
potentially save more than you might think.    In this example, the
common expression elimination speeds the code up by a factor of 10,
roughly.

-Dave