VERSION.txt

Deepend Version History.

deepend-3.9 (Current Version)
- Updates to support compilation with Janus Ada compiler for Ada 95
  version.
- Eliminate all usage of 'Unchecked_Access. In most cases, replace with
  direct conversions to access type of derived class from access type of
  parent class.
- Move all instantiations of Address_To_Access_Conversions to library
  level, to avoid accessibility check violations, in turn needed to
  eliminate use of 'Unchecked_Access
- Rename binary_trees_without_subpools_adaXXXX.adb to
  binary_trees_basic_pool_adaXXXX.adb to avoid name conflicts of object
  files in Janus Ada, when reduced to an 8.3 filename.
- Rename bounded_binary_trees_without_subpools_adaXXXX.adb to
  binary_trees_basic_bounded_pool_adaXXXX.adb to avoid name conflicts of
  object files in Janus Ada, when reduced to an 8.3 filename.
- Rename bounded_binary_trees_with_subpools_adaXXXX.adb to
  binary_trees_with_bounded_subpools_adaXXXX.adb to avoid name conflicts
  of object files in Janus Ada, when reduced to an 8.3 filename.
- Remove use Dynamic_Pools; clause in subpool tree examples, which makes
  it more obvious where declarations come from in the examples, and also
  gets around a name resolution bug in ObjectAda.
- Convert Handle, Storage_Size, and Storage_Used to expression functions
  in Ada 2012 version.
- Use Storage_Pool aspect in Ada 2012 version, rather than pragmas
- In Ada95 version, separate Inline pragmas to accommodate Janus which
  does not currently support mentioning more than one subprogram in a
  single Inline pragma
- Eliminate Use Sys; in Ada95 version to improve readability in making
  it clear where declarations are coming from, and also to work around
  name resolution bug in Janus.

deepend-3.8
- For the Ada95, Ada2005, and Ada 2012 versions, the generic
  Subpool_Allocators package adds the Default_Value as a generic
  formal object, rather than as a function of the package. In addition,
  the allocation_type can now be an unconstrained type, so it is
  possible to allocate objects such as variable length Strings or
  objects with immutable discriminants to a specific subpool. 
  It is still not possible to allocate objects of a limited type using
  this approach, but for that, one can always use the Ada "new" keyword
  syntax to allocate objects of limited types to the pool, but these
  allocations will always go to the default subpool, unless the
  the Ada 2012 subpool allocator syntax is used, in which case the
  allocation goes to the specified subpool.

deepend-3.7.1
- A minor update that Inlines the new Default_Value functions, and in
  the 2012 version of the code, all pragma Inlines are replaced with
  use of the Inline aspect.

deepend-3.7
- An issue was reported that allocations using the generic allocators,
  (Allocation and Scoped_Allocation) do not initialize memory, which is 
  not consistent with how Ada allocators work. In particular, allocating
  an object of a type should have its discriminants set to the value of
  the designated subtype, and any default initializers should have been
  applied. To remedy this, these calls were removed, and instead, the 
  two other generic calls, Initialized_Allocation, and
  Scoped_Initialized_Allocation were moved to a nested package and 
  both renamed to Allocate, and the Value parameter (previously called the
  Qualified_Expression parameter) is now supplied with a default that is
  a value of the generic formal type that is default initialized.
  These changes were applied to the Ada 95, Ada 2005, and Ada 2012 versions
  of the libraries. Prior to this release, the calls worked as expected
  so long as the users code initialized the allocations to a valid 
  object value, prior to use. Now the allocations of these subprograms
  should work consistent with the "new" keyword allocations for
  uninitialized allocations.
  
deepend-3.6
- Improved portability and safety by replacing usage of Ada.Unchecked_Conversion
  with System.Address_To_Access_Conversions in the Bounded_Dynamic_Pool and the
  Dynamic_Pool libraries. In particular, the Janus Ada compiler
  complained, rightfully so, since access types and System.Address are
  different sizes, and Unchecked_Conversion is dangerous in such context. As
  a result of this change, GNAT pointed out a bunch of other errors having to
  do with using access types when general access types should have been used
  instead. These changes were made to the Bounded_Dynamic_Pools library and the
  Dynamic_Pools library, which in turn required changes to the client code to
  use general access types. (i.e. access types with the "all" keyword as in; 
  type xxx is access all type).
