Re: Ada Compilers

[gab@rational.com (Greg Bek)]

As a compiler vendor I'd just like to echo MDC's comments.
Don't just use standard benchmarks, use your application or
portions of it for testing performance.  Benchmarks like
the PIWG's are not sufficiently sophisticated to properly
perform timing of null loops etc.

Ada compilers have many advantages over languages like C/C++
in that the compiler has greater visibility into the rest of
a user program.  An Ada compiler can automatically inline
code across multiple levels of subprogram call, C/C++ have
difficulty doing this as any called subprogram is usually
compiled into a different object module.  This means that
C/C++ must perform a call/return where the Ada code may
have the call/return (and associated prolog/epilog, stack
check) eliminated.

Our compiler (Rational Apex), performs this kind of inlining
as well as loop unrolling etc.  Another very useful technique
is "value propagation", this is where the compiler tracks the
range of values taken by an object.  Knowing the possible
range of values means that the compiler can eliminate 
constraint checks that are not needed.  This can have some
very disconcerting side affects for the unwary.

If the compiler determines that a section of code has no
side affects (ie: no exceptions can be raised), and that the
results of that section of code are not used, then it 
eliminates all of the code.   The PIWG henessey benchmark
is an example of code that suffers because of this. The
large matrix multiplication contained within the benchmark
is eliminated as the matracies are populated with small-ish
values, the compiler concludes that the range of the resulting
sum of products will never overflow.  It then discovers that
the resulting matrix is never used, so it throws out the entire 
matrix multiplication.  The surrounding timing loop is now 
timing a null operation.

Modern compilers are very good at producing optimized code
under most circumstances.

However there are some subtle issues with Ada that can 
prevent getting the best code possible.  The best example
of this is using controlled objects within your program.
Controlled types require the compiler to generate invisible
code that makes sure any objects are properly finalized when
a scope is exited.

When compiling a routine that uses a class wide type the
compiler may not know whether controlled types are used 
to extend the base type, so it must be pessimistic and 
generate finalization code that may never be called.

If you don't have controlled objects and your compiler has a 
mechanism for optimizing accordingly, then use that mechanism
(switch, library directive, configuration pragma).

As always your milage will vary.

Greg Bek
-------------------------------------------
Greg Bek  mailto:gab@rational.com
Product Manager, Rational Apex Family
Rational Software
-------------------------------------------