Concurrent Counting is harder than Queuing

1. Concurrent Counting is harder than Queuing Costas Busch Rensselaer Polytechnic Intitute Srikanta Tirthapura Iowa State University

2. Arbitrary graph

3. Distributed Counting count count count count Some processors request a counter value

4. Distributed Counting Final state

5. Distributed Queuing Enq(B) Enq(A) A B Enq(C) C Enq(D) D Some processors perform enqueue operations

6. Distributed Queuing Previous=D Previous=nil A B Previous=A C D Previous=B A D B C Tail head

7. Applications Counting:- parallel scientific applications - load balancing (counting networks) Queuing:- distributed directories for mobile objects- distributed mutual exclusion

8. Ordered Multicast Multicast with the condition:all messages received at all nodes in the same order Either Queuing or Counting will do Which is more efficient?

9. Queuing vs Counting? • Total orders • Queuing = finding predecessor • Needs local knowledge • Counting = finding rank • Needs global knowledge

10. Problem • Is there a formal sense in which Counting is harder problem than Queuing? • Reductions don’t seem to help

11. Our Result • Concurrent Countingis harder thanConcurrent Queuing • on a variety of graphs including: • many common interconnection topologies • complete graph, • mesh • hypercube • perfect binary trees

12. Model • Synchronous system G=(V,E) - edges of unit delay • Congestion: Each node can process only one message in a single time step • Concurrent one-shot scenario: • a set R subset V of nodes issue queuing (or counting) operations at time zero • No more operations added later

13. Cost Model • : delay till v gets back queuing result • Cost of algorithm A on request set R is • Queuing Complexity = • Define Counting Complexity Similarly

14. Lower Bounds on Counting For arbitrary graphs: Counting Cost = For graphs with diameter : Counting Cost =

15. Theorem: For graphs with diameter : Counting Cost = Proof: Consider some arbitrary algorithm for counting

16. Graph Take shortest path of length

17. Graph 6 2 7 1 5 3 8 4 make these nodes to count

18. Node of count decides after at least time steps k Needs to be aware of other processors k-1

19. Counting Cost: End of Proof

20. Theorem: For arbitrary graphs: Counting Cost = Proof: Consider some arbitrary algorithm for counting

21. Prove it for a complete graph with nodes: any algorithm on any graph with nodes can be simulated on the complete graph

22. The initial state affects the outcome Red: count Blue: don’t count Initial State

23. Red: count Blue: don’t count 1 Final state 3 2 4 5

24. Red: count Blue: don’t count Initial state

25. Red: count Blue: don’t count 2 Final state 3 5 4 1 8 7 6

26. Let be the set of nodes whose input may affect the decision of

27. Suppose that there is an initial state for which decides Then:

28. These two initial states give same result for

29. If , then would decide less than Thus,

30. Suppose that decides at time We show: times

31. Suppose that decides at time times

32. Cost of node : If nodes wish to count: Counting Cost =

33. Nodes that affect up to time Nodes that affects up to time

34. After , the sets grow

36. Eligible to send message at time There is an initial state such that that sends a message to

37. Eligible to send message at time Suppose that Then, there is an initial state such that both send message to

38. Eligible to send message at time However, can receive one message at a time

39. Eligible to send message at time Therefore:

40. Number of nodes like :

41. Therefore:

42. Thus: We can also show: Which give: times End of Proof

43. Upper Bound on Queuing For graphs with spanning trees of constant degree: Queuing Cost = For graphs whose spanning trees are lists or perfect binary trees: Queuing Cost =

44. An arbitrary graph

45. Spanning tree

46. Spanning tree

47. Distributed Queue A Previous = Nil Tail A Tail Head

48. B enq(B) Previous = ? A Previous = Nil Tail A Tail Head

49. B Previous = ? enq(B) A Previous = Nil Tail A Tail Head

50. B Previous = ? enq(B) A Previous = Nil Tail A Tail Head