Re: Ada Generic Overhead Inquiry

Re: Ada Generic Overhead Inquiry

[CPT Jacques C. Choiniere]

In reply to Joe Rubel, on run-time overhead associated with Ada Generics:

  Tim Porter of SAIC ((porter@nosc-tecr)) did some work for us that explored
this issue.  His team developed an automatic code generator that, among other
things, uses Ada generics.  This work was done for WWMCCS Information System,
and is public domain software that will be sent to the Ada Repository on Simtel
20 in the next several months.  A formal report on this work is in the 
Proceedings of the Joint Ada Conference, 5th National Conference & Washington
Ada Symposium pages 334 to 343.
  In sum, he found that speed of the applications code was not noticeably 
different from "regular" code when running the compiled code.  Compilation
speed was fairly slow with the large system his team worked with (see report).
The PROBLEM he found was the size of the Ada code modules created by the 
automatic code generator and the generics it used.  The compiled code was
big.  He told me that this was a function of current VAX Compiler technology
and NOT a function of the Ada language.  The Compiler did not share any code
at all, even when the modules were identical.  THIS PROBLEM WAS SOLVED BY
TIM.  With careful selections of implementation alternatives (see report or
send him a note) he was able to shrink the generated code size and (I forgot
to mention this problem) handle the problem of in-line expansions of generics.
BY ALL MEANS READ THE REPORT OR TALK TO TIM TO GET THE DETAILS.  

CPT CHOINIERE, USA
WIS JPMO/XPT
jcc@mitre

Re: Ada Generic Overhead Inquiry

[mdash]

Runtime overhead of generics is implementation-dependent.  The
issue is the degree of interpretation done by the code body.
This is determined by the restrictions on instantiations set
by generic formal type parameters, and whether the implementation
chooses to instantiate via code sharing or macro-style expansion.

I believe that most current implementations do limited code sharing
for generic instantiations.  Expect a low runtime TIME overhead for
generics, and a correspondingly high SPACE penalty.

Ada Generic Overhead Inquiry

[adaisc]

 ................................................................

     Can anybody tell me if there is any significant, run-time
     overhead associated with the use of Ada's Generics?
 
                                   Thanks,
                                    
                                   Joe Rubel <byrley@ntsc-74>

 ................................................................


------

Re: Ada Generic Overhead Inquiry

[firth]

In article <8704090138.AA12598@ucbvax.Berkeley.EDU> "Paul Byrley" <adaisc@ntsc-74> writes:

>     Can anybody tell me if there is any significant, run-time
>     overhead associated with the use of Ada's Generics?
> 

With the current state of Ada compiler maturity, this very
much depends on the compiler.  However, here are a few
general comments that I hope are of use - at least they
might tell you what to look for!

One way of implementing generics is by replicating the code
at each instantiation.  This has no runtime overhead, since
the effect should be just as if you had written dozens of
non-generic bodies.  It can cause enormous code expansion,
for which reason you might prefer to look for compilers
that don't do that.

Code sharing may or may not cause overhead, depending on
the generic parameter types:

(a) Pure type parameters should cause no overhead - the
    shared body is exactly what would be used for a non
    generic.  However, watch for things like

	if FORMAL_TYPE'MANTISSA < 20 then ...

    which are compile-time evaluable in the non-generic
    case but may require major overhead in a shared body.

(b) Procedure parameters require a procedure descriptor to
    be passed.  The minimum is normally 2 values - code
    address and static environment chain pointer.  If there
    are more than 3 values passed then I think you should
    worry.

(c) Value parameters appear in the code body as initialised
    constants.  You possibly lose some value-tracking
    optimisation.

(d) Subtype parameters may have to pass constraint information.
    That costs, and you also may lose some optimisations.

If you want the specific detail for the compiler of your
choice, then ask

A: under precisely what circumstances is code shared between
   instantiations?

B: when code is shared, what is the runtime representation of

    . procedures
    . values and objects
    . subtype constraints
    . type attributes

   that might have to be passed to the body

C: what specific optimisations are inhibited as a result of
   code sharing.

Hope this helps.