Re: Ada to C++ translator

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

"Florian Weimer" <fw@deneb.enyo.de> wrote in message
news:877j8ngrnx.fsf@mid.deneb.enyo.de...
> * Randy Brukardt:
>
> > "Florian Weimer" <fw@deneb.enyo.de> wrote in message
> > news:877j8oow1r.fsf@mid.deneb.enyo.de...
> > ...
> >> It's an abort-deferred operation (like assignment, which I should have
> >> mentioned as well).
> >
> > That's expensive how? Abort-deferral is (or should be) just toggling a
bit
> > in the TCB.
>
> You need to find the TCB first, and you need to check for abortion
> once deferral has ended.  Especially the first part probably prevents
> inlining on some POSIX platforms.

Huh? The TCB has to be readily accessible, or the whole program isn't going
to work at anything faster than a crawl. And the abortion check is just a
check for an empty list (i.e. compare against null): it's only expensive if
in fact there is a task on the list. But having abort be expensive is
irrelevent.

The TCB contains the heads of the exception and finalization chains (which
also contains the temporary storage pools on Janus/Ada),  the display
registers (for up-level access), some temporaries for expressions (since the
80x86 architecture is register-poor), along with all of the tasking stuff.
Essentially, it contains everything in Ada semantics that is task-specific.
You have to have cheap access to that, or *everything* is bogged down (most
subprogram calls have to do operations on the exception and finalization
chains and with the display registers). On our never-quite-finished 68K
compiler, we allocated a register permanently to the TCB. Our MS-DOS
compilers used a global block for this stuff (and copied it each time a task
switch happened - great for non-tasking programs, not so hot for tasking
ones).

I haven't studied the details of POSIX threads (they didn't exist when I
last seriously worked on UNIX systems), but there is *always* a way to have
easy access to thread-specific data. At worst, you'd have to allocate a
register to finding it.

There is a persistent myth that finalization, and particularly Ada
finalization is expensive. But I've never seen any real evidence of that --
particularly in apples-to-apples comparisons. (No fair comparing an Ada
program full of tasks with a C++ one that contains none, for instance.)
Surely the cases where its tiny overhead really matters are very few in
number. (OTOH, I'll grant that there is a space cost for it, and that can
make a difference in some situations.)

                               Randy.