Operating Systems, 112 Synchronization, Part 2 Semaphores.

Operating Systems, 112

Synchronization, Part 2Semaphores

Semaphores

2

NOTE: Semaphore’s interface doesn’t enforce the implementation of starvation freedom.

up(S) [the `v’ operation]If (there are blocked

processes) wake-up one of them

Else S++

down(S) [the ‘p’ operation]If (S≤0)

the process is blocked. It will resume execution only after it is woken-up

Else S--

Init(i) S = i

Negative values semaphores

3

NOTE: If S is negative, there are |S| blocked processes

up(S) [the `v’ operation]S++If (there are blocked

processes) wake-up one of them

down(S)S--If (S<0)

the process is blocked. It will resume execution only after it is woken-up

type semaphore = recordvalue: integer; L: list of process;

end;

-3

L

Counting Semaphores (Barz)

4

down(S)down(S2);down(S1);S.value--;if (S.value>0) then

up(S2);up(S1);

up(S):down(S1);S.value++;if (S.value == 1) then up(S2); up(S1);

S.value=init_value binary-semaphore: S1=1, S2=min(1, init_value),

Create a counting semaphore, S, by using binary semaphores

? ?Variables ?

Question 1

Consider the following code snippets run by two processes, P and Q:

Add the minimal number of semaphores, initialize them and place them in the code snippets, so the result of the calculation will be correct (52=25).

Process PloopP: if (n==0)

goto endP; n=n-1; goto loopP;endP: print(sqr)

Process QloopQ: sqr = sqr + 2*n +1; goto loopQ;

Shared memoryn=5;sqr=0;

5

Question 1

Note that we can break 25 in more than one way:• 25=11+9+5=[(5*2+1)+(4*2+1)+(2*2+1)]• 25=9+7+5+3+1=[(4*2+1)+(3*2+1)+(2*2+1)+(2*1+1)+(0+1)]

Process PloopP: if (n==0)

goto endP; down(semA); n=n-1; up(semB); goto loopP;endP: down(semA); print(sqr)

Process QloopQ: down(semB); sqr = sqr + 2*n +1; up(semA); goto loopQ;

Shared memoryn=5;sqr=0;

semA=1;semB=0;

6

7

Question 2 (2007 Moed A)

7

The following constraint graph is a DAG that defines a partial order over code lines. Each vertex is associated with a single line of code in a possible program. A directed edge e(u,v) is used to represent the precedence constraint: code line u must be completed prior to the beginning of code line v. For example, code line S1 should be completed before S2, S5 or S8 are executed, while S6 can only be executed after both S2 and S5 were completed.

Question 2a

88

The following code is executed by two processes, A and B._______________________________________Process A Process B

S1 S2S5 S3S8 S6S9 S4S7

9

Question 2a

Use two counting semaphores with properly initialized values so that in every execution of A and B the execution order of code lines will be consistent with the constraint graph defined above. That is, add up and down operations within A and B’s code lines so that no precedence constraint is violated.You may assume that in every execution both A and B run their code only once.

Note: Partial scoring will be given to solutions using more than two semaphores.9

10

Question 2a

Semaphores: semA=0, semB=0Process A S1 SemB.up S5 SemB.up S8 S9 SemA.downS7SemB.up

Process BSemB.downS2S3SemB.downS6SemA.upSemB.downS4

10

11

Question 2b

Give a concise but accurate explanation why a single semaphore is insufficient for maintaining consistency of the above constraint graph and the two processes.

11

12

Question 2b

A single semaphore is insufficient because there are constraints which require that A waits until B completes one of its lines and vice versa. In such a state, having A signaling B and immediately waiting for it on the same semaphore will result in either a deadlock or a breaking of one of its constraints.

12

Question 3 – Producer Consumer Problem

13

#define N 100 /* Buffer size */semaphore mutex = 1; /* access control to critical section */semaphore empty = N; /* counts empty buffer slots */semaphore full = 0; /* full slots */

void producer(void) {int item;while(TRUE) {

produce_item(&item); /* generate something... */down(&empty); /* decrement count of empty */down(&mutex); /* enter critical section */enter_item(item); /* insert into buffer */up(&mutex); /* leave critical section */up(&full); /* increment count of full slots */

} }

void consumer(void){int item;

while(TRUE){ down(&full); /* decrement count of full */ down(&mutex); /* enter critical section */ remove_item(&item); /* take item from buffer

*/ up(&mutex); /* leave critical section */ up(&empty); /* update count of empty */ consume_item(item); /* do something... */}

}

Question 3 – Producer Consumer Problem

14

Question 31. The red lines of the following code were swapped. How will this affect the

algorithm?


produce_item(&item); /* generate something... */down(&empty); /* decrement count of empty */down(&mutex); /* enter critical section */up(&mutex); /* leave critical section */enter_item(item); /* insert into buffer */up(&full); /* increment count of full slots */

}}

15No mutual exclusion!

Question 32. What will happen now?


produce_item(&item); /* generate something... */down(&empty); /* decrement count of empty */down(&mutex); /* enter critical section */enter_item(item); /* insert into buffer */up(&full); /* increment count of full slots */up(&mutex); /* leave critical section */

}}

16

No problems…

Question 33. And now?

void consumer(void){int item;

while(TRUE){ down(&mutex); /* enter critical section */ down(&full); /* decrement count of full */ remove_item(&item); /* take item from buffer */ up(&mutex); /* leave critical section */ up(&empty); /* update count of empty */ consume_item(item); /* do something... */}

}

17

Deadlock!

Question 4 (Moed B 2010)

