1 Chapter 2 Synchronization Algorithms and Concurrent Programming Gadi Taubenfeld © 2007 Synchronization Algorithms and Concurrent Programming Gadi Taubenfeld

Chapter 2 Synchronization Algorithms and Concurrent Programming Gadi Taubenfeld © 2007

1

Synchronization Algorithms Synchronization Algorithms and Concurrent Programmingand Concurrent Programming

Gadi TaubenfeldGadi Taubenfeld

Chapter 2 Mutual Exclusion using atomic registers:

Basic Topics

Version: November 2007


2

A note on the use of these ppt slides:I am making these slides freely available to all (faculty, students, readers). They are in PowerPoint form so you can add, modify, and delete slides and slide content to suit your needs. They obviously represent a lot of work on my part. In return for use, I only ask the following:

That you mention their source, after all, I would like people to use my

book!

That you note that they are adapted from (or perhaps identical to) my slides, and note my copyright of this material.

Thanks and enjoy! Gadi Taubenfeld

All material copyright 2007Gadi Taubenfeld, All Rights Reserved

A note on the use of these ppt slides:I am making these slides freely available to all (faculty, students, readers). They are in PowerPoint form so you can add, modify, and delete slides and slide content to suit your needs. They obviously represent a lot of work on my part. In return for use, I only ask the following:

That you mention their source, after all, I would like people to use my

book!

That you note that they are adapted from (or perhaps identical to) my slides, and note my copyright of this material.

Thanks and enjoy! Gadi Taubenfeld

All material copyright 2007Gadi Taubenfeld, All Rights Reserved

Synchronization Algorithms Synchronization Algorithms and Concurrent Programmingand Concurrent Programming

ISBN: 0131972596, 1ISBN: 0131972596, 1stst edition edition

To get the most updated version of these slides go to: http://www.faculty.idc.ac.il/gadi/book.htm


3

2.1 Algorithms for Two Processes2.2 Tournament Algorithms2.3 A Fast Mutual Exclusion

Algorithms2.4 Starvation-free Algorithms2.5 Tight Space bounds2.6 Automatic Discovery of

algorithms

2.1 Algorithms for Two Processes2.2 Tournament Algorithms2.3 A Fast Mutual Exclusion

Algorithms2.4 Starvation-free Algorithms2.5 Tight Space bounds2.6 Automatic Discovery of

algorithms

Chapter 2 Chapter 2 Mutual Exclusion using atomic Mutual Exclusion using atomic

registers: Basic Topicsregisters: Basic Topics


4

remainder coderemainder code

entry codeentry code

critical sectioncritical section

exit codeexit code

The problem is to design the entry and exit code in a way that guarantees that the mutual exclusion and deadlock-freedom properties are satisfied.

The mutual exclusion problemThe mutual exclusion problem


5


Mutual Exclusion: No two processes are in their critical sections at the same time.

Deadlock-freedom: If a process is trying to enter its critical section, then some process, not necessarily the same one, eventually enters its critical section.

Starvation-freedom: If a process is trying to enter its critical section, then this process must eventually enter its critical section.

Mutual Exclusion: No two processes are in their critical sections at the same time.

Deadlock-freedom: If a process is trying to enter its critical section, then some process, not necessarily the same one, eventually enters its critical section.

Starvation-freedom: If a process is trying to enter its critical section, then this process must eventually enter its critical section.

entry code

exit code

criticalsection

remainder


6

Question: true or false ?Question: true or false ?

A and B are deadlock-free C is deadlock-free.

A and B are starvation-free C is starvation-free.

A or B satisfies mutual exclusion C satisfies mutual exclusion.

A is deadlock-free and B is starvation-free C is starvation-free.

A is starvation-free and B is deadlock-free C is starvation-free.

A and B are deadlock-free C is deadlock-free.

A and B are starvation-free C is starvation-free.

A or B satisfies mutual exclusion C satisfies mutual exclusion.

A is deadlock-free and B is starvation-free C is starvation-free.

A is starvation-free and B is deadlock-free C is starvation-free.

