Some Useful Memory Pools (GNAT User’s Guide for Native Platforms)

#### 6.7.1 Some Useful Memory Pools ¶

The `System.Pool_Global` package provides the `Unbounded_No_Reclaim_Pool` storage pool. Allocations use the standard system call `malloc` while deallocations use the standard system call `free`. No reclamation is performed when the pool goes out of scope. For performance reasons, the standard default Ada allocators/deallocators do not use any explicit storage pools but if they did, they could use this storage pool without any change in behavior. That is why this storage pool is used when the user makes the default implicit allocator explicit as in this example:

>     type T1 is access Something;
>      -- no Storage pool is defined for T2

>     type T2 is access Something_Else;
>     for T2'Storage_Pool use T1'Storage_Pool;
>     -- the above is equivalent to
>     for T2'Storage_Pool use System.Pool_Global.Global_Pool_Object;

The `System.Pool_Local` package provides the `Unbounded_Reclaim_Pool` storage pool. Its allocation strategy is similar to `Pool_Local` except that the all storage allocated with this pool is reclaimed when the pool object goes out of scope. This pool provides a explicit mechanism similar to the implicit one provided by several Ada 83 compilers for allocations performed through a local access type and whose purpose was to reclaim memory when exiting the scope of a given local access. As an example, the following program does not leak memory even though it does not perform explicit deallocation:

>     with System.Pool_Local;
>     procedure Pooloc1 is
>        procedure Internal is
>           type A is access Integer;
>           X : System.Pool_Local.Unbounded_Reclaim_Pool;
>           for A'Storage_Pool use X;
>           v : A;
>        begin
>           for I in 1 .. 50 loop
>              v := new Integer;
>           end loop;
>        end Internal;
>     begin
>        for I in 1 .. 100 loop
>           Internal;
>        end loop;
>     end Pooloc1;

The `System.Pool_Size` package implements the `Stack_Bounded_Pool` used when `Storage_Size` is specified for an access type. The whole storage for the pool is allocated at once, usually on the stack at the point where the access type is elaborated. It is automatically reclaimed when exiting the scope where the access type is defined. This package is not intended to be used directly by the user; it is implicitly used for each declaration with a specified `Storage_Size`:

>     type T1 is access Something;
>     for T1'Storage_Size use 10_000;