Re: Question about OO programming in Ada

[Ludovic Brenta <ludovic.brenta@insalien.org>]

Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> writes:

But the GNAT doc says that deallocation occurs when the storage pool
is finalized.  Your example does not demonstrate this since your
storage pool does not override Finalize.

> 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; 

     procedure Finalize (Stack : in out Pool);

> 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; 

     procedure Finalize (Stack : in out Pool) is
     begin
        Put_Line ("Deallocating all objects.");
        Deallocate (Stack, To_Address (Integer_Address (0)), 0, 0);
     end Finalize;

> 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!

  Deallocating all objects.  (yes, I tested it)
  Deallocated

> 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.

The finalization is not that of the allocated objects, it is that of
the storage pool itself (storage pools are limited controlled).  So,
this scheme actually works pretty well and is quite straightforward to
implement.

The part that I do not understand is why GNAT's Unbounded_Reclaim_Pool
doesn't seem to be selected for a local access type.  I think this
either contradicts the GNAT reference manual, or is an instance of me
not understanding it.

-- 
Ludovic Brenta.