1

Adaptive and Efficient

Mutual Exclusion

Presented by:

By Hagit Attya and Vita Bortnikov

Mian Huang

2

Talk OutlineTalk Outline

Introduction Related Work Preliminaries Algorithms Future Work

3

IntroductionIntroduction

Mutual Exclusion Problem Limitations of most of current solutions Adaptive solutions

Contributions of this Paper

- Adaptive algorithms using only read and write operations that achieve: Remote step complexity O(k), where k is actual contention System response time O(log k) Space complexity

Long-lived renaming - O(nN) where N is the range of processes’ names

One-shot renaming – O(n2) where n is total # of processes

4

Related WorkRelated Work

Dijkstra 1965.

Lamport 1987. A fast mutual exclusion algorithm

Alur and Taubenfeld 1992. Results about fast mutual exclusion

Step complexity could not be adaptive for any asynchronous Algo.

Choy and Singh 1994. Adaptive solutions to the mutual exclusion problem

Without assuming hardware-provided synchronization primitives Performance to be governed solely by # of contending processes

5

PreliminariesPreliminaries

Adaptive algorithms Point contention (strongest) Interval contention

Renaming algorithms(getName/releaseName) Long-lived

One-shot

Non-wait-free algorithms

6

Preliminaries (Cont.)Preliminaries (Cont.)

The Computation Model

A standard asynchronous shared-memory model of computation.

n processes

Multi-writer multi-reader registers

shared primitives – atomic read/write registers

7

Preliminaries(Cont.)Preliminaries(Cont.)

The Complexity Measures

Remote step complexity - Max # of shared memory operations performed by a process,

where a wait is counted as a single operation

Remote memory references - A stronger version of the above parameter - Assumption of local spin

System response time - The time interval between subsequent entries into the critical section,

where a time unit is the min execution interval in which each active process performs at least one step

8

How the Basic Algorithm WorksHow the Basic Algorithm Works

Architecture An adaptive long-lived non-wait-free k-renaming An adaptive tournament tree for mutual exclusion

What it does A process gets a name in a range of size O(k) using long-lived renaming

Uses this name to enter an adaptive tournament tree for mutual exclusion

The winner of the tournament tree enters the critical section

9

The Basic AlgorithmThe Basic AlgorithmCritical Section

Long-Lived Renaming

Figure 1. Algorithm Structure

Adaptive Tournament Tree

10

Non-Wait-Free RenamingNon-Wait-Free Renaming

The basic building block Filter with an entry point and an exit point success or fail Modified filter improves time complexity

An array of n entries Each entry contains a pointer to a chain of filters/a chain The name that the process receives is the index of the chain it wins

A chain of filters Concatenated one after the other Process succeeds Process fails - If failed in the r’th filter of the l’th chain, then it skips the next

r-1 chains and tries to win in the (l+r)’th chain

Non-Wait-Free RenamingNon-Wait-Free Renaming

Figure 2. The next chain calculation

0 l (r-1) l + r n-1

1

0 0 0 0

r’th r-12

Filters

Chains

12

The code of Basic AlgorithmThe code of Basic Algorithm

Private variables

lastFilter : interger

Procedure getName() //get a new name

1. l := 0

2. Index := -1

3. Repeat

4. l := l + index +1

//calculate next chain to enter

5. <result,index> := executeChain(l)

6. Until result = win

7. lastFilter := startFilter[l] + index

8. Return l+1

Procedure releaseName(name) // release a name

1. startFilter[name] := lastFilter + 1

Procedure executeChain(l) // access chain l

1. filters := Chains[l][startFilter[l]]

2. curr := 0

3. while (true)

4. if executeFilter(Filters[curr]) = success then

5. if curr > 0 and Filters[curr-1].c then

6. return <win, curr>

7. else curr ++

8. else return <lose, curr>

Figure 3. Adaptive long-lived non-wait-free k-renaming with unbounded memory

13

The code of Basic Algorithm(Cont.)The code of Basic Algorithm(Cont.)

Procedure executeFilter(filter) // access a specific filter

