Process Synchronization

Question 1

Cooperating Process

Answer 1

A process that can affect or be affected by other executing process. Done by accessing the data section and shared memory.

Question 2

Race condition

Answer 2

Several process try to access and manilpuate the same data concurrently.

Question 3

Critical Section solution 3 requirements

Answer 3

1. Mutual exclusion: only one process executes the critical section at a given time.
2. Progress: there should be progress, if a process needs to enter the cirital section and it can, then it should.
3. Bounded waiting: There should be a limit on how much a process needs to wait before being granted permission to enter.

Question 4

Nonepreemptive kernel

Answer 4

A process running in kernel mode is not allowed to be preempted, insuring no race conditions happen on kernel data structures.

Question 5

Preemptive kernel

Answer 5

Processes running in kernel mode are allowed to be preemted. The kernel needs to be carefully designed to prevent race conditions. Better since it is more responsive and doesn;t let the kernel hog the system.

Question 6

Peterson’s Solution

Answer 6

Shared data:
int turn;
boolean flag[N]; Indicates if a process is ready to enter.

Flow for proecess i:

flag[i] = TRUE;
turn=j;
while ( flag[j] & turn == j);
CRITICAL SECTION
flag[i] = FALSE;
REMAINDER SECTION

Question 7

Atomic operation

Answer 7

Sequence of instructions that must run inorder and with no interference.

Question 8

TestAndSet

Answer 8

boolean TestAndset (boolean *target)
{
boolean rv = *target;
*target = TRUE;
return rv:
}

Question 9

void Swap (boolean *a, boolean *b)
{
boolean temp = *a;
a=b;
*b= temp;
}

Question 10

Semaphore

Answer 10

Basically an integer that is used to solve the mutual problem.
accessed through two atomic operations:
wait(s){
while s <= 0;
; //no op
s–;
}

signal(s){
s++;
}

Question 11

Binary semphore

Answer 11

Basically a mitex lock, a semaphore that is only 0 or 1.

Question 12

Semaphore busy waiting fix

Answer 12

Define semaphore as a struct with a value and a process list. If a process needs to wait, it adds itself to the list and blocks itself from continuing execution.
The signal operation removes theprocess from the list and wakes it up (moving it from waiting to ready).