Question

Describe a message-transfer protocol for buffered sends and receives in which the
buffering is performed only by the sending process. What kind of additional hardware
support is needed to make these types of protocols practical?

Answer 1

Principles of Message-Passing Programming:--

1. The logical view of a machine supporting the message-passing paradigm consists of p processes, each with its own exclusive address space.
2. Each data element must belong to one of the partitions of the space; hence, data must be explicitly partitioned and placed.
3. All interactions (read-only or read/write) require cooperation of two processes – the process that has the data and the process that wants to access the data.
4. These two constraints, while onerous, make underlying costs very explicit to the programmer.

Principles of Message-Passing Programming:--

1. Message-passing programs are often written using the asynchronous or loosely synchronous paradigms.
2. In the asynchronous paradigm, all concurrent tasks execute asynchronously.
3. In the loosely synchronous model, tasks or subsets of tasks synchronize to perform interactions. Between these interactions, tasks execute completely asynchronously.
4. Most message-passing programs are written using the single program multiple data (SPMD) model.

The Building Blocks: Send and Receive Operations:--

1. The prototypes of these operations are as follows: send(void *sendbuf, int nelems, int dest) receive(void *recvbuf, int nelems, int source)
2. Consider the following code segments: P0 P1 a = 100; receive(&a, 1, 0) send(&a, 1, 1); printf("%d\n", a); a = 0;
3. The semantics of the send operation require that the value received by process P1 must be 100 as opposed to 0.
4. This motivates the design of the send and receive protocols.

Buffered Blocking Message Passing Operations:-

Bounded buffer sizes can have significant impact on performance

P0

for (i = 0; i < 1000; i++)

{ produce_data(&a);

send(&a, 1, 1);

}

P1

{ for (i = 0; i < 1000; i++)

receive(&a, 1, 0);

consume_data(&a);

}

What if consumer was much slower than producer?