Freezing an Ada task

Question

How can I freeze a task?

I mean, if I have a task

task body My_Task is
begin 
  accept Start;
  loop
    Put ("1");
    Put ("2");
    Put ("3");
    ...
    Put ("n");
  end loop;
end My_Task;

is there a way that I can "freeze" the task in its current state? If, for instance, the execution finished executing Put ("2");, how can I freeze it and later I can turn it to continue? I want to provoque a freeze from outside the task, and also from outside, order it to continue.

Update

I could sure implement, if I had the spec like

type State_Type is
  (RUN,
   FROZEN);

task type My_Task (State : State_Type) is
   entry Start;
end My_Task;

the body

task body My_Task is
begin 
  accept Start;
  loop
    Put ("1");
    Put ("2");
    Put ("3");
    ...
    Put ("n");

    loop 
     if State = RUN then exit; end if;
    end loop;
  end loop;
end My_Task;

but it would not be the case because I had to wait for the nth Put instruction line (i.e., the task would not be actually frozen, because the inside loop would be running).

Answer 1

You can use a "selective accept" to allow your task to be interrupted by an external caller (another task or the main program). You can't (easily) interrupt a task at an arbitrary point in its execution; instead, the task itself needs to determine when it will accept entry calls.

So you'll probably want to replace your sequence

Put("1");
Put("2");
Put("3");
...
Put("n");

by a loop that calls Put once on each iteration, with a select statement that's executed each time.

Here's a demo program that I just threw together. The counter increments once per second (approximately). The counter value is printed if Running is true; otherwise the loop proceeds silently. The main program alternatively calls Pause and Resume every 3 seconds.

The else clause in the select statement cause it to continue executing if neither entry has been called.

with Ada.Text_IO; use Ada.Text_IO;
procedure T is

    task Looper is
        entry Pause;
        entry Resume;
    end Looper;

    task body Looper is
        Running: Boolean := True;
        Count: Integer := 0;
    begin
        loop
            select
                accept Pause do
                    Running := False;
                end;
            or
                accept Resume do
                    Running := True;
                end;
            else
                null;
            end select;
            delay 1.0;
            if Running then
                Put_Line("Running, Count = " & Integer'Image(Count));
            end if;
            Count := Count + 1;
        end loop;
    end Looper;

begin -- T
    loop
        delay 3.0;
        Looper.Pause;
        delay 3.0;
        Looper.Resume;
    end loop;
end T;

There may be a more elegant approach than this. It's been a long time since I've really used Ada.

Answer 2

Wow, haven't seen an Ada question in awhile. Anyway whenever you need to pause a task you use the delay or delay until reserved words.

you would specify a time you want to resume execution, then say:

delay <time>

or

delay until <time>

I don't remember the exact details, but here is the Ada95 specification example: http://www.adaic.org/resources/add_content/docs/95style/html/sec_6/6-1-7.html

Answer 3

One aspect of the intent of the design underlying the Ada language is that behavior be explicit. An executing task that suddenly found itself "frozen" at an arbitrary point for no readily discernible reason--there being nothing in the task that would lead to that behavior--would be disconcerting at best. And possibly a bug if the task was not designed to allow for unexpected, arbitrary execution suspension. (I know OS time-slicing imposes this behavior on executing programs, but that's a function of the OS, not the programming language.)

In short, I would seriously question a design approach that relied on externally imposed task suspension. A task should know it's own state, thus know when it's safe to pause, and what invariants have to hold for pausing in order to ensure a proper resumption.

Answer 4

To get the granularity you need to correctly interrupt your put("x") sequence, you should write that as a procedure that saves its state within task my_task (knowing which atomic instruction has been executed).

Then I think you could then use a guard on your State_Type and only execute when not frozen. of course this will not stop the task, it will simply protect the put("x") sequence from being executed (which is what you want, i think!)

Answer 5

If you have a specific line where you would always like your task to wait, the solution is fairly easy: Just put an accept statement there. The task will hang until some other task calls that entry.

If you want to generalize this idea (so multiple tasks can be made to wait, or multiple different tasks can safely perform the release action), it might be better to encapsulate your State variable inside a protected object (as NWS suggested). The feature of protected objects was put in the language specifically to facilitate the creation of synchornization objects for tasks like this.

Answer 6

You mentioned, in response to one of the comments, that you want this because of some shared resources. The answer, then, seems to be that you want to wrap that shared-resource in a protected-object and call that protected-object's procedures/entries from the task; while a task is queued up on (or executing) a protected-object call it is put into the 'blocked' state until it returns thereby 'freezing' the further processing.

Edit: Added a code example.

---

With
Ada.Text_IO,
Ada.Strings.Fixed,
Ada.Numerics.Float_Random
;

with ada.Integer_Text_IO;
with Ada.Strings;

Use Ada.Numerics.Float_Random;
Procedure Experiment is

   Task Type Testing( Text : Not Null Access String ) is
      end Testing;

   protected Resource is
      procedure Write( Input : In String );
   private
   end Resource;

   Task Body Testing is
      G : Ada.Numerics.Float_Random.Generator;
      D : Duration := Duration( Random(G) );
   Begin
      delay  D;
      Resource.Write( Text.ALL );
   End Testing;

   protected body Resource is
      procedure Write( Input : In String ) is
      begin
         Ada.Text_IO.Put_Line( Input );
      end Write;

   end Resource;

   Function Make(Input : in String) Return Access Testing is
   begin
      Return Result : Access Testing:= New Testing( New String'(Input) );
   end Make;


   TaskList : Array (Positive Range <>) of Access Testing:=
     ( Make("Anger"), Make("Rage"), Make("Joy"), Make("Contentment") );
  Use Ada.Text_IO;
Begin

   Put_Line( "Terminating." );

End Experiment;

---

Note: The use of put_line is technically not thread-safe, and [IIRC] potentially blocking... so while the above should never deadlock such is not actually guaranteed.

Answer 7

I got also an answer from Anh Vo in comp.lang.ada (Freezing a task), which includes the Rendevouz also with task termination. With some adjustments, it gets:

task type My_Task is
   entry Start;
   entry Pause;
   entry Quit;
   entry Stop;
end My_Task;

-- (...)
task body My_Task is
begin
   Outer_Loop : loop
      select
         accept Start;

         Main_Loop : loop
            select
               accept Pause;

               select
                  accept Quit;
               or
                  accept Stop;
                  exit Outer_Loop;
               or
                  terminate;
               end select;
            or
               accept Stop;
               exit Outer_Loop;
            else
               Put ("Main code here");
               delay MYCYCLE; -- MYCYCLE is 2.0; (whatever)
            end select;
         end loop Main_Loop;
      or
         terminate;
      end select;
  end loop Outer_Loop;
end My_Task;

I confess I think this solution is very elegant.