Re: gnat: time-slicing

["David C. Hoos" <david.c.hoos.sr@ada95.com>]

----- Original Message -----
From: "Jan Prazak" <janp9@gmx.net>
Newsgroups: comp.lang.ada
To: <comp.lang.ada@ada.eu.org>
Sent: Monday, July 15, 2002 2:10 PM
Subject: Re: gnat: time-slicing


<snip>
> Where should this be placed? This looks like the suggestions from David,
> he suggested "Delay 0.02" after each Put_Line, but it gives not the
> result I want.
What result did it give?

When I ran your program on my RedHat 6.2 box with dual 1.0 gHz. processors,
it gave the result you wanted.

When I ran it on my Win2K box with one 1.8 gHz. processor, it gave the reult
a
a
b
b

When I added the suggested delay statements, it gave the result
b
a
b
a

which interleaves the actions of the tasks, but with Task_A beginning
execution before the main program.

There is no way your program can be deterministic over different
OSs, and hardware platforms.  Time slicing will not do it either.

>
> Think of a timer:
>
> task Timer is ...
> ...
> loop
>   Delay 1.0;
>   Put(current_time);
> end loop;
> ...
>
> The task uses one Put, which puts current time somewhere on the screen.
> And this task has to be completely independent from other tasks (= main
> procedure). There has to be a way to do this with gnat, and that's also
> my question. I don't want to slow down other tasks with "Delay", just to
> let Timer-task do the next step (for example when doing some difficult
> computing, maybe array-sorting or similar things), so there has to be a
> "direct" way (like a pragma).
This restatement of what you want to do is completely different from what
you described in your original post.

If I understand what you want is a task that will run once per some time
interval
independently of the other task(s).

Here is an example of how that can be done:

   Interval : constant Duration := 1.0;
   use type Ada.Calendar.Time;
   Next_Time : Ada.Calendar.Time :=
       Ada.Calendar.Clock + Interval;
begin
    loop
        Delay until Next_Time;
        Next_Time := Next_Time + Interval;
        ......
   end loop;


Since delays are for a _minimum_ of the specified time, using a simple
delay statement in a "timer" will result in an accumulation of time error.

What I have shown above will put the task on the ready queue for its
priority at precisely Interval-second intervals without accumulation of
time errors.

However, just how soon after the task becomes ready it will actually
run depends on what other tasks are running, their priorities relative to
the priority of the "timer" task, and whether these other tasks are
"civilized" about yielding the CPU from time-to-time if they are compute-
intensive.

For example, if you have a compute-intensive task that executes a
delay 0.0 statement no time will be lost if there is no other task ready
to run.  But, when your timer task is ready, and is of a higher priority,
it will run when given the opportunity.