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 requests and of clients are synchronized.
• In the loop, it chooses randomly either to receive a new request, or to execute one from the queue. Instead of this, the server can be implemented using two threads: one focused only on receiving requests, one focused only on processing them. The two threads synchronize using the queues.
• 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.

Peer to Peer Systems

• An alternative to the client-server model where the clients are also repositories or resources and can contribute to the network.
• Typical applications: Skype, software updates for massively multi-client systems.
• Some specialized (super)nodes keep the system working, connecting a node that needs a resource with one that might have it.
• Both are examples of the idea of modularity.