Re: 4 beginner's questions on the PL Ada

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

This is getting a bit esoterical -- beyond the simple questions the
OP was asking about how to print out the Image of a task!
But anyway:

Adam Beneschan <adambeneschan@aol.com> writes:

> But there's another factor: if you allocate a task (or a record
> containing a task), using Unchecked_Deallocation (or automatic memory
> reclamation) won't terminate the task.

Well, there's no notion in Ada of "to terminate a task" (as in "task T1
terminates T2").  Tasks terminate themselves.  Normally, when they're
done.  In the case of "terminate" alternatives of select statements, a
task signals that it is in a ready-to-terminate state, and then gets
told to go ahead and terminate itself.  In the case of "abort", the task
is told to terminate itself as soon as possible after it is out of any
abort-deferred region.

In no case does a task get terminated from outside itself.
And that's as it should be.  Anything else is just asking for
all sorts of race conditions.

So I claim it makes no sense at all for Unchecked_Deallocation of an
object containing tasks to terminate those tasks.  And I don't think
it makes sense for U_D to abort those tasks (and then what? wait for
them to terminate themselves?  Or just go ahead, and hope they do so?).

>...That's just the way the
> language authors decided.  This discussion has come up before, and
> it's surprised other people that a task will still run after
> Unchecked_Deallocation has been used on it, but there were reasons why
> things are the way they are.  I don't remember the reasons, though.

I think it would make sense for U_D to await the termination of those
tasks, and then free up the memory.

But the actual Ada semantics are admittedly weird:  U_D on an object
containing running tasks doesn't free all the memory, but it expresses
a hope that the memory will be freed when the tasks terminate.
GNAT was recently changed so that "hope" comes true, but it's not
required, and older versions of GNAT, and probably other compilers,
just leak memory if you do U_D on running tasks.

- Bob