Re: Possible Ada deficiency?

[Robert A Duff <bobduff@shell01.TheWorld.com>]

Jeffrey Carter <spam@spam.com> writes:

> Robert A Duff wrote:
> > The main thing is that the compiler needs to know the size of a private
> > type in order to allocate things, unless it treats all private types as
> > dynamic-sized, which would be annoying -- you shouldn't have to pay an
> > efficiency cost to get the benefits of encapsulation, information
> > hiding, etc.  So if the full type were in the body, the compiler would
> > have to look at the body (at least in optimizing mode).
> 
> It's always seemed to me that such types could be implemented as access
> types, allocated where declared, deallocated when they went out of
> scope, and with all operations dealing with the designated value, not
> the access value.

That could work.  But you don't *need* to do any heap allocation.
If you say:

    subtype My_String is String(1..X);

where X is a run-time quantity, and:

    type R is
        record
            A, B, C: My_String;
        end record;

    Obj: R;

most compilers will implement Obj as a contiguous hunk of storage.
Accessing the components of Obj requires adding the appropriate
offsets to the address of Obj (at run time).  But it's still more
efficient than putting the three strings on the heap.

Note that the upper bound of My_String is typically stored just once --
not in every object of type R.  And the lower bound need not be stored
at all.  (If A,B,C were aliased, then every object of type R would
typically contain 3 lower bounds and 3 upper bounds.)

If the compiler can't see the full type of a private type, then it could
do the same thing as for My_String -- just assume that the size is a
run-time quantity.  And, I suppose, assume worst-case alignment.

But I still don't like it.  I think there should be *zero* overhead for
making a type private.

> All such types would, of course, be passed by reference.

Well, that would require changing the current rules,
which require pass-by-copy for a private type if the
full type is elementary.  (I don't much like the existing rules
in this area, but I'm not sure the change suggested here would
be an improvement.  It would be seriously incompatible, for
one thing.)

- Bob