1. O(log n / log log n) RMRs Randomized Mutual Exclusion
Danny Hendler
Philipp Woelfel
PODC 2009
Ben-Gurion University
University of Calgary

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

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

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

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

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

7. Basic Algorithm – Data Structures
Δ-1 Δ 1
Δ=Θ(log n / log log n)
Key idea:
Processes apply randomized promotion 1 2 Δ 1 2 n

8. Basic Algorithm – Data Structures (cont'd)
pi1
pi2
pik
Promotion Queue
notified[1…n]
Δ-1 Δ 1 2 n
Per-node structure
lock{P,}
apply:
<v1,v2, …,vΔ>

9. Basic Algorithm – Entry Section
Δ-1 Δ 1
Lock=
apply:
<v1, , …,vΔ> i
CAS(, i)  i i

10. Basic Algorithm – Entry Section: scenario #2
Δ-1 Δ 1
Lock=q
apply:
<v1, , …,vΔ>
Failure
CAS(,i) i i

11. Basic Algorithm – Entry Section: scenario #2
Δ-1 Δ 1
Lock=q
apply:
<v1, , …,vΔ> i
await (n.lock=) || apply[ch]=) i

12. Basic Algorithm – Entry Section: scenario #2
Δ-1 Δ 1
Lock=q
<v1, , …,vΔ>
apply: i
await (n.lock=) || apply[ch]=) i

13. Basic Algorithm – Entry Section: scenario #2
Δ-1 Δ 1
await (notified[i) =true) CS i

14. Basic Algorithm – Exit Section
Δ-1 Δ 1
Lock=p
apply:
<v1, q, …,vΔ>
Climb up from leaf until last node captured in entry section 
Lottery p

15. Basic Algorithm – Exit Section
Perform a lottery on the root
Δ-1 Δ 1
Lock=p
apply:
<v1, , …,vΔ> 
Promotion Queue q s t p

16. Basic Algorithm – Exit SectionCS
Δ-1 Δ 1
await (notified[i) =true)
Promotion Queue q s t i

17. Basic Algorithm – Exit Section (scenario #2)
Free Root Lock
Δ-1 Δ 1
Promotion Queue
EMPTY i

18. 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
When lock is free, it is captured atomically by CAS

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

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

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

22. The enhanced algorithm.
Key idea
Quit 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?

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

24. Counting RMRs: solution
Key idea
Perform both randomized and deterministic promotion
Lock=p
apply:
<v1, q, …,vΔ>
token:
Increment promotion token whenever releasing a node
Perform deterministic promotion according to promotion index in addition to randomized promotion

25. Waiting processes may incur RMRs without participating in lotteries!
The enhanced algorithm: quitting problem
Upon exceeding allowed number of RMRs, why can't a process simply release captured locks and revert to a deterministic algorithm? ? 1 2 Δ N
Waiting processes may incur RMRs without participating in lotteries!

26. Δ Quitting problem: solution
Add a deterministic Δ-process mutex object to each node
Δ-1 Δ 1 2 n
Per-node structure
lock{P,}
apply:
<v1,v2, …,vΔ>
token:
MX: Δ-process mutex

27. Quitting problem: solution (cont'd)
Per-node structure
lock{P,}
apply:
<v1,v2, …,vΔ>
token:
MX: Δ-process mutex
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.

28. Worst-case number of RMRs = O(Δ log Δ)=O(log n)
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)

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

30. Data-structures
the i'th leaf
i'th

31. The entry section
i'th

32. The exit section
i'th

33. 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?