Assignment 3

Submitted By
Muneeb Shahid
Roll No
19011598-138
Section
SE-4C
Submitted To
Mr Shahzaib Abbas
QUESTION # 04
Deadlock is a line between safe and unsafe state.

A Deadlock is a situation where each of the computer process waits for a

resource which is being

assigned to some another process. In this situation, none of the process

gets executed since the resource

it needs, is held by some other process which is also waiting for some other
resource to be released

A state is safe if the system can allocate resources to each process (up to its
maximum) in some order and

still avoid a deadlock.

More formally, a system is in a safe state only if there exists a safe

sequence.

A sequence of processes is a safe sequence for the current allocation state

if, for

each the resource requests that can still make can be satisfied by the
currently available resources

plus the resources held by all, with.

In this situation, if the resources that needs are not immediately available,
then can wait until

all have finished.

When they have finished, can obtain all of its needed resources, complete
its designated task, return its

allocated resources, and terminate.

 When terminates, can obtain its needed resources, and so on.If no such
sequence exists, then

the system state is said to be unsafe.

A safe state is not a deadlocked state. Conversely, a deadlocked state is an

unsafe state. Not all unsafe states

are deadlocks

QUESTION # 05
Concurrent programs are well known for containing errors that are difficult
to detect,

reproduce, and diagnose. Deadlock is a common concurrency error, which

occurs when a set of

threads are blocked, due to each attempting to acquire a lock held by

another.

Multi-Threaded application counter deadlock easily because threads run

simultaneously and

when more than one thread tries to access the same resource
simultaneously there is a

deadlock. Hence in Multi-threaded applications deadlocks are encountered

easily.

There are two popular ways to detect deadlocks.

One is to have threads set checkpoints. For example, if you have a thread
that has a work loop,

you set a timer at the beginning of doing work that's set for longer than you
think the work could
possibly take. If the timer _res, you assume the thread is deadlocked. When
the work is done, you

cancel the timer.

Another (sometimes used in combination) is to have things that a thread

might block on track

what other resources a thread might hold. This can directly detect an
attempt to acquire one lock

while holding another one when other threads have acquired those locks in
the opposite order. This

can even detect deadlock risk without the deadlock actually occurring. If
one thread acquires lock

A then B and another acquires lock B Then A, there is no deadlock unless

they overlap. But this

method can detect it.

Advanced deadlock detection is typically only used during debugging. Other

than coding the

application to check each blocking lock for a possible deadlock and knowing
what to do if it

happens, the only thing you can do after a deadlock is tear the application
down. You can't release

locks blindly because the resources they protect may be in an inconsistent

state.

Sometimes you deliberately write code that you know can deadlock and
specifically code it to

avoid the problem. For example, if you know lots of threads take lock A and
then try to acquire
 lock B, and some other thread needs to do the reverse, you can code it do a
non-blocking attempt

to lock B and release lock A if it fails.

Typically, it's more useful to spend your effort making deadlocks impossible
rather than making

the code detects and work around deadlocks.

Benefits of Multithreading:

Improved throughput. Many concurrent computer operations and I/O

requests within a
single process.
Simultaneous and fully symmetric use of multiple processors for
computation and I/O
Superior application responsiveness. If a request can be launched on its
own thread,
applications do not freeze or show the "hourglass". An entire application
will not block,
or otherwise wait, pending the completion of another request.
Improved server responsiveness. Large or complex requests or slow
clients don't block
other requests for service. The overall throughput of the server is much
greater.
Minimized system resource usage. Threads impose minimal impact on
system resources.
Threads require less overhead to create, maintain, and manage than a
traditional process.

QUESTION # 06
How monitor helps to solve synchronization problems.

Classical Problem of Synchronization:

Dining-Philosophers Problem

Solution to Dining Philosophers:

monitor DiningPhilosophers

enum { THINKING; HUNGRY, EATING) state [5] ;

condition self [5];

void pickup (int i) {

state[i] = HUNGRY;

test(i);

if (state[i] != EATING) self[i].wait;}

void putdown (int i) {

state[i] = THINKING;

// test left and right neighbors

test((i + 4) % 5);

test((i + 1) % 5);}

void test (int i) {

if ((state[(i + 4) % 5] != EATING) &&

(state[i] == HUNGRY) &&

(state[(i + 1) % 5] != EATING) ) {

state[i] = EATING ;
 self[i].signal () ;}}

initialization_code() {

for (int i = 0; i < 5; i++)

state[i] = THINKING;}}

Each philosopher i invokes the operations pickup() and putdown() in the

following sequence:

DiningPhilosophers.pickup(i);

EAT

DiningPhilosophers.putdown(i);

No deadlock
QUESTION # 07

Write important term keywords from Chapter of Process Synchronization

and Deadlock.
Keywords from Process Synchronization:
 Producer-Consumer Process
 Race Condition
 Critical Section Problem
 Mutual exclusion
 Progress.
 Bounded waiting.
 Preemptive kernels
 Non-Preemptive kernels
 Peterson’s Solution
 Synchronization Hardware
 Mutex Locks
 Acquire () and Release ()
 Semaphore
 Semaphore Usage
 Deadlock
 Starvation
 Priority Inversion
 Classical Problems of Synchronization
 Dining-Philosophers Problem
  Monitors
 Monitor with Condition Variables

Keywords from Deadlock:

 System Model
 Mutual exclusion
 Hold and wait
 No preemption
 Circular wait
 Deadlock with Mutex Locks
 Resource-Allocation Graph
 Deadlock Prevention
 Deadlock Avoidance
 Safe State
 Unsafe State
 Deadlock State
 Banker’s Algorithm
 Safety Algorithm
 Deadlock Detection
 Wait-for Graph
 Detection Algorithm
 Process Termination
 Resource Preemption