1) List four design issues for which the concept of concurrency is relevant.

Answer:

The concept of concurrency is related to the things that happen at the same
time in a system. Concurrency leads to the following issues.

Deadlock: Two or more processes executing in parallel wait for the resource
that is held by another waiting process. These processes never run to
completion and the situation is termed as deadlock.

Mutual exclusion: It is used to prevent simultaneous access to a shared

resource. It is achieved through a locking mechanism.

Starvation: This occurs when a process waits for a resource indefinitely.

Synchronization: Coordinating access to shared resources among the

concurrently running processes is know as synchronization.

2) What is the basic requirement for the execution of concurrent

processes?
Answer:
When processes that are running concurrently access a shared resource, it
results in an inconsistent state of the resource. In order to eliminate this
situation, the principle of mutual exclusion must be in place. The part of
code that accesses the shared resource is referred to as a critical section.
When one process enters the critical section of the code, no other
processes executing in parallel ae allowed to enter the critical section.

3) What is the distinction between competing processes and cooperating

processes?
Answer:
Competing processes require access to the shared resource at the same
time whereas the cooperating processes coordinate among themselves
when accessing a shared resource.
4) List the three control problems associated with competing processes,
and briefly define each.
Answer:
Mutual exclusion: It should implement one at a time policy. The section
of code accessing the shared resource is referred to as the critical
section. Only one process can enter the critical section at a time.
Deadlock: When competing processes have access to one or more
shared resources, then there might arise a situation when one or more
processes wait for a resource that is held by other waiting processes.
Starvation: The situation in which a low priority process is denied access
to the resource indefinitely because of several high priority processes
gaining access to the resource repeatedly.

5) List the requirements for mutual exclusion.

Answer:
Mutual exclusion is a concurrency control mechanism which prevents
concurrent access to the shared resources. The lists of requirements for
the mutual exclusions are mentioned below.
• Enforcement of mutual exclusion which ensures that only a single
process has entered the critical section for a resource at a
particular point of time.
• A process must exit its critical section after a finite amount of time
so that it does not block other processes from entering their
critical section for that resource.
• A process requesting access to the critical section must be granted
within a finite amount of time so that it does not lead to
starvation or deadlock.
• Processes that have been terminated in the non-critical section
must not affect other processes
• If there is no process in the critical section of a resource, then a
process requiring access to that critical section must be granted
access immediately.
• Number of processors and their speed are immaterial.
6) What operations can be performed on a semaphore?
Answer:

Initialization of semaphore --- to a non-negative value.

Decrementing the semaphore on wait --- for each wait operation
performed by processes, the value of semaphore is decremented until it
reaches a negative value which results in blocking of the process which
performed the recent wait operation.
Incrementing the semaphore on signal--- For each signal operation
performed by processes, the value of semaphore is incremented and if it
still remains negative, a blocked process is unblocked.

7) In this chapter, it is stated that multiprogramming and multiprocessing

present the same problems, with respect to concurrency. This is true as
far as it goes. However, cite two differences in terms of concurrency
between multiprogramming and multiprocessing.
Answer:
A multiprocessor system consists of interleaving as well as overlapping
of processes which might lead to more occurrences of concurrency
problems as compared to multiprogramming systems which only consist
of interleaved processes.
At a certain point of time in a multiprogramming system, only a single
process executes and accesses the resources, whereas, in a
multiprocessing system, multiple processes execute at the same time
and access multiple resources which increases the overall complexity of
the system.
 8) Consider the following program:

P1 : { P2 : {
shared int x; shared int x;
x =10 ; x = 10 ;
while (1) { while (1) {
x = x – 1; x = x – 1;
x = x + 1; x = x + 1;
if (x != 10) if (x != 10)
printf (“x is %d”,x) printf (“x is %d”,x)
} }
} }
} }

Note the scheduler in a uniprocessor system would implement pseudo-parallel

execution of these two concurrent processes by interleaving their instructions,
without restriction on the order of the interleaving.

a. Show a sequence (i.e., trace the sequence of interleavings of statements)

such that the statement “x is 10” is printed.

Answer:
a) The process P1 assigns the value of x to 10. The CPU executes the
instruction corresponding to P1 to decrement x then increment x
so that the value of x is 10. Then it executes the statement in P2
to decrement x so that x becomes 9. Now, it checks whether x
equals 10 corresponding to P1. It increments x and then executes
the statement to display x which displays “x is 10”.
The sequence of interleaved statements are mentioned below:
P1: x = x-1; 9
P1: x = x+1; 10
P2: x = x-1; 9
P1: if (x!= 10); 9
P2: x = x+1; 10
P1: printf (“x is %d”, x); 10
“ x is 10” is printed.
 9) Consider the following program:

