Re: Question about OO programming in Ada

[Dmitry A. Kazakov <mailbox@dmitry-kazakov.de>]

On 03 Dec 2003 13:49:20 +0100, Ludovic Brenta
<ludovic.brenta@insalien.org> wrote:

>Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> writes:
>
>> On 03 Dec 2003 10:29:17 +0100, Pascal Obry <p.obry@wanadoo.fr> wrote:
>> 
>> >
>> >Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> writes:
>> >
>> >> All controlled objects allocated by the allocator new, being not
>> >> explicity destroyed using Unchecked_Deallocation, will be destroyed
>> >> upon finalization of the access type.
>> >
>> >There is no magic done by Finalize here! Finalize gives a chance to the
>> >component implementer to do the memory deallocation for the end user. That's
>> >all.
>> 
>> Yes, you are right. Controlled objects will be finalized, but the
>> memory might be not reclaimed. At least, it seems that ARM does not
>> require that.
>
>I am confused.  I thought that the storage would be reclaimed when the
>access type went out of scope, but I tested it with GNAT 3.15p and it
>isn't.  Granted, the ARM doesn't seem to require it, but GNAT has the
>following in its reference manual:
>
>    *53*.  The manner of choosing a storage pool for an access type
>    when `Storage_Pool' is not specified for the type.  See 13.11(17).
>
>    There are 3 different standard pools used by the compiler when
>    `Storage_Pool' is not specified depending whether the type is
>    local to a subprogram or defined at the library level and whether
>    `Storage_Size'is specified or not.  See documentation in the
>    runtime library units `System.Pool_Global', `System.Pool_Size' and
>    `System.Pool_Local' in files `s-poosiz.ads', `s-pooglo.ads' and
>    `s-pooloc.ads' for full details on the default pools used.
>
>And in s-pooloc.ads it says:
>
>   ----------------------------
>   -- Unbounded_Reclaim_Pool --
>   ----------------------------
>
>   --  Allocation strategy:
>
>   --    Call to malloc/free for each Allocate/Deallocate
>   --    no user specifiable size
>   --    Space of allocated objects is reclaimed at pool finalization
>   --    Manages a list of allocated objects
>
>   --  Default pool in the compiler for access types locally declared
>
>   type Unbounded_Reclaim_Pool is new [...]
>
>I tried to run a test program in gnatgdb but couldn't check what the
>storage pool actually was.  Would anyone care to shed some light on
>this?  Now I'm really curious.

No storage pool can help, if deallocator is not called. If we continue
the example:

with Ada.Finalization;
with System;  use System;
with System.Storage_Elements;  use System.Storage_Elements;
with System.Storage_Pools;  use System.Storage_Pools;
package A is
   type Misty is
      new Ada.Finalization.Limited_Controlled with null record;
   procedure Finalize (X : in out Misty);
   type Pool is new Root_Storage_Pool with record
      Free   : Storage_Offset := 1;
      Memory : aliased Storage_Array (1..1024);
   end record;
   procedure Allocate
             (  Stack     : in out Pool;
                Place     : out Address;
                Size      : Storage_Count;
                Alignment : Storage_Count
             );
   procedure Deallocate
             (  Stack     : in out Pool;
                Place     : Address;
                Size      : Storage_Count;
                Alignment : Storage_Count
             );
   function Storage_Size (Stack : Pool) return Storage_Count; 
end A;

with Text_IO; use Text_IO;
package body A is
   procedure Finalize (X : in out Misty) is
   begin
      Put_Line ("finalized!");
   end Finalize;
   procedure Allocate
             (  Stack     : in out Pool;
                Place     : out Address;
                Size      : Storage_Count;
                Alignment : Storage_Count
             )  is
   begin -- Alignment is ignored for simplicity sake
      Put_Line ("Allocated");
      Place := Stack.Memory (Stack.Free)'Address;
      Stack.Free := Stack.Free + Size;
   end Allocate;
   procedure Deallocate
             (  Stack     : in out Pool;
                Place     : Address;
                Size      : Storage_Count;
                Alignment : Storage_Count
             )  is
   begin -- Does nothing
      Put_Line ("Deallocated");   
   end Deallocate;
   function Storage_Size (Stack : Pool) return Storage_Count is
   begin
      return 0;
   end Storage_Size; 
end A;

with A;  use A;
with Text_IO;  use Text_IO;
procedure Test is
   Storage : Pool;
begin
   Put_Line ("Begin of a scope");
   declare
      type Pointer is access Misty;
      for Pointer'Storage_Pool use Storage;
      X : Pointer;
   begin
      X := new Misty; -- This is not dangled!
   end;
   Put_Line ("End of the scope");
end Test;

With GNAT Test should print:

Begin of a scope
Allocated
finalized!
End of the scope

So even with a user-defined pool it does not work as "should be".

Of course one could call Unchecked_Deallocation from Finalize as
Pascal noted. But it would be awful for an uncounted number of
reasons. To start with, you never know, who calls Finalize, then you
have no pointer to the object, you can get it, but that will be of a
generic access type, so if you have several pools how do you know,
where the object was allocated? and so on and so far.

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