- The Janus Ada compiler also pointed out an issue in the Ada 95 test code
  where a generic access type could not be automatically converted to a
  non-generic access type of the same name. This was fixed the the tree creation
  test code.
- Removed Restriction No_Local_Protected_Object which is valid, and somehow
  became detectable once Unchecked_Conversion usage was removed.
- Shortened horrendously long folder names under the test folder
  
deepend-3.5.1
- Support for ObjectAda64 (9.2) for both Ada 2005 and Ada 95
- Added ObjectAda .PRJ files to build all the test executables associated with
  the Ada 95 and Ada 2005 libraries.
- Fixed compile issue detected by the ObjectAda compiler, and missed by GNAT
  where an overriding subprogram was not fully conformant to the parameter
  profile of the subprogram it was overriding. Specifically, the derived
  subprogram added a null exclusion ("non null) to an access parameter, whereas
  the parent subprogram did not have the null exclusion for that parameter." 

deepend-3.5
- The Ada 2012 dynamic pool and bounded dynamic pool libraries were broken
  with GNAT GPL 2016. Changes were made to get these working again.
- One problem seemed to be that there are issues auto-allocating a default
  subpool, during the process of deleting the current default subpool.
  To address this, auto-recreation of the default subpool is no longer
  supported. When the default subpool is deallocated, you can no longer
  allocate to the default subpool, until making a call to a new subprogram,
  Create_Default_Subpool, which reinstates a default subpool.
- Added ability to set ownership of the storage pool. (Before ownership could
  only set on subpools. This is particularly important for allocations to the
  default storage pool.
- Some of the make files were failing also, due to containing a build option
  that either is no longer supported, or requires special configuration.
  This callgraph compile option was removed, allowing the make to build 
  successfully.
- Removed temporary hack code relating to the default subpool, due to bugs
  in GNAT which were not recognizing allocations to the default subpool.
  These issues are fixed in GNAT GPL 2016, so the temporary hack code was
  removed, and default subpools work as expected.
- Improved documentation comments in package specifications

deepend-3.4
- Fixed issues preventing compilation of Ada 2012 version for 
  GNAT GPL 2014
- The Pool parameter of the 
  System.Storage_Pools.Subpools.Default_Subpool_For_Pool function was
  finalized to be an in out parameter for the Ada 2012 standard.
  This requires changes to the Deepend pools, since they override this
  function. In addition, the Ada 2005 and Ada 95 versions of Deepend
  also were modified to reflect this change. In Ada 95 and Ada 2005,
  functions cannot have in out parameters, so instead, the parameters
  were changed to be access parameters, so that the Ada 95 and Ada 2005
  version more closely matches the Ada 2012 version.
- In the Ada 2012 version, there were static_predicates defined for
  private declarations, which in fact needed to be dynamic_predicates.
  Since these were private declarations, the predicates were removed,
  since they weren't very useful since they were private declarations,
  and the need for dynamic checks for this was deemed as worthwhile.
- Removed workarounds for GNAT compiler bugs that were fixed in the
  GNAT GPL 2014 version of the compiler. In particular, the storage 
  pools have default discriminants which now can be left unspecified
  to use the defaults.

deepend-3.3
- Fixed issues preventing compilation of Ada 2012 version for 
  GNAT GPL 2013
- Removed workarounds for GNAT compiler bugs for the Ada 2012
  version that were fixed in the GNAT GPL 2013 version of the compiler.

deepend-3.2
- Ada 95 versions added
- Added Bounded forms for all the storage pool types.
- Added exception handling, and allowed scoped subpools to not be
  allocated from the heap.
- Storage_Size call fixed to match description in the Standard. It is
  supposed to return the size of all storage allocated, including free
  storage and used storage. Previously, Deepend was reporting the 
  amount of used storage. Instead, a new call, Storage_Used exists,
  which now reports the amount of used storage.
- Scoped subpools are no longer created by the Create_Subpool call.
  Instead they are just declared with appropriate discriminants.
- Fix bug with deallocation subpools, which needed to call the base
  class, but then ensure not calling back into the protected object,
  which caused hanging.
- Added accessibility check suppressions for Ada 2012 test code.
- Split source into three folders for Ada 95, Ada 2005, and Ada 2012
- Removed assertions that the size of the allocation had to be <=
  the size of the block size. This restriction was unnecessary, as the
  code will allocate a larger block if necessary to accommodate the
  request
- Added portability restrictions to Ada 2012 version of the code
- Removed non-portable use of System.Task_Info package
- Moved pragma Precondition and Postcondition for Ada 2005 version to
  body as portable assertions.
- Removed compile time warnings that were incorrect or no longer needed. 
- Updated ICC compiler build instructions

deepend-3.1
- Can now deallocate the default subpool, then continue to allocate
  from the default subpool.
- Took advantage of new Ada 2012 features including;
   o New Iterator syntax for containers
   o Expression Functions
   o Conditional expressions
   o Invariants
   o Pre and Post conditions
   o static subtype predicates
- Corrected build documentation for ICC Ada 2005 compiler
- Test drivers improved with more comprehensive tests
- Tree benchmark tests more specialized between Ada 2012 vs Ada 2005
- Removed warning that claimed GNAT was mapping all subpool allocators to
  the default subpool. That was not correct, as GNAT does correctly allocate
  from the specified subpool.
- Restructured compiler output folders

deepend-3.0 
- Major revision now supports both Ada 2012 and Ada 2005
- Storage_Size is now implemented.

deepend-2.6 (Mostly a minor release with documentation updates)
- Runs on Android OS. Dual core Samsung Galaxy S II
- Compiles under the Irvine Ada 2005 Compiler, Windows Linux
- Compiles under GNAT AUX FSF 4.6.1, Android
- Compiles under GNAT GPL 2010-2011
- Warning flagged as Ada 2005 bug, renamed to GNAT bug, since Irvine
  compile does not exhibit that bug.
- Added build instructions for Irvine compiler, and added more notes to
  README

deepend-2.5
- Added Basic_Dynamic_Pools package, which is a subset of the functionality
  of Dynamic_Pools, with a simpler interface. It does not provide subpools,
  but still can be reclaimed all at once, similar to Dynamic_Pools.
  The idea is that these pools are declared at nested scopes, and 
  access types are defined with Storage_Pool attribute set to the pool object.
  Basic_Dynamic_Pools should be forward compatible to Ada 2012, unlike
  Dynamic_Pools which will need modifications to the interface.
  
deepend-2.4
- Major update to comments in the code. 
- Improvement to performance for call Default_Subpool_Of_Pool, avoids 
  accessing protected object 
- A Default_Block_Size of 0 on the pool object discriminant causes the 
  default subpool to not be created 
- Attempting to allocate from the default storage pool if the pool's 
  Default_Block_Size is 0 raises Storage_Error

deepend-2.3
- Since removing the bindings to the Apache Run Time pool library in
  the earlier deepend-1.1 version, deepend has been running much more
  slowly than the Apache Binding version, due to a logic error.
  Now the binary tree tests outperform the Apache runtime binding version. 
  e.g. For depth 20, the Apache version takes about 4.6 seconds to run.
  This new deepend version takes about 3.8 seconds to run. 

deepend-2.2
- Since Ada.Unchecked_Deallocate_Subpool doesn't exist, 
  Unchecked_Deallocate_Subpool and Unchecked_Deallocate_Objects need to 
  get same effect, by dispatching to Deallocate_Subpool. 
  Otherwise, these routine aren't doing anything. Once that is done, it 
  exposed a bug. The finalization of the pool cannot call 
  Unchecked_Deallocate_Subpool, because that leaves the protected object, 
  then tries to regain access to the protected object on the dispatching, 
  which leads to a deadlock. This bug was fixed, by simply calling code that
  frees the subpool objects.

deepend-2.1
- Renamed Scope_Bomb type to Scoped_Subpool_Handle
- Added Create_Subpool call that returns a Scoped_Subpool_Handle
- Changed binary tree test code to use Scoped_Subpool_Handles

deepend-2.0
- Major redesign to work with the Ada 2012 described in AI05-0111-3.
- Subpools can no longer have subpools. This did not seem to be necessary
  and added runtime complexity. Instead, the root pool can have any number
  of subpools concurrently.
- Synchronization added to pools subpool list, to allow tasks to create 
  subpools

deepend-1.3
- Added alternate preview of Ada 2012 version, depending on whether
  further changes can be made to the Ada 2012 proposal. The alternate
  version is intended to be considered as safer than the previous version
  since it avoids dangling reference possibilities for subpool handles.

deepend-1.2
- Removed binding to Apache Runtime Pools library. Deepend is now pure Ada 
  source.

deepend-1.1
-  Addressed comments from initial code review. 

deepend-1.0	- Initial Version