Operating Systems

Lecture 7

Agenda for Today Review of previous lecture The wait and exec system calls and

sample code Cooperating processes Producer-consumer problem Interprocess communication (IPC) and

process synchronization Recap of the lecture

Review of Lecture 6

Schedulers (long-, and short-, and medium-term)

Dispatcher Process creation and terminationfork and exit system calls

wait() The wait system call suspends the

calling process until one of its immediate children terminates, or until a child that is being traced stops because it has hit an event of interest.

wait returns prematurely if a signal is received. If all children processes stopped or terminated prior to the call on wait, return is immediate.

Synopsis of wait()

#include <sys/types.h>

#include <sys/wait.h>

pid_t wait(int *stat_loc);

<sys/types.h>:

/usr/include/sys/types.h

wait() ... If the call is successful, the

process ID of the terminating child is returned.

If parent terminates all its children have assigned as their new parent, the init process. Thus the children still have a parent to collect their status and execution statistics.

wait() ...

Zombie process—a process that has terminated but whose exit status has not yet been received by its parent process or by init.

Sample Code—fork#include <stdio.h>

void main()

{

int pid, status;

pid = fork();

if(pid == -1) {

printf(“fork failed\n”);

exit(1);

}

Sample Code—fork if(pid == 0) { /* Child */

printf(“Child here!\n”);

exit(0);

}

else { /* Parent */

wait(&status);

printf(“Well done kid!\n”);

exit(0);

}

}

Semantics of fork

P

P

fork

exec()

Typically the exec system call is used after a fork system call by one of the two processes to replace the process’ memory space with a new executable program.

The new process image is constructed from an ordinary, executable file.

exec()

There can be no return from a successful exec because the calling process image is overlaid by the new process image

Synopsis of exec()

#include <unistd.h>

int execlp (const char *file, const

char *arg0, ..., const char *argn,

(char *)0);

Sample Code—fork and exec

#include <stdio.h>

void main()

{

int pid, status;

pid = fork();

if(pid == -1) {

printf(“fork failed\n”);

exit(1);

}

Sample Code—fork and exec

if(pid == 0) { /* Child */

if (execlp(“/bin/ls”, “ls”, NULL)< 0) {

printf(“exec failed\n”);

exit(1);

}

}

else { /* Parent */

wait(&status);

printf(“Well done kid!\n”);

exit(0);

}

}

Semantics of fork

P

P

fork

parent

child

P

P

parent

child

exec ls

P

ls

parent

child

1 2 3

Cooperating Processes Independent process cannot

affect or be affected by the execution of another process.

Cooperating process can affect or be affected by the execution of another process

Cooperating Processes Advantages of process cooperation

Information sharing Computation speed-up Modularity Convenience

Paradigm for cooperating processes, producer process produces information that is consumed by a consumer process. unbounded-buffer places no practical

limit on the size of the buffer bounded-buffer assumes that there is

a fixed buffer size

Producer-Consumer Problem

Bounded-Buffer Problem

ProducerProducer ConsumerConsumer

Empty Pool

Full Pool

Bounded-Buffer Solution Shared data

#define BUFFER_SIZE 10

typedef struct {

. . .

} item;

item buffer[BUFFER_SIZE];

int in = 0;

int out = 0;

Solution is correct, but can only use BUFFER_SIZE-1 elements

Producer Processitem nextProduced;

while (1) {

while (((in + 1) % BUFFER_SIZE) == out)

; /* do nothing */

buffer[in] = nextProduced;

in = (in + 1) % BUFFER_SIZE;

}

Consumer Process

item nextConsumed;

while (1) {while (in == out)

; /* do nothing */nextConsumed = buffer[out];out = (out + 1) % BUFFER_SIZE;

}

Interprocess Communication (IPC)

Mechanism for processes to communicate and to synchronize their actions.

Message system – processes communicate with each other without resorting to shared variables.

IPC facility provides two operations:Send (message) – message size

fixed or variable Receive (message)

Interprocess Communication (IPC)

If P and Q wish to communicate, they need to:establish a communication link

between themexchange messages via

send/receive

Interprocess Communication (IPC)

Implementation of communication linkphysical (e.g., shared memory,

hardware bus) logical (e.g., logical properties)

Interprocess Communication (IPC)

Implementation Questions

How are links established? Can a link be associated with more

than two processes? How many links can there be

between every pair of communicating processes?

Implementation Questions

What is the capacity of a link? Is the size of a message that the

link can accommodate fixed or variable?

Is a link unidirectional or bi-directional?

Direct Communication

Processes must name each other explicitly:send (P, message) – send a

message to process PReceive (Q, message) – receive a

message from process Q

Direct Communication

Properties of communication link Links are established automatically. A link is associated with exactly one

pair of communicating processes. Between each pair there exists

exactly one link. The link may be unidirectional, but is

usually bi-directional.

Indirect Communication

Messages are directed and received from mailboxes (also referred to as ports). Each mailbox has a unique id. Processes can communicate only if

they share a mailbox.

Indirect Communication … Properties of communication link

Link established only if processes share a common mailbox

A link may be associated with many processes.

Each pair of processes may share several communication links.

Link may be unidirectional or bi-directional.

Operations create a new mailbox send and receive messages through

mailbox destroy a mailbox

Primitives are defined as:send (A, message)

receive (A, message)

Indirect Communication …

Mailbox sharingP1, P2, and P3 share mailbox A.

P1, sends; P2 and P3 receive.

Who gets the message?

Indirect Communication …

SolutionsAllow a link to be associated with

at most two processes.Allow only one process at a time

to execute a receive operation.Allow the system to select

arbitrarily the receiver. Sender is notified who the receiver was.

Indirect Communication …

Synchronization Message passing may be either

blocking or non-blocking. Blocking is considered

synchronous Non-blocking is considered

asynchronous send and receive primitives may

be either blocking or non-blocking.

Buffering Queue of messages attached to the

link; implemented in one of three ways.

Zero capacity – No messages Sender must wait for receiver

Bounded capacity – n messagesSender must wait if link full.

Unbounded capacity – infinite length Sender never waits.

Recap of Lecture Review of previous lecture The wait and exec system call and

sample code Cooperating processes Producer-consumer problem Sample codes Interprocess communication (IPC) and

process synchronization Recap of the lecture