ANNOUNCE: Deepend 2.6 for GNAT and ICC Ada 2005 compilers

[Brad Moore]

I am pleased to announce the availability of Deepend 2.6.

Deepend is an efficient and safer form of storage management for Ada
2005 that can outperform garbage collection schemes.

Since the initial (previous) announcement of Deepend on comp.lang.ada,
there have been a number of improvements.

Some of these include:

1) When Deepend was first announced, it was a binding to the Apache
run time pool library. Since then, the Apache library has been
removed as a dependency, and Deepend is now 100% pure Ada. Testing
has shown that the new version of Deepend runs noticeably faster
than the earlier version that called out to the Apache library.

2) Deepend and the Irvine ICC Ada 2005 compiler

Deepend has been compiled and tested using the Irvine ICC Ada 2005
compiler, running on Windows and purportedly on Linux.
See http://www.irvine.com for more information about their compiler

3) Deepend on an Android Samsung Galaxy S II smart phone

Deepend has been compiled and tested using GNAT AUX on an Android
Samsung Galaxy S II Smart phone.
See http://www.dragonlace.net for more information about this compiler

4) Deepend and the GNAT 2011 GPL compiler

Deepend has been compiled and tested using GNAT 2010 and 2011 GPL
versions of the compiler on both Windows and Linux.
See http://libre.adacore.com/libre for more information about this
compiler.

5) Deepend Aligned with the Ada 2012 subpools proposal.

Deepend provides two storage management options,
- Basic_Dynamic_Pools
- Dynamic_Pools

The Basic_Dynamic_Pools package is forward compatible with the Ada
2012 proposal for Storage_Pools, since it only allows allocations
via the existing "new" operator. This facility relies on access
type finalization to free all the objects from a pool.

Dynamic_Pools provides the capabilities of Basic_Dynamic_Pools, but
in addition allows the creation of subpools, and allocations can be
made from subpools. Subpools can be deallocated, which deallocates
all objects allocated from the subpool. The Dynamic_Pools package
is designed to closely align with the Ada 2012 proposal, except
that it works for Ada 2005, and doesn't support deallocation of
fat pointers, or controlled types. When Ada 2012 is available, the
interfaces may change to match the proposal, and capabilities
offered by Ada 2012.

Deepend is a dynamic storage pool with Subpool capabilities for Ada 2005
where all the objects in a subpool can be reclaimed all at once,
instead of requiring each object to be individually reclaimed one at a
time. A Dynamic Pool may have any number of subpools. If subpools are
not reclaimed prior to finalization of the pool, then they are
finalized when the pool is finalized.

Rather than deallocate items individually which is error prone and
subceptable to memory leaks and other memory issues, a subpool can be
freed all at once automatically when the pool object goes out of scope.

With this Storage pool, Unchecked_Deallocation is implemented as a
No-Op (null procedure), because it is not needed or intended to be used.

Subpool based storage management provides a safer means of memory
management, which can outperform other mechanisms for storage
reclamation including garbage collection.

You can get the source code of Deepend from SourceForge:
https://sourceforge.net/projects/deepend/files/

If performance is a desired goal, you may also want to check out
Paraffin, which provides Ada 2005 generics to add Parallelism to
loops and recursive algorithms. Paraffin and Deepend complement
each other for obtaining faster execution times.

for Paraffin,
see https://sourceforge.net/projects/paraffin/files/

Brad Moore

[Brad Moore]

A minor correction to the announcement.

I said:
> The Dynamic_Pools package
> is designed to closely align with the Ada 2012 proposal, except
> that it works for Ada 2005, and doesn't support deallocation of
> fat pointers, or controlled types.

Actually, the limitation is that fat pointers
(access to objects of unconstrained types) cannot be allocated to
subpools, but they can be allocated to a deepend pool using the "new"
operator. Controlled types can be allocated to subpools, but it is
erroneous to cause the finalization of these objects to occur before
they would have otherwise been finalized, such as when the access type
is finalized. It is otherwise OK to allocate controlled types to
subpools, but recommended that they instead be allocated to the pool,
using the "new" operator. Similarly, allocated task objects cannot be
finalized earlier than when they would have ordinarily been finalized.

Ada 2012 will provide new syntax for the "new" operator to allow objects
of unconstrained types to be allocated to subpools, as well as
expose machinery that will allow objects of controlled types to be
finalized when a subpool is finalized. The limitation for allocated task
objects will remain however.