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

[Jeffrey Carter <spam@spam.com>]

Per Lindquist wrote:
> Jeffrey Carter wrote:
> 
>>   procedure Q is
>>      package That is new PragmARC.Reflection;
> 
> 
> Hm, I was so excited about your solution I didn't notice the potential
> problem with overhead, but a collegue of mine did:
> 
> One of our target environments is a time-critical real-time system. We
> are worried about the execution overhead implied by a package
> instantiation (or any 'new' statement) in every subprogram in the
> system.
> 
> Will your solution cause overhead for each subprogram call?

It will definitely cause overhead, as I see you've discovered. There's a 
call to Expanded_Name, 2 to Index, and another to Mixed_Case. This 
component is certainly not suitable for systems with critical timing 
requirements.

There may also be overhead in terms of the amount of storage used. The 
package declares a number of constant Strings, and I doubt if we can 
rely on a compiler to discard them (although inside a subprogram, they 
should go away when the subprogram returns).

You can eliminate the call to Mixed_Case, if you don't mind what the 
result looks like, and one of the calls to Index (it will always return 
'Last - 1), and possibly the call to Expanded_Name, if your compilers 
have 'External_Tag returning the same thing and you're willing to have 
that compiler dependency in your code (though 'External_Tag probably has 
similar overhead to Expanded_Name in that case). That still leaves a 
call to Index. You could eliminate that if you always name your 
instantiations the same thing and don't mind that extra name on the end.

This is really only a problem in subprograms, where the package is 
elaborated every time the subprogram is called. In packages and other 
things where the elaboration will only occur once, it may be acceptable 
overhead.

It's too late now, but this might have been a good thing to suggest for 
Ada 0X. Compilers already have to have this information available, or 
PragmARC.Reflection wouldn't work. We should be able to get at it 
without all this overhead.

Finally, if you only need the name in exceptional circumstances (error 
logging or the like), I could make Unit_Name a function. Then you'd only 
have the overhead when you actually use the name.

-- 
Jeff Carter
"C++ is like jamming a helicopter inside a Miata
and expecting some sort of improvement."
Drew Olbrich
51