Adaptive and Efficient Mutual Exclusion

1
Adaptive and Efficient Mutual Exclusion
By Hagit Attya and Vita Bortnikov
Presented by
Mian Huang
2
Talk Outline

• Introduction
• Related Work
• Preliminaries
• Algorithms
• Future Work

3
Introduction

• 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 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
Preliminaries

• Adaptive algorithms
• Point contention (strongest)
• Interval contention
• Renaming algorithms(getName/releaseName)
• Long-lived
• One-shot
• Non-wait-free algorithms

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

• 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 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 Algorithm

• Critical Section

Figure 1. Algorithm Structure
10
Non-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 rth filter of
  the lth chain, then it skips the next r-1 chains
  and tries to win in the (lr)th chain

11
Non-Wait-Free Renaming
rth r-1
2
1
0
0
0
0
Filters Chains
0 l (r-1) l r
n-1
Figure 2. The next chain calculation
12
The code of Basic Algorithm

• Private variables
• lastFilter interger
• Procedure getName() //get a new name
• l 0
• Index -1
• Repeat
• l l index 1
• //calculate next chain to enter
• ltresult,indexgt executeChain(l)
• Until result win
• lastFilter startFilterl index
• Return l1

• Procedure releaseName(name) // release a name
• startFiltername lastFilter 1
• Procedure executeChain(l) // access
  chain l
• filters ChainslstartFilterl
• curr 0
• while (true)
• if executeFilter(Filterscurr) success then
• if curr gt 0 and ?Filterscurr-1.c
  then
• return ltwin, currgt
• else curr
• else return ltlose, currgt

Figure 3. Adaptive long-lived non-wait-free
k-renaming with unbounded memory
13
The code of Basic Algorithm(Cont.)

• Procedure executeFilter(filter)
  // access a specific filter
• if filter.turn ? ? then return fail
• filter.turn id
• if filter.d then return fail
  // there is a winner - fail
• wait until ?filter.b or filter.turn ? id or
  filter.d
• if filter.d then return fail
• if filter.turn id then filter.b true
  // try to succeed
• if filter.turn ? id then // failing
  in the filter
• filter.c true
• filter.b false
• return fail
• else // succeeding in the filter
• filter.d true
• return success

Figure 3. Adaptive long-lived non-wait-free
k-renaming with unbounded memory
14
The Procedures Basic Algorithm

• getName()
• Obtains a new name
• Invokes procedure executeChain ()
• executeChain (l)
• Returns a pair ltwin or lose, the index of the
  last accessed filter in the chaingt
• 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 Algorithm - Filter Properties

• The following properties ensure that exactly one
  process eventually remains in the chain and wins
  it.
• Safety
• If k processes enter the filter, then at most
  ?k/2? processes succeed in it.
• Progress
• If one or more processes enter the filter, then
  at least one process succeeds in it.
• Modified filter will also have the property
• Time complexity
• Some process succeeds in the filter O(1) time
  units after the first process enters it

16
Result of the Algorithm - Chain Properties

• 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 lt 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 winners execution
  interval System response
  time

17
An 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 Tree
A process with a name in the range 0, , k-1
climbs at most 2logk 1 nodes
Root
1
2 3
4 5 6 7
8 9 10 11 12 13 14 15
19
Complexity 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 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 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 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 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