entry code of A

exit code of A

criticalsection

remainder

entry code of B

exit code of B

Algorithm C


7

Does it work?

Atomic read/write registersAtomic read/write registersProposed solution 1Proposed solution 1

Thread 0while (true} {remainder codewhile (turn = 1) {skip}critical sectionturn = 1}

Thread 1while (true} {remainder codewhile (turn = 0) {skip}critical sectionturn = 0}

entry code

exit code

0/1

turn mutual exclusion deadlock-freedom


8

Proposed solution 2Proposed solution 2

Thread 0

flag[0] = truewhile (flag[1]) {skip}critical sectionflag[0] = false

Thread 1

flag[1] = truewhile (flag[0]) {skip}critical sectionflag[1] = false

false

flag

false

0

1

Does it work?

mutual exclusion deadlock-freedom


9

Proposed solution 3Proposed solution 3

Thread 0

while (flag[1])

{skip}flag[0] = truecritical sectionflag[0] = false

Thread 1

while (flag[0])

{skip}flag[1] = truecritical sectionflag[1] = false

falseflag

false01

Does it work?

mutual exclusionDeadlock-freedom


10

Peterson’s algorithmPeterson’s algorithm

Thread 0flag[0] = trueturn = 1while (flag[1] and turn = 1) {skip}critical sectionflag[0] = false


false

flag

false

0

1

0/1turn

Section 2.1.1


11

0/10/1

A variant of Peterson’s algorithmA variant of Peterson’s algorithm

false

flag

false

0

1

turn

Is it correct ?

true

true

10

Thread 0turn = 1flag[0] = truewhile (flag[1] and turn = 1) {skip}critical sectionflag[0] = false

Thread 1turn = 0flag[1] = truewhile (flag[0] and turn = 0) {skip}critical sectionflag[1] = false


12

Indicate contendingb[i] := true


Barrierturn := iBarrier

turn := i

Contention?b[i] = true ?Contention?b[i] = true ?


exit codeb[i] = false ?

exit codeb[i] = false ?

First to cross the barrier?turn = j ?

First to cross the barrier?turn = j ?

yes

yes

no / maybe

no

Schematic for Peterson’s algorithmSchematic for Peterson’s algorithm


13

Properties of Peterson’s SolutionProperties of Peterson’s Solution Satisfies mutual exclusion and starvation-

freedom Memory accesses are assumed to be atomic Solution for two processes only


14

QuestionQuestion

Replace the multi-writer register turn with two single-writer registers. What is new algorithm?

Hint: use Solution #4 for the too-much-milk problem.

Answer (Kessels’ Alg.)turn = 0 turn[0] =

turn[1]turn = 1 turn[0]

turn[1]

Using only single-writer registersUsing only single-writer registers

Section 2.1.2


15

Solutions for Many ProcessesSolutions for Many Processes

How can we use a two-process algorithm to construct an algorithm for many processes?

How can we use a two-process algorithm to construct an algorithm for many processes?


16

Tournament AlgorithmsTournament Algorithms

1 2 3 4 5 6 7 8

Section 2.2


17

QuestionQuestion

Assume that the base two-process algorithm satisfies starvation-freedom. Does the tournament algorithm also satisfy starvation-freedom?

Assume that the base two-process algorithm satisfies starvation-freedom. Does the tournament algorithm also satisfy starvation-freedom?

YesYes


18

Properties & complexity Properties & complexity

Time complexity Fast Adaptive

Fairness FIFO, ...

Fault-tolerance Local spinning Space complexity Communication primitives

Time complexity Fast Adaptive

Fairness FIFO, ...

Fault-tolerance Local spinning Space complexity Communication primitives


19

Complexity Measures Complexity Measures

Counting steps process step complexity process time complexity contention-free time

complexity Counting time units

system response time process response time

Counting communications distributed shared memory coherent cashing

Space complexity

Counting steps process step complexity process time complexity contention-free time

complexity Counting time units

system response time process response time

Counting communications distributed shared memory coherent cashing

