Chapter 2 Synchronization Algorithms and Concurrent Programming Gadi Taubenfeld © 2014 - PowerPoint Presentation

346 views
Uploaded On 2020-08-28

Chapter 2 Synchronization Algorithms and Concurrent Programming Gadi Taubenfeld © 2014 - PPT Presentation

Synchronization Algorithms and Concurrent Programming Gadi Taubenfeld Chapter 2 Mutual Exclusion using atomic registers Basic Topics Version June 2014 Chapter 2 Synchronization Algorithms and Concurrent Programming Gadi Taubenfeld 2014 ID: 809956

false algorithms concurrent gadi algorithms false gadi concurrent taubenfeld chapter programming synchronization 2014 number section critical process flag code

Link:

Copy

Embed:

<iframe width="560" height="315" src="https://www.docslides.com/embed/809956" frameborder="0" allowfullscreen></iframe>

Download Presentation from below link

Download The PPT/PDF document "Chapter 2 Synchronization Algorithms and..." is the property of its rightful owner. Permission is granted to download and print the materials on this web site for personal, non-commercial use only, and to display it on your personal computer provided you do not modify the materials and that you retain all copyright notices contained in the materials. By downloading content from our website, you accept the terms of this agreement.

Presentation Transcript

Slide1

Chapter 2

Synchronization Algorithms and Concurrent Programming

Gadi Taubenfeld

Chapter 2 Mutual Exclusion using atomic registers: Basic Topics

Version:

June 2014

Slide2

Chapter 2

A note on the use of these power-point 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

Synchronization Algorithms and Concurrent Programming

ISBN: 0131972596, 1

edition

To get the most updated version of these slides go to:

http://www.faculty.idc.ac.il/gadi/book.htm

Slide3

Chapter 2

2.1

Algorithms for Two Processes2.2 Tournament Algorithms2.3 A Fast Mutual Exclusion Algorithms2.4 Starvation-free Algorithms2.5 Tight Space bounds

2.6 Automatic Discovery of algorithms Chapter 2 Mutual Exclusion using atomic registers: Basic Topics

Slide4

The Mutual Exclusion Problem

Basic definitions

Chapter 1

Slide5

Chapter 2

remainder code

entry code

critical sectionexit 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 problem

Slide6

Chapter 2

The mutual exclusion problem

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

critical

section

remainder

Slide7

Chapter 2

Question: true or false ?

entry code of A

exit code of A

critical

section

remainder

entry code of B

exit code of B

Algorithm C

entry code

exit code

critical

section

remainder

Algorithm A

Algorithm B

Slide8

Chapter 2

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.

entry code of A

exit code of A

critical

section

remainder

entry code of B

exit code of B

Algorithm C

Slide9

Chapter 2

Does it work?

Atomic read/write registers

Proposed solution 1Thread 0

while (true} {remainder code

while (turn = 1) {

skip

}

critical section

turn = 1

}

Thread 1

while (true} {

remainder code

while

(turn = 0)

{

skip

}

critical section

turn = 0

}

entry

code

exit

code

0/1

turn

mutual exclusion

deadlock-freedom

Slide10

Chapter 2

Convention

Thread 0

while (true} {remainder code

}

Thread 1

while (true} {

remainder code

}

entry code

exit code

critical section

entry code

exit code

critical section

Slide11

Chapter 2

Convention

Thread 0

Thread 1

entry code

exit code

critical section

entry code

exit code

critical section

Slide12

Chapter 2

Proposed solution 2

Thread 0

flag[0] = truewhile (flag[1])

{skip}critical section

flag[0] = false

Thread 1

flag[1] = true

while

(flag[0])

{

skip

}

critical section

flag[1] = false

false

flag

false

Does it work?

mutual exclusion

deadlock-freedom

Slide13

Chapter 2

Proposed solution 3

Thread 0

while (flag[1]) {

skip}flag[0] = true

critical sectionflag[0] = false

Thread 1

while

(flag[0])

{

skip

}

flag[1] = true

critical section

flag[1] = false

false

flag

false

Does it work?

mutual exclusion

Deadlock-freedom

Slide14

Algorithms for Two Processes

Section 2.1

