Message Passing Tutorial: Difference between revisions

You should have a structure to be sent to another threadprocess. I'll refer to this as the message, and I will assume you have these fields:

Sending and receiving must be atomic. This means you must prevent task switches until it's finished. I have two different timertimers in my OS, one for the wallclock, and another for preemption. So for me this means masking the latter, and reenabling it at the end. You could also use a [[mutex]] or [[semaphore]] to accomplish mutual exclusion.

Blocking and non blocking: the sender can be blocked upon sendsending a message, but this does not necessarily have to be so. ReceiverThe receiver must block if there's no message waiting. Blocking means the OS will remove the process from ready queue, and won't allocate CPU resourceresources for it until the blockade canceledis cancelled. When it happens, it simply puts back the process toback into the ready queue (most likely to the top), so next time it gains CPU, it can run. Processes on the blocked queue will not use any CPU time. This savesprevents you froma [[busy loop]].

You should maintain a queue for every process to record blocked waiting processes. This queue must not be a circular buffer, you can implement it as a simple chained list. I assume you have written the following functions already (they will be required by the tutorial):

Now a few words on synchronization: if it's asynchronous, it means the sender is not interested whether the receiver accepts the message or not. It will send the message and move on (won't block). This also means the message could be lost, hence messaging is unreliable. On the other hand, a synchronous sender will wait (block) until the message is delivered, this creates a randezvousrendezvous point (so the sender process and the receiver process will run synchronized after the message is accepted). Also because the sender knows when and if the message has arrived, it's a reliable messaging system.

Finally, [[circular buffer]]. It's a FIFO (First In, First Out) buffer. It's implemented by pointers (or indeces) head and tail. If you push something in a FIFO, it will be stored at the memory pointed to by head, and head will be adjusted. On pop, the item will be read from the memory pointed to by tail, and tail will be adjusted. If head or tail reaches the end of the buffer, they will wrap around.

You could calculate the number of items in the buffer byusing the head- and tail variables, but as being circular, there's a special case which cannot be handled without a count variable: head will be equal to tail if the buffer is empty, and also when it's full.