-------------------------------------------------------------------------------
Mohamed G. Gouda                                        CS 356
Spring      2007                                        Homework 2 Solution

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

1. (4 points)

process p

var   conr : boolean         {init. false}
      cons : boolean         {init. false}

begin
     timeout ~conr ^ (#ch.p.q + #ch.q.p=0) -> send crqst to q

[]   rcv crply from q -> conr, cons := true, true

[]   conr -> if cons -> send data to q
             [] true -> send drqst to q; cons:=false
             fi

[]   rcv data from q -> if conr  -> {accept data} skip
                        [] ~conr -> {discard data} skip
                        fi

[]   rcv drply from q -> conr:=false

end

----

process q

var   conr : boolean         {init. false}
      cons : boolean         {init. false}

begin
    rcv crqst from p -> if true -> conr := false; send drply to q
                        [] true -> conr := true; send crply to q
                        fi; cons := false

[]  rcv data from p -> if  conr -> {accept data} cons:= true
                       [] ~conr -> {discard data} send drply to p
                       fi

[]  cons -> send data to p

[]  conr -> conr, cons := false, false;

[]  rcv drqst from p -> conr, cons := false, false; send drply to p

end

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

2. (3 points)

process p
const   m,n
inp	dp : array[integer] of 0..255
var	pp : array[0..n-1] of 0..255
	x  : integer, 			{index of dp, init. = 0}
	i  : 0..m
	j  : 0..n-1

begin
	true -> pp, i, j := 0,0,0;

	do i<m -> send byte(dp[x]) to q;
		  pp[j], x, j := pp[j] xor dp[x], x+1, j +n 1;
		  if j=0  -> i := i+1
 		  [] j!=0 -> skip
		  fi;
	od; {i=m ^ j=0}

	do j<n-1 -> send byte(pp[j]) to q; 

		    j:=j+1
	od;
	send byte(pp[n-1]) to q
end

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

3. (3 points)

process p
const  n
inp    txt : array[integer]of integer 

var    i   : integer, 			{index of txt, init. 0}
       s   : 0..(2n-1)			{seq. number of next message, init. 0}

begin
	true -> send data(txt[i], seq) to q;
		i, s := i+1, s +2n 1
end

---


process q
const  n
var    txt  : array[integer]of integer,
       i    : integer, 			    {index of txt, init. 0}
       exp  : 0..(2n-1), 		    {seq. # of exp. message init. 0}
       bff  : array[0..(2n-1)] of boolean,  {init. false}

       rcvt : array[0..(2n-1)] of integer,  {received text out of order}
       t    : integer, 			    {received text}
       s    : 0..(2n-1)			    {received seq. number}

begin
      rcv data(t,s) from p -> rcvt[s], buff[s] := t, true;
			      do buff[exp] ->
				  txt[i], i, exp, bff[exp] = rcvt[exp], i+1, exp +2n 1, false
			      od
 			      

end