Re: terminate applications

["Robert I. Eachus" <rieachus@attbi.com>]

Marin David Condic wrote:

> If Ada wants to be competitive against C, C++, Java or whatever else is 
> out there, it has to be focused on customer needs. It can't be dependent 
> on sending the customer to the competitor for features it can't or won't 
> support, or the customer just starts to wonder why he is bothering with 
> Ada when he has to have the other product anyway in order to get the job 
> done. Ada needs to provide "One-Stop Shopping" so a developer doesn't 
> need to look elsewhere for an answer.

As I have said, I think that you may have a need that should be 
addressed.  But remember what you are asking for here.  To get to the 
point where you need this feature in Ada, you have to use not normal 
(Ada 83) tasking but protected objects or asynchronous transfer of 
control.  Furthermore you have to place a blocking action--or more 
normally an endless loop--inside an abort deferred region.

As I said, I certainly agree that, especially for debugging situations, 
such a feature would be nice to have.  But the more I think about it, 
the more I think that the right solution may be to add a special 
procedure that breaks the abort deferral.  Let's see,

with Ada.Task_Identification; use Ada.Task_Identification;
procedure Exit_Abort_Deferred_Region is
begin
   if Is_Terminated(Current_Task) then raise Program_Error; end if;
end Exit_Abort_Deferred_Region;

Not very special after all, but you do need Ada.Task_Identification from 
Annex C.  And if you do insist on putting loops inside protected object, 
probably a useful tool to have around.  (For example, if you do a search 
through a linked list. Or use an AVL or other type of tree and do 
lookups.)  Putting that in busy waits inside protected objects and in 
other loops where you might have a problem solves part of the problem.

The other problem, of aborting a task that is waiting IN the OS has to 
be an implementation defined thing.  But it shouldn't be too hard to 
talk your vendor in to checking whether a task that is being aborted is 
waiting in an OS call and doing whatever OS specific thing is required 
to get out there.  Especially where Ada tasks correspond to OS threads, 
that shouldn't be too hard.  You don't care why that (abort protected) 
thread is not in a ready state in the OS, you want to kill any such 
threads.  (Since making a blocking call from an abort protected region 
is a bounded error, I don't think any langauge changes are required for 
this.)

-- 

                                                Robert I. Eachus

�In an ally, considerations of house, clan, planet, race are 
insignificant beside two prime questions, which are: 1. Can he shoot? 2. 
Will he aim at your enemy?� -- from the Laiden novels by Sharon Lee and 
Steve Miller.