Space complexity


20



What is the contention-free time complexity?

44


21



What is the process step complexity?

Theorem: There is no two process mutual exclusion algorithm with an upper bound on the process time/step complexity. [1992]

Proof: see Section 3.2.5 .

Theorem: There is no two process mutual exclusion algorithm with an upper bound on the process time/step complexity. [1992]

Proof: see Section 3.2.5 .


22

Show a run of Peterson’s algorithm where thesystem response time is 5 time units.

What is the system response time?

1 2 3 4 5




23

Fast Mutual exclusion AlgorithmFast Mutual exclusion Algorithm

Mutual exclusion and deadlock-freedom Starvation of individual processes is

possible fast access

in the absence of contention, only 7 accesses to shared memory are needed

With contention Even if only 2 processes contend, the

winner may need to check all the 0(n) shared registers

System response time is of order n time units

n+2 shared registers are used

Mutual exclusion and deadlock-freedom Starvation of individual processes is

possible fast access

in the absence of contention, only 7 accesses to shared memory are needed

With contention Even if only 2 processes contend, the

winner may need to check all the 0(n) shared registers

System response time is of order n time units

n+2 shared registers are used

Section 2.3


24

At most n-1 can move

right

At most n-1 can move

down

At most 1 can win

In solo run 1 win

Splitter Splitter

rightwin

down

n

1 n-1

n-1

right


25

The code of the splitter The code of the splitter

x = i if y = 1 then go right fi y = 1 if x i then go down fi win

x

0y

win

down

n

1 n-1

n-1

right


26

NotationNotation

await (condition) == while (not condition) do skip od


27

Fast Mutual exclusion AlgorithmFast Mutual exclusion Algorithmcode of process i , i {1 ,..., n}

start: b[i] = true

x = i if y 0 then b[i] = false await y = 0 goto start fi y = i if x i then b[i] = false for j = 1 to n do await b[j] = false od if y i then await y = 0 goto start fi fi critical section y = 0 b[i] = false

1 2 n

b false false falsefalseyx 0


28

Can we switch the order of the last two statements?

start: b[i] = true

x = i if y 0 then b[i] = false await y = 0 goto start fi y = i if x i then b[i] = false for j = 1 to n do await b[j] = false od if y i then await y = 0 goto start fi fi critical section b[i] = false y = 0

yx 0

What is the maximum number of processes that can be in their CS at the same time?


29

Can we replace y=0 in line 12 with ... ?

start: b[i] = true

x = i if y 0 then b[i] = false await y = 0 goto start fi y = i if x i then b[i] = false for j = 1 to n do await b[j] = false od if y i then await y = 0 goto start fi fi critical section y = 0 replace with: if y = i then y = 0 fi b[i] = false

Yes


30

Can we remove await y=0 in line 4 ?

start: b[i] = true


No. Deadlock is possible

remove ?


31

Can we remove await y=0 in line 9 ?

start: b[i] = true


Yes

remove ?


32



Barrierturn := iBarrier

turn := i

Contention?x i ?

Contention?x i ?


exit codeexit code

Last to cross the barrier?y = i ?

Last to cross the barrier?y = i ?

yes

yes

Contention?y = 0 ?

Contention?y = 0 ?

Continue only after it is guaranteed that no one cancross the barrier

Continue only after it is guaranteed that no one cancross the barrier

no

Wait until CS is releasedWait until CS is released

Wait until CS is releasedWait until CS is releasedyes

The last to crossthe barrier!

no

no

Schematic for the fast algorithmSchematic for the fast algorithm


33

4.1 Basic Definitions (i.e., FIFO) 4.2 The Bakery Algorithm4.3 The Black-White Bakery

Algorithm Algorithm

4.1 Basic Definitions (i.e., FIFO) 4.2 The Bakery Algorithm4.3 The Black-White Bakery

Algorithm Algorithm

Starvation-free AlgorithmsStarvation-free Algorithms

Section 2.4


34


entry code

exit code

criticalsection

remainder Mutual Exclusion

