----------------------------------------------------------------------
Mohamed G. Gouda                                     CS 356
Fall 2005                                            Solution to HW 2 
----------------------------------------------------------------------

1.

process p[i:0..n-1]

inp m      : integer         {m>0}

var conp   : boolean,        {initially, false}
    cansnd : 0..m,
    sp,sq  : integer,
    x,y    : integer

begin
   ~conp  -> send crqst(sp) to q
 
[] rcv crply(x,y) from q ->
       if ~conp ^ sp=x   -> conp, cansnd, sq := true, m, y
       [] conp v sp != x -> skip
       fi

[] conp -> 
       if cansnd > 0 -> send data(sp, sq) to q;
                        cansnd := cansnd - 1;
       [] true       -> send drqst(sp, sq) to q;
                        cansnd := 0
       fi

[] rcv drply(x,y) from q ->
       if sp = x  -> conp, sp := false, sp + 1
       [] sp != x -> skip
       fi
end

process q

const n

var conq : boolean,  {initially, false}
    sq   : integer,
    with : 0 .. n-1
    x,y  : integer

par i    : 0 .. n-1

begin
   rcv crqst(x) from p[i] ->
       if ~conq -> conq, with, y := true, i, sq;
                   send crply(x,y) to p[i]
       [] ~conq -> conq, sq, y := false, sq+1, sq; 
                   send drply(x,y) to p[i]
       [] conq ^ with=i  -> 
                   if true -> conq, with, y := true, i, sq;
                              send crply(x,y) to p[i]
                   [] true -> conq, sq, y := false, sq+1, sq; 
                              send drply(x,y) to p[i]
                   fi
       [] conq ^ with!=i -> send drply(x,sq) to p[i]  
       fi

[] conq -> conq, sq := false, sq+1

[] rcv data(x,y) from p[i] ->
       if sq != y -> {discard data msg} send drply(x,y) to p[i]
       [] sq = y  -> {store data msg} skip
       fi

[] rcv drqst(x,y) from p[i] ->
       if sq !=y -> skip
       [] sq = y -> conq, sq := false, sq+1
       fi; send drply(x,y) to p[i]
end	
              
----------------------------------------------------------------------

2. 

process q
const r
var rcvd : array[integer] of boolean, {initially, every rcvd[k]=false}
    exp  : integer,                   {initially, 0}
    i    : 0..r 

begin 
   rcv data(i) from p -> 
       if exp mod (r+1) = i  -> rcvd[exp], exp := true, exp+1
       [] exp mod (r+1) != i -> 
              do exp mod (r+1) != i -> exp := exp + 1 od; 
              rcvd[exp], exp := true, exp+1
       fi
end 

----------------------------------------------------------------------

3.

length of longest solid corruption burst that can be detected =

   if m is even -> (m+1)*n
   [] m is odd  -> (m+1)*n - 1 
   fi

----------------------------------------------------------------------

4. 

process p

const n
var   i : 0 .. 2*n

begin
   true -> i := 0
           do i<n -> send data(i) to q; i := i+1 od; i := 0;
           do i<n -> send data(i) to q; i := i+1 od;
           do i<2*n -> send data(i) to q; i := i+1 od; i := n; 
           do i<2*n -> send data(i) to q; i := i+1 od
end

process q

const n
var exp : 0 .. 2*n-1,  {initially, 0}
    i   : 0 .. 2*n-1   

begin
   rcv data(i) from p -> 
       if exp = i  -> {accept data(i)} exp := exp +2*n 1
       [] exp != i -> {reject data(i)} skip
       fi
end

----------------------------------------------------------------------