boolean blocked [2];

int turn;
void P (int id)
{
while (true) {
blocked[id] = true;
while (turn != id) {
while (blocked[1-id])
/* do nothing */;
turn = id;
}
/* critical section */
blocked[id] = false;
/* remainder */
}
}
void main()
{
blocked[0] = false;
blocked[1] = false;
turn = 0;
parbegin (P(0), P(1));
}

This software is a solution to the mutual exclusion problem for two processes .
Find a counterexample that demonstrates that this solution is incorrect.

Answer:

Consider the scenario when turn equals to 0 and P[1] sets blocked[1] to true. It
finds that blocked[0] is set to false. Now, P[0] sets blocked[0] to true. It finds
turn equals 0 and therefore, enters the critical section, since the condition while
(turn != id) is false. P[1] sets turn equals to 1 and therefore, it exits the loop
while (turn != id). So, P1 also enters the critical section. Hence, mutual
exclusion is not enforced properly in the mentioned algorithm.
 10) Demonstrate the correctness of Dekker’s algorithm.

1. Show that mutual exclusion is enforced. Hint: Show that when Pi enters
its critical section, the following expression is true:

flag[i] and ( not flag[1 – i] )

2. Show that a process requiring access to its critical section will not be
delayed indefinitely. Hint: Consider the following cases: (1) a single
process is attempting to enter the critical section; (2) both processes are
attempting to enter the critical section, and (2a) turn = 0 and
flag[0] = false, and (2b) turn = 0 and flag[0] = true.
Boolean flag[2];
Void P1()
int turn;
{
Void P0()
while (true) { Void main ()
{
flag[1] = true; {
while (true) {
while (flag[0]) { flag[0] = false;
flag[0] = true;
if (turn == 0) { flag[1] = false;
while (flag[1]) {
flag[1] = false; turn = 1;
if (turn == 1) {
while (turn ==0) parbegin (P0, P1);
flag[0] = false;
/* do nothing */; }
while (turn ==1)
flag[1] = true;
/* do nothing */;
}
flag[0] = true;
}
}
/* critical section */;
}
turn = 0;
/* critical section */;
flag[1] = false;
Turn = 1;
/* remainder */;
flag[0] = false;
}
/* remainder */;
}
}
}

Solution:
Part1:
First, consider that a process P1 is in its critical section and then prove that no
other process is allowed to enter its critical section until P1 is out of its critical
section.
Considering the Dekker’s algorithm , assume that the process P1 enters the
critical section first. Then, according to the algorithm, flag[1] must be true.
Now, another process P0 wants to enter the critical section. Since P1 is in the
critical section, P0 will be executing outside the critical section. The while loop
is the only construct that stops P0 from entering the critical section. As long as
P1 is executing the critical section, flag[1] is true. P0 won’t be able to exit the
while loop as long as flag[1] is true, that is, it won’t be able to enter the critical
section until flag[1] is set to false.
The process P1 sets flag[1] to false only after exiting the critical section. When
one process is in the critical section, other processes are not allowed to enter
the critical section. Thus, it enforces mutual exclusion.
Part2:
Prove that the process can enter the critical section whenever it wants to.
Assume process P1 wants to enter the critical section. The while loop is the
only construct that blocks a process from entering the critical section.
There are two possible outcomes of the while loop condition which are
mentioned below:
Case 1: flag[0] = false
It indicates that P0 is not in the critical section and therefore, P1 enters the
critical section. The other possibility is that P1 is not able to reach while(flag[0])
since it is trapped in the while condition while(turn-==0). This means that
flag[1]=false.
Therefore, P0 enters the critical section, and eventually when it exits, it sets
flag[0] to false and turns to 1.
Now , P1 exits the loop while(turn==0) and enters the critical section, since
flag[0] = false.
Case2 : flag[0] = true
Currently, P0 is executing the critical section. Once it finishes it sets turn=1 and
flag[0] =false. Now , process P1 exits the loop while(flag[0]) and enters the
critical section.
Thus, no process starves according to Dekker’s algorithm.
All the processes are equivalent and no priority is assigned to any process, so
eventually, any process will be able to access the critical section.