Deadlock-freedom

Starvation-freedom

FIFO

doorway

waiting


35

The Bakery AlgorithmThe Bakery Algorithm

Section 2.4.2


36

time

The Bakery AlgorithmThe Bakery Algorithm

0 0 0 0 0 0

doorway

1 2 3 4 5 n

CS

exit

1

1

2 2

2 2

1

1

0

2

2

0

3

3

2

2

0

4

4waiting

en

try

remainder

Section 2.4.2


37

Implementation 1Implementation 1code of process i , i {1 ,..., n}

number[i] = 1 + max {number[j] | (1 j n)}for j = 1 to n { await (number[j] = 0) (number[j] > number[i])}critical sectionnumber[i] = 0

1 2 3 4 n

number integer0 0 0 0 0 0

Answer: No! can deadlock


38

time

Implementation 1: deadlockImplementation 1: deadlock

0 0 0 0 0 0

doorway

1 2 3 4 5 n

CS

exit

1

1

2 2

2 2

1

1

0

waiting

en

try

remainder

deadlock


39


number[i] = 1 + max {number[j] | (1 j n)}for j = 1 to n { await (number[j] = 0) (number[j] > number[i])}critical sectionnumber[i] = 0

1 2 3 4 n


Answer: does not satisy mutual exclusion

What if we replace > with ?


40

number[i] = 1 + max {number[j] | (1 j n)}for j = 1 to n { await (number[j] = 0) (number[j],j) number[i],i)

// lexicographical order

}critical sectionnumber[i] = 0

1 2 3 4 n


Answer: does not satisfy mutual exclusion



41

time

Implementation 2: no mutual exclusionImplementation 2: no mutual exclusion

0 0 0 0 0

doorway

1 2 3 4 5 n

CS

exit

0

1

0 0

2 2

1

1

0

2 2

waiting

en

try

remainder

1 2 2

0

2


42

The Bakery AlgorithmThe Bakery Algorithmcode of process i , i {1 ,..., n}

choosing[i] = true

number[i] = 1 + max {number[j] | (1 j n)}choosing[i] = falsefor j = 1 to n { await choosing[j] = false await (number[j] = 0) (number[j],j) (number[i],i)}critical sectionnumber[i] = 0

1 2 3 4 n

choosing bitsfalse


false false false false false


44

Is the following version correct?Is the following version correct?code of process i , i {1 ,..., n}

choosing[i] = true

number[i] = 1 + max {number[j] | (1 j n)}choosing[i] = falsefor j = 1 to n { if i > j { await choosing[j] = false } await (number[j] = 0) (number[j],j) (number[i],i)}critical sectionnumber[i] = 0

1 2 3 4 n

choosing bitsfalse




45

time

NoNo

0 0 0 0 0

doorway

1 2 3 4 5 n

CS

exit

0

1

0 0

2 1

1

1

0

2 1

waiting

en

try

remainder

1 2 1

0

1


46

Is the following version correct?Is the following version correct?code of process i , i {1 ,..., n}

number[i] = -1number[i] = 1 + max {number[j] | (1 j n) , 0}for j = 1 to n { await number[j] -1 await (number[j] 0) (number[j],j) (number[i],i)}critical sectionnumber[i] = 0

1 2 3 4 n

choosing bitsfalse



Yes

Can we replace with = ?


47

Computing the Maximum #1Computing the Maximum #1code of process i , i {1 ,..., n}

Correct implementation

local1 = 0for local2 = 1 to n do local3 = number[local2] if local1 < local3 then local1 = local3 fi odnumber[i] = 1 + local1

1 2 3 4 nnumber integer0 0 0 0 0 0

number[i] = 1 + max {number[j] | (1 j n)}


48


Is the following implementation correct ?

local1 = ifor local2 = 1 to n do if number[local1] < number[local2] then local1 = local2 fi odnumber[i] = 1 + number[local1]

1 2 3 4 nnumber integer0 0 0 0 0 0

number[i] = 1 + max {number[j] | (1 j n)}


