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