Message-Passing Concurrency

A port is an asynchronous FIFO communication channel that supports two operations:

• {New Port S P} that creates a new port P and a stream S.
• {Send P X} appends X to a stream corresponding to port P.

• Client sends a request for the server and then waits for reply.

• Similar to RMI, but the client continues its execution after sending the request.

• Like RMI, but the server calls the client in order to fullfill a request.
• The server knows the client's reference because it's part of the message.
• The client needs to create a new thread to wait for the server, to avoid deadlocks.

The solution of the previous example creates a new thread for each client call. This assumes that threads are inexpensive. How do we solve the problem if we are not allowed to create a new thread? The solution is for the client to pass a continuation to the server. After the server is done, it passes the continuation back to the client so that the client can continue. In that way, the client never waits and deadlock is avoided.

(Van Roy and Haridi 2004, 358 chap.5 part.5.3.4)

% server side
proc {ServerProc Msg}
  case Msg
  of calc(X Client Cont) then X1 D Y in
    {Send Client delta(D)}
    X1=X+D
    Y=X1*X1+2.0*X1+2.0
    {Send Client Cont#Y}
  end
end
Server={NewPortObject2 ServerProc}

% client side
proc {ClientProc Msg}
  case Msg
  of work(?Z) then
    {Send Server calc(10.0 Client cont(Z))}
  [] cont(Z)#Y then
    Z=Y+100.0
  [] delta(?D) then
    D=1.0
  end
end
Client={NewPortObject2 ClientProc}
{Browse {Send Client work($)}}

• Same as the previous method, but uses a procedure instead of a record.

proc {ClientProc Msg}
  case Msg
  of work(?Z) then
    C=proc {$ Y} Z=Y+100.0 end
  in
    {Send Server calc(10.0 Client cont(C))}
  [] cont(C)#Y then
    {C Y}
  [] delta(?D) then
    D=1.0
  end
end
Client={NewPortObject2 ClientProc}
{Browse {Send Client work($)}}

In this model, a concurrent component is a procedure with inputs and outputs. When invoked, the procedure creates a component instance, which is a port object. An input is a port whose stream is read by the component. An output is a port to which the component can send.

(Van Roy and Haridi 2004, 362 chap.5 part.5.4.1)

• Concurrent Components interact with their environment via interfaces, which consists as a set of inputs/outputs (collectivelly know as wires).
• There are two basic kinds of wires:
  • One-Shot
  • Two-Shot

• Instantiation: Creates an instance of an component.
• Composition: Builds a new component out of other components.
• Linking: Combines component instances by connecting inputs/outputs (wires) together.
• Restriction: Restricts visibility of inputs or outputs.

The following set ofdesign rules makes developing concurrent programs easier:

• Informal Specification: Write down an informal (but realistically precise) specification.
• Components: Enumerate all the different forms of concurrent activity.
• Message Protocols: Define what kinds of messages the components will send and their protocols.
• State Diagrams: For each concurrent entity, write its state diagram.
• Implement and Schedule: Implement the system and pick a scheduling algorithm.
• Test and Iterate: Until you get a satisfactory system.

The nondeterministic concurrent model is the model used by concurrent logic programming. It is sometimes called the process model of logic programming, since it models predicates as concurrent computations.

(Van Roy and Haridi 2004, 395 chap.5 part.5.8.1)