An unfair semaphore is a semaphore which does not guarantee that the wakeup order of processes is similar to their falling asleep order.It does, however, provide the following simple guarantee: if there are sleeping processes on the semaphore while an up operation is invoked, then one of these processes will be woken up (not necessarily the first amongst the waiting processes to do a down).

Question 4

Now you are required to implement a starvation free mutual exclusion algorithm for three processes using 3 unfair counting semaphores: R, S and T, initialized to 1. You are not allowed to use any other variable but these semaphores. Add your code and complete the entry and exit section of each process.Briefly explain why your code satisfies both mutual exclusion and starvation freedom.

Question 4

P1’s code:entry:

Critical_section()exit:

P2’s code:entry:


P3’s code:entry:


unfair counting semaphores: R, S and T initialized to 1

Question 4

P1’s code:entry:


P2’s code:entry:


P3’s code:entry:



down (S)down (R)

down (R)down (T)

down (S)down (T)

up(R)up(S)

up(T)up(R)

up(T)up (S)

Question 4

Mutual exclusion:Any process wishing to enter its critical section must successfully complete two ‘down’ operations on two distinct semaphores. Since any process competes over one different “successful down” with each of the other processes, only a single process may successfully enter the critical section at any given moment.

Question 4

Starvation freedom:We first note that there is no starvation problem when using an unfair semaphore with 2 processes (convince yourselves!). Since entrance to the critical section requires passing semaphores which are only shared in pairs no starvation problems will occur.

Question 4, supplement

Will this solution work?

P1’s code:entry:


P2’s code:entry:


P3’s code:entry:



down (S)down (R)

down (R)down (T)

down (T)down (S)

up(R)up(S)

up(T)up(R)

up(S)up (T)

Deadlock!

Question 5 (Midterm 2009)לממש עליכם זה בינאריים event counterבסעיף בסמאפורים שימוש תוך

, .) שלמדתם ) כפי בלבד ובכתיבות בקריאות התומכים משתנים וברגיסטריםevent counter E - ל ומאותחל שלם ערך פעולות. 0מכיל בשלוש תומך הוא

פעולת: של Advance(E)אטומיות ערכו את -Eמקדמת לערך v-1מערך 1ב v ( כאשרv-1 של ערכו ( Eהוא אשר התהליכים כל את ומעירה הפעולה לפני

על לערך Eישנו לה Await(E,v)פעולת. vבהמתנה הקורא לתהליך גורמתשל ערכו אשר עד -Eלישון ל של. vמגיע ערכו -Eאם ל שווה או בעת vגדול

לפעולת . Awaitהקריאה פעולת, בריצתו ממשיך התהליך את Read(E)אזי מחזירהשל הנוכחי .Eערכו

(. event counterממשו הוגנים ) הם כי להניח ניתן בינאריים בסמאפורים שימוש תוךישנם כי -Nהניחו ב המשתמשים הינם Eתהליכים שלהם המזהים כל. N-1,…,1, 0וכי

במשתנה להשתמש יכול .MyIDתהליך שלו המזהה את השומר

25

Question 5int waitval[N] (all are initialized to 0)int v = 0semaphore wait[N] (all are initialized to 0)semaphore mutex (initialized to 1)

Advance(E)down(mutex);E.v++;for (i = 0; i < N; i++) if (waitval[i] == E.v) up(wait[i]);up(mutex);

Await(E,v)boolean wait = false;down(mutex)if (v > E.v) { wait = true; waitval[MyId] = v;}up(mutex);if (wait) down(wait[MyId]);

Read(E)return E.v;

26

Shared variables

Question 5b

Counting semaphore mutex=1Counting semaphore b=0register v=0, register waiting=0

procedure down( ) { mutex.down( ) if (v == 1){ v=0 mutex.up( )} else { waiting=waiting+1 mutex.up( ) b.down( ) }}

procedure up( ){ mutex.down( ) if (waiting > 0){ waiting=waiting-1 b.up( )} else if (v == 0) v=1 mutex.up( )}

כללי סמאפור לממש פשוט זה אין כי ( counting semaphore)למדתםמסמאפורים בינאריים. מסתבר כי גם הכוון ההפוך אינו פשוט. להלן קטע

countingקוד המכיל מימוש של סמאפור בינארי מסמאפורים כלליים )semaphores.ומרגיסטרים )

27

Question 5b . הוגנים שלמעלה הקוד משתמש בהם הכלליים הסמאפורים כי להניח ניתן

בצורה בינארי סמאפור מממש אינו שלמעלה הקוד קטע מדוע להסביר עליכםנכונה.

סמאפור א- של הסמאנטיקה מהי במדויק הסבירו בינארי.

בלבד1 או 0בעל הערכים 1.

או שמשנה את ערך 0: או שחוסם אם ערך הסמפור הוא downפעולת 2..0הסמפור ל-

: או שמעיר תהליך שממתין )אם קיים אחד(, או שמשנה את ערך upפעולת 3..1הסמאפור ל-

28

Question 5bובו לעיל המימוש על פעולות מבצעים תהליכים מספר בו תסריט במדויק תארו

. זו סמאנטיקה מקיים אינו המימוש

Process p1 does down and stops prior to b.downProcess p2 does down and stops prior to b.downProcess p3 does up and finishes the operation (b == 1)Process p4 does up and finishes the operation (b == 2)Process p5 does down and finishes the operation (b == 1)Process p6 does down and finishes the operation (b == 0)

התסריט אינו אפשרי כאשר משתמשים בסמפור בינארי מכיוון שלא יכול להיות ושניהם יצליחו.DOWNמצב שבו שני תהליכים יעשו

29

Operating Systems, 112 Synchronization, Part 2 Semaphores.

Documents

Transcript of Operating Systems, 112 Synchronization, Part 2 Semaphores.