O(log n / log log n) RMRs Randomized Mutual Exclusion Danny Hendler Philipp Woelfel PODC 2009 Ben-Gurion University University 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 12 Δ Δ-1 Δ 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 Δ Δ 12n lock  {P,} apply: p i1 p i2 p ik Promotion Queue notified[1…n] Per-node structure

Basic Algorithm – Key Idea Δ-1 Δ 0 1 i Lock= apply: i i Randomized Promotion Randomized Promotion

Basic Algorithm – Entry Section Δ-1 Δ 0 1 i Lock= apply: i CAS(, i) i 

Basic Algorithm – Entry Section: scenario #2 Δ-1 Δ 0 1 i Lock=q apply: i CAS(,i) Failure

Basic Algorithm – Entry Section: scenario #2 Δ-1 Δ 0 1 i Lock=q apply: i await (n.lock=) || apply[ch]=)

Basic Algorithm – Entry Section: scenario #2 Δ-1 Δ 0 1 i Lock=q apply: 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 captured in entry section Lock=p apply: Basic Algorithm – Exit Section Δ-1 Δ 0 1 p  Lottery

Perform a lottery on the root Lock=p apply: 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 CS

Basic Algorithm – Exit Section (scenario #2) Δ-1 Δ 0 1 i Promotion Queue EMPTY Free 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 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?

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 idea Perform both randomized and deterministic promotion Lock=p apply:  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 12 Δ 12N 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 Δ Δ 12n lock  {P,} apply: 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: 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?