Emulating placement new

Emulating placement new

[Florian Weimer]

Is there a way to specify a storage pool (or something similar) on the
allocator, and not on the access type?

Re: Emulating placement new

[Dmitry A. Kazakov]

On Sun, 29 Jul 2012 15:56:27 +0200, Florian Weimer wrote:

> Is there a way to specify a storage pool (or something similar) on the
> allocator, and not on the access type?

Qualified expression?

   Access_Type'(new T)

Maybe something like this:

   function Allocate_In (Pool : in out Root_Storage_Pool'Class)
       return not null access T is
       type T_Ptr is access T;
       for T_Ptr'Storage_Pool use Pool;
       Ptr : T_Ptr;
   begin
       Ptr := new T;
       return Ptr.all'Unchecked_Access;
   end Allocate_In;

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Emulating placement new

[Florian Weimer]

* Dmitry A. Kazakov:

> On Sun, 29 Jul 2012 15:56:27 +0200, Florian Weimer wrote:
>
>> Is there a way to specify a storage pool (or something similar) on the
>> allocator, and not on the access type?

> Maybe something like this:
>
>    function Allocate_In (Pool : in out Root_Storage_Pool'Class)
>        return not null access T is
>        type T_Ptr is access T;
>        for T_Ptr'Storage_Pool use Pool;
>        Ptr : T_Ptr;
>    begin
>        Ptr := new T;
>        return Ptr.all'Unchecked_Access;
>    end Allocate_In;

This doesn't work for unconstrained types.

Re: Emulating placement new

[Dmitry A. Kazakov]

On Sun, 29 Jul 2012 16:15:01 +0200, Florian Weimer wrote:

> * Dmitry A. Kazakov:
> 
>> On Sun, 29 Jul 2012 15:56:27 +0200, Florian Weimer wrote:
>>
>>> Is there a way to specify a storage pool (or something similar) on the
>>> allocator, and not on the access type?
> 
>> Maybe something like this:
>>
>>    function Allocate_In (Pool : in out Root_Storage_Pool'Class)
>>        return not null access T is
>>        type T_Ptr is access T;
>>        for T_Ptr'Storage_Pool use Pool;
>>        Ptr : T_Ptr;
>>    begin
>>        Ptr := new T;
>>        return Ptr.all'Unchecked_Access;
>>    end Allocate_In;
> 
> This doesn't work for unconstrained types.

Why?

   Ptr := new T (discriminants);

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Emulating placement new

[Georg Bauhaus]

On 29.07.12 15:56, Florian Weimer wrote:
> Is there a way to specify a storage pool (or something similar) on the
> allocator, and not on the access type?
>

Would subpools do? (I see that the access type's storage pool must be a
Root_Storage_Pool_With_Subpools.)

allocator ::=
    new [subpool_specification] subtype_indication
  | new [subpool_specification] qualified_expression

subpool_specification ::= (subpool_handle_name)

Re: Emulating placement new

[Robert A Duff]

Florian Weimer <fw@deneb.enyo.de> writes:

> Is there a way to specify a storage pool (or something similar) on the
> allocator, and not on the access type?

Ada 2012 has such a feature.  Instead of:

    X := new T'(This => 123, That => 456);

which allocates in T's storage pool, you can say:

    X := new (My_Pool) T'(This => 123, That => 456);

which allocates in My_Pool.

Look up "subpools" in the Ada 2012 RM for details.

For "placement new", you will want to write a pool
that takes an address-to-allocate-at as a discriminant.

- Bob

Re: Emulating placement new

[Florian Weimer]

* Robert A. Duff:

> Florian Weimer <fw@deneb.enyo.de> writes:
>
>> Is there a way to specify a storage pool (or something similar) on the
>> allocator, and not on the access type?
>
> Ada 2012 has such a feature.  Instead of:
>
>     X := new T'(This => 123, That => 456);
>
> which allocates in T's storage pool, you can say:
>
>     X := new (My_Pool) T'(This => 123, That => 456);
>
> which allocates in My_Pool.

Interesting.  But think this goes into the wrong direction.  The owner
pool still controls the allocation, Allocate_From_Subpool dispatches
on the master pool, not the subpool.  So I'd still need a special
access type type inject the owner pool.

Re: Emulating placement new

[Robert A Duff]

Florian Weimer <fw@deneb.enyo.de> writes:

> Interesting.  But think this goes into the wrong direction.  The owner
> pool still controls the allocation, Allocate_From_Subpool dispatches
> on the master pool, not the subpool.

I don't see the problem.  The allocator specifies the subpool, and
Allocate_From_Subpool takes the subpool as a parameter.  It could
dispatch on some operation of the subpool, if you want, but for
placement new, you don't even need that -- you just need the
address to allocate at.

>...So I'd still need a special
> access type type inject the owner pool.

I'm not sure what you mean.  You have to attach the "master pool"
to each access type that you want to work this way.  Is that
what you mean?

You don't need a new access type for each allocation address.
That wouldn't work anyway due to accessibility rules, which
is the weakness that subpools are trying to address.

You might also be interested in pragma Default_Storage_Pool,
which can be used to specify the pool for all access types in a
given subsystem, or (with "null") can be used to make sure
you don't forget to specify pools explicitly.

- Bob