Asynchronous Exclusive Selection Bogdan Chlebus, U. Colorado Darek Kowalski, U. Liverpool
Jan 17, 2018
Asynchronous Exclusive Selection
Bogdan Chlebus, U. ColoradoDarek Kowalski, U. Liverpool
Model and Problem
17
READ
WRITE
processes registers
1
2
4
3
7 6
2827
13
5
1
8
9
1112
14 15
Model Details
PROCESSES:• n processes• unique ids from {1,...,N} • asynchronous• prone to crash failures
REGISTERS:• r registers• unique ids from {1,...,r} • read/write• store O(log N) bits each
PROBLEMS:Assigning exclusive integers to processes
Plan
Example 1: RenamingExample 2: Store&CollectExample 3: Unbounded Naming
Example 1: Renaming
Problem definition:• k ≤ n processes contend to acquire unique
integers as new names in a smaller range {1,...,M}
Complexity measures:– Max number of local steps per process– Length of the new name interval M– Number r of registers used
Competing for Register
Splitter(R):• If one process contends then
it wins R• R can be won by at most one
contending process• If there is more than one
contending process then at least two different outputs are achieved
Compete-for-Register(R):
• If one process contends then it wins R
• R can be won by at most one contending process
Pair of registers is more useful than single ones
Main Technique
17
7
8
6
4
2
1
3
5
processesregisters
28
27
13
5
1
.
.
.
Main Technique: Majority Renaming(l,N)-Majority-Renaming (MR) Problem:
at least half of l contending processes acquire new unique names in the interval {1,...,M}.
We implement MR for any l, N, and for M=12e7l log(N/l)We need:• Bipartite graph G between set of processes and set of
registers such that:– Input degree is 4 log(N/l)– A majority of contending processes have unique neighbours
(i.e., no other contending process has it as a neighbour)
From Majority Renaming to Renaming• Assume known k known N• Let Si, for i=0,1,...,lg k, be mutually disjoint sets of
registers, s.t., |Si|=12e7(k/2i) log(2iN/k)• Solve (k/2i,N)-Majority-Renaming for i=0,1,...,lg k
– For ith execution, use set Si of registers
COMPLEXITY of algorithm Basic-Rename(k,N):• Local steps: O(log k log N)• M, r = O(k log(N/k)), i.e., M = 24e7k log(N/k)
Cascade Renaming• Assume known k known N• Execute Basic-Rename(k,Nj), for j=0,1,...,j*
– N0 := N
– Nj := 24e7klog(Nj-1/k), for j>0,
until Nj ≤ e14k
COMPLEXITY of algorithm Cascade-Rename(k,N):• Local steps: O(log k (log N + log k loglog N))• M ≤ e14k• r = O(k log(N/k))
Relaxing parameters k and N• Known k unknown N
– Local steps: O(k)– M = 2k-1– r = O(k2)
• Unknown k known N – Local steps: O(log2k (log N + log k loglog N))– M = O(k)– r = O(n log(N/n))
• Unknown k, N MA AF AM– Local steps: O(k) O(k) O(k log k) O(k2)– M = 8k – lg k -1 O(k2) O(k) 2k-1– r = O(n2) O(n2) O(n2) O(n2)
Example 2: Store&Collect• Problem definition:some arbitrary k processes repeatedly execute
operations Store and Collect– Store: updates the value that the process wants to be
collected by others– Collect: learns all the values proposed most recently by
other processes, one value per process• Complexity Measures:
– Max number of local steps per process– Number r of registers used
From Renaming to Store&Collect• Organize registers into consecutive intervals of lengths
2,4,8,...• Associate a control register with every interval First Store operation (of process p): • Set control regs of intervals of size smaller than p into used• Acquire a new name i using renaming algorithm and
deposit the value in the register with the name i located in the shortest interval of length not smaller than p
Collect operation:• Collect all values from consecutive intervals
until the first empty control register occurs
Store&Collect results• N,k – known:
– Store time: O(log k (log N + log k loglog N))– Collect time: O(k)– Number of registers: O(k log(N/k))
...• N,k – unknown:
– Store/Collect time: O(k) – Number of registers: O(n2) (different approach: Afek, De Levie, DC 2007)
Lower BoundsAny wait-free solution of Renaming requires
1 + min{k-1, log2r (N/2M)}
local steps in the worst case.
Space-efficient solution: O(k) registers
Any wait-free space-efficient solution of Store operation in Store&Collect requires
(min{k, logr (N/k)})
local steps in the worst case.
Example 3: Unbounded NamingProblem:• Infinite number of registers dedicated to depositing• Fairly distributed deposit requests (each process eventually
receives a new value to deposit)• Deposit operation must be acknowledgedMeasure:• Number of registers never used for depositingNaive solution (infinite number of unused registers):• Process p deposits in consecutive registers congruent to p
modulo N
Repository
Repository: concurrent data structure, s.t., each process can deposit consecutive values in dedicated registers to guarantee:
Persistence – for any register R dedicated for depositing, after an ack(R) event, no value is ever written to R
Non-blocking – each time at least one non-faulty process wants to deposit a value, then eventually the value gets deposited
Implementing a RepositoryMinimizing the number of unused registers (n-1)• Each process p maintains (locally):
– list Lp of 2n-1 register numbers (available for deposits)
– next possibly empty register Ap
• Atomic snapshot object of n SWMR registers• Verification procedure: process p verifies list Lp by reading
consecutive registers, removing non-empty ones and searching for a new one (starting from Ap)
• Choosing by rank: a process of rank k among other acquiring processes selects kth register from its list and verifies, using snapshot, if it is unique
Implementing a Repository cont.
Wait free implementation with n(n-1) deposit-free registers
• Array Help[1..n,1..n] of shared registers• Two parallel threads intertwined:
– Verification: process p keeps reading Help[p,*] in a cyclic fashion,every Help[p,q] = null is replaced by new name obtained from the previous algorithm
– Depositing: process p keeps reading Help[*,p] in a cyclic fashion,until finding q s.t. Help[q,p] = x ≠ null, deposits in Rx and writes null to Help[q,p]
Conclusion
• We presented a variety of selection techniques and their applications
• There is enough evidence that new methods and applications are needed
• How to reduce the number of registers:– Quadratic number of registers is used in most of
the presented applications