Chapter 2

Slide15

Chapter 2

Peterson’s algorithm

Thread 0

flag[0] = trueturn = 1

while (flag[1] and turn = 1)

{skip

}

critical section

flag[0] = false

Thread 1

flag[1] = true

turn = 0

while

(flag[0]

and

turn = 0)

{

skip

}

critical section

flag[1] = false

false

flag

false

0/1

turn

Section 2.1.1

Slide16

Chapter 2

0/1

A variant of Peterson’s algorithm

false

flag

false

turn

Is it correct ?

true

Thread 0

turn = 1

flag[0] = true

while

(flag[1]

and

turn = 1)

{

skip

}

critical section

flag[0] = false

Thread 1

turn = 0

flag[1] = true

while

(flag[0]

and

turn = 0)

{

skip

}

critical section

flag[1] = false

Slide17

Chapter 2

Indicate contending

b[i] := trueBarrier

turn := iContention?b[i] = true ?

critical sectionexit codeb

[i] = false ?

First to cross

the barrier?

turn

yes

no / maybe

Schematic for Peterson’s algorithm

Slide18

Chapter 2

Properties of Peterson’s Solution

Satisfies mutual exclusion and starvation-freedomMemory accesses are assumed to be atomicSolution for two processes only

Slide19

Chapter 2

Question

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 registers

Section 2.1.2

Slide20

Algorithms for Many Processes

Section 2.2

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

Slide21

Chapter 2

Tournament Algorithms

Section 2.2

Yes

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

Slide22

Models, Properties & Complexity

Basic definitions and notations

Chapter 2

Slide23

Chapter 2

. . .

Shared Memory Models

Coherent Caching

Distributed Shared Memory

Simple Shared Memory

Slide24

Chapter 2

Properties & complexity

Time complexityFastAdaptiveFairnessFIFO, ...Fault-toleranceLocal spinning Space complexityCommunication primitives

Slide25

Chapter 2

Complexity Measures

Counting stepscontention-free time complexityprocess time complexityprocess step complexityCounting time unitssystem response timeprocess response timeCounting communicationsdistributed shared memorycoherent cachingSpace complexity

Slide26

Chapter 2

Thread 0

flag[0] = true

turn = 1while (flag[1] and turn = 1)

{skip}

critical section

flag[0] = false

Thread 1

flag[1] = true

turn = 0

while

(flag[0]

and

turn = 0)

{

skip

}

critical section

flag[1] = false

What is the contention-free time complexity?

Contention-free time complexity

(3 in the entry + 1 in the exit)

Slide27

Chapter 2

Process time complexity

time

A single run

Formal:

The max # of (shared memory) steps a winning process need to take in its entry/exit sections since the last time some process released its critical section.

Given an algorithm divide it steps …

A – entry/exit steps;

B – critical section steps;

C – other steps (remainder).

Informal:

The longest

black

interval, counting steps.

Process step complexity:

# of steps, since it has started…

Slide28

Chapter 2

∞

Thread 0

flag[0] = trueturn = 1while

(flag[1] and turn = 1)

{skip}

critical section

flag[0] = false

Thread 1

flag[1] = true

turn = 0

while

(flag[0]

and

turn = 0)

{

skip

}

critical section

flag[1] = false

What is the process time/step complexity?

Theorem:

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

Proof:

see Section 3.2.5 .

Process time complexity

Slide29

Chapter 2

System response time

time

A single run

one

time

unit

Slide30

Chapter 2

System response time

time

A single run

Formal:

The longest time interval where some process is in its entry code while no process is in its CS, assuming an

upper bound of one time unit

for step time, and no lower bound.

Given an algorithm divide it steps …

A – entry/exit steps;

B – critical section steps;

C – other steps (remainder).

Informal:

The longest

black

interval, counting time units.

Slide31

Chapter 2

How many time units

time

A single run

Slide32

Chapter 2

How many time units

time

A single run

Slide33

Chapter 2

Show a run of Peterson’s algorithm where the

system response time is 5 time units.

What is the system response time?

Thread 0

flag[0] = true

turn = 1

while

(flag[1]

and

turn = 1)

{

skip

}

