Re: Delayed deallocation of non-terminated task in Gnat?

[Robert A Duff <bobduff@shell01.TheWorld.com>]

"J-P. Rosen" <rosen@adalog.fr> writes:

> Le 31/08/2011 20:12, Robert A Duff a �crit :
>> I consider it a flaw in Ada that there's no general-purpose
>> way to block waiting for the termination of a task.
>> 
> With some cooperation of the other task...
>
> Declare in the waited task an entry (Wait_For_Terminate) which is never
> accepted. The waiting task calls the entry, and gets Tasking_Error when
> the waited task terminates (for whatever reason).

We thought of that while implementing the feature that started this
thread.  Unfortunately, it doesn't quite work.  The Tasking_Error is
raised when the task is completed, so at the time T_E is handled, the
other task could still be going about its business doing finalization.
And even if there's no user-level finalization involved, there's still
some stuff going on in the run-time system between completion and
termination.  So there's an inherent race condition here.

What I claim is missing from Ada (and is hard to implement) is a feature
that blocks a task until some other task(s) is/are really and truly
terminated, and won't execute a single 'nother instruction.

You can loop, checking 'Terminated, with a delay.  But the delay is
guaranteed to be either too long or too short -- most likely both.  The
feature we're talking about was implemented because there was such a
loop, and it was causing an AdaCore customer's program (with thousands
of dynamically allocated tasks) to take half an hour.  After
implementing this feature, and removing the loop-with-delay, it took a
few seconds.

- Bob