Dynamic Priority

[Adrian Lawrence <adrian.lawrence@xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx>]

URGENT events
~~~~~~~~~~~~~

The CSPP semantics for PRI PAR was a generalization of the transputer
implementation, written
               <-
          P_1  ||  P_2
               E

where E is the set of synchronized events.

Another version is

               <-
          P_1  ||  P_2
               <-
               E
where the lower <- is annotating the set E. Best I can do in ASCII...

Maybe           <-   
is              <-
better?    P_1  ||  P_2
                E

The difference is that in the original PRI PAR, it is only the unsynchronized
events that are promoted. But the second version promotes E as well. Which
seems right because they are in the alphabet of P_1.
One might regard that as a design flaw in the original PRI PAR?

I think that this may capture the essence of the "priority attached to events 
rather than processes" discussion?

Given that we need backwards compatibility, I suggest that we keep PRI PAR,
add the optional (CHAN of type priority), but add an extra keyword
URGENT to channel declarations which may only appear within the
SCOPE of a PRI PAR. (You might prefer URGENT to qualify PRI PAR, but we
just might want both URGENT and ordinary channels.)

Thus

PRI PAR (CHAN OF []INT priority)
  URGENT CHAN OF foo bar   :
  URGENT CHAN OF fizz bang :
  P0
  P1
  ...
  PN

This is rather tentative: just testing the water at this stage.

Abolish PRI PAR?
~~~~~~~~~~~~~~~~ 

I like the explicit control of PRI PAR.  And we now have a semantics so we
can prove properties of programs. But Barry and others argue that sometimes
(always?) the compiler is the right place in which to determine optimum
scheduler implementation details. But how do we arrange language bindings?

I suggest SATISFIES.
Thus: PAR can have an annotation like

PAR(SATISFIES PRED1, PRED2,...)

This asks the compiler to build a refinement of PAR that satisfies the
list of predicates. We will need to find a stylised form to express 
feasible predicates. That way we can still prove theorems at the existing
CSPP level, but we ought to be able to use the predicates as well. 

OK. Over to the compiler writers. Implementation please. :-)

Again, just flying a kite in the water.

Adrian
-- 
A E Lawrence, MA., DPhil.  	adrian.lawrence@xxxxxxxxxxxxxx
MicroProcessor Unit, 13, Banbury Road, Oxford. OX2 6NN. UK.                
Voice: (+44)-1865-273274,  Fax: (+44)-1865-273275