58 views

Uploaded by Muhammad Ali

You are on page 1of 25

OS Winter 06

Critical section algorithm for any n>1 Each time a process is requesting an

entry to CS, assign it a ticket which is

Unique and monotonically increasing

their numbers

OS Winter 03

Choosing a ticket

Shared : int number[ n ]; boolean choosing [n];

number [i ] ! max( number[0], number [1], - number [ n 1]) 1;

Process need to know that somebody perhaps chose a smaller number:

choosing[i ] ! true; nu ber[i ] ! max(nu ber[0], nu ber[1], - nu ber[n 1]) 1; choosing[i ] ! false;

OS Winter 03

Process Pi do { choosing[i ] ! true; number[i ] ! max(number[0], number[1],- number[n 1]) 1; choosing[i ] ! false; for ( j ! 0; j n; j ) { while(choosing[ j ]); while(( number[ j ]! ! 0) & &((number[ j ], j ) (number[i ], i ))); } critical section number[i ] ! 0; remainder section } while(1)

OS Winter 03

R

Process Pi do { choosing[i ] ! true; T D number[i ] ! max(number[0], number[1],- number[n 1]) 1; choosing[i ] ! false; for ( j ! 0; j n; j ) { T-D while(choosing[ j ]); while(( number[ j ]! ! 0) & &((number[ j ], j ) (number[i ], i ))); } C critical section number[i ] ! 0; E remainder section } while(1)

OS Winter 03

R code prior to using Bakery algorithm T creating of a ticket and awaiting for

permission to enter critical section

D creation of a number (first part of a ticket) T-D awaiting for the permission to enter critical section

section

OS Winter 03

Basic Lemma

Lemma 1:

For any i { j , i

i

is in C and

is in C (T - D), then

OS Winter 03

Lemma 1 - proof

Denote s time point where lemmas conditions

hold At time s, P is in C (critical section) i

number[i] has been selected and still exists number[j] has been selected and still exists Exist time point t1<s, where P performs a check i (choosing[j]==0) and passes it Exists time point t2, t1<t2<s, where P performs a i check (number[j]!=0) and (number[i],i)<(number[j],j)

OS Winter 03

Since at time t1 exists (choosing[j]==0)

one of the following has to be true

CASE A: number[j] was chosen after time t1 and before time s CASE B: number[j] was chosen before t1

OS Winter 03

Since at time t1

checks for permission to enter critical section, computation of number[i] was computed before that and persists until s Thus, at the time j starts to compute its number[j], it has to take into account of max value of number[i]. So it creates a value which is greater then number[i] at least by 1, and it persists until time s That is (number[i],i)<(number[j],j) at time s

OS Winter 03

i already

Both number[i] and number[j] were computed

before t1, thus also before time t2 and persisted until s At time t2 Pi performed check (number[j]!=0) & (number[j],j)<(number[i],i), which failed, since P is in C at time s i number[j] was chosen before t2 and persisted, thus first part of the check could not fail, also i and j are different, so (number[i],i)<(number[j],j) at time s

OS Winter 03

Lemmata 2,3,4

Lemma 2 mutual exclusion:

Bakery Algorithm satisfies mutual exclusion property

Lemma 3 progress

Bakery Algorithm guarantees progress

Lemma 4 fairness

Bakery Algorithm guarantees lockoutfreedom

OS Winter 03

Lemma 2 Proof

Assume in contradiction that there are two

different processes that have entered critical section Then conditions of Lemma 1 are true for both processes simmetrically that is (number[i],i)<(number[j],j]) and (number[j],j)<(number[i],i) : contradiction We conclude that mutual exclusion is satisfied

OS Winter 03

Lemma 3 Proof

Suppose progress is not guaranteed Then eventually a point is reached after which

all processes are in T or R By the code, all the processes in T eventually complete D and reach T-D Then the process with the lowest (number,ID) pair is not blocked from reaching C, that is enters critical section We conclude that Bakery algorithm satisfies Progress

