Re: This can't be done in Ada...or?

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

"Mark Lorenzen" <mark.lorenzen@ofir.dk> wrote in message
news:m3wttaciqw.fsf@0x53586c67.boanxx18.adsl-dhcp.tele.dk...
> "Per Lindquist" <commander@death-star.com> writes:
...
> > Will your solution cause overhead for each subprogram call?
>
> A compile-time instantiation of a package has nothing to do with
> run-time efficiency. You can also define a new type in a subprogram,
> which doesn't affect run-time efficiency either.

That's sometimes true, but never on a compiler that code shared generics by
default (like Janus/Ada). And even on compilers that treat generics as
macros, it depends on the elaboration overhead. So it is a mistake to give
that as a general rule. Similarly, a type declared in a subprogram might or
might not have run-time overhead (it depends on what the elaboration of the
type does - if it depends on a parameter, for instance, there almost
certainly is some overhead).

Not having the code for the generic in question (I couldn't find any easy
way to see it on the PragmaARC site, and I didn't want to download the whole
thing), I can't say what overhead it has. Clearly there is some size
overhead, but that might not be much more than the size overhead of the
explicit constants.

Personally, I'd stick with the constants, because they can be tailored to
disambiguate overloaded subprograms, and there is no possibility of
overhead. But YMMV.

                   Randy Brukardt.

P.S. I don't find the "if" statements surrounding the tracing particularly
"yucky". Unless your system is rather small, you'll need a way to control
what is traced, and that can be combined into the if statement with no
overhead when the traces are all off. One way is to use an extra constant:

    if (not Tracing.No_Logging) and then Tracing.Log_This (Where => ...)
then
        Tracing.Log_Item (Where => ..., Item => "This is a log entry.");
    end if;

We use variations on this in the Janus/Ada compiler, the AdaIC web server,
the Trash Finder spam filter, and other tools. (Claw doesn't have any
built-in tracing; it's too intrusive.)

If you only need a variable to control tracing, you can change that to a
constant to get rid of all of the overhead and use if statements with a
single item:

    if Tracing.Log_Me then
       ...

This solution requires a bit more version control (which is outside of Ada,
of course), but it isn't bad.

                RLB