49

time

0 0 0 0

doorway

1 2 3 4 5 n

CS

exit

1 1

1 1

1

1

0

1

waiting

en

try

remainder 00

?

1

1

?local1 2

1

NoNo

Passed process 1Waiting for process 2


50


Is the following implementation correct ?

local1 = ifor local2 = 1 to n do if number[local1] number[local2] then local1 = local2 fi odnumber[i] = 1 + number[local1]

A difficult question !!!

This is Problem 2.39


51

Properties of the Bakery AlgorithmProperties of the Bakery Algorithm

Satisfies mutex & FIFO.

The size of number[i] is unbounded.

Safe registers: reads which are concurrent

with writes may return arbitrary value.


52

The Black-White Bakery AlgorithmThe Black-White Bakery Algorithm

Section 2.4.3

Bounding the space of the Bakery Algorithm

Bakery (FIFO, unbounded)

The Black-White Bakery Algorithm

FIFOBounded space+ one bit


53

time


0 0 0 0 0

doorway

1 2 3 4 5 n

CS

exit

0

1

0 0

2 2

1

1

0

2

2

0

1

2

2

0

2waiting

en

try

remainder

1 20 201 2

1

1

00

color bit


54


1 2 3 4 n

choosing

Data StructuresData Structures

mycolor

number

color bit

bits

bits

{0,1,...,n}

{black,white}


55

The Black-White Bakery AlgorithmThe Black-White Bakery Algorithmcode of process i , i {1 ,..., n}

choosing[i] = truemycolor[i] = colornumber[i] = 1 + max{number[j] | (1 j n) (mycolor[j] = mycolor[i])}choosing[i] = falsefor j = 0 to n do await choosing[j] = false if mycolor[j] = mycolor[i] then await (number[j] = 0) (number[j],j) (number[i],i) (mycolor[j] mycolor[i]) else await (number[j] = 0) (mycolor[i] color) (mycolor[j] = mycolor[i]) fi odcritical sectionif mycolor[i] = black then color = white else color = black finumber[i] = 0


56

What happens if in the algorithm each process chooses its identifier instead of choosing 1 + max ? Would the algorithm be correct? What properties would it satisfy?

QuestionQuestion

Answer: Incorrect.Run process i first until it enters its CS; Now run a process with a smaller id until it also enters its CS.


57

Does it matter if we change the order of the last two statements (in the exit code) of the Black-White Bakery Algorithm?

QuestionQuestion

Answer: Yes, it matters.


58

Bakery

Black-White Bakery

Use single-writer bits only!

QuestionQuestion

Replace the multi-writer bit color with n single-writer bits.

Answer: See page 57.


59

• A lower bound (Section 2.5.1)• An Upper Bound (Section 2.5.2)

Tight space bounds for mutual Tight space bounds for mutual exclusion using atomic registersexclusion using atomic registers


60

A Simple ObservationA Simple Observation

Theorem: Any deadlock-free mutual exclusion algorithm for n processes using only SWMR registers must use at least n such registers.

Theorem: Any deadlock-free mutual exclusion algorithm for n processes using only SWMR registers must use at least n such registers.

A very simple Lower Bound

Proof: Before entering its critical section a process must write at least once …

Question: Can we do better using MWMR registers ?

Answer: No.

(SWMR == Single Writer Multi Reader)


61

Tight Space BoundsTight Space Bounds

Theorem: Any deadlock-free mutual exclusion algorithm for n processes must use at least n shared registers.

Theorem: Any deadlock-free mutual exclusion algorithm for n processes must use at least n shared registers.

Section 2.5.1

A Lower Bound (very difficult to prove!)

Proof: (see next few slides)


62

DefinitionsDefinitions

run – a sequence of events run x looks like run y to process p process p is hidden in run x process p covers register r in run x


63

ExampleExamplerun x looks like run y to process p

run x• p reads 5 from r• q writes 6 to r• p writes 7 to r• q writes 8 to r• p reads 8 from r

