Operating System Concepts and Techniques Lecture 14

Operating System Concepts and

Techniques Lecture 14

Interprocess communication-3

M. Naghibzadeh

ReferenceM. Naghibzadeh, Operating System Concepts and Techniques, irst ed., iUniverse Inc., 2011.

To order: www.iUniverse.com, www.barnesandnoble.com, or www.amazon.com

Main program to spawn producer and consumer processes

void main (void){

int pid; pid = fork();

if (pid != 0) producer(); else consumer();

}

2

Semaphore adv/disadvAdvantages

A general solution for binary and integer constraints

No busy-wait; if a process wants to use an unavailable resource it sleeps in the queue

of waiting processes for that resource

Disadvantages Somewhat difficult to use, but remember, OS

designers are highly skilled

3

 Dijkstra’s P and VDijkstra first implemented down and up

methods as followsP(s)

s = s-1;if s < 0 wait (s);

 V(s)

s = s+1;if s ≤ 0 signal(s);

It is simple, symmetric, and it knows how many processes are waiting for the resource

With down and up we do not know how many processes are waiting for the resource

4

Monitor Based IPCMonitor concept is for simplifying

the implementation of MEPrimitives are:

Wait Signal

On condition variables wait and signal may be executed

Only one process could be inside monitor at any time ME

5

Sample monitorclass insert_remove : public monitor

{ private: condition available, occupied;

int count; public:

  insert (struct buffer_slot &entity);

{ if (count == BC) wait (&available); insert_entity(&entity);

count = count +1; if (count ==1) signal(&occupied) }

  remove (struct buffer_slot &entity)

{ if (count == 0) wait (&cooupied); remove_entity(&entity);

count = count - 1; if (count = BC-1) signal(&available); }

Insert_remove (condition available=BC, condition occupied=0, int count=0);

}insert_remove IR;

6

Producer-Consumer class producer_consumer

{ private:

struct buffer_slot entity; public:

producer() {

while (true) { produce_entity (&entity);

IR.insert (&entity) ; } }

  consumer()

{ while (true) {

IR.remove(&entity); consume_entity(&entity); }

} producer_consumer (struct buffer_slot entity =””);

}

7

Message-Based IPC method

Message is mainly used for information interchange between in distributed

systems, however, it can be used within standalone computers

There are two main system calls, send and receive; usually with the following

format send (source, destination, message)

receive (source, destination, message)

8

Blocking/Non-blockingSending/receiving could be blocking or non-

blocking; we are interested in non-blocking send and blocking receive

Blocking send: The execution of the sender process is suspended until the message is delivered and the receiver

informs the sender of the matter Nonblocking send: The sender executes the send and

continues its execution; The sender will not become aware of whether or not the message was actually delivered

Blocking receive: The receiver(s) executes a receive and waits until the message is fully received before proceeding

Non-blocking receive: The receiver executes a receive and continues its execution; if the message is available it is received, otherwise, when the message is received the kernel will send an

interrupt to the corresponding receiver process informing it of the receipt of message

9

How to enforce mutual exclusion

Suppose we have a common mailbox with one message in it

Whichever process grabs the message is allowed to use the critical resource

After the execution of its critical section, the process sends back the message to the

mailboxProper send and receive statements for this

purpose would be: receive (mailbox, message)

send (mailbox, message)

10

The producer procedureThe following is the initialization and

the producer#define true 1

#define BC 1000 // Buffer capacity void producer (void)

{ struct buffer_slot entity;

message msg1, msg2; while (true) {

produce_an_entity(&entity); receive (consumer, producer, &msg1); //Wait for consumer’s message

receive (mailbox,&msg2); //Get permission to use the entity-queue insert_the_entity(&entity); //Put entity in queue

send (mailbox, &msg2); //Free the resource, i.e., queue send (producer, consumer,&msg1); //One slot is filled

}}

11

The consumer procedurevoid consumer (void)

{ struct buffer_slot entity;

message msg1, msg2; for (i=0; i<BC; i++) send (consumer, producer, &msg1); //BC slots are

free while (true) {

receive (producer, consumer, &msg1); //Wait until there is an entity

receive (mailbox, &msg2); remove_the_entity(&entity);

send (maibox, msg2); send (consumer, producer,msg1);

consume_the_entity(&entity); }

}

12

Main program to spawn producer and consumer processes

void main (void){

int pid; message msg2;

send (mailbox, &msg2); pid = fork();

if (pid != 0) producer(); else consumer();

}

13

SummaryThe semaphore method does not suffer from

busy-wait; it is not restricted to two processes; it can be used in multiprocessor environments.

The message-based method is borrowed from distributed operating systems, but it works on

centralized systems, as wellDepending on the types of send and receive,

there are four possible combinationsNon-blocking send and blocking receive fits our need to solve problems like producer-consumer

In message passing solutions, message loss could pose a problem

14

15

Find outWhether a process can wake itself up after

sleeping due to the execution of wait(&s)If it is logical to execute wait (&mutex) before wait

(&available) in the producer-consumer problemThe correspondence between P and V on to down

and up, respectivelyHow can we modify down and up to count the

number of processes sleeping in the queue of a resource

What would happen if we used non-blocking receive for the implementation of producer

consumer

16

Any questions?