Re: Policies In Ada

[dewar@merv.cs.nyu.edu (Robert Dewar)]

Samuel said

  <<it's a feature of the default task dispatching policy
  ("FIFO_Within_Priorities").  Tasks run until they hit a
  "task dispatching point">>

That's wrong. The default dispatching policy is not specified
by the RM. You only get the above behavior if you specify
pragma Dispatching_Policy (FIFO_Within_Priorities), and
your compiler supports this pragma.

  <<-- a same-priority task CAN'T
  interrupt the current task.  To get time-slicing, you must
  use a Task_Dispatching_Policy pragma (AND the compiler
  must support a time-slicing policy, which is not required).>>

That's potentially misleading, since it implies that another
equal priority task cannot execute -- that's of course not
true on multi-processors. What is true is that a priority X
task will not get preempted by another priority X task.

  <<you get pot luck for task dispatching policy.  However,
  FIFO_Within_Priorities is still likely because it's easier
  to build than time-slicing.>>

That's likely wrong. Most Ada runtime systems are likely to be
built over the underlying threads, and typically these OS
level threads *do* support time slicing, so I would say
that time slicing is more likely if you are using a general
purpose compiler in default mode on top of an OS. 

The new version of GNAT on Solaris for example will give system
threads and time slicing as the default dispatching policy, but
if you use FIFO_Within_Priorities, then we use our own completely
Annex_D accurate threads package which does not give time slicing

  <<** For Ada 83 **
  I don't remember the rules for same-priority tasks (if any).>>

Not surprising, there are no rules governing this in Ada 83, i.e.
the behavior in Ada 83 is equivalent to Ada 95 in the absence of
a Dispatching_Policy pragma -- undefined.