Re: Bug in GNAT? - Max_size_in_storage_elements insufficient

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

"Luke A. Guest" <laguest@archeia.com> wrote in message 
news:647636100.498533813.258228.laguest-archeia.com@nntp.aioe.org...
> Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
>
>>> Well, then it's at least a bug in [Barnes] because there's an example
>>> like the above ones just with a simpler type. But I still think the idea
>>> here is/was to provide enough space for N items of some type.
>>
>> I am not sure if that were technically possible. Considering an
>> implementation of, for example, a marked-margins pool, the penalty to
>> have a guarantee would be extremely high.
>
> Surely that's what a static language can supply, the actual amount of 
> space
> required?

Depends on the implementation of the storage pool, of course. The amount of 
memory used by objects can be figured out at compile-time (assuming that the 
subtype is definite and there aren't any discriminant-dependent components - 
it's possible to declare such objects non-contiguously), but the pool will 
have some overhead.

Besides, that's irrelevant. S'Max_Storage_Size_in_Elements is not a static 
attribute and thus doesn't have to be calculatable at compile-time. The OP's 
example is legal because the value of Storage_Size doesn't have to be 
static, either. Of course, that means that whatever the OP is trying to do 
probably isn't going to happen here.

Turning to the OP's question:

I would never expect to be able say anything useful about the size of a task 
object - it's going to have to be allocated in pieces all over the memory 
map (there's limits on where the stack can be allocated, for instance). No 
attribute (Size, Object_Size, Max_Storage_Size_in_Elements) can have 
anything useful to say about non-contiguous objects.

Note: I've always interpreted Max_Storage_Size_in_Elements to apply to a 
single call to Allocate; there might be multiple calls to Allocate to 
allocate a single object (Janus/Ada works this way; there is a separate call 
to Allocate for each contiguous part of an object). Indeed, I wrote the 
definition of the attribute with this model in mind. Whether any other Ada 
lawyers would agree with me is unclear. :-)

                          Randy.