• A very common pattern in parallel programming.
• Several client processes request some service in any order.
• A server process loops on the following: receiving a request, processing the request, sending the result back.

The simple model: the server receives a request and processes it right away.

Server() {
  while (true) {
    Recv(request, any_source);
    client = source;
    result = Process(request);
    Send(result, client);
  }
}

Client() {
  while (true) {
    request = Generate_request();
    Send(request, server);
    Recv(result, server);
    Process_result(result);
  }
}

A more complex model: using a queue of requests.

• This model supposes that the requests come in faster then they can be executed.
• The server receives the requests from the clients and stores them in a queue.
• The server must also store the identity of the client when it stores the request so that it knows which client to send the result to.
• The queue of request and of clients are synchronized.
• In the loop, it chooses randomly either to receive a new request, or to execute one from the queue.
• When the server decides to receive a new request, no client process may be sending it one, so it's better to use a non-blocking receive for the server.

Server() {
  Queue clientq, requestq;

  Initiate_receive(request, any_source); // non-blocking
  while (true) {
    choose randomly between
      Process_request(clientq, requestq);
      Get_request(clientq, requestq, request);
}

Process_request(clientq, requestq) {
  if (!requestq.is_empty()) {
    request = requestq.dequeue();
    client = clientq.dequeue();
    result = Process(request);
    Send(result, client);
  }
}

Get_request(clientq, requestq, request) {
  if (Received(request)){
    client = source;
    clientq.enqueue(client);
    requestq.enqueue(request);
    Initiate_receive(request, any_source);
  }
}

In a more complex model, we could sort the tasks by order of priority in the queue. To avoid a deadlock, the priority of any task in the queue should increase with time.