run y• p reads 5 from r• p writes 7 to r• q writes 6 to r• q reads 6 from r• q writes 8 to r• p reads 8 from r

8r 8r

• q write 6 to r1

6

The values of the shared registers must also be the same


64

ExampleExample

• p reads 5 from r• q reads 5 from r• p writes 7 to r• q writes 8 to r• p reads 8 from r• q writes 6 from r

r

writes must be overwritten before any other process has read the value written

process p is hidden in run x


65

ExampleExample

• p reads 5 from r• p reads 5 from r• q reads 5 from r• p writes 7 to r• q writes 8 to r• p reads 8 from r• p writes 2 to r

r

writes must be overwritten before any other process has read the value written

process p covers register r in run x

p covers r at these

three points


66

Lemma 2.17Lemma 2.17 (very simple)(very simple)

x y

run x looks like run y to processes in P

z

P events only

then, this is also a

run

Proof: By induction on the number of events in (z-x) …


67

Lemma 2.18Lemma 2.18 (very simple)(very simple)

If p is in its critical section in run z then p is not hidden in z.

z

p is in its

critical section

then, p is not hidden

Proof: Assume to the contrary … by Lemma 2.17 …


68

Lemma 2.19Lemma 2.19

x

all the processes

are hidden

all processes except may p are

in their remainders

y

Then, for any p there exists y such that x looks like y to p

Proof: By induction on the number of steps of processes other than p in x ...


69

Lemma 2.19Lemma 2.19: Example: Example

• w reads 5• p reads 5• q reads 5• p writes 7• q writes 8• q reads 8• w writes 3• w reads 3• p write 9• p in its critical section• p exits

5 r w is hidden remove ww is in its remainder

q is in its remainder

important: q is still hidden !!!

q is hidden remove q

p is in its remainder

Formal proof: By induction on the number of steps of processes other than p in x ...


70

Lemma 2.20Lemma 2.20 (simple)(simple)

x

all the processe

s are hidden

only p takes steps

zp covers unique register

Then, for every p there exists z


71

Lemma 2.20: ProofLemma 2.20: Proof

x

all the processes are hidden

all processes except may p are

in their remainders

x looks like y to p

p is in its critical section

p is in its critical section

By Lemma 2.17 …

… p is hidden … imp. by Lemma 2.18

p covers unique register

z

By Lemma 2.19: there exists y …

By the deadlock-freedom assumption …


72

Lemma 2.21Lemma 2.21 (main lemma)(main lemma)

x

all the processes are in their remainder

z

only P take steps

P are hidden and cover |P|

distinct register

Then, for every set of processes P there exists z

Proof: By induction on k the size of P.


73

Lemma 2.21Lemma 2.21 (main lemma)(main lemma)

Proof: By induction on k the size of P. Base: k = 0 is trivial. Induction hypothesis: Assume that it holds for k 0. Step: We prove that it holds for k+1.

let P be a set of processes where |P|= k; let p be a process not in P. We show that:

z

only P+p take steps

P+p are hidden and cover |P+p| distinct register


74

Lemma 2.21Lemma 2.21

x y1

W1

... ... ...y2 yi

yj

W2 Wi Wj

only P take steps

P are hidden and cover |P|

distinct registers

By the induction hypothesis:

z1

w1

z2 zi zj

w2 wi wj

...

each process in P takes one step first; all in their remainders ; ...

equals

This completes the lower bound proof

only p takes steps

p covers a unique register

w1 W1(Lemma 2.20)

P are hidden? YesP cover W1 ? Yesp covers w1? Yesp is hidden? Maybe

P are hidden? YesP cover Wj ? Yesp covers wj? Yesp is hidden? Yes!


75

QuestionQuestion

• p reads 5 from r• q reads 5 to r• p writes 7 to r• q writes 8 to r• p reads 8 from r• p writes 8 to r

8r

What breaks in the lower bound proof if we change the definition of “process p is hidden in run x” as follows:

this write does not

change the value of r!


76

Tight Space BoundsTight Space Bounds

