Re: terminate applications

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

Marin David Condic wrote:
> I think the answer is to have a standard library of stuff that provides 
> connections to common OS operations. Most OS's support some kind of 
> process kill capability - we just need a standard interface to it. In 
> "normal" conditions, you use the Ada task abortion. When you need some 
> specialized OS capability (such as killing without concern for cleanup, 
> etc.) you connect to the OS in a standard way and let it do the wet-work 
> for you.

First you ignored this code snippet for putting in any loops in an abort 
deferred region.  You should probably wrap OS calls in an abort deferred 
region with a tendancy to hang in an ATC with similar effects. Of 
course, better is not to put OS calls in protected objects, but 
sometimes, as in device drivers or interrupt handlers, it is necessary.

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;

Having said that, in one sense this argument is specious.  In Ada 83, 
abort meant "terminate with extreme predjudice."  Ada 83 code compiled 
with an Ada 95 compiler will have the same semantics--Ada 95 abort can 
only hang in the presense of Ada 95 extensions to Ada 83.

The argument that you couldn't abort the environment task in Ada 83 is 
also specious.  Ada 83 did not forbid it, but also did not provide a 
non-implementation specific name for the environment task.  However, the 
main program, or anything running in the main task could execute an 
abort with no argument, which aborted the environment task and all 
dependent tasks.

So the question should not be, "Is this feature in good taste?" but "Is 
this feature needed in the presence of the new Ada 95 extensions.  There 
are good arguments on both sides, but I tend to feel that such a 
super-abort or �berkill is necessary and should be provided in Annex D. 
  And as I also said, the procedure should do as much cleanup as 
possible, subject to a time limit, something like:

procedure Abort_All(Timeout: Duration);

So that Abort_All(3.0) allows for reasonable last wishes, and 
Abort_All(0.0) says kill everything now.  The reference manual can say 
that the Timeout value should be chosen to allow all non-abort deferred 
tasks to complete their cleanup.

-- 

                                                        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.