1. Self-tuning Reactive Distributed Trees for Counting and Balancing Phuong Hoai Ha Marina Papatriantafilou Philippas Tsigas OPODIS ’04, Grenoble, France Dec. 15 – 17, 2004

2. OPODIS '042 Schedule Introduction –Coordinating Objects –Reactive Shared Objects Self-tuning Reactive Trees –Algorithms –Evaluation Conclusions

3. OPODIS '043 What are coordinating objects? Data structures that evenly distribute processes into small groups, which each accesses different shared objects in a coordinated manner.       check-in Coordination high load ! high collision ! check-in

4. OPODIS '044 Example: Diffracting trees A highly distributed data structure: –Small groups of processes locally access shared data in a global coordinated manner. A disadvantage: – Optimal only for a small range of contention levels C4 C6 C5 C7 B1 B2 B3 A:0 B:1 E:4, F:5, C:2 D:3 AB,F, E, D, C, AB,F, E, D, C, C1 F:5, E:4, D:3, C:2, B:1, A:0 ( F(4k), k++) ( F(4k+1), k++) ( F(4k+2), k++) ( F(4k+3), k++) ( F(k), k++)

5. OPODIS '045 Schedule Introduction –Coordinating Objects –Reactive Shared Objects Self-tuning Reactive Trees –Algorithms –Evaluation Conclusions

6. OPODIS '046 Why are reactive objects useful? Performance of concurrent objects heavily rely on their surrounding environment. Challenges –In multiprocessor systems, processors’ surrounding environment changes too fast compared with their reactions. –Multiprogramming systems are unpredictable Interference among processes  traffic on the bus/network, contention on memory modules, load on processors etc. are unpredictable.

7. OPODIS '047 Example: Reactive diffracting trees Each counter locally react according to its current load. Disadvantages: –Require experimentally tuned parameters for each system and each application –Inefficient reactive scheme: Shrink/expand one level in one adjustment step Costly adjustment C7 C6 B1 C4 C5 B2 B3 A:0 B:1 E:4, C:2, F:5, D:3 AB,F, E, D, C, C2 ( F(2k), k++) ( F(4k+1), k++) ( F(4k+3), k++)

8. OPODIS '048 Reactive policy

9. OPODIS '049 Schedule Introduction –Coordinating Objects –Reactive Shared Objects Self-tuning Reactive Trees –Algorithms –Evaluation Conclusions

10. OPODIS '0410 Self-tuning trees Advantages: –No need of any experimentally tuned parameters –Efficient reactive scheme: Ability to shrink and expand many levels at one time Reasonable costs for adjustments.

11. OPODIS '0411 Reactive policy Problem: balancing the trade-off between two key measures, the contention level and the depth of the tree.          

12. OPODIS '0412 When to expand/shrink ? Advantages: –Reduce contention & keep traversal short –Favor to expand leaves with high contention. Similar for shrinkage Rules for expansion (cf. threat-based algorithm): –Expand a leaf only when the estimated current total load is the highest so far in the present transaction phase, – When expanding, expand just enough to keep the competitive ratio c =  - (  -1)/  1/(  -1), where  = P/2

13. OPODIS '0413 Expanding a leaf to a subtree IN 2 3 5 8 12 6 10 2 pending processor s

14. OPODIS '0414 Shrinking a subtree to a leaf Elect2Shrink: check whether half the number of leaves in the subtree vote for the leaf Shrink: IN 12 3 5 4 8 2 6 5 active processors 3/4  shrin k

15. OPODIS '0415 Results: Full contention benchmark

16. OPODIS '0416 Results: Index distribution benchmark

17. OPODIS '0417 Results: Surge load benchmark

18. OPODIS '0418 Schedule Introduction –Coordinating Objects –Reactive Shared Objects Self-tuning Reactive Trees –Algorithms –Evaluation Conclusions

19. OPODIS '0419 Conclusions We have presented a new data structure that: –Distributes a set of processors to many smaller groups accessing disjoint critical sections in a global coordinated manner. –Collects information about the contention at the leaves and then efficiently adjusts itself to attain optimal performance without using any experimental parameters. Methodology: –Ideally, reactive algorithms should be able to observe the changes in the environment and react automatically. Fixed/tuned parameters cannot support good reactive schemes in dynamic environments such as multiprocessor systems. –Online algorithms and competitive analysis seem to be a promising direction.

20. OPODIS '0420 Thank you!