Re: Custom Storage Pool questions

[Simon Wright <simon@pushface.org>]

Jere <jhb.chat@gmail.com> writes:

> But after reading the following AdaCore article, my assumption is now
> called into question:
> https://blog.adacore.com/header-storage-pools
>
> In particular, the blog there advocates for separately counting for
> things like unconstrained array First/Last indices or the Prev/Next
> pointers used for Controlled objects.  Normally I would have assumed
> that the Size_In_Storage_Elements parameter in Allocate would account
> for that, but the blog clearly shows that it doesn't

Well, I may well have missed the point somewhere, and maybe things have
changed since 2015, but as far as I can see, with FSF GCC 11.1.0, the
technique described in the blog is completely unnecessary.

To save having to recompile the runtime with debug symbols, I wrote a
tiny pool which delegates to GNAT's
System.Pool_Global.Global_Pool_Object (the default pool), e.g.

   overriding procedure Allocate
     (Pool                     : in out My_Pool.Pool;
      Storage_Address          :    out Address;
      Size_In_Storage_Elements : in     Storage_Elements.Storage_Count;
      Alignment                : in     Storage_Elements.Storage_Count)
   is
      pragma Unreferenced (Pool);
   begin
      Global_Pool_Object.Allocate
        (Address      => Storage_Address,
         Storage_Size => Size_In_Storage_Elements,
         Alignment    => Alignment);
   end Allocate;

and I find with

      Pool : My_Pool.Pool;

      type C is new Ada.Finalization.Controlled with null record;
      type Cs is array (Natural range <>) of C;
      type Csp is access Cs with Storage_Pool => Pool;
      procedure Free is new Ada.Unchecked_Deallocation (Cs, Csp);
      Pcs : Csp;

   begin

      Pcs := new Cs (0 .. 5);
      Free (Pcs);

that

* the alignment requested is 8 (was 4 for an array of Boolean);
* the size requested is 72, which is 24 bytes more than required for the
  6 minimal POs;
* the value returned by Allocate is 24 bytes more than the address of
  the array object Pcs (which is the same as that of Pcs(0));
* the value passed to Deallocate is the same as that returned by
  Allocate.

I think it's more than likely (!) that the extra allocation of 24 bytes
is made up of 2 pointers at 8 bytes each, used to implement the
finalization chain, and two integers at 4 bytes each, holding the array
bounds.

So I'd say that to create a pool with extra header information, you'd
need to allocate space for your header + padding to ensure that the
compiler's object is properly aligned + the compiler-requested size,
aligned to the max of your header's alignment and the compiler-requested
alignment.

Mind, I don't quite see how to actually access the header info for a
particular allocation ...