Theorem: There is a deadlock-free mutual exclusion algorithm for n processes that uses n shared bits.

Theorem: There is a deadlock-free mutual exclusion algorithm for n processes that uses n shared bits.

Section 2.5.2

An Upper Bound


77

The One-Bit AlgorithmThe One-Bit Algorithmcode of process i , i {1 ,..., n}

1 2 3 4 n

b bits false false false false false false true true false false true true false

critical section

false

p3 writes true

p3 writes false

pn writes true

pn writes false


78

The One-Bit AlgorithmThe One-Bit Algorithmcode of process i , i {1 ,..., n}

repeat b[i] = true; j = 1; while (b[i] = true) and (j < i) do if b[j] = true then b[i] = false; await b[j] =false fi j = j+1 oduntil b[i] = truefor j = i+1 to n do await b[j] = false odcritical sectionb[i] = false

1 2 3 4 n

b bitsfalse false false false false false


79

Does the correctness of the One-bit algorithm depend on the order in which the bits are read in the loops ?

QuestionQuestion


80

Properties of the One-Bit AlgorithmProperties of the One-Bit Algorithm

• Satisfies mutual exclusion and deadlock-freedom• Starvation is possible• It is not fast• It is not symmetric• It uses only n shared bits and hence it is space optimal

• Would it work with safe bits?

• Satisfies mutual exclusion and deadlock-freedom• Starvation is possible• It is not fast• It is not symmetric• It uses only n shared bits and hence it is space optimal

• Would it work with safe bits?


81

QuestionQuestion

Does it follow from the lower bound that there is no solution when the number of processes is not known in advance or when the number is infinite?

Computing with Infinitely Many ProcessComputing with Infinitely Many Process

Section 2.5.3

No. It follows that in such a case infinitely many registers are needed. A simple algorithm for infinitely many processes is presented in Section 2.5.3.


82

Computing with Infinitely Many Process: The algorithmComputing with Infinitely Many Process: The algorithm

Section 2.5.3

0 0 0 0 0 0 0 0 0 0owner

0 0 0 0 0 0 0 0 0 0other

0 0 0 0 0 0 0 0 0 0loser

0 0 0 0 0 0 0 0 0 0winner

1 2 3 4 5 6 7 8 9 10

1

1

1 1 1 1

process 4 runs alone …

process 4 is the winner

process 3 runs ...

1

1

process 3 lost

process 6 runs ...

1

1

1 1 1 1

process 3 lost

This is just one game, we need infinitely many …

…

…

…

…


83

Automatic Discovery of AlgorithmsAutomatic Discovery of Algorithms

How do we invent algorithms?

Section 2.6

eureka

This is one way

See next slide for another way ...(maybe they are the same ...)


84

Automatic DiscoveryAutomatic Discovery

Algorithm Generator

Algorithm Generator

Algorithm Verifier

Algorithm Verifier

algorithmscorrectalgorithms


85

System OverviewSystem Overview

Algorithm Generator

Algorithm Generator

Algorithm Verifier

Algorithm Verifier

User InterfaceUser Interface

algorithms

verificationresults

correctalgorithms

parameters(# of: processes, bits, lines of code)


86

ResultsResults

Sharedbits

223344456

Entry

674645655

Exit

111111111

Complexconditions

Yes

Yes

Yes

Starvationfreedom

YesYesYes

Yes

Tested algorithms

7,196,536,269846,712,05925,221,389

1,838,128,995129,542,873129,190,403

*900,000,000*22,000,000*70,000,000

Correct alg.

066

10510

4805680

10696

appx. runninghours

216390.44711

120.4

1

User-defined parameters Results

* This run was stopped after few solutions were found. Not all algorithms were tested.


87

Next ChapterNext Chapter

In Chapter 3 we will consider more advanced solutions to the mutual exclusion problem using atomic registers.

-- Gadi

Documents

1 Chapter 2 Synchronization Algorithms and Concurrent Programming Gadi Taubenfeld © 2007 Synchronization Algorithms and Concurrent Programming Gadi Taubenfeld