O(log n / log log n) RMRs Randomized Mutual Exclusion

Danny HendlerPhilipp Woelfel

PODC 2009

Ben-Gurion UniversityUniversity of Calgary

Talk outline

Prior art and our results Basic Algorithm (CC) Enhanced Algorithm (CC) Pseudo-code Open questions

Most Relevant Prior Art

Best upper bound for mutual exclusion: O(log n) RMRs (Yang and Anderson, Distributed Computing '96).

A tight Θ(n log n) RMRs lower bound for deterministic mutex

(Attiya, Hendler and Woelfel, STOC '08)

Compare-and-swap (CAS) is equivalent to read/write for RMR complexity(Golab, Hadzilacos, Hendler and Woelfel, PODC '07)

Our Results

Randomized mutual exclusion algorithms (for both CC/DSM)

that have:

O(log N / log log N) expected RMR complexity

against a strong adversary, and

O(log N) deterministic worst-case RMR complexity

Separation in terms of RMR complexity between

deterministic/randomized mutual exclusion algorithms

Shared-memory scheduling adversary types

Oblivious adversary: Makes all scheduling decisions in

advance

Weak adversary: Sees a process' coin-flip only after the

process takes the following step, can change future

scheduling based on history

Strong adversary: Can change future scheduling after

each coin-flip / step based on history

Talk outline

Prior art and our results Basic algorithm (CC model) Enhanced Algorithm (CC model) Pseudo-code Open questions

Basic Algorithm – Data Structures

1 2 Δ

Δ-1

Δ

0

1

1 2 n

Δ=Θ(log n / log log n)

Key idea:

Processes apply

randomized promotion

Key idea:

Processes apply

randomized promotion

Basic Algorithm – Data Structures (cont'd)

Δ-1Δ

0

1

1 2 Δ

1 2 n

lock{P,}

apply: <v1,v2, …,vΔ>

pi1 pi2 pik

Promotion Queue

notified[1…n]

Per-node structure

Basic Algorithm – Entry Section

Δ-1

Δ

0

1

i

Lock=

apply: <v1, , …,vΔ>iCAS(, i)

i

Basic Algorithm – Entry Section: scenario #2

Δ-1

Δ

0

1

i

Lock=q

apply: <v1, , …,vΔ>iCAS(,i)

Failure

Basic Algorithm – Entry Section: scenario #2

Δ-1

Δ

0

1

i

Lock=q

apply: <v1, , …,vΔ>i

await (n.lock=) || apply[ch]=)

Basic Algorithm – Entry Section: scenario #2

Δ-1

Δ

0

1

i

Lock=q

apply: <v1, , …,vΔ>i

await (n.lock=) || apply[ch]=)

Basic Algorithm – Entry Section: scenario #2

Δ-1

Δ

0

1

i

await (notified[i) =true)

CS

Climb up from leaf until last node capturedin entry section

Lock=p

apply: <v1, q, …,vΔ>

Basic Algorithm – Exit Section

Δ-1

Δ

0

1

p

Lottery

Perform a lottery on the root

Perform a lottery on the rootLock=p

apply: <v1, , …,vΔ>

Basic Algorithm – Exit Section

Δ-1

Δ

0

1

p

s

Promotion Queue

t

q

Basic Algorithm – Exit Section

Δ-1

Δ

0

1

i

await (notified[i) =true)

t

s

Promotion Queue

q

t

CSCS

Basic Algorithm – Exit Section (scenario #2)

Δ-1

Δ

0

1

i

Promotion Queue

EMPTY

Free Root LockFree Root Lock

Basic Algorithm – Properties

Lemma: mutual exclusion is satisfied

Proof intuition: when a process exits, it either

signals a single process without releasing the root's lock, or

if the promoted-processes queue is empty, releases the lock.

o When lock is free, it is captured atomically by CAS

Basic Algorithm – Properties (cont'd)

Lemma: Expected RMR complexity is Θ(log N / log log N)

await (n.lock=) || apply[ch]=)

A waiting process participates in a lottery every constant number of RMRs incurred here

Probability of winning a lottery is 1/Δ

Expected #RMRs incurred before promotion is Θ(log N / log log N)

Basic Algorithm – Properties (cont'd)

Mutual Exclusion

Expected RMR complexity:Θ(log N / log log N)

Non-optimal worst-case complexity and (even worse) starvation possible.

Talk outline

Prior art and our results Basic algorithm (CC) Enhanced Algorithm (CC) Pseudo-code Open questions

The enhanced algorithm.

Key ideaQuit randomized algorithm after incurring ‘'too many’’ RMRS and then execute a deterministic algorithm.

Problems How do we count the number of RMRs incurred? How do we “quit” the randomized algorithm?

Enhanced algorithm: counting RMRs problem

await (n.lock=) || apply[ch]=)

The problem: A process may incur here an unbounded number of RMRs without being aware of it.

Counting RMRs: solution

Key ideaPerform both randomized and deterministic promotion

Lock=p

apply: <v1, q, …,vΔ>

Increment promotion token whenever releasing a node

Perform deterministic promotion according to promotion index in addition to randomized promotion

token:

The enhanced algorithm: quitting problem

1 2 Δ

12 N

Upon exceeding allowed number of RMRs, why can't a

process simply release captured locks

and revert to a deterministic algorithm?

?

Upon exceeding allowed number of RMRs, why can't a

process simply release captured locks

and revert to a deterministic algorithm?

?

Waiting processes may incur RMRs without participating in lotteries!

Quitting problem: solution

Add a deterministic Δ-process mutex object to each node

Δ-1Δ

0

1

1 2 Δ

1 2 n

lock{P,}

apply: <v1,v2, …,vΔ>

Per-node structure

MX: Δ-process mutex token:

Quitting problem: solution (cont'd)

• After incurring O(log Δ) RMRs on a node, compete for the MX lock. Then spin trying to capture node lock.

• In addition to randomized and deterministic promotion, an exiting process promotes also the process that holds the MX lock, if any.

lock{P,}

apply: <v1,v2, …,vΔ>

Per-node structure

MX: Δ-process mutex

token:

Quitting problem: solution (cont'd)

• After incurring O(log Δ) RMRs on a node, compete for the MX lock. Then spin trying to capture node lock.

Worst-case number of RMRs = O(Δ log Δ)=O(log n)

Talk outline

Prior art and our results Basic algorithm (CC) Enhanced Algorithm (CC) Pseudo-code Open questions

Data-structures

i'th the i'th leaf

The entry section

i'th

The exit section

i'th

Open Problems

Is this best possible?• For strong adversary?

• For weak adversary?

• For oblivious adversary?

Is there an abortable randomized algorithm?

Is there an adaptive one?