Professional Documents
Culture Documents
UNIT 2 – Process
Management
Processes
• Process Concept
• Process Scheduling
• Operations on Processes
• Interprocess Communication
• Examples of IPC Systems
• Communication in Client-Server Systems
• Some operating systems do not allow child to exists if its parent has
terminated. If a process terminates, then all its children must also be
terminated.
– cascading termination. All children, grandchildren, etc. are terminated.
– The termination is initiated by the operating system.
• The parent process may wait for termination of a child process by using the
wait()system call. The call returns status information and the pid of the
terminated process
pid = wait(&status);
• If no parent waiting (did not invoke wait()) process is a zombie
• If parent terminated without invoking wait , process is an orphan
item buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
message next_produced;
while (true) {
/* produce an item in next produced */
send(next_produced);
}
message next_consumed;
while (true) {
receive(next_consumed);
• Sockets
• Remote Procedure Calls
• Pipes
• Remote Method Invocation (Java)
• All ports below 1024 are well known, used for standard services
Process Thread
A Process is a program in A thread is the unit of execution
execution with in a process
A process can have anywhere
from just one thread to many
threads
Process
• Types of parallelism
– Data parallelism – distributes subsets of the same data
across multiple cores, same operation on each
– Task parallelism – distributing threads across cores,
each thread performing unique operation
• As # of threads grows, so does architectural support for
threading
– CPUs have cores as well as hardware threads
– Consider Oracle SPARC T4 with 8 cores, and 8
hardware threads per core
• That is, if application is 75% parallel / 25% serial, moving from 1 to 2 cores
results in speedup of 1.6 times
• As N approaches infinity, speedup approaches 1 / S
• But does the law take into account contemporary multicore systems?
• Many-to-One
• One-to-One
• Many-to-Many
Race Condition
•Race conditions are most commonly associated with computer science
and programming. They occur when two computer program processes,
or threads, attempt to access the same resource at the same time and
cause problems in the system.
•Race conditions are considered a common issue for multithreaded
applications
register1 = counter
register1 = register1 + 1
counter = register1
• counter-- could be implemented as
register2 = counter
register2 = register2 - 1
counter = register2
• Consider this execution interleaving with “count = 5” initially:
do {
do {
flag[i] = true;
turn = j;
while (flag[j] && turn = = j);
critical section
flag[i] = false;
remainder section
} while (true);
do {
acquire lock
critical section
release lock
remainder section
} while (TRUE);
Definition:
boolean test_and_set (boolean *target)
{
boolean rv = *target;
*target = TRUE;
return rv:
}
1. Executed atomically
2. Returns the original value of passed parameter
3. Set the new value of passed parameter to “TRUE”.
} while (true);
if (*value == expected)
*value = new_value;
return temp;
}
1. Executed atomically
2. Returns the original value of passed parameter “value”
3. Set the variable “value” the value of the passed parameter
“new_value” but only if “value” ==“expected”. That is, the
swap takes place only under this condition.
do {
waiting[i] = true;
key = true;
while (waiting[i] && key)
key = test_and_set(&lock);
waiting[i] = false;
/* critical section */
j = (i + 1) % n;
while ((j != i) && !waiting[j])
j = (j + 1) % n;
if (j == i)
lock = false;
else
waiting[j] = false;
/* remainder section */
} while (true);
wait(semaphore *S) {
S->value--;
if (S->value < 0) {
add this process to S->list;
block();
}
}
signal(semaphore *S) {
S->value++;
if (S->value <= 0) {
remove a process P from S->list;
wakeup(P);
}
}
do {
...
/* produce an item in next_produced */
...
wait(empty);
wait(mutex);
...
/* add next produced to the buffer */
...
signal(mutex);
signal(full);
} while (true);
Do {
wait(full);
wait(mutex);
...
/* remove an item from buffer to next_consumed */
...
signal(mutex);
signal(empty);
...
/* consume the item in next consumed */
...
} while (true);
do {
wait(rw_mutex);
...
/* writing is performed */
...
signal(rw_mutex);
} while (true);
// eat
signal (chopstick[i] );
signal (chopstick[ (i + 1) % 5] );
// think
} while (TRUE);
• What is the problem with this algorithm?
• Deadlock handling
– Allow at most 4 philosophers to be sitting
simultaneously at the table.
– Allow a philosopher to pick up the forks only if both
are available (picking must be done in a critical
section.
– Use an asymmetric solution -- an odd-numbered
philosopher picks up first the left chopstick and then
the right chopstick. Even-numbered philosopher picks
up first the right chopstick and then the left chopstick.
monitor monitor-name
{
// shared variable declarations
procedure P1 (…) { …. }
initialization_code() {
for (int i = 0; i < 5; i++)
state[i] = THINKING;
}
}
DiningPhilosophers.pickup(i);
EAT
DiningPhilosophers.putdown(i);
• Variables
wait(mutex);
…
body of F;
…
if (next_count > 0)
signal(next)
else
signal(mutex);
x_count++;
if (next_count > 0)
signal(next);
else
signal(mutex);
wait(x_sem);
x_count--;
if (x_count > 0) {
next_count++;
signal(x_sem);
wait(next);
next_count--;
}
R.acquire(t);
...
access the resurce;
...
R.release;