OS Winter 03

Lemma 4 Proof

Consider a particular process

never reaches C The process eventually completes D and reaches T-D After that any new process that enters D perceives number[i] and chooses a higher number Thus, since P does not reach C, none of these new i processes reach C either But by Lemma 3 there must be continuing progress, that is infinitely many entries to C Contradiction: P blocks the entry to C i

OS Winter 03

Pi in T and suppose it

Remark on Fairness

A process that obtained a ticket (number[k],k)

will wait at most for (n-1) turns, when other processes will enter the critical section For example if all the processes obtained their tickets at the same time they will look like (q,1),(q,2)(q,n) In which case process n will wait for processes 1 n 1 to complete the critical section

OS Winter 03

Bibliography

Nancy Ann Lynch, Distributed

Algorithms, JMC 243.9 LY53 Leslie Lamport A new solution of Dijkstras concurrent programming problem Communications of the ACM 17(8):453-455, 1974

OS Winter 03

Hardware primitives

Elementary building blocks capable of

performing certain steps atomically

Should be universal to allow for solving versatile synchronization problems

identified:

Test-and-set Fetch-and-add Compare-and-swap

OS Winter 03

Test-and-Set (TS)

boolean test-and-set(boolean &lock) { temp=lock; lock=TRUE; return temp; } reset(boolean &lock) { lock=FALSE; }

OS Winter 03

Shared boolean lock, initially FALSE do { while(test-and-set(&lock)); critical section; Check yourself! reset(&lock); Is mutual exclusion reminder section; satisfied? } while(1); Is progress satisfied? Is fairness satisfied?

OS Winter 03

Discussion

Satisfies Mutual Exclusion and Progress Does not satisfies Fairness Provides exclusion among unbounded

number of processes

Process IDs and number are unknown

Busy waiting

Burning CPU cycles while being blocked

OS Winter 03

Fetch-and-Add (FAA)

s: shared, a: local int FAA(int &s, int a) { temp=s; s=s+a; return temp; FAA can be used } as a ticket machine

OS Winter 03

Shared: int s, turn; Initially: s = 0; turn=0; Process Pi code: Entry: me = FAA(s,1); while(turn < me); // busy wait for my turn Critical section Check yourself! Exit: Is mutual exclusion FAA(turn,1); satisfied?

OS Winter 03

Discussion

Satisfies all three properties Supports unbounded number of

processes Unbounded counter Busy waiting

OS Winter 03

Critical section framework is inconvenient

for programming Performance penalty

Busy waiting Too coarse synchronization

in non-portable code

OS Winter 03

- CCN Lecture 4Uploaded byMuhammad Ali
- CCN Chapter6 4th Ed June 18 2007Uploaded byMuhammad Ali
- CCN Lecture 6(1)Uploaded byMuhammad Ali
- ReadmeUploaded byMuhammad Ali
- Words ListUploaded byMuhammad Ali
- CCN Lecture 7Uploaded byMuhammad Ali
- CCN1Uploaded byMuhammad Ali
- ProgressUploaded byMuhammad Ali
- CCN Lecture 3(1)Uploaded byMuhammad Ali
- CCN Lecture 3(2)Uploaded byMuhammad Ali
- CCN Lecture 6(2)Uploaded byMuhammad Ali
- CCN Lecture 2Uploaded byMuhammad Ali
- bbc urduUploaded byMuhammad Ali
- UploadUploaded byMuhammad Ali
- UploadUploaded byMuhammad Ali
- StringsUploaded byMuhammad Ali
- ER DiagramUploaded byMuhammad Ali
- ER DiagramUploaded byMuhammad Ali
- File and IndexingUploaded byMuhammad Ali
- Normal 1Uploaded byMuhammad Ali
- Final Project PresentationUploaded byMuhammad Ali
- Solutions-COA7e-2Uploaded byapi-19981384
- er3Uploaded byMuhammad Ali
- Normal 1 (2)Uploaded byMuhammad Ali