critical section

flag[0] = false

Thread 1

flag[1] = true

turn = 0

while

(flag[0]

and

turn = 0)

{

skip

}

critical section

flag[1] = false

Slide34

A Fast Mutual exclusion Algorithm

Section 2.3

Chapter 2

Slide35

Chapter 2

A Fast Mutual exclusion Algorithm

Mutual exclusion and deadlock-freedomStarvation of individual processes is possiblefast accessin the absence of contention, only 7 accesses to shared memory are neededWith 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 unitsn+2 shared registers are used

Slide36

Chapter 2

At most

n-1 can move rightAt most n-1 can move downAt most 1 can winIn solo run 

1 winSplitter

right

win

down

right

x = i

 0

then

go right

y = 1



then

go down

win

Slide37

Chapter 2

Notation

await (condition) == while

(not condition) do skip od

Example:await (x=5) == wait until x=5

Slide38

Chapter 2

Fast Mutual exclusion Algorithm

code 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

 i

then

b[i] = false

for

j = 1

await b[j] = false

 i

then

await y = 0

goto

start

fi fi

critical section

y = 0

b[i] = false

false

right

down

win

Slide39

Chapter 2

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

await b[j] = false

 i

then

await y = 0

goto

start

fi fi

critical section

b[i] = false

y = 0

What is the

maximum

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

Slide40

Chapter 2

Fast Mutual exclusion Algorithm

code 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

 i

then

b[i] = false

for

j = 1

await b[j] = false

 i

then

await y = 0

goto

start

fi fi

critical section

y = 0 b[i] = false

false

Can we replace the order of these two statements ?

No. Mutual exclusion is not satisfied.

Slide41

Chapter 2

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

await b[j] = false

 i

then

await y = 0

goto

start

fi fi

critical section

y = 0

replace with:

= i

then

y = 0 fi b[i] = false

Yes

Slide42

Chapter 2

Can we remove

await y=0 in line 4 ?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

await b[j] = false

 i

then

await y = 0

goto

start

fi fi

critical section

y = 0

b[i] = false

No. Deadlock is possible

remove ?

Slide43

Chapter 2

Can we remove

await y=0 in line 9 ?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

await b[j] = false

 i

then

await y = 0

goto

start

fi fi

critical section

y = 0

b[i] = false

Yes

remove ?

Slide44

Chapter 2

Would this work ?

start: b[i] = true x = i

if y  0 and y =i then b[i] = false await y = 0

goto start fi y = i if x

 i then b[i] = false

for

j = 1

await b[j] = false

 i

then

await y = 0

goto

start

fi fi

critical section

y = 0

b[i] = false

remove

add

and

No. Mutual exclusion is not satisfied.

Slide45

Chapter 2

Indicate contending

b[i] := true

Barrierturn := iContention?x  i ?

critical sectionexit code

Last to cross the barrier?y = i

yes

Contention?

Continue only after it is

guaranteed that no one can

cross the barrier

Wait until CS is released

yes

The last to cross

the barrier!

Schematic for the fast algorithm

Slide46

Starvation-free

Algorithms

Section 2.4Chapter 2

2.4.1

Basic Definitions (i.e., FIFO) 2.4.2 The Bakery Algorithm2.4.3 The Black-White Bakery Algorithm

Slide47

Chapter 2

The mutual exclusion problem

entry code

exit code

critical

section

remainder

Mutual Exclusion

Deadlock-freedom

Starvation-freedom

FIFO

doorway

waiting

Slide48

Chapter 2

time

The Bakery Algorithm

doorway

exit

waiting

entry

remainder

Section 2.4.2

Slide49

Chapter 2

Implementation 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

number

integer

Answer: No! can deadlock

Slide50

Chapter 2

time

Implementation 1: deadlock

doorway

exit

waiting

entry

remainder

deadlock

Slide51

Chapter 2

Implementation 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

number

integer

Answer: does not satisfy mutual exclusion

What if we replace

with



Slide52

Chapter 2

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

number

integer

Answer: does not satisfy mutual exclusion

Implementation 2

code of process i , i



{1 ,..., n}

Slide53

Chapter 2

time

Implementation 2: no mutual exclusion