1. if filter.turn then return fail 2. filter.turn :=id3. if filter.d then return fail // there is a winner - fail4. wait until filter.b or filter.turn id or filter.d5. if filter.d then return fail6. if filter.turn = id then filter.b := true // try to succeed7. if filter.turn id then // failing in the filter8. filter.c := true9. filter.b := false10. return fail11. else // succeeding in the filter12. filter.d := true13. return success

Figure 3. Adaptive long-lived non-wait-free k-renaming with unbounded memory

14

The Procedures – The Procedures – Basic AlgorithmBasic Algorithm

getName() Obtains a new name Invokes procedure executeChain ()

executeChain (l) Returns a pair: <win or lose, the index of the last accessed filter in the

chain> Executes a filter of a chain

executeFilter(filter) Modification of the filter suggested by Choy and Singh Shared variables

releaseName(name)

15

Result of the AlgorithmResult of the Algorithm - - Filter PropertiesFilter Properties

The following properties ensure that exactly one process eventually remains in the chain and wins it.

SafetyIf k processes enter the filter, then at most k/2 processes succeed in it.

ProgressIf one or more processes enter the filter, then at least one process succeeds in it.

Modified filter will also have the property:

Time complexitySome process succeeds in the filter O(1) time units after the first process

enters it

16

An execution interval of a process pi includes one iteration of enter, critical section, and exit

If the point contention during pi ‘s execution interval is k, then pi wins in chain l <= k-1

A process wins some chain within O(k) steps Remote step complexity

If k processes enter the chain, then some process wins the chain in log k + 2 filters

Some process wins the chain within O(logk) time units after the chain became busy, where k is the point contention of the winner’s execution interval System response time

Result of the AlgorithmResult of the Algorithm - - Chain PropertiesChain Properties

17

An Adaptive Tournament TreeAn Adaptive Tournament Tree

What is it Is an unbalanced binary tree Constructed from log N complete binary tree of

exponentially growing sizes(1,2,22,… nodes) – N is size of name space Connected by a single path of nodes Embedded two-process mutual exclusion algorithm with

O(1) remote steps - Yang and Anderson

18

An adaptive Tournament TreeAn adaptive Tournament Tree

A process with a name in the range 0, …, k-1 climbs at most 2logk +1 nodes

Root

The leaves are numbered from left to right.

1

2 3

4 5 6 7

8 9 10 11 12 13 14 15

19

Complexity of the Basic AlgorithmComplexity of the Basic Algorithm

Renaming Algorithm + Tournament Tree

Step complexity: O(k) + O(logk) O(k) Time complexity: O(logk) + O(logk) O(logk)

20

Bounding The Number of FiltersBounding The Number of Filters

Basic idea The number of filters in a chain is bounded by recycling previously used

filters

Solutions A chain of only 2N filters are used cyclically

The process that exits from the critical section detects “slow” processes and promotes them to enter the critical section

In addition, the scan also initializes the recycled filters

Space Complexity of the Renaming Algorithm Is dominated by the size of array Chains – O(nN)

21

Reducing The Space ComplexityReducing The Space Complexity

Basic idea one-shot f(n)-renaming

Complexity of the n-renaming Algorithm System response time O(logk) Remote step complexity O(k’), where k’ is the interval contention Space complexity O(n log n)

Space Complexity of the Mutual Exclusion Algorithm O(n2) – n times the range of names

22

Summary of ResultSummary of Result

Algorithms Remote Step Complexity

System Response Time

Space Complexity

Choy & Singh O(N) O(k) O(N)

Adaptive Bakery Algorithm

O(k4) O(k4) O(N3)

Afek et al. O(min(k2,klogN)) O(k2) O(N2 2n)

Anderson & Kim O(k) O(k) O(N)

Algorithm with long-lived renaming

O(k) O(logk) O(nN)

Algorithm with one-shot renaming

O(k) O(logk) O(n2)

Talbe1 . Comparison with previous adaptive mutual exclusion algorithms

23

Future WorkFuture Work

Improve the remote step complexity of the algorithm or show that it is optimal

Prove a lower bound on the system response time

Design an algorithm with O(k) remote memory references and O(logk) system response time