Re: C++0x and Threads - a poor relation to Ada's tasking model?

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

"REH" <spamjunk@stny.rr.com> wrote in message 
news:6d23274b-d649-4a83-a6f1-6d1e9c4c3998@d34g2000vbm.googlegroups.com...
On Aug 12, 4:41 pm, Robert A Duff <bobd...@shell01.TheWorld.com>
wrote:
...
>> C++ and Ada both share this philosophy. It's called
>> "avoid distributed overhead".
>
>The reason I said "potentially" is you may or maybe pay the cost in
>Ada, depending on the implementation. There are implementations where
>you will always pay a speed penalty for exceptions (e.g., in setting
>up the frame), and there are ones where you only pay if an exception
>is raised (e.g., a table-based implementation).  A C++ compiler will
>not make me "pay" the cost of exceptions if I never make use of them.
>What I mean by that is, if I don't have a try block, there will never
>be any setup code to catch or propagate exceptions. In Ada, you may or
>may not.

It seems to me that you are says Ada and C++ are exactly the same here. The 
cost for exception handling in Ada only exists if you have an exception 
handler. I've never seen an Ada implementation that has any overhead for a 
frame that doesn't contain a handler - it would be a horrible performance 
drag. That's essentially equivalent to the C++ situation, as a "try block" 
is roughly equivalent to an Ada block with an exception handler. (Ada just 
allows handlers in more places.)

>Similarly with range-checking. If I index an array in Ada, it may or
>may not range check the index (a smart compiler can remove the check
>if it can prove it cannot be out-of-range). C++ will not range check
>the index. I have to do it explicitly (which is why I used that word),
>or if I am using vectors, call the at member explicitly.

Range checking is very cheap (generally only a couple of instructions); you 
can only detect the overhead in benchmarks. The odds that it would matter to 
a program is minimal (and the program is a lot safer for its enclusion). 
Overhead from exceptions and potentially finalizations are several orders of 
magnitude larger, and matter a lot more.

Premature optimization (which includes worrying about overhead without 
determining that it is significant) is the root of much evil.

                                                       Randy.

REH