doorway

exit

waiting

entry

remainder

Slide54

Chapter 2

The Bakery Algorithmcode of process i , i

 {1 ,..., n}choosing[i] = tru

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

choosing[i] = falsefor j = 1 to n {

await choosing[j] = false

await

(number[j]



(number[j],j)



(number[

)

}

critical section

number[

] = 0

choosing

bits

false

number

integer

false

Slide55

Chapter 2

Properties 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.

Slide56

Chapter 2

time

The Bakery Algorithm

doorway

exit

waiting

entry

remainder

Slide57

Chapter 2

Is the following version correct?

code of process i , i  {1 ,..., n}choosing[i] = truenumber[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 section

number[i] = 0

choosing

bits

false

number

integer

false

Slide58

Chapter 2

time

doorway

exit

waiting

entry

remainder

Slide59

Chapter 2

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 section

number[i] = 0

choosing

bits

false

number

integer

false

Yes

Can we replace



with

Slide60

Chapter 2

Computing the Maximum #1

code 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

number

integer

number[i] = 1 +

max {

number[j]

 j  n

)

}

Slide61

Chapter 2

Computing the Maximum #2

code of process i , i  {1 ,..., n} 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]

number

integer

number[i] = 1 +

max {

number[j]

 j  n

)

}

Slide62

Chapter 2

time

doorway

exit

waiting

entry

remainder

local1

Passed process 1

Waiting for process 2

Slide63

Chapter 2

Computing the Maximum #3

code of process i , i  {1 ,..., n} 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

Slide64

Chapter 2

The Black-White Bakery Algorithm

Section 2.4.3

Bounding the space of the Bakery Algorithm

Bakery (FIFO, unbounded)

The Black-White Bakery Algorithm

FIFO

Bounded space

+ one bit

Slide65

Chapter 2

time

The Black-White Bakery Algorithm

doorway

exit

waiting

entry

remainder

color bit

Slide66

Chapter 2

The Black-White Bakery Algorithm

choosing

Data Structures

mycolor

number

color bit

bits

{0,1,...,n}

{black,white}

Slide67

Chapter 2

The Black-White Bakery Algorithm

code of process i , i

 {1 ,..., n}

choosing[i] = truemycolor[i] = color

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

 j  n

)



(mycolor[j] = mycolor[i])

}

choosing[i] = false

for

j = 0

await

choosing[j] = false

mycolor[j] = mycolor[i]

then

await

(number[j]



(number[j],j)  (number[i],i)  (mycolor[j]  mycolor[i]) else await (number[j]

= 0)  (mycolor[i]  color) 

(mycolor[j] = mycolor[i])

fi od

critical section

mycolor[i] = black

then

color =

white

else

color = black

number[i] = 0

Slide68

Chapter 2

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?

Question

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.

Slide69

Chapter 2

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

Question

Answer: Yes, it matters.

Slide70

Chapter 2

Bakery

Black-White Bakery

Use single-writer bits only!

Question

Replace the multi-writer bit

color

with n single-writer bits.

Answer: See page 57.

Slide71

Tight Space Bounds

Section 2.5

Chapter 2

Slide72

Chapter 2

A Simple Observation

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)

Slide73

Chapter 2

Tight Space Bounds

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)

Slide74

Chapter 2

Definitions

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

Slide75

Chapter 2

Example

run x looks like run y to process p

run xp reads 5 from rq writes 6 to rp writes 7 to rq writes 8 to rp reads 8 from r

run yp reads 5 from r

p writes 7 to rq writes 6 to rq reads 6 from r

q writes 8 to r

p reads 8 from r

q write 6 to r1

The values of the shared registers must also be the same

Slide76

Chapter 2

Example

p reads 5 from rq reads 5 from r

p writes 7 to rq writes 8 to rp reads 8 from rq writes 6 from r

writes must be overwritten before any other process has

read the value written

process p is

hidden

in run x

Slide77

Chapter 2

Example

p reads 5 from rp reads 5 from r

q reads 5 from rp writes 7 to rq writes 8 to rp reads 8 from rp writes 2 to r

writes must be overwritten before any other process has

read the value written

process p

covers

