reclamation of memory for dynamic ada tasking  while working on several large-scale ada projects, i have found what i consider a major problem with the ada tasking mechanism, that is, the reclamation of memory allocated to a dynamic task after the task has been terminated. i have written my own utility package to specifically deallocate the memory assigned to any such task.  the problem arises from the fact that dynamically created tasks are generated by the use of allocators. the ada language reference manual ( lrm ) states  "an implementation must guarantee that any object created by the evaluation of an allocator remains allocated for as long as this object or one of its subcomponents is accessible directly or indirectly, that is, as long as it can be denoted by some name."1  this stipulation presents an interesting problem when applied to tasks. if the access type of a task is created within a library unit, memory allocated to execute this task will remain allocated for the entire span of the execution of program, even though the actual task object may have been terminated. diagram 1 illustrates that memory is retained after a task is terminated.  a more truly dynamic tasking model is needed in the ada language. the model which is provided within the language does allow for the creation of tasks at runtime. this facility is useful when creating tasks that exist for the lifetime of the program, or for applications where memory management is not relevant. the problem with the current tasking model is that it does not allow a task, whose master is a library unit, to be created dynamically, to perform a specific action, and then to terminate and release all the memory reserved for the execution of the task.  this failure to properly deallocate memory seems to be a problem inherent in the ada language. it was at first believed that the algorithms used in ada compilers to implement dynamic allocation of objects would enable them to perform sufficient garbage collection to improve management of the heap at runtime. this, however, did not prove to be the case. an optional unchecked_deallocation procedure was added to the standard predefined library units that may be delivered with an ada development system. the unchecked_deallocation procedure does solve the problem of most storage reclamation, but the developers of the language did not allow memory allocated to dynamically created task objects to be reclaimed in a similar manner. the lrm states "if x designates a task object, the call free(x) has no effect on the task designated by the value of this task object."2 i suspect that this specification was an attempt to prevent deallocating a currently active task.  because the language implementors are specifically prohibited from properly deallocating dynamic task memory, it is left to the individual ada programmer to implement his or her own solution. for my solution i have identified two major functions which any algorithm attempting to solve this problem must address. first, the algorithm must have the ability to dynamically create tasks whose masters are blocks that can be exited, reclaiming the memory used to execute the tasks. second, the algorithm must increase the scope of this task to areas outside of this block to allow task communication. this increase of scope must be done within the confines of the ada language so that the utility is portable.  the concept behind the utility is the declaration of an access type of a task type within a block statement or a subprogram that can be exited after the completion of the task ( see diagram 2 ). i will refer to this block as the master block. since the access type is declare inside the master block, any task that is created by an allocator of that access type ( referred to as the dynamic task ) will have the master block as its master. after the task is terminated, the block is exited and all the storage allocated to that task is reclaimed.  note that if the environment task ( the task that calls the main program ) were to call the master block, all other activity within the environment task would be suspended until the dynamic task completed. upon completion, control would be released from the master block and given back to the environment task. the same effect would be exhibited by any other task calling the master block. obviously, this reduction of execution to a fully sequential path is not acceptable; a second task must be created which can call the master block. i will refer to this task at the base task.  task communication can be accomplished by use of the unchecked_conversion utility ( see diagram 2 ). to provide visibility to the dynamically created task, the access type within the master block is not checked when converting it to an object of a second access task type who's master is the program unit. this point will be elaborated on in the task communication section.  several more complex questions remain in the description of the algorithm.  how does the algorithm create more than one task?  how does the algorithm determine when a task is terminated?  how does the algorithm control access to the pointers to prevent access to deallocated storage?  how does the algorithm allow for rendezvous with these tasks?  these questions are addressed individually below.  philip j. lefebvre