// ************************************************************************** //
//                                                                            //
//    eses                   eses                                             //
//   eses                     eses                                            //
//  eses    eseses  esesese    eses   Embedded Systems Group                  //
//  ese    ese  ese ese         ese                                           //
//  ese    eseseses eseseses    ese   Department of Computer Science          //
//  eses   eses          ese   eses                                           //
//   eses   eseses  eseseses  eses    University of Kaiserslautern            //
//    eses                   eses                                             //
//                                                                            //
// ************************************************************************** //
// filename:    ./ComputerArchitecture/AsynchronousCircuits/                  //
//              AsyncArbiterBoch82/Client.qrz                                 //
// author:      Manuel Gesell                                                 //
//                                                                            //
// description:                                                               //
// The arbiter is based on a four-cycle signaling scheme between a client and //
// a server. Both modules communicate via the two signals req and ack with each//
// other. The client's output is thereby the req signal and its input is the  //
// ack signal, and conversesly the server's output is the ack signal and its  //
// input is the req signal. The protocl works then as follows:                //
//                                                                            //
//     (1) In the first phase, the client may or may not raise its req        //
//  signal. If it raises the req signal, the req signal must remain           //
//  true until ack is seen.                                                   //
//     (2) After the client raised req, the control is now on the side of the //
//  server which must now raise the ack signal. The ack signal must           //
//  remain true until the req signal becomes false.                           //
//     (3) After the server has raised the ack signal, the control comes back //
//         to the client. The client will now lower the req signal and the    //
//  req signal must remain low until the ack signal becomes also false.       //
//     (4) After the client hs lowered the req signal, the control comes back //
//  to the server. The server will now lower the ack signal.                  //
// There may be arbitrary delay times between these phases, but all delays    //
// should be finite.                                                          //
// ************************************************************************** //
package ComputerArchitecture.AsynchronousCircuits.AsyncArbiterBoch82;


module Client(bool ?react,!req,?ack) {
    loop {
        await(react);
        req = true;
        await(ack);
        await(react);
        req = false;
        await(!ack);
    }
}