p covers r at these three points

Slide78

Chapter 2

Lemma 2.17

(very simple)

run x

looks like

run y to processes in P

P events only

then, this is also a run

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

Slide79

Chapter 2

Lemma 2.18

(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 …

Slide80

Chapter 2

Lemma 2.19

all the processes are hidden

all processes, except maybe p, are in their remainders

Then, for any p there

exists y such that

looks like

y to p

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

Slide81

Chapter 2

Lemma 2.19: Example

w reads 5

p reads 5q reads 5p writes 7q writes 8q reads 8w writes 3w reads 3

p write 9p in its critical sectionp exits

w is hidden

 remove w

w 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 ...

Slide82

Chapter 2

Lemma 2.20

(simple)

xall the processes are hidden

only p takes steps

p covers unique register

Then, for every

p there exists z

Slide83

Chapter 2

Lemma 2.20: Proof

all the processes are hidden

all processes, except maybe p, are in their remainders

looks like

y to p

p is in its critical section

By Lemma 2.17 …

… p is hidden … imp. by Lemma 2.18

p covers unique register

By Lemma 2.19: there exists y …

By the deadlock-freedom assumption …

Slide84

Chapter 2

Lemma 2.21

(main lemma)

xall the processes are in their remainder

only P take steps

P are hidden and cover |P| distinct registers

Then, for every set of

processes P there exists z

Proof: By induction on k the size of P.

Slide85

Chapter 2

Lemma 2.21

(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:

only P+p take steps

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

Slide86

Chapter 2

Lemma 2.21

...

only P take steps

P are hidden and cover |P| distinct registers

By the induction hypothesis:

...

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



(Lemma 2.20)

P are hidden? Yes

P cover

? Yes

p covers

? Yes

p is hidden?

Maybe

P are hidden? Yes

P cover

? Yes

p covers

? Yes

p is hidden?

Yes!

Slide87

Chapter 2

Question

p reads 5 from rq reads 5 to r

p writes 7 to rq writes 8 to rp reads 8 from rp writes 8 to r

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!

Slide88

Chapter 2

Tight Space Bounds

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

Section 2.5.2

An Upper Bound

Slide89

Chapter 2

The One-Bit Algorithmcode of process i , i

 {1 ,..., n}1

bits

false

true

false

true

false

critical section

false

writes true

writes false

writes true

writes false

Slide90

Chapter 2

The 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 od

critical section

b[i] = false

bits

false

Slide91

Chapter 2

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

Question

Slide92

Chapter 2

Properties 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?

Slide93

Chapter 2

Question

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

Computing with Infinitely Many ProcessSection 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.

Slide94

Chapter 2

Computing with Infinitely Many Process: The algorithm

Section 2.5.3

owner

other

loser

winner

process 4 runs alone …

process 4 is the winner

process 3 runs ...

process 3 lost

process 6 runs ...

process 3 lost

This is just one game, we need infinitely many …

…

Slide95

Automatic Discovery of Algorithms

Section 2.6

Chapter 2

Slide96

Chapter 2

Automatic 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 ...)

Slide97

Chapter 2

Automatic Discovery

Algorithm GeneratorAlgorithm Verifier

algorithms

correctalgorithms

Slide98

Chapter 2

System Overview

Algorithm GeneratorAlgorithm Verifier

User Interface

algorithms

verification

results

correct

algorithms

parameters

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

Slide99

Chapter 2

Results

Shared

bits

23344456

Entry

Exit

Complex

conditions

Yes

Starvation

freedom

YesYesYesYes

Tested algorithms 7,196,536,269846,712,05925,221,3891,838,128,995129,542,873129,190,403*900,000,000*22,000,000*70,000,000

Correct

alg.

105

480

106

appx.

running

hours

216

0.4

User-defined parameters Results

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

Slide100

Chapter 2

Next Chapter

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

Chapter 2 Synchronization Algorithms and Concurrent Programming Gadi Taubenfeld © 2014 - PowerPoint Presentation

Chapter 2 Synchronization Algorithms and Concurrent Programming Gadi Taubenfeld © 2014 - PPT Presentation

Share:

Link:

Embed:

Related Contents