Upload
elinor-blake
View
219
Download
0
Tags:
Embed Size (px)
Citation preview
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?